# 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:
# 1. Open Integrations in the sidebar and find Zoom under Meetings
# 2. Select Connect, sign in to Zoom and approve access
# 3. Turn on Cloud recording in your Zoom settings (a paid Zoom feature)
#
# Connecting does not import anything by itself.
# The next step sets up the automation that does.

# In Speak AI:
# 1. Open Automations and create a new automation
# 2. Choose the trigger: New Zoom cloud recording
# 3. Add the steps you want, for example transcribe, summarize, or send to your CRM
#
# Each new cloud recording on the connected Zoom account starts a run
# once Zoom finishes processing it. Speak AI checks Zoom every couple of minutes.
# Zoom keeps more than one file per meeting; Speak AI takes one per meeting,
# the video where there is one and the audio otherwise.

// Use this only if you want custom routing instead of the New Zoom cloud recording automation.
// For example: route audio-only and video 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, or the M4A audio when there is no video
  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: audio-only recordings use M4A, video recordings use MP4
  const isAudioOnly = file.file_type === "M4A";
  const folderId = isAudioOnly ? process.env.SPEAK_AUDIO_FOLDER : process.env.SPEAK_MEETINGS_FOLDER;
  const tags = isAudioOnly ? "zoom,zoom-audio" : "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: isAudioOnly ? "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_audio_only = file["file_type"] == "M4A"
    folder_id = os.environ.get("SPEAK_AUDIO_FOLDER" if is_audio_only else "SPEAK_MEETINGS_FOLDER")
    tags = "zoom,zoom-audio" if is_audio_only 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_audio_only 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 MCP connector (web) και ChatGPT
# Settings > Integrations > Add MCP Server
# Remote URL:    https://api.speakai.co/v1/mcp
# Auth header:   x-speakai-key: YOUR_SPEAK_API_KEY