# 1. Exchange Connected App credentials for an OAuth token
curl -X POST https://login.salesforce.com/services/oauth2/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&client_id=$SF_CLIENT_ID&client_secret=$SF_CLIENT_SECRET"
# Response: {"access_token":"00D...","instance_url":"https://yourorg.my.salesforce.com",...}

# 2. Create the Task on the matching Contact
curl -X POST "$INSTANCE_URL/services/data/v66.0/sobjects/Task/" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "Subject": "Acme Corp - Discovery call",
    "Description": "Speak AI Summary: Acme is evaluating Speak for sales enablement. Next step: send pricing.\n\nTranscript: https://app.speakai.co/media/med_abc123",
    "WhoId": "003XX000004C0vMQAS",
    "WhatId": "006XX000005Lk0ZQAS",
    "Status": "Completed",
    "ActivityDate": "2026-05-06",
    "Type": "Call",
    "CallDurationInSeconds": 1820,
    "TaskSubtype": "Call"
  }'

import express from "express";
const app = express();
app.use(express.json());

app.post("/speak-webhook", async (req, res) => {
  // Speak fires {eventType, state, mediaId} -- flat.
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fetch full insight + Magic Prompt summary in parallel.
  const [insightRes, summary] = await Promise.all([
    fetch(`https://api.speakai.co/v1/media/insight/${mediaId}`,
      { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }).then(r => r.json()),
    runMagicPrompt(mediaId,
      "Summarize this sales call in 2 sentences. End with the next step."),
  ]);
  const media = insightRes.data;

  // 2. Salesforce token (cache; refresh ~15 min before expiry).
  const tokenRes = await fetch("https://login.salesforce.com/services/oauth2/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      grant_type: "client_credentials",
      client_id: process.env.SF_CLIENT_ID,
      client_secret: process.env.SF_CLIENT_SECRET,
    }),
  });
  const { access_token, instance_url } = await tokenRes.json();

  // 3. Resolve Contact by speaker email (insight.speakers carries the
  //    speaker name; pair with your own email lookup, e.g. calendar).
  const email = await emailFromMedia(media);
  const q = `SELECT Id, AccountId FROM Contact WHERE Email = '${email}' LIMIT 1`;
  const contactRes = await fetch(
    `${instance_url}/services/data/v66.0/query/?q=${encodeURIComponent(q)}`,
    { headers: { Authorization: `Bearer ${access_token}` } }
  );
  const contact = (await contactRes.json()).records[0];

  // 4. Create the Task.
  await fetch(`${instance_url}/services/data/v66.0/sobjects/Task/`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${access_token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      Subject: media.name || "Speak AI call",
      Description: `${summary}

Transcript: https://app.speakai.co/media/${mediaId}`,
      WhoId: contact?.Id,
      Status: "Completed",
      ActivityDate: media.createdAt.slice(0, 10),
      Type: "Call",
      CallDurationInSeconds: media.duration?.inSecond,
      TaskSubtype: "Call",
    }),
  });
});

// Helper: fire Magic Prompt + poll until completed (~2-3s typical).
async function runMagicPrompt(mediaId, prompt) {
  await fetch("https://api.speakai.co/v1/prompt/", {
    method: "POST",
    headers: {
      "x-speakai-key": process.env.SPEAK_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      mediaIds: [mediaId], prompt,
      isStream: false, isIndividualPrompt: true,
    }),
  });
  for (let i = 0; i < 20; i++) {
    await new Promise(r => setTimeout(r, 1000));
    const r = await fetch(
      `https://api.speakai.co/v1/prompt/messages?mediaIds=${mediaId}&pageSize=1`,
      { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
    );
    const j = await r.json();
    const msg = j?.data?.history?.[0]?.messages?.[0];
    if (msg && msg.state === "completed") return msg.answer;
  }
  return ""; // Magic Prompt timed out -- skip the summary field.
}

app.listen(3000);

import asyncio, os
from fastapi import FastAPI, Request
import httpx

app = FastAPI()
SF_CLIENT_ID = os.environ["SF_CLIENT_ID"]
SF_CLIENT_SECRET = os.environ["SF_CLIENT_SECRET"]

async def sf_token():
    async with httpx.AsyncClient() as c:
        r = await c.post(
            "https://login.salesforce.com/services/oauth2/token",
            data={
                "grant_type": "client_credentials",
                "client_id": SF_CLIENT_ID,
                "client_secret": SF_CLIENT_SECRET,
            },
        )
        return r.json()

