@gakr-gakr/google-meet 0.1.0

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@gakr-gakr/google-meet",
+  "version": "0.1.0",
+  "description": "AutoBot Google Meet participant plugin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/autobot/autobot"
+  },
+  "type": "module",
+  "dependencies": {
+    "commander": "14.0.3",
+    "typebox": "1.1.38"
+  },
+  "devDependencies": {
+    "@gakr-gakr/plugin-sdk": "workspace:*",
+    "@gakr-gakr/autobot": "workspace:*",
+    "autobot": "workspace:@gakr-gakr/autobot@*"
+  },
+  "peerDependencies": {
+    "@gakr-gakr/autobot": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@gakr-gakr/autobot": {
+      "optional": true
+    }
+  },
+  "autobot": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "npmSpec": "@gakr-gakr/google-meet",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.4.20"
+    },
+    "compat": {
+      "pluginApi": ">=2026.5.19"
+    },
+    "build": {
+      "autobotVersion": "2026.5.19"
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    }
+  }
+}

package/src/agent-consult.ts

@@ -0,0 +1,158 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import type { PluginRuntime, RuntimeLogger } from "autobot/plugin-sdk/plugin-runtime";
+import {
+  buildRealtimeVoiceAgentConsultWorkingResponse,
+  consultRealtimeVoiceAgent,
+  REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
+  resolveRealtimeVoiceAgentConsultTools,
+  resolveRealtimeVoiceAgentConsultToolsAllow,
+  type RealtimeVoiceBridgeSession,
+  type RealtimeVoiceToolCallEvent,
+  type RealtimeVoiceTool,
+  type TalkEventInput,
+} from "autobot/plugin-sdk/realtime-voice";
+import { normalizeAgentId } from "autobot/plugin-sdk/routing";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { GoogleMeetConfig, GoogleMeetToolPolicy } from "./config.js";
+
+export const GOOGLE_MEET_AGENT_CONSULT_TOOL_NAME = REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME;
+
+const GOOGLE_MEET_CONSULT_SYSTEM_PROMPT = [
+  "You are a behind-the-scenes consultant for a live meeting voice agent.",
+  "Prioritize a fast, speakable answer over exhaustive investigation.",
+  "For tool-backed status checks, prefer one or two bounded read-only queries before answering.",
+  "Do not print secret values or dump environment variables; only check whether required configuration is present.",
+  "Be accurate, brief, and speakable.",
+].join(" ");
+
+export function resolveGoogleMeetRealtimeTools(policy: GoogleMeetToolPolicy): RealtimeVoiceTool[] {
+  return resolveRealtimeVoiceAgentConsultTools(policy);
+}
+
+export function submitGoogleMeetConsultWorkingResponse(
+  session: RealtimeVoiceBridgeSession,
+  callId: string,
+): void {
+  if (!session.bridge.supportsToolResultContinuation) {
+    return;
+  }
+  session.submitToolResult(callId, buildRealtimeVoiceAgentConsultWorkingResponse("participant"), {
+    willContinue: true,
+  });
+}
+
+export async function consultAutoBotAgentForGoogleMeet(params: {
+  config: GoogleMeetConfig;
+  fullConfig: AutoBotConfig;
+  runtime: PluginRuntime;
+  logger: RuntimeLogger;
+  meetingSessionId: string;
+  requesterSessionKey?: string;
+  args: unknown;
+  transcript: Array<{ role: "user" | "assistant"; text: string }>;
+}): Promise<{ text: string }> {
+  const agentId = normalizeAgentId(params.config.realtime.agentId);
+  const requesterSessionKey =
+    normalizeOptionalString(params.requesterSessionKey) ?? `agent:${agentId}:main`;
+  const sessionKey = `agent:${agentId}:subagent:google-meet:${params.meetingSessionId}`;
+  return await consultRealtimeVoiceAgent({
+    cfg: params.fullConfig,
+    agentRuntime: params.runtime.agent,
+    logger: params.logger,
+    agentId,
+    sessionKey,
+    messageProvider: "google-meet",
+    lane: "google-meet",
+    runIdPrefix: `google-meet:${params.meetingSessionId}`,
+    spawnedBy: requesterSessionKey,
+    contextMode: "fork",
+    args: params.args,
+    transcript: params.transcript,
+    surface: "a private Google Meet",
+    userLabel: "Participant",
+    assistantLabel: "Agent",
+    questionSourceLabel: "participant",
+    toolsAllow: resolveRealtimeVoiceAgentConsultToolsAllow(params.config.realtime.toolPolicy),
+    extraSystemPrompt: GOOGLE_MEET_CONSULT_SYSTEM_PROMPT,
+  });
+}
+
+export function handleGoogleMeetRealtimeConsultToolCall(params: {
+  strategy: string;
+  session: RealtimeVoiceBridgeSession;
+  event: RealtimeVoiceToolCallEvent;
+  config: GoogleMeetConfig;
+  fullConfig: AutoBotConfig;
+  runtime: PluginRuntime;
+  logger: RuntimeLogger;
+  meetingSessionId: string;
+  requesterSessionKey?: string;
+  transcript: Array<{ role: "user" | "assistant"; text: string }>;
+  onTalkEvent?: (event: TalkEventInput) => void;
+}): void {
+  const callId = params.event.callId || params.event.itemId;
+  if (params.strategy !== "bidi") {
+    params.onTalkEvent?.({
+      type: "tool.error",
+      callId,
+      payload: {
+        name: params.event.name,
+        error: `Tool "${params.event.name}" is only available in bidi realtime strategy`,
+      },
+      final: true,
+    });
+    params.session.submitToolResult(callId, {
+      error: `Tool "${params.event.name}" is only available in bidi realtime strategy`,
+    });
+    return;
+  }
+  if (params.event.name !== GOOGLE_MEET_AGENT_CONSULT_TOOL_NAME) {
+    params.onTalkEvent?.({
+      type: "tool.error",
+      callId,
+      payload: { name: params.event.name, error: `Tool "${params.event.name}" not available` },
+      final: true,
+    });
+    params.session.submitToolResult(callId, {
+      error: `Tool "${params.event.name}" not available`,
+    });
+    return;
+  }
+  params.onTalkEvent?.({
+    type: "tool.progress",
+    callId,
+    payload: { name: params.event.name, status: "working" },
+  });
+  submitGoogleMeetConsultWorkingResponse(params.session, callId);
+  void consultAutoBotAgentForGoogleMeet({
+    config: params.config,
+    fullConfig: params.fullConfig,
+    runtime: params.runtime,
+    logger: params.logger,
+    meetingSessionId: params.meetingSessionId,
+    requesterSessionKey: params.requesterSessionKey,
+    args: params.event.args,
+    transcript: params.transcript,
+  })
+    .then((result) => {
+      params.onTalkEvent?.({
+        type: "tool.result",
+        callId,
+        payload: { name: params.event.name, result },
+        final: true,
+      });
+      params.session.submitToolResult(callId, result);
+    })
+    .catch((error: Error) => {
+      params.onTalkEvent?.({
+        type: "tool.error",
+        callId,
+        payload: { name: params.event.name, error: formatErrorMessage(error) },
+        final: true,
+      });
+      params.session.submitToolResult(callId, {
+        error: formatErrorMessage(error),
+      });
+    });
+}

