agenticros 0.1.18 → 0.1.19

package/runtime/packages/agenticros-claude-code/src/transport.ts

@@ -1,58 +1,58 @@
-import type { RosTransport } from "@agenticros/core";
-import { createTransport, getTransportConfig } from "@agenticros/core";
-import type { AgenticROSConfig } from "@agenticros/core";
+/**
+ * Transport lifecycle for the AgenticROS MCP server (Claude Code adapter).
+ *
+ * Thin wrapper around `@agenticros/core`'s shared `TransportPool`. The
+ * pool owns the per-robot routing logic — see its docstring for the
+ * full contract. This module just exposes a module-level singleton so
+ * the rest of the adapter doesn't need to thread a pool reference
+ * through every call site.
+ *
+ * Why a module-level singleton: the MCP server is one process. Two
+ * pools would mean two transports — exactly what the pool is designed
+ * to prevent. Tests inject their own pool via `_swapPoolForTests`.
+ */
+
+import type { AgenticROSConfig, ResolvedRobot, RosTransport } from "@agenticros/core";
+import { TransportPool } from "@agenticros/core";
 
-let transport: RosTransport | null = null;
+let pool = new TransportPool();
 
 /**
- * Get the active transport. Throws if not connected.
+ * Async per-robot transport accessor — the path every tool call takes
+ * once it has resolved a target robot. Lazy-connects on first use.
  */
-export function getTransport(): RosTransport {
-  if (!transport) {
-    throw new Error("Transport not initialized. Ensure config is loaded and connect() has been called.");
-  }
-  return transport;
-}
-
-export function getTransportOrNull(): RosTransport | null {
-  return transport;
+export async function getTransportForRobot(
+  config: AgenticROSConfig,
+  robot: ResolvedRobot,
+): Promise<RosTransport> {
+  return pool.acquire(config, robot);
 }
 
-const CONNECT_TIMEOUT_MS = 15_000;
-
 /**
- * Create and connect the transport. Idempotent.
- * Fails after CONNECT_TIMEOUT_MS if Zenoh/router is unreachable.
+ * Pre-warm the active robot's transport at server start. Called from
+ * `index.ts` before the first tool dispatch — keeps the legacy
+ * "connect at startup" UX while routing through the pool internally.
  */
 export async function connect(config: AgenticROSConfig): Promise<void> {
-  if (transport && transport.getStatus() === "connected") {
-    return;
-  }
-  if (transport) {
-    await transport.disconnect();
-    transport = null;
-  }
-  const transportCfg = getTransportConfig(config);
-  const newTransport = await createTransport(transportCfg);
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    setTimeout(
-      () => reject(new Error(
-        `Transport connection timed out after ${CONNECT_TIMEOUT_MS / 1000}s. ` +
-        "Is zenohd running? (e.g. ws://localhost:10000). Check config and MCP log.",
-      )),
-      CONNECT_TIMEOUT_MS,
-    );
-  });
-  await Promise.race([newTransport.connect(), timeoutPromise]);
-  transport = newTransport;
+  await pool.connectActive(config);
 }
 
 /**
- * Disconnect and clear the transport. Call on process exit.
+ * Drain every connection. Called on SIGINT/SIGTERM.
  */
 export async function disconnect(): Promise<void> {
-  if (transport) {
-    await transport.disconnect();
-    transport = null;
-  }
+  await pool.disconnectAll();
+}
+
+/**
+ * For tests only — replace the module singleton with a custom pool
+ * (typically one constructed with a fake factory). Restores via the
+ * returned undo function.
+ */
+export function _swapPoolForTests(replacement: TransportPool): () => void {
+  const previous = pool;
+  pool = replacement;
+  return () => {
+    pool = previous;
+  };
 }

package/runtime/packages/agenticros-gemini/package.json

@@ -10,6 +10,7 @@
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
+    "test": "node --test --test-force-exit \"dist/__tests__/*.test.js\"",
     "smoke-api": "node scripts/smoke-api.mjs",
     "chat": "node dist/index.js"
   },

