@openclaw/google-meet 2026.5.1-beta.2

package/src/transports/twilio.ts

@@ -0,0 +1,46 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+
+const DTMF_PATTERN = /^[0-9*#wWpP,]+$/;
+
+export function normalizeDialInNumber(value: unknown): string | undefined {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return undefined;
+  }
+  const compact = normalized.replace(/[()\s.-]/g, "");
+  if (!/^\+?[0-9]{5,20}$/.test(compact)) {
+    throw new Error("dialInNumber must be a phone number");
+  }
+  return compact;
+}
+
+function normalizeDtmfSequence(value: unknown): string | undefined {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return undefined;
+  }
+  const compact = normalized.replace(/\s+/g, "");
+  if (!DTMF_PATTERN.test(compact)) {
+    throw new Error("dtmfSequence may only contain digits, *, #, comma, w, p");
+  }
+  return compact;
+}
+
+export function buildMeetDtmfSequence(params: {
+  pin?: string;
+  dtmfSequence?: string;
+}): string | undefined {
+  const explicit = normalizeDtmfSequence(params.dtmfSequence);
+  if (explicit) {
+    return explicit;
+  }
+  const pin = normalizeOptionalString(params.pin);
+  if (!pin) {
+    return undefined;
+  }
+  const compactPin = pin.replace(/\s+/g, "");
+  if (!/^[0-9]+#?$/.test(compactPin)) {
+    throw new Error("pin may only contain digits and an optional trailing #");
+  }
+  return compactPin.endsWith("#") ? compactPin : `${compactPin}#`;
+}

package/src/transports/types.ts

@@ -0,0 +1,112 @@
+import type { GoogleMeetMode, GoogleMeetTransport } from "../config.js";
+
+type GoogleMeetSessionState = "active" | "ended";
+
+export type GoogleMeetJoinRequest = {
+  url: string;
+  transport?: GoogleMeetTransport;
+  mode?: GoogleMeetMode;
+  message?: string;
+  dialInNumber?: string;
+  pin?: string;
+  dtmfSequence?: string;
+};
+
+type GoogleMeetManualActionReason =
+  | "google-login-required"
+  | "meet-admission-required"
+  | "meet-permission-required"
+  | "meet-audio-choice-required"
+  | "browser-control-unavailable";
+
+type GoogleMeetSpeechBlockedReason =
+  | GoogleMeetManualActionReason
+  | "not-in-call"
+  | "browser-unverified"
+  | "audio-bridge-unavailable";
+
+export type GoogleMeetChromeHealth = {
+  inCall?: boolean;
+  micMuted?: boolean;
+  lobbyWaiting?: boolean;
+  leaveReason?: string;
+  captioning?: boolean;
+  captionsEnabledAttempted?: boolean;
+  transcriptLines?: number;
+  lastCaptionAt?: string;
+  lastCaptionSpeaker?: string;
+  lastCaptionText?: string;
+  recentTranscript?: Array<{
+    at?: string;
+    speaker?: string;
+    text: string;
+  }>;
+  manualActionRequired?: boolean;
+  manualActionReason?: GoogleMeetManualActionReason;
+  manualActionMessage?: string;
+  speechReady?: boolean;
+  speechBlockedReason?: GoogleMeetSpeechBlockedReason;
+  speechBlockedMessage?: string;
+  providerConnected?: boolean;
+  realtimeReady?: boolean;
+  audioInputActive?: boolean;
+  audioOutputActive?: boolean;
+  lastInputAt?: string;
+  lastOutputAt?: string;
+  lastSuppressedInputAt?: string;
+  lastClearAt?: string;
+  lastInputBytes?: number;
+  lastOutputBytes?: number;
+  suppressedInputBytes?: number;
+  consecutiveInputErrors?: number;
+  lastInputError?: string;
+  clearCount?: number;
+  queuedInputChunks?: number;
+  browserUrl?: string;
+  browserTitle?: string;
+  bridgeClosed?: boolean;
+  status?: string;
+  notes?: string[];
+};
+
+export type GoogleMeetSession = {
+  id: string;
+  url: string;
+  transport: GoogleMeetTransport;
+  mode: GoogleMeetMode;
+  state: GoogleMeetSessionState;
+  createdAt: string;
+  updatedAt: string;
+  participantIdentity: string;
+  realtime: {
+    enabled: boolean;
+    provider?: string;
+    model?: string;
+    toolPolicy: string;
+  };
+  chrome?: {
+    audioBackend: "blackhole-2ch";
+    launched: boolean;
+    nodeId?: string;
+    browserProfile?: string;
+    audioBridge?: {
+      type: "command-pair" | "node-command-pair" | "external-command";
+      provider?: string;
+    };
+    health?: GoogleMeetChromeHealth;
+  };
+  twilio?: {
+    dialInNumber: string;
+    pinProvided: boolean;
+    dtmfSequence?: string;
+    voiceCallId?: string;
+    dtmfSent?: boolean;
+    introSent?: boolean;
+  };
+  notes: string[];
+};
+
+export type GoogleMeetJoinResult = {
+  session: GoogleMeetSession;
+  spoken?: boolean;
+};

