# Manual: open the calendar event (Outlook, Google Calendar, etc.) that contains the Webex meeting link.
# Click "Add attendees" and enter:
#     [email protected]
# Save the event. The bot accepts the invite and joins the Webex call automatically.

# Programmatic (Google Calendar API) - add the bot as an attendee:
curl -X PATCH "https://www.googleapis.com/calendar/v3/calendars/primary/events/$EVENT_ID" \
  -H "Authorization: Bearer $GCAL_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "attendees": [
      { "email": "[email protected]", "displayName": "Speak AI Notetaker" }
    ]
  }'

# In Speak AI dashboard:
# 1. Go to Meeting Assistant -> Calendar
# 2. Click "Connect Google Calendar" or "Connect Microsoft 365"
# 3. Approve the OAuth scopes when prompted
# 4. Speak scans upcoming calendar events for Webex meeting URLs
# 5. Bot joins every Webex call that appears on your connected calendar automatically

# Note: auto-coverage works through your calendar OAuth (Google or Microsoft 365),
# not a native Webex OAuth. The Webex URL on the calendar event is the trigger.

curl -X POST https://api.speakai.co/v1/meeting-assistant/events/schedule \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Acme Corp - Demo Call",
    "meetingURL": "https://acme.webex.com/meet/acme-team",
    "meetingDate": "2026-05-15T16:00:00.000Z",
    "meetingLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

// Call this when your CRM creates a Webex meeting.
async function scheduleSpeakBot({ title, webexURL, scheduledAt, folderId }) {
  const r = await fetch(
    "https://api.speakai.co/v1/meeting-assistant/events/schedule",
    {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        title,
        meetingURL: webexURL,
        meetingDate: scheduledAt,
        meetingLanguage: "en-US",
        folderId,
      }),
    }
  );
  if (!r.ok) throw new Error(`Speak schedule failed: ${r.status}`);
  const { data } = await r.json();
  // Persist data.meetingAssistantEventId for pause / resume / remove later.
  return data.meetingAssistantEventId;
}

import os, requests