package/runtime/packages/agenticros-gemini/src/__tests__/mission-cancel.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Phase 1.f — Gemini adapter tests for `mission_cancel` and the
+ * mission_id round-trip from `run_mission`.
+ *
+ * Drives the `executeTool` entry point directly (no network) and
+ * verifies:
+ *   1. `mission_cancel` returns success / found:false on unknown ids
+ *      (idempotent, never errors out — safe to spam from the agent).
+ *   2. `mission_cancel` rejects empty / missing mission_id with
+ *      success:false and a useful error message.
+ *   3. `run_mission` echoes a mission_id in its compact JSON payload
+ *      so a sibling `mission_cancel` call can target it.
+ *   4. `mission_cancel` is in the function-declaration list.
+ *
+ * Mirrors the Claude Code + OpenClaw tests; together they pin the
+ * cross-adapter contract for Phase 1.f.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { executeTool, GEMINI_FUNCTION_DECLARATIONS } from "../tools.js";
+import type { AgenticROSConfig } from "@agenticros/core";
+
+function makeHermeticConfig(): AgenticROSConfig {
+  // Minimal config that satisfies the Zod schema with defaults. We
+  // never reach the transport because mission_cancel + the empty
+  // run_mission paths short-circuit before getTransport(). The
+  // rosbridge mode + port 1 ensures Phase 1.g goal tests fail FAST
+  // (ECONNREFUSED) when a goal compiles to a transport-bound step.
+  return {
+    transport: { mode: "rosbridge" },
+    zenoh: {
+      routerEndpoint: "ws://localhost:10000",
+      domainId: 0,
+      keyFormat: "ros2dds",
+    },
+    rosbridge: { url: "ws://127.0.0.1:1", reconnect: false, reconnectInterval: 3000 },
+    local: { domainId: 0 },
+    webrtc: { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] },
+    robot: { name: "Test", namespace: "test_robot", cameraTopic: "" },
+    safety: {
+      maxLinearVelocity: 1,
+      maxAngularVelocity: 1.5,
+      workspaceLimits: { xMin: -10, xMax: 10, yMin: -10, yMax: 10 },
+    },
+    teleop: {
+      cameraTopic: "",
+      cameraTopics: [],
+      cmdVelTopic: "",
+      speedDefault: 0.3,
+      cameraPollMs: 150,
+    },
+    describer: {
+      enabled: false,
+      url: "http://localhost:11435/v1/chat/completions",
+      model: "qwen2.5vl:7b",
+      maxTokens: 400,
+      timeoutMs: 60000,
+      maxImageDimension: 896,
+    },
+    memory: {
+      enabled: false,
+      backend: "local",
+      local: { storePath: "~/.agenticros/memory.json" },
+      mem0: {
+        inferOnWrite: false,
+        historyDbPath: "~/.agenticros/memory-history.db",
+      },
+    },
+    skills: {},
+    skillPaths: [],
+    skillPackages: [],
+    robots: [],
+  } as unknown as AgenticROSConfig;
+}
+
+test("gemini: GEMINI_FUNCTION_DECLARATIONS includes mission_cancel with required mission_id", () => {
+  const decl = GEMINI_FUNCTION_DECLARATIONS.find((d) => d.name === "mission_cancel");
+  assert.ok(decl, "mission_cancel must be in the function declaration set");
+  const schema = decl!.parametersJsonSchema as {
+    properties?: Record<string, unknown>;
+    required?: string[];
+  };
+  assert.ok(schema?.properties?.["mission_id"], "must advertise 'mission_id'");
+  assert.ok(schema?.properties?.["reason"], "must advertise optional 'reason'");
+  assert.deepEqual(schema?.required, ["mission_id"]);
+});
+
+test("gemini: mission_cancel on unknown id returns success+found:false (no error, idempotent)", async () => {
+  const config = makeHermeticConfig();
+  const result = await executeTool(
+    "mission_cancel",
+    { mission_id: "mn_unknown_xyz" },
+    config,
+  );
+  const payload = JSON.parse(result.output) as {
+    success: boolean;
+    mission_id: string;
+    found: boolean;
+    already_cancelled: boolean;
+    reason: string | null;
+  };
+  assert.equal(payload.success, true);
+  assert.equal(payload.found, false);
+  assert.equal(payload.already_cancelled, false);
+  assert.equal(payload.mission_id, "mn_unknown_xyz");
+  assert.equal(payload.reason, null);
+});
+
+test("gemini: mission_cancel rejects empty mission_id with success:false + useful error", async () => {
+  const config = makeHermeticConfig();
+  const result = await executeTool("mission_cancel", { mission_id: "   " }, config);
+  const payload = JSON.parse(result.output) as { success: boolean; error?: string };
+  assert.equal(payload.success, false);
+  assert.ok(payload.error?.toLowerCase().includes("mission_id"));
+});
+
+test("gemini: run_mission echoes a mission_id so a sibling mission_cancel can target it", async () => {
+  const config = makeHermeticConfig();
+  // Empty steps means we don't dispatch any sub-tool — no transport needed.
+  const result = await executeTool(
+    "run_mission",
+    { mission: { name: "yield mission_id", steps: [] } },
+    config,
+  );
+  // The text payload is "<summary>\n<json>" — pull the JSON line.
+  const lines = result.output.split("\n");
+  const jsonLine = lines.find((l) => l.trim().startsWith("{")) ?? "";
+  const payload = JSON.parse(jsonLine) as {
+    mission_id?: string;
+    status: string;
+    steps: unknown[];
+  };
+  assert.ok(
+    typeof payload.mission_id === "string" && payload.mission_id.startsWith("mn_"),
+    `run_mission compact JSON must include a mission_id; got: ${jsonLine}`,
+  );
+});
+
+// --- Phase 1.g: run_mission { goal } natural-language compile path ---
+
+test("gemini: GEMINI_FUNCTION_DECLARATIONS run_mission advertises both 'mission' AND 'goal' (Phase 1.g)", () => {
+  const decl = GEMINI_FUNCTION_DECLARATIONS.find((d) => d.name === "run_mission");
+  assert.ok(decl);
+  const schema = decl!.parametersJsonSchema as {
+    properties?: Record<string, unknown>;
+    required?: string[];
+  };
+  assert.ok(schema?.properties?.["mission"], "must still accept 'mission'");
+  assert.ok(schema?.properties?.["goal"], "must also accept natural-language 'goal'");
+  assert.ok(schema?.properties?.["robot_id"], "must accept top-level robot_id when goal is used");
+  // Neither field is individually required — the handler enforces
+  // "at least one of mission/goal" at runtime.
+  assert.deepEqual(schema?.required ?? [], []);
+});
+
+test("gemini: run_mission { goal: 'take a picture' } compiles + echoes planner info (Phase 1.g)", async () => {
+  const config = makeHermeticConfig();
+  // The compiled mission step (take_snapshot) WILL try to dispatch
+  // ros2_camera_snapshot which fails fast against the bogus zenoh
+  // endpoint — but the run_mission response still includes the
+  // planner info + mission_id, which is what we assert here.
+  const result = await executeTool("run_mission", { goal: "take a picture" }, config);
+  const lines = result.output.split("\n");
+  const jsonLine = lines.find((l) => l.trim().startsWith("{")) ?? "";
+  const payload = JSON.parse(jsonLine) as {
+    mission_id?: string;
+    planner?: {
+      compiled_from_goal: string;
+      candidates: Array<{ capability_id: string }>;
+    };
+    steps?: Array<{ capability: string }>;
+  };
+  assert.equal(payload.planner?.compiled_from_goal, "take a picture");
+  assert.equal(payload.planner?.candidates[0].capability_id, "take_snapshot");
+  assert.ok(typeof payload.mission_id === "string" && payload.mission_id.startsWith("mn_"));
+});
+
+test("gemini: run_mission { goal: 'paint the wall' } surfaces a clean compile error (Phase 1.g)", async () => {
+  const config = makeHermeticConfig();
+  const result = await executeTool("run_mission", { goal: "paint the wall blue" }, config);
+  const payload = JSON.parse(result.output) as {
+    success: boolean;
+    error?: string;
+    suggestions?: string[];
+  };
+  assert.equal(payload.success, false);
+  assert.ok(payload.error);
+  assert.ok(Array.isArray(payload.suggestions) && payload.suggestions.length > 0);
+});
+
+test("gemini: run_mission with NEITHER mission nor goal returns a clear error (Phase 1.g)", async () => {
+  const config = makeHermeticConfig();
+  const result = await executeTool("run_mission", {}, config);
+  assert.ok(result.output.toLowerCase().includes("mission"));
+  assert.ok(result.output.toLowerCase().includes("goal"));
+});