@app.post("/speak-webhook")
async def speak_webhook(req: Request):
    # Speak fires {eventType, state, mediaId} -- flat.
    body = await req.json()
    if body.get("eventType") != "media.analyzed" or body.get("state") != "processed":
        return {"ok": True}
    media_id = body["mediaId"]

    # 1. Fetch insight + Magic Prompt summary in parallel.
    headers = {"x-speakai-key": os.environ["SPEAK_API_KEY"]}
    async with httpx.AsyncClient(timeout=30) as c:
        ir = await c.get(f"https://api.speakai.co/v1/media/insight/{media_id}", headers=headers)
        media = ir.json()["data"]
    summary = await run_magic_prompt(media_id,
        "Summarize this sales call in 2 sentences. End with the next step.")

    tok = await sf_token()
    sf_headers = {"Authorization": f"Bearer {tok['access_token']}"}
    inst = tok["instance_url"]

    email = await email_from_media(media)
    q = f"SELECT Id, AccountId FROM Contact WHERE Email = '{email}' LIMIT 1"
    async with httpx.AsyncClient() as c:
        cr = await c.get(f"{inst}/services/data/v66.0/query/", params={"q": q}, headers=sf_headers)
        records = cr.json().get("records", [])
        contact = records[0] if records else None

        await c.post(
            f"{inst}/services/data/v66.0/sobjects/Task/",
            headers={**sf_headers, "Content-Type": "application/json"},
            json={
                "Subject": media.get("name") or "Speak AI call",
                "Description": f"{summary}

Transcript: https://app.speakai.co/media/{media_id}",
                "WhoId": contact["Id"] if contact else None,
                "Status": "Completed",
                "ActivityDate": media["createdAt"][:10],
                "Type": "Call",
                "CallDurationInSeconds": (media.get("duration") or {}).get("inSecond"),
                "TaskSubtype": "Call",
            },
        )
    return {"ok": True}

async def run_magic_prompt(media_id: str, prompt: str) -> str:
    """Fire Magic Prompt + poll until completed (~2-3s typical)."""
    headers = {"x-speakai-key": os.environ["SPEAK_API_KEY"], "Content-Type": "application/json"}
    async with httpx.AsyncClient(timeout=30) as c:
        await c.post("https://api.speakai.co/v1/prompt/", headers=headers, json={
            "mediaIds": [media_id], "prompt": prompt,
            "isStream": False, "isIndividualPrompt": True,
        })
        for _ in range(20):
            await asyncio.sleep(1)
            r = await c.get(
                "https://api.speakai.co/v1/prompt/messages",
                params={"mediaIds": media_id, "pageSize": 1},
                headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
            )
            history = r.json().get("data", {}).get("history", [])
            msg = history[0]["messages"][0] if history and history[0].get("messages") else None
            if msg and msg.get("state") == "completed":
                return msg.get("answer", "")
    return ""  # timed out

# Custom fields created in Setup > Object Manager > Opportunity > Fields
# Speak_Last_Call_Sentiment__c (Picklist: Positive/Neutral/Negative)
# Speak_Last_Call_Topics__c (Long Text)
# Speak_Competitors_Mentioned__c (Long Text)

curl -X PATCH \
  "$INSTANCE_URL/services/data/v66.0/sobjects/Opportunity/006XX000005Lk0ZQAS" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "Speak_Last_Call_Sentiment__c": "Positive",
    "Speak_Last_Call_Topics__c": "pricing, integrations, security",
    "Speak_Competitors_Mentioned__c": "Gong, Chorus"
  }'

async function pushInsightsToOpportunity(oppId, magicPrompt) {
  const { access_token, instance_url } = await getSalesforceToken();
  const r = await fetch(
    `${instance_url}/services/data/v66.0/sobjects/Opportunity/${oppId}`,
    {
      method: "PATCH",
      headers: {
        Authorization: `Bearer ${access_token}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        Speak_Last_Call_Sentiment__c: magicPrompt.sentiment,
        Speak_Last_Call_Topics__c: magicPrompt.topics.join(", "),
        Speak_Competitors_Mentioned__c: magicPrompt.competitors.join(", "),
      }),
    }
  );
  if (!r.ok && r.status !== 204) throw new Error(`SF PATCH failed: ${r.status}`);
}

// SpeakInsightsController.cls
public with sharing class SpeakInsightsController {
    @AuraEnabled(cacheable=true)
    public static String getInsights(String mediaId) {
        Http http = new Http();
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:Speak_AI/v1/media/insight/' + mediaId);
        req.setMethod('GET');
        HttpResponse res = http.send(req);
        return res.getBody();
    }
}

// speakInsightsPanel.js
import { LightningElement, api, wire } from 'lwc';
import getInsights from '@salesforce/apex/SpeakInsightsController.getInsights';

export default class SpeakInsightsPanel extends LightningElement {
    @api recordId;          // Opportunity Id passed by App Builder
    @api speakMediaId;      // resolved via custom field on Opportunity

    @wire(getInsights, { mediaId: '$speakMediaId' })
    insights;

    get summary() { return JSON.parse(this.insights?.data || '{}').summary; }
    get sentiment() { return JSON.parse(this.insights?.data || '{}').sentiment; }
    get topics() { return JSON.parse(this.insights?.data || '{}').topics; }
}

# Claude Desktop / Claude Code (auto-detects your installation)
npx @speakai/mcp-server init

# Paste your Speak API key when prompted. Setup takes about 2 minutes.

# Claude.ai (web) and ChatGPT MCP connector
# Settings > Integrations > Add MCP Server
# Remote URL:    https://api.speakai.co/v1/mcp
# Auth header:   x-speakai-key: YOUR_SPEAK_API_KEY

# Verify the connection responds:
curl -s https://api.speakai.co/v1/mcp \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Accept: application/json"