package/src/voice-call-gateway.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { resolveGoogleMeetConfig } from "./config.js";
+import { joinMeetViaVoiceCallGateway } from "./voice-call-gateway.js";
+
+const gatewayMocks = vi.hoisted(() => ({
+  request: vi.fn(),
+  stopAndWait: vi.fn(async () => {}),
+  startGatewayClientWhenEventLoopReady: vi.fn(async () => ({ ready: true, aborted: false })),
+}));
+
+vi.mock("openclaw/plugin-sdk/gateway-runtime", () => ({
+  GatewayClient: vi.fn(function MockGatewayClient(params: { onHelloOk?: () => void }) {
+    queueMicrotask(() => params.onHelloOk?.());
+    return {
+      request: gatewayMocks.request,
+      stopAndWait: gatewayMocks.stopAndWait,
+    };
+  }),
+  startGatewayClientWhenEventLoopReady: gatewayMocks.startGatewayClientWhenEventLoopReady,
+}));
+
+describe("Google Meet voice-call gateway", () => {
+  beforeEach(() => {
+    gatewayMocks.request.mockReset();
+    gatewayMocks.request.mockResolvedValue({ callId: "call-1" });
+    gatewayMocks.stopAndWait.mockClear();
+    gatewayMocks.startGatewayClientWhenEventLoopReady.mockClear();
+  });
+
+  it("starts Twilio Meet calls with pre-connect DTMF and intro metadata", async () => {
+    const config = resolveGoogleMeetConfig({
+      voiceCall: {
+        gatewayUrl: "ws://127.0.0.1:18789",
+        dtmfDelayMs: 1,
+      },
+      realtime: { introMessage: "Say exactly: I'm here and listening." },
+    });
+
+    await joinMeetViaVoiceCallGateway({
+      config,
+      dialInNumber: "+15551234567",
+      dtmfSequence: "123456#",
+      message: "Say exactly: I'm here and listening.",
+    });
+
+    expect(gatewayMocks.request).toHaveBeenNthCalledWith(
+      1,
+      "voicecall.start",
+      {
+        to: "+15551234567",
+        mode: "conversation",
+        message: "Say exactly: I'm here and listening.",
+        dtmfSequence: "123456#",
+      },
+      { timeoutMs: 30_000 },
+    );
+    expect(gatewayMocks.request).toHaveBeenCalledTimes(1);
+  });
+});

package/src/voice-call-gateway.ts