package/src/calendar.ts

@@ -0,0 +1,252 @@
+import { fetchWithSsrFGuard } from "autobot/plugin-sdk/ssrf-runtime";
+import { googleApiError } from "./google-api-errors.js";
+
+const GOOGLE_CALENDAR_API_BASE_URL = "https://www.googleapis.com/calendar/v3";
+const GOOGLE_CALENDAR_API_HOST = "www.googleapis.com";
+const GOOGLE_MEET_URL_HOST = "meet.google.com";
+const GOOGLE_CALENDAR_EVENTS_SCOPE = "https://www.googleapis.com/auth/calendar.events.readonly";
+
+type GoogleCalendarEventDate = {
+  date?: string;
+  dateTime?: string;
+  timeZone?: string;
+};
+
+type GoogleCalendarConferenceEntryPoint = {
+  entryPointType?: string;
+  uri?: string;
+  label?: string;
+};
+
+type GoogleMeetCalendarEvent = {
+  id?: string;
+  summary?: string;
+  description?: string;
+  location?: string;
+  status?: string;
+  htmlLink?: string;
+  hangoutLink?: string;
+  start?: GoogleCalendarEventDate;
+  end?: GoogleCalendarEventDate;
+  conferenceData?: {
+    conferenceId?: string;
+    conferenceSolution?: {
+      key?: { type?: string };
+      name?: string;
+    };
+    entryPoints?: GoogleCalendarConferenceEntryPoint[];
+  };
+};
+
+export type GoogleMeetCalendarLookupResult = {
+  calendarId: string;
+  event: GoogleMeetCalendarEvent;
+  meetingUri: string;
+};
+
+type GoogleMeetCalendarEventsResult = {
+  calendarId: string;
+  events: Array<{
+    event: GoogleMeetCalendarEvent;
+    meetingUri: string;
+    selected: boolean;
+  }>;
+};
+
+function appendQuery(url: string, query: Record<string, string | number | boolean | undefined>) {
+  const parsed = new URL(url);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined) {
+      parsed.searchParams.set(key, String(value));
+    }
+  }
+  return parsed.toString();
+}
+
+function isGoogleMeetUri(value: string | undefined): value is string {
+  if (!value?.trim()) {
+    return false;
+  }
+  try {
+    return new URL(value).hostname === GOOGLE_MEET_URL_HOST;
+  } catch {
+    return false;
+  }
+}
+
+function extractGoogleMeetUriFromText(value: string | undefined): string | undefined {
+  const match = value?.match(/https:\/\/meet\.google\.com\/[a-z0-9-]+/i);
+  return match?.[0];
+}
+
+export function extractGoogleMeetUriFromCalendarEvent(
+  event: GoogleMeetCalendarEvent,
+): string | undefined {
+  if (isGoogleMeetUri(event.hangoutLink)) {
+    return event.hangoutLink;
+  }
+  const entryPoints = event.conferenceData?.entryPoints ?? [];
+  const videoEntry = entryPoints.find(
+    (entry) => entry.entryPointType === "video" && isGoogleMeetUri(entry.uri),
+  );
+  if (videoEntry?.uri) {
+    return videoEntry.uri;
+  }
+  const meetEntry = entryPoints.find((entry) => isGoogleMeetUri(entry.uri));
+  if (meetEntry?.uri) {
+    return meetEntry.uri;
+  }
+  return (
+    extractGoogleMeetUriFromText(event.location) ?? extractGoogleMeetUriFromText(event.description)
+  );
+}
+
+export function buildGoogleMeetCalendarDayWindow(now = new Date()): {
+  timeMin: string;
+  timeMax: string;
+} {
+  const start = new Date(now);
+  start.setHours(0, 0, 0, 0);
+  const end = new Date(start);
+  end.setDate(start.getDate() + 1);
+  return { timeMin: start.toISOString(), timeMax: end.toISOString() };
+}
+
+function parseCalendarEventTime(value: GoogleCalendarEventDate | undefined): number | undefined {
+  const raw = value?.dateTime ?? value?.date;
+  if (!raw) {
+    return undefined;
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function rankCalendarEvent(event: GoogleMeetCalendarEvent, nowMs: number): number {
+  const startMs = parseCalendarEventTime(event.start) ?? Number.POSITIVE_INFINITY;
+  const endMs = parseCalendarEventTime(event.end) ?? startMs;
+  if (startMs <= nowMs && endMs >= nowMs) {
+    return 0;
+  }
+  if (startMs > nowMs) {
+    return startMs - nowMs;
+  }
+  return nowMs - startMs + 30 * 24 * 60 * 60 * 1000;
+}
+
+function chooseBestMeetCalendarEvent(
+  events: GoogleMeetCalendarEvent[],
+  now: Date,
+): GoogleMeetCalendarLookupResult["event"] | undefined {
+  const nowMs = now.getTime();
+  let selected: GoogleMeetCalendarEvent | undefined;
+  let selectedRank = Number.POSITIVE_INFINITY;
+  for (const event of events) {
+    if (event.status === "cancelled" || !extractGoogleMeetUriFromCalendarEvent(event)) {
+      continue;
+    }
+    const rank = rankCalendarEvent(event, nowMs);
+    if (!selected || rank < selectedRank) {
+      selected = event;
+      selectedRank = rank;
+    }
+  }
+  return selected;
+}
+
+async function fetchGoogleCalendarEvents(params: {
+  accessToken: string;
+  calendarId?: string;
+  eventQuery?: string;
+  timeMin?: string;
+  timeMax?: string;
+  maxResults?: number;
+  now?: Date;
+}): Promise<{ calendarId: string; events: GoogleMeetCalendarEvent[]; now: Date }> {
+  const calendarId = params.calendarId?.trim() || "primary";
+  const now = params.now ?? new Date();
+  const defaultTimeMax = new Date(now);
+  defaultTimeMax.setDate(defaultTimeMax.getDate() + 7);
+  const { response, release } = await fetchWithSsrFGuard({
+    url: appendQuery(
+      `${GOOGLE_CALENDAR_API_BASE_URL}/calendars/${encodeURIComponent(calendarId)}/events`,
+      {
+        maxResults: params.maxResults ?? 50,
+        orderBy: "startTime",
+        q: params.eventQuery?.trim() || undefined,
+        showDeleted: false,
+        singleEvents: true,
+        timeMin: params.timeMin ?? now.toISOString(),
+        timeMax: params.timeMax ?? defaultTimeMax.toISOString(),
+      },
+    ),
+    init: {
+      headers: {
+        Authorization: `Bearer ${params.accessToken}`,
+        Accept: "application/json",
+      },
+    },
+    policy: { allowedHostnames: [GOOGLE_CALENDAR_API_HOST] },
+    auditContext: "google-meet.calendar.events.list",
+  });
+  try {
+    if (!response.ok) {
+      const detail = await response.text();
+      throw await googleApiError({
+        response,
+        detail,
+        prefix: "Google Calendar events.list",
+        scopes: [GOOGLE_CALENDAR_EVENTS_SCOPE],
+      });
+    }
+    const payload = (await response.json()) as { items?: unknown };
+    if (payload.items !== undefined && !Array.isArray(payload.items)) {
+      throw new Error("Google Calendar events.list response had non-array items");
+    }
+    return { calendarId, events: (payload.items ?? []) as GoogleMeetCalendarEvent[], now };
+  } finally {
+    await release();
+  }
+}
+
+export async function listGoogleMeetCalendarEvents(params: {
+  accessToken: string;
+  calendarId?: string;
+  eventQuery?: string;
+  timeMin?: string;
+  timeMax?: string;
+  maxResults?: number;
+  now?: Date;
+}): Promise<GoogleMeetCalendarEventsResult> {
+  const { calendarId, events, now } = await fetchGoogleCalendarEvents(params);
+  const best = chooseBestMeetCalendarEvent(events, now);
+  return {
+    calendarId,
+    events: events
+      .map((event) => {
+        const meetingUri = extractGoogleMeetUriFromCalendarEvent(event);
+        return meetingUri ? { event, meetingUri, selected: event === best } : undefined;
+      })
+      .filter((event): event is GoogleMeetCalendarEventsResult["events"][number] => Boolean(event)),
+  };
+}
+
+export async function findGoogleMeetCalendarEvent(params: {
+  accessToken: string;
+  calendarId?: string;
+  eventQuery?: string;
+  timeMin?: string;
+  timeMax?: string;
+  maxResults?: number;
+  now?: Date;
+}): Promise<GoogleMeetCalendarLookupResult> {
+  const result = await listGoogleMeetCalendarEvents(params);
+  const selected = result.events.find((event) => event.selected) ?? result.events[0];
+  if (!selected) {
+    throw new Error("No Google Calendar event with a Google Meet link matched the query");
+  }
+  return {
+    calendarId: result.calendarId,
+    event: selected.event,
+    meetingUri: selected.meetingUri,
+  };
+}