# Manual: open the Google Calendar event with the Meet link.
# Click "Add guests" and enter:
#     [email protected]
# Save the event. The bot accepts the invite and joins the Meet automatically.

# Same email works for Zoom, Microsoft Teams, and Webex events.

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

# In Speak AI dashboard:
# 1. Go to Meeting Assistant -> Calendar
# 2. Click "Connect Google Calendar"
# 3. Approve OAuth scopes:
#      https://www.googleapis.com/auth/calendar.readonly
#      https://www.googleapis.com/auth/calendar.events.readonly
# 4. Speak finds existing future Meet events immediately
# 5. Bot joins your next scheduled Meet automatically

# Or use Capture Live Meeting / Schedule Live Meeting in the
# Meeting Assistant UI to send the bot to one specific Meet URL.

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/meet-webhook",
    "events": ["media.analyzed"],
    "description": "Google Meet to CRM"
  }'

// Register the webhook once
await fetch("https://api.speakai.co/v1/webhook", {
  method: "POST",
  headers: {
    "x-speakai-key": process.env.SPEAK_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    callbackUrl: "https://your-app.example.com/speak/meet-webhook",
    events: ["media.analyzed"],
    description: "Google Meet to CRM",
  }),
});

import os, requests

requests.post(
    "https://api.speakai.co/v1/webhook",
    headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
    json={
        "callbackUrl": "https://your-app.example.com/speak/meet-webhook",
        "events": ["media.analyzed"],
        "description": "Google Meet to CRM",
    },
    timeout=30,
)

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

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

  // Fetch the 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";

  // Push to your CRM (HubSpot example; same pattern works for Salesforce, Zoho)
  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: media.createdAt,
        hs_meeting_title: media.name,
        hs_meeting_body: `Sentiment: ${sentiment}. Open in Speak: https://app.speakai.co/media/${mediaId}`,
      },
    }),
  });
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/meet-webhook")
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"

    requests.post(
        "https://api.hubapi.com/crm/v3/objects/meetings",
        headers={
            "Authorization": f"Bearer {os.environ['HUBSPOT_TOKEN']}",
            "Content-Type": "application/json",
        },
        json={
            "properties": {
                "hs_timestamp": insight["createdAt"],
                "hs_meeting_title": insight["name"],
                "hs_meeting_body": f"Sentiment: {sentiment}. Open in Speak: https://app.speakai.co/media/{media_id}",
            },
        },
        timeout=15,
    )
    return {"ok": True}

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 - Discovery Call",
    "meetingURL": "https://meet.google.com/abc-defg-hij",
    "meetingDate": "2026-05-15T16:00:00.000Z",
    "meetingLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

# Response includes a meetingAssistantEventId you store on the CRM record
# so you can pause / resume / remove the assistant later.

// Call this when your CRM creates a meeting in your scheduling tool.
async function scheduleSpeakBot({ title, meetURL, 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: meetURL,
        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 on the CRM activity record.
  return data.meetingAssistantEventId;
}

import os, requests

def schedule_speak_bot(title: str, meet_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": meet_url,
            "meetingDate": scheduled_at,
            "meetingLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    # Persist meetingAssistantEventId on the CRM activity record
    return r.json()["data"]["meetingAssistantEventId"]

# Pause the bot (it will not join even if the meeting starts)
curl -X POST https://api.speakai.co/v1/meeting-assistant/events/pause \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"meetingAssistantEventId": "abc123"}'

# Resume a previously paused bot
curl -X POST https://api.speakai.co/v1/meeting-assistant/events/resume \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"meetingAssistantEventId": "abc123"}'

# Remove the bot from the meeting entirely
curl -X POST https://api.speakai.co/v1/meeting-assistant/events/remove \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"meetingAssistantEventId": "abc123"}'

# List recordings in the Meet Recordings folder (Drive API v3)
curl "https://www.googleapis.com/drive/v3/files?q=name+contains+'Meet+Recording'+and+mimeType='video/mp4'&orderBy=createdTime+desc&fields=files(id,name,createdTime,webViewLink)&pageSize=20" \
  -H "Authorization: Bearer $GOOGLE_OAUTH_TOKEN"

# Get a download URL for a specific recording
curl "https://www.googleapis.com/drive/v3/files/$FILE_ID?alt=media" \
  -H "Authorization: Bearer $GOOGLE_OAUTH_TOKEN" \
  -L -o recording.mp4

// Find recent Meet recordings, send each to Speak.
async function importRecentMeetRecordings(googleToken) {
  // Drive's "Meet Recordings" folder is auto-created when the host first records.
  // Filter by mimeType + name pattern.
  const list = await fetch(
    "https://www.googleapis.com/drive/v3/files?" + new URLSearchParams({
      q: "name contains 'Meet Recording' and mimeType='video/mp4'",
      orderBy: "createdTime desc",
      fields: "files(id,name,createdTime,webViewLink)",
      pageSize: "20",
    }),
    { headers: { Authorization: `Bearer ${googleToken}` } }
  ).then(r => r.json());

  for (const file of list.files) {
    // Drive v3 supports alt=media downloads; Speak fetches by URL.
    const downloadUrl = `https://www.googleapis.com/drive/v3/files/${file.id}?alt=media`;

    await fetch("https://api.speakai.co/v1/media/upload", {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        name: file.name,
        url: downloadUrl,
        mediaType: "video",
        sourceLanguage: "en-US",
        tags: "google-meet,drive-import",
        // Drive download requires the Authorization header on Speak's fetch.
        // Use a short-lived signed URL via /files.get?fields=webContentLink
        // for production setups, or proxy through your own server.
      }),
    });
  }
}

# Drive supports change notifications via the changes.watch endpoint.
# Set up a one-time channel on the Meet Recordings folder.
curl -X POST "https://www.googleapis.com/drive/v3/files/$FOLDER_ID/watch" \
  -H "Authorization: Bearer $GOOGLE_OAUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "id": "meet-recordings-channel-1",
    "type": "web_hook",
    "address": "https://your-app.example.com/drive/meet-recordings"
  }'

# When Drive POSTs a change notification, your handler:
#   1. Lists recent files in the folder via files.list
#   2. Forwards new mp4 files to /v1/media/upload (same as Tab 3 step 1)
#
# Channels expire after 7 days. Renew with another POST to /watch.

# 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 (optional sanity check):
curl -s https://api.speakai.co/v1/mcp \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Accept: application/json"