def schedule_speak_bot(title: str, webex_url: str, scheduled_at: str, folder_id: str | None = None):
    r = requests.post(
        "https://api.speakai.co/v1/meeting-assistant/events/schedule",
        headers={
            "x-speakai-key": os.environ["SPEAK_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "title": title,
            "meetingURL": webex_url,
            "meetingDate": scheduled_at,
            "meetingLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["data"]["meetingAssistantEventId"]

# 1. Go to https://developer.webex.com
# 2. Click "My Webex Apps" -> "Create a New App" -> "Create a Bot"
# 3. Name: "Speak AI Notetaker", Bot Username: speakai-notetaker
# 4. Click "Add Bot" and copy the Bot Access Token
# 5. Store as WEBEX_BOT_TOKEN in your handler's .env
#
# 6. Invite the bot to the target Webex space:
#    In Webex App: open the space -> Add People -> search for [email protected]
#
# 7. Find the space's roomId:
curl https://webexapis.com/v1/rooms \
  -H "Authorization: Bearer $WEBEX_BOT_TOKEN"
# Copy the id from the room you invited the bot to. Store as WEBEX_ROOM_ID.

curl -X POST https://api.speakai.co/v1/webhook \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "callbackUrl": "https://your-app.example.com/speak/webex-space",
    "events": ["media.analyzed"],
    "description": "Forward Speak insights to Webex space"
  }'

// Speak posts a thin notification: { eventType, state, mediaId } (verified 2026-05-07).
import express from "express";
const app = express();
app.use(express.json());

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

  // 1. Fetch full insight from Speak
  const insight = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  const media = insight.data;
  const compound = media.sentiment?.[0]?.document?.Compound ?? 0;
  const sentiment = compound > 10 ? "Positive"
                  : compound < -10 ? "Negative" : "Neutral";

  // 2. Build a Webex Adaptive Card (Buttons and Cards / Adaptive Cards 1.2)
  const message = {
    roomId: process.env.WEBEX_ROOM_ID,
    markdown: `**${media.name}** - Sentiment: ${sentiment}`,
    attachments: [{
      contentType: "application/vnd.microsoft.card.adaptive",
      content: {
        $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
        type: "AdaptiveCard",
        version: "1.2",
        body: [
          { type: "TextBlock", size: "Large", weight: "Bolder", text: media.name },
          { type: "TextBlock", text: `Sentiment: ${sentiment} (Compound ${compound})`, wrap: true },
          { type: "TextBlock",
            text: `Duration: ${Math.round(media.duration?.inSecond / 60)} min`,
            isSubtle: true, spacing: "None" },
        ],
        actions: [{
          type: "Action.OpenUrl",
          title: "Open in Speak",
          url: `https://app.speakai.co/media/${mediaId}`,
        }],
      },
    }],
  };

  // 3. POST to the Webex Messaging API
  await fetch("https://webexapis.com/v1/messages", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.WEBEX_BOT_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(message),
  });
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/webex-space")
async def hook(req: Request):
    body = await req.json()
    if body.get("eventType") != "media.analyzed" or body.get("state") != "processed":
        return {"ok": True}
    media_id = body["mediaId"]

    insight = requests.get(
        f"https://api.speakai.co/v1/media/insight/{media_id}",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        timeout=30,
    ).json()["data"]

    compound = (insight.get("sentiment") or [{}])[0].get("document", {}).get("Compound", 0)
    sentiment = "Positive" if compound > 10 else "Negative" if compound < -10 else "Neutral"

    message = {
        "roomId": os.environ["WEBEX_ROOM_ID"],
        "markdown": f"**{insight['name']}** - Sentiment: {sentiment}",
        "attachments": [{
            "contentType": "application/vnd.microsoft.card.adaptive",
            "content": {
                "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                "type": "AdaptiveCard",
                "version": "1.2",
                "body": [
                    {"type": "TextBlock", "size": "Large", "weight": "Bolder", "text": insight["name"]},
                    {"type": "TextBlock", "text": f"Sentiment: {sentiment} (Compound {compound})", "wrap": True},
                    {"type": "TextBlock",
                     "text": f"Duration: {round(insight.get('duration', {}).get('inSecond', 0) / 60)} min",
                     "isSubtle": True, "spacing": "None"},
                ],
                "actions": [{
                    "type": "Action.OpenUrl",
                    "title": "Open in Speak",
                    "url": f"https://app.speakai.co/media/{media_id}",
                }],
            },
        }],
    }

    requests.post(
        "https://webexapis.com/v1/messages",
        headers={
            "Authorization": f"Bearer {os.environ['WEBEX_BOT_TOKEN']}",
            "Content-Type": "application/json",
        },
        json=message,
        timeout=15,
    )
    return {"ok": True}

// Speak webhook body shape (verified 2026-05-07): { eventType, state, mediaId }
import express from "express";
const app = express();
app.use(express.json());

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

  // 1. Fetch full insight
  const { data } = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  // 2. Push to HubSpot Meetings (or Salesforce Tasks, or Zoho Calls)
  const start = new Date(data.createdAt);
  const end = new Date(start.getTime() + (data.duration?.inSecond || 0) * 1000);

  await fetch("https://api.hubapi.com/crm/v3/objects/meetings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      properties: {
        hs_timestamp: start.toISOString(),
        hs_meeting_title: data.name,
        hs_meeting_body: `Webex call summary. Open in Speak: https://app.speakai.co/media/${mediaId}`,
        hs_meeting_external_url: `https://app.speakai.co/media/${mediaId}`,
        hs_meeting_start_time: start.toISOString(),
        hs_meeting_end_time: end.toISOString(),
        hs_meeting_outcome: "COMPLETED",
      },
    }),
  });
});

app.listen(3000);

# 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"