# Open the calendar event with the Zoom meeting URL.
# Add [email protected] as an attendee. Save.
# Bot accepts the invite and joins the Zoom call automatically.

# Programmatic via Microsoft Graph (Outlook):
curl -X PATCH "https://graph.microsoft.com/v1.0/me/events/$EVENT_ID" 
  -H "Authorization: Bearer $GRAPH_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "attendees": [{
      "emailAddress": { "address": "[email protected]", "name": "Speak AI Notetaker" },
      "type": "required"
    }]
  }'

# Programmatic via Google Calendar:
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]" }] }'

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",
    "meetingURL": "https://us02web.zoom.us/j/82345678901?pwd=xyz",
    "meetingDate": "2026-05-15T16:00:00.000Z",
    "meetingLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

async function scheduleSpeakBotForZoom({ title, zoomURL, 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: zoomURL,
        meetingDate: scheduledAt,
        meetingLanguage: "en-US",
        folderId,
      }),
    }
  );
  if (!r.ok) throw new Error(`Speak schedule failed: ${r.status}`);
  const { data } = await r.json();
  return data.meetingAssistantEventId;
}

import os, requests

def schedule_speak_bot_for_zoom(title: str, zoom_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": zoom_url,
            "meetingDate": scheduled_at,
            "meetingLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["data"]["meetingAssistantEventId"]

# In Speak AI dashboard:
# 1. Go to Settings -> Integrations -> Zoom
# 2. Click "Connect Zoom"
# 3. Approve OAuth scopes:
#      meeting:read     - read meeting metadata
#      recording:read   - access cloud recordings
#      user:read        - identify the connected user
# 4. Speak stores the OAuth tokens server-side and registers the webhook

# Or hit Speak's connect endpoint programmatically:
curl -X POST https://api.speakai.co/v1/integration/zoom/connect 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"code": "$ZOOM_OAUTH_CODE", "redirectUri": "https://yourapp/zoom-redirect"}'

# Speak's public Zoom webhook endpoint (server-to-server):
#   POST https://api.speakai.co/v1/integration/zoom/notify
#
# Zoom posts these events to Speak automatically once OAuth is connected:
#   - recording.completed       (cloud recording ready)
#   - recording.transcript_completed (Zoom-generated transcript ready)
#   - meeting.started / meeting.ended
#
# Speak validates the X-Zm-Signature header server-side, fetches the
# recording via Zoom's API with your stored OAuth token, and ingests
# the file into your Speak workspace.
#
# YOU DO NOT NEED MIDDLEWARE FOR THIS FLOW.
# The OAuth connect step in Step 1 wires the webhook automatically.

// Use this only if you want custom routing on top of Speak's native Zoom flow.
// For example: route Zoom Phone vs Zoom Meeting recordings to different Speak folders.
import express from "express";
const app = express();
app.use(express.json());

app.post("/zoom/recording", async (req, res) => {
  if (req.body.event !== "recording.completed") return res.sendStatus(204);
  const meeting = req.body.payload.object;

  // Pick the MP4 video for meetings, M4A audio for Zoom Phone
  const file = meeting.recording_files.find(f =>
    f.file_type === "MP4" || f.file_type === "M4A"
  );
  if (!file) return res.sendStatus(204);

  // Zoom download URLs require the meeting download_token appended
  const downloadUrl = `${file.download_url}?access_token=${meeting.download_token}`;

  // Branch: Zoom Phone uses M4A, Meetings use MP4
  const isPhone = file.file_type === "M4A";
  const folderId = isPhone ? process.env.SPEAK_PHONE_FOLDER : process.env.SPEAK_MEETINGS_FOLDER;
  const tags = isPhone ? "zoom,zoom-phone" : "zoom,zoom-meeting";

  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: meeting.topic || `Zoom ${meeting.id}`,
      url: downloadUrl,
      mediaType: isPhone ? "audio" : "video",
      sourceLanguage: "en-US",
      tags,
      folderId,
    }),
  });
  res.sendStatus(200);
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/zoom/recording")
async def zoom_recording(req: Request):
    body = await req.json()
    if body.get("event") != "recording.completed":
        return {"ok": True}
    meeting = body["payload"]["object"]

    file = next(
        (f for f in meeting["recording_files"] if f["file_type"] in ("MP4", "M4A")),
        None,
    )
    if not file:
        return {"ok": True}

    download_url = f"{file['download_url']}?access_token={meeting['download_token']}"
    is_phone = file["file_type"] == "M4A"
    folder_id = os.environ.get("SPEAK_PHONE_FOLDER" if is_phone else "SPEAK_MEETINGS_FOLDER")
    tags = "zoom,zoom-phone" if is_phone else "zoom,zoom-meeting"

    requests.post(
        "https://api.speakai.co/v1/media/upload",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        json={
            "name": meeting.get("topic") or f"Zoom {meeting['id']}",
            "url": download_url,
            "mediaType": "audio" if is_phone else "video",
            "sourceLanguage": "en-US",
            "tags": tags,
            "folderId": folder_id,
        },
        timeout=30,
    )
    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/zoom-to-crm", async (req, res) => {
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  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());

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

  // HubSpot Meeting engagement (full code on /integrations/hubspot/)
  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: `Zoom call. Sentiment: ${sentiment}. 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

# Claude.ai (web) i łącznik ChatGPT MCP
# Ustawienia > Integracje > Dodaj serwer MCP
# Zdalny adres URL:    https://api.speakai.co/v1/mcp
# Nagłówek uwierzytelnienia:   x-speakai-key: YOUR_SPEAK_API_KEY