@actagent/google-meet 2026.6.2

package/node-host.test.ts

@@ -0,0 +1,242 @@
+// Google Meet tests cover node host plugin behavior.
+import { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { afterAll, afterEach, beforeAll, 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[] = [];
+let handleGoogleMeetNodeHostCommand: typeof import("./src/node-host.js").handleGoogleMeetNodeHostCommand;
+
+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", () => {
+  beforeAll(async () => {
+    ({ handleGoogleMeetNodeHostCommand } = await import("./src/node-host.js"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    children.length = 0;
+  });
+
+  afterAll(() => {
+    vi.doUnmock("node:child_process");
+    vi.resetModules();
+  });
+
+  it("reports malformed params JSON with an owned error", async () => {
+    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 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 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 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/npm-shrinkwrap.json

@@ -0,0 +1,39 @@
+{
+  "name": "@actagent/google-meet",
+  "version": "2026.6.2",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@actagent/google-meet",
+      "version": "2026.6.2",
+      "dependencies": {
+        "commander": "14.0.3",
+        "typebox": "1.1.39"
+      },
+      "peerDependencies": {
+        "actagent": ">=2026.6.2"
+      },
+      "peerDependenciesMeta": {
+        "actagent": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/commander": {
+      "version": "14.0.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz",
+      "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/typebox": {
+      "version": "1.1.39",
+      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.1.39.tgz",
+      "integrity": "sha512-vj0afVtOfLQvv0GR0VxVagYxsXN64btL7Z9XoaG0ZggH3mruMMkOO6hXdgMsjCY3shZgEvooAWVeznQVs5c43w==",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@actagent/google-meet",
+  "version": "2026.6.2",
+  "description": "ACTAgent Google Meet participant plugin for joining calls through Chrome or Twilio transports.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/actagent/actagent"
+  },
+  "type": "module",
+  "dependencies": {
+    "commander": "14.0.3",
+    "typebox": "1.1.39"
+  },
+  "devDependencies": {
+    "@actagent/plugin-sdk": "workspace:*",
+    "actagent": "workspace:*"
+  },
+  "peerDependencies": {
+    "actagent": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "actagent": {
+      "optional": true
+    }
+  },
+  "actagent": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "npmSpec": "@actagent/google-meet",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.4.20"
+    },
+    "compat": {
+      "pluginApi": ">=2026.6.2"
+    },
+    "build": {
+      "actagentVersion": "2026.6.2"
+    },
+    "release": {
+      "publishToACTAgentHub": true,
+      "publishToNpm": true
+    }
+  }
+}

package/src/agent-consult.ts

@@ -0,0 +1,159 @@
+// Google Meet plugin module implements agent consult behavior.
+import type { ACTAgentConfig } from "actagent/plugin-sdk/config-contracts";
+import { formatErrorMessage } from "actagent/plugin-sdk/error-runtime";
+import type { PluginRuntime, RuntimeLogger } from "actagent/plugin-sdk/plugin-runtime";
+import {
+  buildRealtimeVoiceAgentConsultWorkingResponse,
+  consultRealtimeVoiceAgent,
+  REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
+  resolveRealtimeVoiceAgentConsultTools,
+  resolveRealtimeVoiceAgentConsultToolsAllow,
+  type RealtimeVoiceBridgeSession,
+  type RealtimeVoiceToolCallEvent,
+  type RealtimeVoiceTool,
+  type TalkEventInput,
+} from "actagent/plugin-sdk/realtime-voice";
+import { normalizeAgentId } from "actagent/plugin-sdk/routing";
+import { normalizeOptionalString } from "actagent/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 consultACTAgentAgentForGoogleMeet(params: {
+  config: GoogleMeetConfig;
+  fullConfig: ACTAgentConfig;
+  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: ACTAgentConfig;
+  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 consultACTAgentAgentForGoogleMeet({
+    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: unknown) => {
+      params.onTalkEvent?.({
+        type: "tool.error",
+        callId,
+        payload: { name: params.event.name, error: formatErrorMessage(error) },
+        final: true,
+      });
+      params.session.submitToolResult(callId, {
+        error: formatErrorMessage(error),
+      });
+    });
+}