agenticros 0.1.18 → 0.2.0

package/runtime/packages/agenticros/src/service.ts

@@ -1,6 +1,11 @@
 import type { TransportConfig } from "@agenticros/core";
-import type { RosTransport } from "@agenticros/core";
-import { createTransport, getTransportConfig } from "@agenticros/core";
+import type { RosTransport, ResolvedRobot } from "@agenticros/core";
+import {
+  createTransport,
+  getTransportConfig,
+  getTransportConfigForRobot,
+  hasRobotTransportOverride,
+} from "@agenticros/core";
 import type { OpenClawPluginApi } from "./plugin-api.js";
 import type { PluginLogger } from "./plugin-api.js";
 import type { AgenticROSConfig } from "@agenticros/core";
@@ -238,6 +243,112 @@ async function ensureTransportConnected(
   await next;
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase 1.d-pool: per-robot transport override pool.
+//
+// The existing `transport` singleton above (with eager-retry / preflight /
+// poll-reconnect) stays the source of truth for every robot WITHOUT a
+// per-robot `transport` override in config. That's the common case and
+// the plugin's hard-won robustness lives in that singleton.
+//
+// For robots that DO declare an override we maintain a smaller, lazier
+// pool here. Override entries don't (yet) get the eager-connect /
+// preflight / polling treatment — they connect on first tool call, fail
+// loudly to the agent on connect timeout, and self-heal on the next
+// acquire. That's intentional: most fleets have one or two override
+// robots and the agent-facing error path is sufficient feedback.
+//
+// Pool key: `robot.id` (validated by `hasRobotTransportOverride`).
+// ─────────────────────────────────────────────────────────────────────────────
+
+const overrideTransports = new Map<string, RosTransport>();
+const overrideInFlight = new Map<string, Promise<RosTransport>>();
+const OVERRIDE_CONNECT_TIMEOUT_MS = 15_000;
+
+/**
+ * Return the right transport for `robot`. Per-robot tools call this
+ * INSTEAD of `getTransport()` so a robot with a custom transport gets
+ * its own connection. Robots without an override fall through to the
+ * service-managed singleton with all its retry / preflight machinery.
+ *
+ * Throws when the singleton is requested but the service hasn't
+ * connected yet — same contract as `getTransport()`.
+ *
+ * Throws (or surfaces as a tool error after the timeout) when an
+ * override entry can't connect — the agent sees a clean failure and
+ * can fall back to a different robot id.
+ */
+export async function getTransportForRobot(
+  config: AgenticROSConfig,
+  robot: ResolvedRobot,
+): Promise<RosTransport> {
+  if (!hasRobotTransportOverride(config, robot.id)) {
+    // Fast path: no override → reuse the service-managed singleton
+    // (with its retries and preflight). Same as the pre-pool behaviour.
+    return getTransport();
+  }
+  return acquireOverrideTransport(config, robot);
+}
+
+async function acquireOverrideTransport(
+  config: AgenticROSConfig,
+  robot: ResolvedRobot,
+): Promise<RosTransport> {
+  const cached = overrideTransports.get(robot.id);
+  if (cached && cached.getStatus() === "connected") return cached;
+
+  // Concurrent first-acquires share one connect promise so two near-
+  // simultaneous tool calls don't double-open the same Zenoh socket.
+  const flight = overrideInFlight.get(robot.id);
+  if (flight) return flight;
+
+  if (cached) {
+    // Stale entry — drop cleanly so a fresh build can proceed.
+    overrideTransports.delete(robot.id);
+    cached.disconnect().catch(() => {});
+  }
+
+  const connectFlight = (async (): Promise<RosTransport> => {
+    const transportCfg = buildTransportConfig(getTransportConfigForRobot(config, robot.id));
+    const t = await createTransport(transportCfg);
+    await connectWithTimeout(t, OVERRIDE_CONNECT_TIMEOUT_MS);
+    overrideTransports.set(robot.id, t);
+    return t;
+  })();
+  overrideInFlight.set(robot.id, connectFlight);
+  try {
+    return await connectFlight;
+  } finally {
+    overrideInFlight.delete(robot.id);
+  }
+}
+
+async function connectWithTimeout(t: RosTransport, timeoutMs: number): Promise<void> {
+  const timeout = new Promise<never>((_, reject) => {
+    setTimeout(
+      () =>
+        reject(
+          new Error(
+            `Per-robot transport connect timed out after ${timeoutMs / 1000}s. ` +
+              "Check the robot's transport override in config (router endpoint, mode).",
+          ),
+        ),
+      timeoutMs,
+    );
+  });
+  await Promise.race([t.connect(), timeout]);
+}
+
+async function drainOverridePool(): Promise<void> {
+  const pending: Promise<unknown>[] = [];
+  for (const t of overrideTransports.values()) {
+    pending.push(t.disconnect().catch(() => {}));
+  }
+  overrideTransports.clear();
+  overrideInFlight.clear();
+  await Promise.all(pending);
+}
+
 const RETRY_INTERVAL_MS = 10000;
 const DISCONNECTED_POLL_MS = 15000;
 
@@ -283,6 +394,13 @@ export function registerService(api: OpenClawPluginApi, config: AgenticROSConfig
         currentMode = null;
         api.logger.info("ROS2 transport disconnected");
       }
+      // Drain any per-robot override connections too — otherwise they'd
+      // leak open Zenoh sockets across plugin reloads.
+      const overrideCount = overrideTransports.size;
+      if (overrideCount > 0) {
+        await drainOverridePool();
+        api.logger.info(`Disconnected ${overrideCount} per-robot override transport(s)`);
+      }
     },
   });
 