@@ -0,0 +1,155 @@
+import {
+  GatewayClient,
+  startGatewayClientWhenEventLoopReady,
+} from "openclaw/plugin-sdk/gateway-runtime";
+import type { RuntimeLogger } from "openclaw/plugin-sdk/plugin-runtime";
+import type { GoogleMeetConfig } from "./config.js";
+
+type VoiceCallGatewayClient = InstanceType<typeof GatewayClient>;
+
+type VoiceCallStartResult = {
+  callId?: string;
+  initiated?: boolean;
+  error?: string;
+};
+
+type VoiceCallSpeakResult = {
+  success?: boolean;
+  error?: string;
+};
+
+type VoiceCallMeetJoinResult = {
+  callId: string;
+  dtmfSent: boolean;
+  introSent: boolean;
+};
+
+async function createConnectedGatewayClient(
+  config: GoogleMeetConfig,
+): Promise<VoiceCallGatewayClient> {
+  let client: VoiceCallGatewayClient;
+  await new Promise<void>((resolve, reject) => {
+    const abortStart = new AbortController();
+    const timer = setTimeout(() => {
+      abortStart.abort();
+      reject(new Error("gateway connect timeout"));
+    }, config.voiceCall.requestTimeoutMs);
+    client = new GatewayClient({
+      url: config.voiceCall.gatewayUrl,
+      token: config.voiceCall.token,
+      requestTimeoutMs: config.voiceCall.requestTimeoutMs,
+      clientName: "cli",
+      clientDisplayName: "Google Meet plugin",
+      scopes: ["operator.write"],
+      onHelloOk: () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      onConnectError: (err) => {
+        clearTimeout(timer);
+        abortStart.abort();
+        reject(err);
+      },
+    });
+    void startGatewayClientWhenEventLoopReady(client, {
+      timeoutMs: config.voiceCall.requestTimeoutMs,
+      signal: abortStart.signal,
+    })
+      .then((readiness) => {
+        if (!readiness.ready && !readiness.aborted) {
+          clearTimeout(timer);
+          reject(new Error("gateway event loop readiness timeout"));
+        }
+      })
+      .catch((err) => {
+        clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+  });
+  return client!;
+}
+
+export async function joinMeetViaVoiceCallGateway(params: {
+  config: GoogleMeetConfig;
+  dialInNumber: string;
+  dtmfSequence?: string;
+  logger?: RuntimeLogger;
+  message?: string;
+}): Promise<VoiceCallMeetJoinResult> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    params.logger?.info(
+      `[google-meet] Delegating Twilio join to Voice Call (dtmf=${params.dtmfSequence ? "yes" : "no"}, intro=${params.message ? "yes" : "no"})`,
+    );
+    const start = (await client.request(
+      "voicecall.start",
+      {
+        to: params.dialInNumber,
+        mode: "conversation",
+        ...(params.message ? { message: params.message } : {}),
+        ...(params.dtmfSequence ? { dtmfSequence: params.dtmfSequence } : {}),
+      },
+      { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+    )) as VoiceCallStartResult;
+    if (!start.callId) {
+      throw new Error(start.error || "voicecall.start did not return callId");
+    }
+    params.logger?.info(
+      `[google-meet] Voice Call Twilio join started: callId=${start.callId} dtmf=${params.dtmfSequence ? "yes" : "no"} intro=${params.message ? "yes" : "no"}`,
+    );
+    return {
+      callId: start.callId,
+      dtmfSent: Boolean(params.dtmfSequence),
+      introSent: Boolean(params.message),
+    };
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}
+
+export async function endMeetVoiceCallGatewayCall(params: {
+  config: GoogleMeetConfig;
+  callId: string;
+}): Promise<void> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    await client.request(
+      "voicecall.end",
+      {
+        callId: params.callId,
+      },
+      { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+    );
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}
+
+export async function speakMeetViaVoiceCallGateway(params: {
+  config: GoogleMeetConfig;
+  callId: string;
+  message: string;
+}): Promise<void> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    const spoken = (await client.request(
+      "voicecall.speak",
+      {
+        callId: params.callId,
+        message: params.message,
+      },
+      { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+    )) as VoiceCallSpeakResult;
+    if (spoken.success === false) {
+      throw new Error(spoken.error || "voicecall.speak failed");
+    }
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}