@kodelyth/google-meet 2026.5.39 → 2026.5.42

package/klaw.plugin.json

@@ -3,24 +3,14 @@
   "name": "Google Meet",
   "description": "Join Google Meet calls through Chrome or Twilio transports.",
   "enabledByDefault": false,
-  "commandAliases": [
-    {
-      "name": "googlemeet"
-    }
-  ],
+  "commandAliases": [{ "name": "googlemeet" }],
   "activation": {
     "onStartup": true,
-    "onCommands": [
-      "googlemeet"
-    ],
-    "onCapabilities": [
-      "tool"
-    ]
+    "onCommands": ["googlemeet"],
+    "onCapabilities": ["tool"]
   },
   "contracts": {
-    "tools": [
-      "google_meet"
-    ]
+    "tools": ["google_meet"]
   },
   "uiHints": {
     "defaults.meeting": {
@@ -251,20 +241,12 @@
       },
       "defaultTransport": {
         "type": "string",
-        "enum": [
-          "chrome",
-          "chrome-node",
-          "twilio"
-        ],
+        "enum": ["chrome", "chrome-node", "twilio"],
         "default": "chrome"
       },
       "defaultMode": {
         "type": "string",
-        "enum": [
-          "agent",
-          "bidi",
-          "transcribe"
-        ],
+        "enum": ["agent", "bidi", "transcribe"],
         "default": "agent"
       },
       "chrome": {
@@ -273,9 +255,7 @@
         "properties": {
           "audioBackend": {
             "type": "string",
-            "enum": [
-              "blackhole-2ch"
-            ],
+            "enum": ["blackhole-2ch"],
             "default": "blackhole-2ch"
           },
           "launch": {
@@ -307,10 +287,7 @@
           },
           "audioFormat": {
             "type": "string",
-            "enum": [
-              "pcm16-24khz",
-              "g711-ulaw-8khz"
-            ],
+            "enum": ["pcm16-24khz", "g711-ulaw-8khz"],
             "default": "pcm16-24khz"
           },
           "audioBufferBytes": {
@@ -464,10 +441,7 @@
         "properties": {
           "strategy": {
             "type": "string",
-            "enum": [
-              "agent",
-              "bidi"
-            ],
+            "enum": ["agent", "bidi"],
             "default": "agent"
           },
           "provider": {
@@ -498,11 +472,7 @@
           },
           "toolPolicy": {
             "type": "string",
-            "enum": [
-              "safe-read-only",
-              "owner",
-              "none"
-            ],
+            "enum": ["safe-read-only", "owner", "none"],
             "default": "safe-read-only"
           },
           "providers": {
@@ -541,9 +511,7 @@
         "properties": {
           "provider": {
             "type": "string",
-            "enum": [
-              "google-oauth"
-            ]
+            "enum": ["google-oauth"]
           },
           "clientId": {
             "type": "string"
@@ -559,8 +527,6 @@
     }
   },
   "configContracts": {
-    "compatibilityMigrationPaths": [
-      "plugins.entries.google-meet.config.realtime.provider"
-    ]
+    "compatibilityMigrationPaths": ["plugins.entries.google-meet.config.realtime.provider"]
   }
 }

package/node-host.test.ts

@@ -0,0 +1,241 @@
+import { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+
+type MockChild = EventEmitter & {
+  exitCode: number | null;
+  signalCode: NodeJS.Signals | null;
+  kill: ReturnType<typeof vi.fn>;
+  stdout?: EventEmitter;
+  stderr?: EventEmitter;
+  stdin?: { write: ReturnType<typeof vi.fn> };
+};
+
+const children: MockChild[] = [];
+
+vi.mock("node:child_process", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:child_process")>();
+  return {
+    ...actual,
+    spawnSync: vi.fn(() => ({
+      status: 0,
+      stdout: "BlackHole 2ch",
+      stderr: "",
+    })),
+    spawn: vi.fn(() => {
+      const child = Object.assign(new EventEmitter(), {
+        exitCode: null,
+        signalCode: null,
+        kill: vi.fn((signal?: NodeJS.Signals) => {
+          child.signalCode = signal ?? "SIGTERM";
+          return true;
+        }),
+        stdout: new EventEmitter(),
+        stderr: new EventEmitter(),
+        stdin: { write: vi.fn() },
+      }) as MockChild;
+      children.push(child);
+      return child;
+    }),
+  };
+});
+
+describe("google-meet node host bridge sessions", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    children.length = 0;
+  });
+
+  afterAll(() => {
+    vi.doUnmock("node:child_process");
+    vi.resetModules();
+  });
+
+  it("reports malformed params JSON with an owned error", async () => {
+    const { handleGoogleMeetNodeHostCommand } = await import("./src/node-host.js");
+
+    await expect(handleGoogleMeetNodeHostCommand("{not json")).rejects.toThrow(
+      "Google Meet node host received malformed params JSON.",
+    );
+  });
+
+  it("starts observe-only Chrome without BlackHole or bridge processes", async () => {
+    const { handleGoogleMeetNodeHostCommand } = await import("./src/node-host.js");
+    const originalPlatform = process.platform;
+    children.length = 0;
+    vi.mocked(spawnSync).mockClear();
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/xyz-abcd-uvw",
+            mode: "transcribe",
+            launch: false,
+            audioInputCommand: ["mock-rec"],
+            audioOutputCommand: ["mock-play"],
+          }),
+        ),
+      );
+
+      expect(start).toEqual({ launched: false });
+      expect(spawnSync).not.toHaveBeenCalled();
+      expect(children).toHaveLength(0);
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+
+  it("clears output playback without closing the active bridge when the old output exits", async () => {
+    const { handleGoogleMeetNodeHostCommand } = await import("./src/node-host.js");
+    const originalPlatform = process.platform;
+    children.length = 0;
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/xyz-abcd-uvw",
+            mode: "realtime",
+            launch: false,
+            audioInputCommand: ["mock-rec"],
+            audioOutputCommand: ["mock-play"],
+          }),
+        ),
+      );
+
+      expect(children).toHaveLength(2);
+      const firstOutput = children[0];
+
+      const cleared = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "clearAudio",
+            bridgeId: start.bridgeId,
+          }),
+        ),
+      );
+
+      expect(cleared).toEqual({ bridgeId: start.bridgeId, ok: true, clearCount: 1 });
+      expect(children).toHaveLength(3);
+      expect(firstOutput?.kill).toHaveBeenCalledWith("SIGTERM");
+
+      firstOutput?.emit("error", new Error("stale output failed after clear"));
+      firstOutput?.emit("exit", 0, "SIGTERM");
+
+      const status = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "status",
+            bridgeId: start.bridgeId,
+          }),
+        ),
+      );
+
+      expect(status.bridge.bridgeId).toBe(start.bridgeId);
+      expect(status.bridge.closed).toBe(false);
+      expect(status.bridge.clearCount).toBe(1);
+      expect(typeof status.bridge.createdAt).toBe("string");
+
+      const audio = Buffer.from([1, 2, 3]);
+      await handleGoogleMeetNodeHostCommand(
+        JSON.stringify({
+          action: "pushAudio",
+          bridgeId: start.bridgeId,
+          base64: audio.toString("base64"),
+        }),
+      );
+
+      expect(children[2]?.stdin?.write).toHaveBeenCalledWith(audio);
+      expect(firstOutput?.stdin?.write).not.toHaveBeenCalled();
+
+      await handleGoogleMeetNodeHostCommand(
+        JSON.stringify({
+          action: "stop",
+          bridgeId: start.bridgeId,
+        }),
+      );
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+
+  it("lists active bridge sessions and hides closed sessions", async () => {
+    const { handleGoogleMeetNodeHostCommand } = await import("./src/node-host.js");
+    const originalPlatform = process.platform;
+    children.length = 0;
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/abc-defg-hij?authuser=1",
+            mode: "realtime",
+            launch: false,
+            audioInputCommand: ["mock-rec"],
+            audioOutputCommand: ["mock-play"],
+          }),
+        ),
+      );
+
+      expect(typeof start.bridgeId).toBe("string");
+      expect(start.bridgeId.length).toBeGreaterThan(0);
+      expect(start).toEqual({
+        audioBridge: { type: "node-command-pair" },
+        bridgeId: start.bridgeId,
+        launched: false,
+      });
+
+      const activeList = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "list",
+            url: "https://meet.google.com/abc-defg-hij",
+            mode: "realtime",
+          }),
+        ),
+      );
+
+      expect(activeList.bridges).toHaveLength(1);
+      expect(activeList.bridges[0]?.bridgeId).toBe(start.bridgeId);
+      expect(activeList.bridges[0]?.closed).toBe(false);
+      expect(activeList.bridges[0]?.mode).toBe("realtime");
+      expect(activeList.bridges[0]?.url).toBe("https://meet.google.com/abc-defg-hij?authuser=1");
+      expect(typeof activeList.bridges[0]?.createdAt).toBe("string");
+
+      children[1]?.emit("exit", 0, null);
+
+      const afterExitList = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "list",
+            url: "https://meet.google.com/abc-defg-hij",
+            mode: "realtime",
+          }),
+        ),
+      );
+
+      expect(afterExitList).toEqual({ bridges: [] });
+
+      const stopped = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "stopByUrl",
+            url: "https://meet.google.com/abc-defg-hij",
+            mode: "realtime",
+          }),
+        ),
+      );
+
+      expect(stopped).toEqual({ ok: true, stopped: 0 });
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodelyth/google-meet",
-  "version": "2026.5.39",
+  "version": "2026.5.42",
   "description": "Klaw Google Meet participant plugin",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   },
   "devDependencies": {
     "@kodelyth/plugin-sdk": "1.0.1",
-    "@kodelyth/klaw": "2026.5.41"
+    "@kodelyth/klaw": "2026.5.42"
   },
   "peerDependencies": {
     "@kodelyth/klaw": ">=2026.5.19"
@@ -25,7 +25,7 @@
   },
   "klaw": {
     "extensions": [
-      "./index.js"
+      "./index.ts"
     ],
     "install": {
       "npmSpec": "@kodelyth/google-meet",

package/src/agent-consult.ts

@@ -0,0 +1,158 @@
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
+import type { PluginRuntime, RuntimeLogger } from "klaw/plugin-sdk/plugin-runtime";
+import {
+  buildRealtimeVoiceAgentConsultWorkingResponse,
+  consultRealtimeVoiceAgent,
+  REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
+  resolveRealtimeVoiceAgentConsultTools,
+  resolveRealtimeVoiceAgentConsultToolsAllow,
+  type RealtimeVoiceBridgeSession,
+  type RealtimeVoiceToolCallEvent,
+  type RealtimeVoiceTool,
+  type TalkEventInput,
+} from "klaw/plugin-sdk/realtime-voice";
+import { normalizeAgentId } from "klaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "klaw/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 consultKlawAgentForGoogleMeet(params: {
+  config: GoogleMeetConfig;
+  fullConfig: KlawConfig;
+  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: KlawConfig;
+  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 consultKlawAgentForGoogleMeet({
+    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),
+      });
+    });
+}