package/runtime/packages/agenticros/src/skill-loader.ts

@@ -20,8 +20,8 @@
 
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
-import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
 import type { OpenClawPluginApi } from "./plugin-api.js";
 import type { AgenticROSConfig } from "@agenticros/core";
 import type { RegisterSkill, SkillContext } from "./skill-api.js";
@@ -41,12 +41,40 @@ export function getLoadedSkillIds(): string[] {
   return [...loadedSkillIds];
 }
 
-function deriveSkillId(packageName: string): string {
-  const lower = packageName.toLowerCase();
-  if (lower.startsWith("agenticros-skill-")) {
-    return lower.slice("agenticros-skill-".length);
+/**
+ * Read the `agenticros` block from a skill's package.json. The block is now
+ * the single source of truth for the skill id, display name, and capability
+ * manifest. The legacy `agenticrosSkill: true | { capabilities }` form is
+ * NOT supported — every skill must declare a fully-formed `agenticros` block.
+ */
+interface AgenticROSBlock {
+  id: string;
+  displayName?: string;
+  description?: string;
+  categories?: string[];
+  screenshots?: string[];
+  demoVideoUrl?: string;
+  capabilities?: unknown[];
+}
+
+interface SkillManifest {
+  name?: string;
+  main?: string;
+  agenticros?: AgenticROSBlock;
+}
+
+function readSkillManifest(pkgJsonPath: string): SkillManifest | null {
+  try {
+    return JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as SkillManifest;
+  } catch {
+    return null;
   }
-  return lower.replace(/^@[^/]+\//, "").replace(/[^a-z0-9]/g, "");
+}
+
+function isValidBlock(block: unknown): block is AgenticROSBlock {
+  if (!block || typeof block !== "object") return false;
+  const b = block as { id?: unknown };
+  return typeof b.id === "string" && /^[a-z0-9][a-z0-9-]*$/.test(b.id);
 }
 
 /**
@@ -56,7 +84,7 @@ function deriveSkillId(packageName: string): string {
  * — including any `api.registerTool(...)` the skill makes — completes before
  * we return, and therefore before the OpenClaw host snapshots `captured.tools`.
  *
- * Returns the derived skill id on success, or `null` (with a logged warning /
+ * Returns the declared skill id on success, or `null` (with a logged warning /
  * error) on any failure mode: missing export, top-level await (which surfaces
  * as `ERR_REQUIRE_ASYNC_MODULE`), or thrown initialization error.
  */
@@ -66,8 +94,8 @@ function loadSkillModuleSync(
   context: SkillContext,
   entryPath: string,
   packageName: string,
+  skillId: string,
 ): string | null {
-  const skillId = deriveSkillId(packageName);
   let mod: unknown;
   try {
     mod = require(entryPath);
@@ -110,36 +138,80 @@ function loadSkillModuleSync(
   }
 }
 
+interface ResolvedSkill {
+  entry: string;
+  packageName: string;
+  skillId: string;
+}
+
 /**
- * Resolve a package name to its main entry path (Node resolution).
+ * Resolve an npm package name to a `ResolvedSkill` (entry + name + skill id).
+ * Reads the package's package.json to extract `pkg.agenticros.id`; refuses
+ * to register the skill if the block is missing or malformed.
  */
-function resolvePackageEntry(packageName: string): string | null {
+function resolveSkillByPackage(
+  api: OpenClawPluginApi,
+  packageName: string,
+): ResolvedSkill | null {
+  let entry: string;
   try {
-    const pkgPath = require.resolve(packageName, { paths: [process.cwd()] });
-    return pkgPath;
+    entry = require.resolve(packageName, { paths: [process.cwd()] });
   } catch {
+    api.logger.warn(`Skill package not found: ${packageName}`);
+    return null;
+  }
+  // Walk up from the resolved entry to find the package.json.
+  const pkgJsonPath = findPackageJsonForEntry(entry);
+  if (!pkgJsonPath) {
+    api.logger.warn(`Skill ${packageName}: cannot locate package.json next to ${entry}`);
+    return null;
+  }
+  const manifest = readSkillManifest(pkgJsonPath);
+  if (!manifest || !isValidBlock(manifest.agenticros)) {
+    api.logger.warn(
+      `Skill ${packageName}: missing or invalid \`agenticros\` block in package.json. ` +
+        "Declare an `agenticros.id` (kebab-case) to register as a skill.",
+    );
     return null;
   }
+  return {
+    entry,
+    packageName: manifest.name ?? packageName,
+    skillId: manifest.agenticros!.id,
+  };
+}
+
+/** Walk up from `entry` (a file inside the package) to find its package.json. */
+function findPackageJsonForEntry(entry: string): string | null {
+  let dir = dirname(entry);
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
 }
 
 /**
- * Scan a directory for package.json with "agenticrosSkill": true and return entry path.
+ * Scan a directory for a package.json with a valid `agenticros` block and
+ * return its entry path + declared id.
  */
-function findSkillInPath(dirPath: string): { entry: string; packageName: string } | null {
+function findSkillInPath(dirPath: string): ResolvedSkill | null {
   if (!existsSync(dirPath)) return null;
   const pkgPath = join(dirPath, "package.json");
   if (!existsSync(pkgPath)) return null;
-  let pkg: { agenticrosSkill?: boolean; main?: string; name?: string };
-  try {
-    pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-  } catch {
-    return null;
-  }
-  if (!pkg.agenticrosSkill) return null;
+  const pkg = readSkillManifest(pkgPath);
+  if (!pkg || !isValidBlock(pkg.agenticros)) return null;
   const main = pkg.main ?? "index.js";
   const entry = join(dirPath, main);
   if (!existsSync(entry)) return null;
-  return { entry, packageName: pkg.name ?? "unknown" };
+  return {
+    entry,
+    packageName: pkg.name ?? "unknown",
+    skillId: pkg.agenticros!.id,
+  };
 }
 
 /**
@@ -166,19 +238,25 @@ export function loadSkills(
   loadedSkillIds.length = 0;
 
   for (const pkgName of packages) {
-    const entryPath = resolvePackageEntry(pkgName);
-    if (!entryPath) {
-      api.logger.warn(`Skill package not found: ${pkgName}`);
-      continue;
-    }
-    const skillId = loadSkillModuleSync(api, config, context, entryPath, pkgName);
+    const resolved = resolveSkillByPackage(api, pkgName);
+    if (!resolved) continue;
+    const skillId = loadSkillModuleSync(
+      api,
+      config,
+      context,
+      resolved.entry,
+      resolved.packageName,
+      resolved.skillId,
+    );
     if (skillId) loadedSkillIds.push(skillId);
   }
 
   for (const dir of paths) {
     const resolved = findSkillInPath(dir);
     if (!resolved) {
-      api.logger.warn(`No agenticros skill in path: ${dir}`);
+      api.logger.warn(
+        `No agenticros skill in path: ${dir} (missing \`agenticros\` block in package.json).`,
+      );
       continue;
     }
     const skillId = loadSkillModuleSync(
@@ -187,6 +265,7 @@ export function loadSkills(
       context,
       resolved.entry,
       resolved.packageName,
+      resolved.skillId,
     );
     if (skillId && !loadedSkillIds.includes(skillId)) loadedSkillIds.push(skillId);
   }

package/runtime/packages/agenticros/src/tools/_robot-helpers.ts

@@ -0,0 +1,68 @@
+/**
+ * Phase 1.d helper — shared by every OpenClaw ROS2 tool that accepts an
+ * optional `robot_id` parameter. Keeping it in one place means the
+ * schema definition and resolution error format stay consistent across
+ * tools and match the claude-code adapter.
+ *
+ * Usage in a tool's parameters:
+ *
+ *     parameters: Type.Object({
+ *       topic: Type.String({ description: "..." }),
+ *       ...ROBOT_ID_SCHEMA,
+ *     })
+ *
+ * Usage in execute():
+ *
+ *     const resolved = resolveRobotForTool(config, params);
+ *     if ("error" in resolved) return resolved.error;
+ *     const ns = resolved.robot.namespace;
+ */
+
+import { Type } from "@sinclair/typebox";
+import { resolveRobotFromArgs, type ResolvedRobot } from "@agenticros/core";
+import type { AgenticROSConfig } from "@agenticros/core";
+
+/**
+ * TypeBox schema fragment — spread into a tool's parameters object to
+ * advertise an optional `robot_id` argument.
+ */
+export const ROBOT_ID_SCHEMA = {
+  robot_id: Type.Optional(
+    Type.String({
+      description:
+        "Optional robot id (from ros2_list_robots) to scope this call. When omitted, the active robot is used.",
+    }),
+  ),
+};
+
+/**
+ * Try to resolve the target robot from the tool's params. On success
+ * returns `{ robot }`. On unknown-id failure returns `{ error }` —
+ * already shaped as an OpenClaw tool response (content + details) so
+ * the caller can `return resolved.error` directly. The error text comes
+ * from `@agenticros/core/resolveRobot` and already lists known ids +
+ * recommends ros2_list_robots, so the agent can self-correct.
+ */
+export function resolveRobotForTool(
+  config: AgenticROSConfig,
+  params: Record<string, unknown>,
+):
+  | { robot: ResolvedRobot }
+  | {
+      error: {
+        content: Array<{ type: "text"; text: string }>;
+        details: { success: false; error: string };
+      };
+    } {
+  try {
+    return { robot: resolveRobotFromArgs(config, params) };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      error: {
+        content: [{ type: "text", text: msg }],
+        details: { success: false, error: msg },
+      },
+    };
+  }
+}

package/runtime/packages/agenticros/src/tools/index.ts

@@ -1,4 +1,4 @@
-import type { OpenClawPluginApi } from "../plugin-api.js";
+import type { AgentTool, OpenClawPluginApi } from "../plugin-api.js";
 import type { AgenticROSConfig } from "@agenticros/core";
 import { registerPublishTool } from "./ros2-publish.js";
 import { registerSubscribeTool } from "./ros2-subscribe.js";
@@ -8,6 +8,39 @@ import { registerParamTools } from "./ros2-param.js";
 import { registerIntrospectTool } from "./ros2-introspect.js";
 import { registerCameraTool } from "./ros2-camera.js";
 import { registerDepthDistanceTool } from "./ros2-depth-distance.js";
+import { registerCapabilitiesTool } from "./ros2-capabilities.js";
+import { registerRobotsTool } from "./ros2-robots.js";
+import { registerDiscoverRobotsTool } from "./ros2-discover.js";
+import { registerFindRobotsForTool } from "./ros2-find-robots-for.js";
+import { registerMissionTool, type ToolRegistry } from "./ros2-mission.js";
+import { registerMissionCancelTool } from "./mission-cancel.js";
+
+/**
+ * Wrap the OpenClaw API so every registerTool() call is also recorded in
+ * a local tool registry. The mission runner uses the registry to
+ * dispatch sub-tool calls by name (e.g. capability "drive_base" routes
+ * to the registered "ros2_publish" tool's execute()).
+ *
+ * We keep this internal — skills that register their own tools via
+ * `api.registerTool` won't appear in the registry, which is fine for
+ * v1: today the mission runner only supports the eight intrinsic
+ * capability bindings declared in ros2-mission.ts. Phase 1.d will
+ * extend this to capture skill-declared tools as well.
+ */
+function wrapApiWithToolCapture(api: OpenClawPluginApi): {
+  wrappedApi: OpenClawPluginApi;
+  registry: ToolRegistry;
+} {
+  const registry: ToolRegistry = new Map();
+  const wrappedApi: OpenClawPluginApi = {
+    ...api,
+    registerTool: (tool: AgentTool, opts) => {
+      registry.set(tool.name, tool);
+      api.registerTool(tool, opts);
+    },
+  };
+  return { wrappedApi, registry };
+}
 
 /**
  * Register core ROS2 tools with the OpenClaw AI agent.
@@ -15,12 +48,19 @@ import { registerDepthDistanceTool } from "./ros2-depth-distance.js";
  * Memory tools register asynchronously from index.ts after initMemory resolves.
  */
 export function registerTools(api: OpenClawPluginApi, config: AgenticROSConfig): void {
-  registerPublishTool(api, config);
-  registerSubscribeTool(api, config);
-  registerServiceTool(api, config);
-  registerActionTool(api, config);
-  registerParamTools(api, config);
-  registerIntrospectTool(api);
-  registerCameraTool(api, config);
-  registerDepthDistanceTool(api, config);
+  const { wrappedApi, registry } = wrapApiWithToolCapture(api);
+  registerPublishTool(wrappedApi, config);
+  registerSubscribeTool(wrappedApi, config);
+  registerServiceTool(wrappedApi, config);
+  registerActionTool(wrappedApi, config);
+  registerParamTools(wrappedApi, config);
+  registerIntrospectTool(wrappedApi);
+  registerCameraTool(wrappedApi, config);
+  registerDepthDistanceTool(wrappedApi, config);
+  registerCapabilitiesTool(wrappedApi, config);
+  registerRobotsTool(wrappedApi, config);
+  registerDiscoverRobotsTool(wrappedApi, config);
+  registerFindRobotsForTool(wrappedApi, config);
+  registerMissionTool(wrappedApi, config, registry);
+  registerMissionCancelTool(wrappedApi);
 }

package/runtime/packages/agenticros/src/tools/mission-cancel.ts

@@ -0,0 +1,70 @@
+/**
+ * Tool: mission_cancel — Phase 1.f of the AgenticROS strategy.
+ *
+ * Cancel a mission that's currently running in this OpenClaw plugin
+ * process. Pass the `mission_id` returned by `run_mission`. The mission
+ * runner stops at the next step boundary (the in-flight step finishes
+ * naturally — per-tool preemption is out of scope for Phase 1.f),
+ * marks remaining steps as "cancelled", and returns a result with
+ * `status: "cancelled"`.
+ *
+ * Idempotent / safe-by-default:
+ *  - Unknown mission_id → `found: false`, never an error
+ *  - Calling twice on the same id → second call returns
+ *    `already_cancelled: true` and is otherwise a no-op
+ *  - No transport required — this only mutates an in-process
+ *    `MissionRegistry`
+ *
+ * Mirrored across all three adapters (Claude Code, OpenClaw, Gemini)
+ * with identical request/response shapes — see
+ * `packages/agenticros-claude-code/src/tools.ts` for the canonical one.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "../plugin-api.js";
+import { getMissionRegistry } from "../mission-registry.js";
+
+export function registerMissionCancelTool(api: OpenClawPluginApi): void {
+  api.registerTool({
+    name: "mission_cancel",
+    label: "Cancel Mission",
+    description:
+      "Cancel a mission that's currently running in this OpenClaw plugin process. " +
+      "Pass the mission_id returned by run_mission. The mission runner stops at the next " +
+      "step boundary (the in-flight step finishes naturally), marks remaining steps as " +
+      "'cancelled', and returns. If the mission has already finished (or the id is unknown), " +
+      "this is a no-op that returns found=false. Optional 'reason' is recorded in the " +
+      "cancelled step results for traceability.",
+    parameters: Type.Object({
+      mission_id: Type.String({
+        description: "The mission_id echoed by run_mission. Required.",
+      }),
+      reason: Type.Optional(
+        Type.String({
+          description: "Optional free-text reason — surfaced in the cancelled mission result.",
+        }),
+      ),
+    }),
+
+    async execute(_toolCallId, params) {
+      const missionId = typeof params["mission_id"] === "string" ? (params["mission_id"] as string).trim() : "";
+      if (!missionId) {
+        const text = "mission_cancel requires 'mission_id' (a non-empty string returned by run_mission).";
+        return { content: [{ type: "text", text }], details: { success: false, error: text } };
+      }
+      const reason = typeof params["reason"] === "string" ? (params["reason"] as string) : undefined;
+      const outcome = getMissionRegistry().cancel(missionId, reason);
+      const details = {
+        success: true,
+        mission_id: missionId,
+        found: outcome.found,
+        already_cancelled: outcome.alreadyCancelled,
+        reason: reason ?? null,
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(details) }],
+        details,
+      };
+    },
+  });
+}

package/runtime/packages/agenticros/src/tools/ros2-action.ts

@@ -2,7 +2,8 @@ import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "../plugin-api.js";
 import type { AgenticROSConfig } from "@agenticros/core";
 import { toNamespacedTopic } from "@agenticros/core";
-import { getTransport } from "../service.js";
+import { getTransportForRobot } from "../service.js";
+import { ROBOT_ID_SCHEMA, resolveRobotForTool } from "./_robot-helpers.js";
 
 /**
  * Register the ros2_action_goal tool with the AI agent.
@@ -14,22 +15,28 @@ export function registerActionTool(api: OpenClawPluginApi, config: AgenticROSCon
     label: "ROS2 Action Goal",
     description:
       "Send a goal to a ROS2 action server and stream feedback. " +
-      "Use this for long-running operations like navigation or arm movements.",
+      "Use this for long-running operations like navigation or arm movements. " +
+      "Pass robot_id (from ros2_list_robots) to target a specific robot.",
     parameters: Type.Object({
       action: Type.String({ description: "The ROS2 action server name (e.g., '/navigate_to_pose')" }),
       actionType: Type.String({ description: "The ROS2 action type (e.g., 'nav2_msgs/action/NavigateToPose')" }),
       goal: Type.Record(Type.String(), Type.Unknown(), {
         description: "The action goal parameters",
       }),
+      ...ROBOT_ID_SCHEMA,
     }),
 
     async execute(_toolCallId, params) {
+      const resolved = resolveRobotForTool(config, params);
+      if ("error" in resolved) return resolved.error;
+      const { robot } = resolved;
+
       const rawAction = params["action"] as string;
-      const action = toNamespacedTopic(config, rawAction);
+      const action = toNamespacedTopic(robot.namespace, rawAction);
       const actionType = params["actionType"] as string;
       const goal = params["goal"] as Record<string, unknown>;
 
-      const transport = getTransport();
+      const transport = await getTransportForRobot(config, robot);
       const actionResult = await transport.sendActionGoal({
         action,
         actionType,

package/runtime/packages/agenticros/src/tools/ros2-camera.ts

@@ -9,11 +9,12 @@ import {
   mimeTypeForSnapshotBase64,
   rosNumericField,
 } from "@agenticros/ros-camera";
-import { getTransport } from "../service.js";
+import { getTransportForRobot } from "../service.js";
 import { normalizePluginToolImageBase64 } from "../plugin-image-base64.js";
 import { trimJpegToLastEoi } from "../image-binary-trim.js";
 import { storeCameraSnapshot } from "../camera-snapshot-cache.js";
 import { describeImageBestEffort } from "../describer.js";
+import { ROBOT_ID_SCHEMA, resolveRobotForTool } from "./_robot-helpers.js";
 
 /** Known camera topic patterns for common setups (e.g. RealSense). */
 export const REALSENSE_CAMERA_TOPICS = {
@@ -64,20 +65,25 @@ export function registerCameraTool(api: OpenClawPluginApi, config: AgenticROSCon
         ),
       ),
       timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds (default: 10000)" })),
+      ...ROBOT_ID_SCHEMA,
     }),
 
     async execute(_toolCallId, params) {
+      const resolved = resolveRobotForTool(config, params);
+      if ("error" in resolved) return resolved.error;
+      const { robot } = resolved;
+
       const defaultTopic =
-        (config.robot?.cameraTopic ?? "").trim() || "/camera/camera/color/image_raw/compressed";
+        (robot.cameraTopic ?? "").trim() || "/camera/camera/color/image_raw/compressed";
       const rawTopic = (params["topic"] as string | undefined) ?? defaultTopic;
-      const topic = resolveCameraSubscribeTopic(config, rawTopic);
+      const topic = resolveCameraSubscribeTopic(robot.namespace, rawTopic);
       const rawMsgType = params["message_type"] as string | undefined;
       const messageType: "CompressedImage" | "Image" =
         rawMsgType === "Image" ? "Image" : "CompressedImage";
       const timeout = (params["timeout"] as number | undefined) ?? 10000;
 
       try {
-        const transport = getTransport();
+        const transport = await getTransportForRobot(config, robot);
         const typeSel = messageType === "Image" ? ROS_MSG_IMAGE : ROS_MSG_COMPRESSED_IMAGE;
 
         const result = await new Promise<{