package/runtime/packages/agenticros-gemini/src/__tests__/mission-transcripts.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Phase 1.f — Gemini adapter test for mission transcripts.
+ *
+ * Pins the end-to-end wiring: when `memory.enabled` is true and we
+ * `executeTool("run_mission", ...)`, every step the runner executes
+ * MUST land in the configured memory provider under the canonical
+ * `mission:<id>` namespace. A second agent (or the same agent
+ * later) can then call `memory_recall({ namespace: "mission:<id>"
+ * })` to read the full timeline.
+ *
+ * The test:
+ *   1. Spins up a hermetic config with the local-JSON memory
+ *      backend pointing at a tmp file.
+ *   2. Runs a mission with one step whose capability isn't in the
+ *      registry — the runner records an "error" step (no transport
+ *      needed) AND emits a transcript entry for it.
+ *   3. Asserts the transcript landed in memory under
+ *      `mission:<id>`, with the expected tags + content.
+ *
+ * Mirrors the cross-adapter contract; the Claude Code and OpenClaw
+ * adapters share the same wiring (see ros2-mission.ts / tools.ts).
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { executeTool } from "../tools.js";
+import { createMemory } from "@agenticros/core";
+import type { AgenticROSConfig } from "@agenticros/core";
+
+function makeMemoryConfig(storePath: string): AgenticROSConfig {
+  return {
+    transport: { mode: "zenoh" },
+    zenoh: {
+      routerEndpoint: "ws://localhost:10000",
+      domainId: 0,
+      keyFormat: "ros2dds",
+    },
+    rosbridge: { url: "ws://localhost:9090", reconnect: true, reconnectInterval: 3000 },
+    local: { domainId: 0 },
+    webrtc: { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] },
+    robot: { name: "Test", namespace: "test_robot", cameraTopic: "" },
+    safety: {
+      maxLinearVelocity: 1,
+      maxAngularVelocity: 1.5,
+      workspaceLimits: { xMin: -10, xMax: 10, yMin: -10, yMax: 10 },
+    },
+    teleop: {
+      cameraTopic: "",
+      cameraTopics: [],
+      cmdVelTopic: "",
+      speedDefault: 0.3,
+      cameraPollMs: 150,
+    },
+    describer: {
+      enabled: false,
+      url: "http://localhost:11435/v1/chat/completions",
+      model: "qwen2.5vl:7b",
+      maxTokens: 400,
+      timeoutMs: 60000,
+      maxImageDimension: 896,
+    },
+    memory: {
+      enabled: true,
+      backend: "local",
+      local: { storePath },
+      mem0: {
+        inferOnWrite: false,
+        historyDbPath: "~/.agenticros/memory-history.db",
+      },
+    },
+    skills: {},
+    skillPaths: [],
+    skillPackages: [],
+    robots: [],
+  } as unknown as AgenticROSConfig;
+}
+
+test("gemini transcripts: run_mission writes per-step transcripts under mission:<id> namespace", async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), "agenticros-gemini-transcripts-"));
+  const storePath = path.join(dir, "memory.json");
+  try {
+    const config = makeMemoryConfig(storePath);
+
+    // Sanity check: the local provider initialises cleanly so we can
+    // attribute any later failure to the adapter wiring rather than
+    // the backend itself.
+    const probe = await createMemory(config);
+    assert.ok(probe, "local memory provider must initialise from hermetic config");
+
+    // Run a mission with one step whose capability isn't in the
+    // registry — the runner emits an "error" step result + transcript
+    // entry for it. No transport / no sub-tool dispatch needed.
+    const result = await executeTool(
+      "run_mission",
+      {
+        mission: {
+          name: "transcript wiring smoke test",
+          steps: [
+            { id: "noop", capability: "this_capability_does_not_exist" },
+          ],
+        },
+      },
+      config,
+    );
+
+    const jsonLine = result.output.split("\n").find((l) => l.trim().startsWith("{")) ?? "";
+    const payload = JSON.parse(jsonLine) as {
+      mission_id?: string;
+      transcript_namespace?: string;
+      steps: Array<{ status: string }>;
+    };
+    assert.ok(payload.mission_id, "run_mission must echo mission_id when memory is enabled");
+    assert.equal(
+      payload.transcript_namespace,
+      `mission:${payload.mission_id}`,
+      "compact result must surface the transcript namespace so the agent can recall",
+    );
+
+    // The transcript sink is fire-and-forget; runMission returns
+    // before the on-disk write necessarily settles. Poll the file
+    // directly (the local backend's atomic-rename guarantees a
+    // self-consistent snapshot once memory.json exists), so we don't
+    // race the writer. Creating a fresh MemoryProvider per poll
+    // sidesteps the per-instance load() cache the local backend
+    // keeps around (it never reloads after the first read).
+    const ns = `mission:${payload.mission_id}`;
+    const deadline = Date.now() + 2000;
+    let recordCount = 0;
+    let reader = null as Awaited<ReturnType<typeof createMemory>>;
+    while (Date.now() < deadline) {
+      reader = await createMemory(config);
+      const status = await reader!.status(ns);
+      recordCount = status.recordCount;
+      if (recordCount >= 1) break;
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    assert.ok(recordCount >= 1, `expected >=1 transcript entry under ${ns}, got ${recordCount}`);
+
+    // Use a meaningful query token (the step id "noop" appears
+    // verbatim inside the serialized transcript JSON) so the
+    // tokenized scorer in the local backend returns hits — not the
+    // hit-everything empty-query path.
+    const hits = await reader!.recall({ query: "noop", namespace: ns, limit: 10 });
+    assert.ok(hits.length >= 1, `recall by content should return >=1 hit, got ${hits.length}`);
+
+    // Every recalled entry should carry the transcript tags so a
+    // future filter-by-tag UI can locate them efficiently.
+    const tagsSeen = new Set<string>();
+    for (const h of hits) {
+      for (const t of h.tags ?? []) tagsSeen.add(t);
+    }
+    assert.ok(tagsSeen.has("mission_transcript"), `tags should include 'mission_transcript'; got: ${[...tagsSeen].join(", ")}`);
+
+    // And the content should be JSON-parseable, carrying the
+    // mission_id back out the other side (round-trip). The sink
+    // packs the per-step snapshot under `step` (not `result`) — see
+    // packages/core/src/mission-transcript-sink.ts.
+    const firstContent = JSON.parse(hits[0].content) as {
+      mission_id: string;
+      adapter?: string;
+      step: { id: string; status: string; capability: string };
+    };
+    assert.equal(firstContent.mission_id, payload.mission_id);
+    assert.equal(firstContent.adapter, "gemini", "transcript should record the originating adapter");
+    assert.equal(firstContent.step.id, "noop");
+    assert.equal(firstContent.step.status, "error");
+    assert.equal(firstContent.step.capability, "this_capability_does_not_exist");
+  } finally {
+    // The transcript sink writes are fire-and-forget — give any
+    // still-in-flight atomic rename (tmp → final) a moment to settle
+    // before we rmdir, otherwise ENOTEMPTY trips the cleanup.
+    await new Promise((r) => setTimeout(r, 250));
+    await rm(dir, { recursive: true, force: true });
+  }
+});