agenticros 0.0.1 → 0.1.1

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

@@ -0,0 +1,50 @@
+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";
+
+/**
+ * Register the ros2_action_goal tool with the AI agent.
+ * Sends action goals with progress feedback streaming.
+ */
+export function registerActionTool(api: OpenClawPluginApi, config: AgenticROSConfig): void {
+  api.registerTool({
+    name: "ros2_action_goal",
+    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.",
+    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",
+      }),
+    }),
+
+    async execute(_toolCallId, params) {
+      const rawAction = params["action"] as string;
+      const action = toNamespacedTopic(config, rawAction);
+      const actionType = params["actionType"] as string;
+      const goal = params["goal"] as Record<string, unknown>;
+
+      const transport = getTransport();
+      const actionResult = await transport.sendActionGoal({
+        action,
+        actionType,
+        args: goal,
+      });
+
+      const result = {
+        success: actionResult.result,
+        action,
+        result: actionResult.values,
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        details: result,
+      };
+    },
+  });
+}

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

@@ -0,0 +1,221 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "../plugin-api.js";
+import type { AgenticROSConfig } from "@agenticros/core";
+import { resolveCameraSubscribeTopic } from "@agenticros/core";
+import {
+  ROS_MSG_COMPRESSED_IMAGE,
+  ROS_MSG_IMAGE,
+  cameraSnapshotFromPlainMessage,
+  mimeTypeForSnapshotBase64,
+  rosNumericField,
+} from "@agenticros/ros-camera";
+import { getTransport } 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";
+
+/** Known camera topic patterns for common setups (e.g. RealSense). */
+export const REALSENSE_CAMERA_TOPICS = {
+  color_compressed: "/camera/camera/color/image_raw/compressed",
+  color_raw: "/camera/camera/color/image_raw",
+  depth_raw: "/camera/camera/depth/image_rect_raw",
+  aligned_depth: "/camera/camera/aligned_depth_to_color/image_raw",
+} as const;
+
+/**
+ * Register the ros2_camera_snapshot tool with the AI agent.
+ * Grabs a single frame from a ROS2 camera topic.
+ * Supports CompressedImage (default) and raw Image (e.g. RealSense color/depth).
+ */
+export function registerCameraTool(api: OpenClawPluginApi, config: AgenticROSConfig): void {
+  const describerEnabled = config.describer?.enabled === true;
+  const baseDescription =
+    "Capture a single image from a ROS2 camera topic. Returns a structured image block for the chat UI (plus a short text summary). " +
+    "Use when the user asks what the robot sees or requests a photo. " +
+    "Do not paste raw base64 or data: URLs in your reply—describe the scene from the image you receive. " +
+    "The tool also embeds an HTTP snapshot link in the text (same kind of URL as teleop) for the chat UI. " +
+    "Supports sensor_msgs/CompressedImage (e.g. /camera/image_raw/compressed, optional zstd) and sensor_msgs/Image (raw encodings are encoded to PNG).";
+  const describerHint =
+    " A `Vision description:` section is appended automatically to the result text when a vision describer is configured; " +
+    "treat that paragraph as the authoritative description of what the camera sees and quote/paraphrase it in your reply.";
+
+  api.registerTool({
+    name: "ros2_camera_snapshot",
+    label: "ROS2 Camera Snapshot",
+    description: describerEnabled ? baseDescription + describerHint : baseDescription,
+    parameters: Type.Object({
+      topic: Type.Optional(
+        Type.String({
+          description:
+            "Camera image topic. Examples: '/camera/image_raw/compressed', RealSense color '/camera/camera/color/image_raw', RealSense depth '/camera/camera/depth/image_rect_raw'. Default: '/camera/image_raw/compressed'.",
+        }),
+      ),
+      message_type: Type.Optional(
+        Type.Union(
+          [
+            Type.Literal("CompressedImage"),
+            Type.Literal("Image"),
+          ],
+          {
+            description:
+              "Message type: 'CompressedImage' for JPEG/PNG topics (default), 'Image' for raw sensor_msgs/Image (e.g. RealSense color/depth).",
+          },
+        ),
+      ),
+      timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds (default: 10000)" })),
+    }),
+
+    async execute(_toolCallId, params) {
+      const defaultTopic =
+        (config.robot?.cameraTopic ?? "").trim() || "/camera/camera/color/image_raw/compressed";
+      const rawTopic = (params["topic"] as string | undefined) ?? defaultTopic;
+      const topic = resolveCameraSubscribeTopic(config, 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 typeSel = messageType === "Image" ? ROS_MSG_IMAGE : ROS_MSG_COMPRESSED_IMAGE;
+
+        const result = await new Promise<{
+          success: boolean;
+          topic: string;
+          format: string;
+          data: string;
+          width?: unknown;
+          height?: unknown;
+        }>((resolve, reject) => {
+          let subscription: { unsubscribe: () => void };
+          let timer: ReturnType<typeof setTimeout>;
+          try {
+            subscription = transport.subscribe({ topic, type: typeSel }, (msg: Record<string, unknown>) => {
+              try {
+                clearTimeout(timer);
+                subscription.unsubscribe();
+                const payload = cameraSnapshotFromPlainMessage(messageType, msg);
+                resolve({
+                  success: true,
+                  topic,
+                  format: payload.formatLabel,
+                  data: payload.dataBase64,
+                  width: payload.width,
+                  height: payload.height,
+                });
+              } catch (err) {
+                clearTimeout(timer);
+                try {
+                  subscription.unsubscribe();
+                } catch {
+                  // ignore
+                }
+                reject(err instanceof Error ? err : new Error(String(err)));
+              }
+            });
+          } catch (err) {
+            reject(err instanceof Error ? err : new Error(String(err)));
+            return;
+          }
+          timer = setTimeout(() => {
+            try {
+              subscription.unsubscribe();
+            } catch {
+              // ignore
+            }
+            reject(new Error(`Timeout waiting for camera frame on ${topic}`));
+          }, timeout);
+        });
+
+        const rawB64 = (result.data as string) ?? "";
+        let base64 = normalizePluginToolImageBase64(rawB64);
+        const formatLabel = String((result.format as string) ?? "jpeg").toLowerCase();
+        let mimeType = base64 ? mimeTypeForSnapshotBase64(base64, formatLabel) : "image/jpeg";
+
+        let buf: Buffer | null = base64 ? Buffer.from(base64, "base64") : null;
+        if (buf && buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xd8) {
+          buf = trimJpegToLastEoi(buf);
+          base64 = buf.toString("base64");
+          mimeType = mimeTypeForSnapshotBase64(base64, formatLabel);
+        }
+
+        const wNum =
+          result.width != null ? rosNumericField(result.width, "width") : undefined;
+        const hNum =
+          result.height != null ? rosNumericField(result.height, "height") : undefined;
+        let summary = `Captured one frame from ${topic}${wNum != null && hNum != null ? ` (${wNum}×${hNum})` : ""}.`;
+
+        let snapshotId: string | undefined;
+        const minDecodedBytes = 80;
+        const decodedLen = buf ? buf.length : 0;
+        if (buf && decodedLen >= minDecodedBytes) {
+          try {
+            snapshotId = storeCameraSnapshot(buf, mimeType);
+          } catch {
+            /* ignore oversized / cache errors */
+          }
+        }
+        if (snapshotId) {
+          const snapPath = `/plugins/agenticros/camera/snapshot?id=${encodeURIComponent(snapshotId)}`;
+          const origin = (process.env.AGENTICROS_GATEWAY_PUBLIC_URL ?? "").trim().replace(/\/$/, "");
+          const snapUrl = origin ? `${origin}${snapPath}` : snapPath;
+          summary += `\n\n![camera snapshot](${snapUrl})`;
+        }
+
+        if (
+          config.describer?.enabled === true &&
+          base64 &&
+          buf &&
+          decodedLen >= minDecodedBytes
+        ) {
+          try {
+            const described = await describeImageBestEffort({
+              config,
+              base64,
+              mimeType,
+              logger: api.logger,
+            });
+            if (described) {
+              summary += `\n\n**Vision description** (auto-generated by ${described.model} in ${described.latencyMs}ms — quote or paraphrase this when reporting what the robot sees):\n${described.description.trim()}`;
+            } else {
+              summary +=
+                "\n\n_(Vision description was requested but the describer endpoint did not respond — the camera image was captured successfully; see the snapshot link above. Report this to the operator if the user needs a description.)_";
+            }
+          } catch {
+            /* describeImageBestEffort never throws; this is just defense in depth */
+          }
+        }
+
+        const content: Array<
+          { type: "text"; text: string } | { type: "image"; data: string; mimeType: string }
+        > = [{ type: "text", text: summary }];
+        if (base64 && buf && decodedLen >= minDecodedBytes) {
+          content.push({ type: "image", data: base64, mimeType });
+        } else if (rawB64 && (!base64 || decodedLen < minDecodedBytes)) {
+          content.push({
+            type: "text",
+            text:
+              " (Image payload was missing, not valid base64 after normalization, or too small—check topic, message_type, or transport.)",
+          });
+        } else if (!rawB64) {
+          content.push({
+            type: "text",
+            text: " (No image data received—topic may be idle or transport returned empty.)",
+          });
+        }
+
+        return {
+          content,
+          details: { success: result.success, topic, width: result.width, height: result.height },
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `ros2_camera_snapshot failed: ${msg}` }],
+          details: { success: false, topic: rawTopic, error: msg },
+        };
+      }
+    },
+  });
+}

package/runtime/packages/agenticros/src/tools/ros2-depth-distance.ts

@@ -0,0 +1,58 @@
+/**
+ * Tool to read distance (meters) from a ROS2 depth image topic (e.g. RealSense).
+ * Use when the user asks "how far am I" or "distance to the robot" / "distance from the robot".
+ */
+
+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 { getDepthDistance } from "../depth.js";
+import { REALSENSE_CAMERA_TOPICS } from "./ros2-camera.js";
+
+const DEFAULT_DEPTH_TOPIC = REALSENSE_CAMERA_TOPICS.depth_raw;
+
+export function registerDepthDistanceTool(api: OpenClawPluginApi, config: AgenticROSConfig): void {
+  api.registerTool({
+    name: "ros2_depth_distance",
+    label: "ROS2 depth distance",
+    description:
+      "Get distance in meters from the robot's depth camera (e.g. RealSense). " +
+      "Samples the center of the depth image and returns distance biased toward nearer pixels (~12th percentile), not median (median often tracks walls when the person only covers part of the patch). " +
+      "Use when the user asks how far they are from the robot, or distance to/from the robot.",
+
+    parameters: Type.Object({
+      topic: Type.Optional(
+        Type.String({
+          description: `Depth image topic (sensor_msgs/Image, 16UC1 or 32FC1). Default: ${DEFAULT_DEPTH_TOPIC}.`,
+        }),
+      ),
+      timeout: Type.Optional(Type.Number({ description: "Timeout in ms (default 5000)" })),
+    }),
+
+    async execute(_toolCallId, params) {
+      const rawTopic = (params["topic"] as string | undefined)?.trim() || DEFAULT_DEPTH_TOPIC;
+      const topic = toNamespacedTopic(config, rawTopic);
+      const timeout = (params["timeout"] as number | undefined) ?? 5000;
+
+      try {
+        const transport = getTransport();
+        const result = await getDepthDistance(transport, topic, timeout);
+        const text = result.valid
+          ? `Distance at center (~12th percentile, nearer surfaces): **${result.distance_m} m** (median in same patch: ${result.median_m} m; range ${result.min_m}–${result.max_m} m; ${result.sample_count} pixels). Topic: ${result.topic}.`
+          : `No valid depth in center region (topic: ${result.topic}, ${result.width}×${result.height}, encoding ${result.encoding}). The scene may be out of range or obscured.`;
+        return {
+          content: [{ type: "text" as const, text }],
+          details: result,
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text" as const, text: `Depth distance failed: ${message}` }],
+          details: { success: false, error: message, topic },
+        };
+      }
+    },
+  });
+}

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

@@ -0,0 +1,62 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "../plugin-api.js";
+import { getTransport } from "../service.js";
+
+/**
+ * Register the ros2_list_topics tool with the AI agent.
+ * Allows the agent to discover available ROS2 topics at runtime.
+ */
+export function registerIntrospectTool(api: OpenClawPluginApi): void {
+  api.registerTool({
+    name: "ros2_list_topics",
+    label: "ROS2 List Topics",
+    description:
+      "List ROS 2 topics seen by the transport (authoritative for this moment). " +
+      "Use when the user asks what topics exist, or when system context did not list discovery results—" +
+      "do not assume names like /odom, /scan, or /battery_state exist without this tool (or subscribe) confirming them.",
+    parameters: Type.Object({}),
+
+    async execute(_toolCallId, _params) {
+      const transport = getTransport();
+      const topics = await transport.listTopics();
+
+      // Cap output size to avoid rate limits / token burn when robot has many topics
+      const MAX_TOPICS_IN_RESPONSE = 50;
+      const MAX_CHARS = 6000;
+      const truncated =
+        topics.length > MAX_TOPICS_IN_RESPONSE
+          ? topics.slice(0, MAX_TOPICS_IN_RESPONSE)
+          : topics;
+      const result = {
+        success: true,
+        topics: truncated,
+        total: topics.length,
+        truncated: topics.length > MAX_TOPICS_IN_RESPONSE,
+        ...(topics.length === 0
+          ? {
+              hint:
+                "No Zenoh keys were sampled. OpenClaw uses WebSocket to the Mac zenohd remote-api (not tcp://ROBOT_IP). " +
+                "If you see traffic with `zenoh subscribe -k '**' -e tcp/ROBOT_IP:7447`, that is often the robot's router — " +
+                "the bridge must peer to the same router as OpenClaw, and CLI garbled output is usually CDR/binary payloads, not topic names. " +
+                "Retry after confirming topology; optionally set AGENTICROS_ZENOH_LIST_TOPICS_MS for a longer sample window.",
+            }
+          : {}),
+      };
+      let text = JSON.stringify(result);
+      if (text.length > MAX_CHARS) {
+        const fewer = truncated.slice(0, 20);
+        text = JSON.stringify({
+          success: true,
+          total: topics.length,
+          message: `Topic list truncated to save tokens (${topics.length} total). Showing first 20.`,
+          topics: fewer,
+        });
+      }
+
+      return {
+        content: [{ type: "text", text }],
+        details: result,
+      };
+    },
+  });
+}

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

@@ -0,0 +1,158 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, ToolContent } from "../plugin-api.js";
+import type { AgenticROSConfig } from "@agenticros/core";
+import { resolveMemoryNamespace } from "@agenticros/core";
+import { getMemory } from "../memory.js";
+
+/**
+ * Register the four memory tools with the OpenClaw AI agent.
+ *
+ * Memory tools are only registered when `config.memory.enabled === true` and
+ * the provider initialized successfully. See ../memory.ts for the provider
+ * lifecycle.
+ */
+export function registerMemoryTools(
+  api: OpenClawPluginApi,
+  config: AgenticROSConfig,
+): void {
+  api.registerTool({
+    name: "memory_remember",
+    label: "Memory: remember",
+    description:
+      "Store a durable fact in long-term memory. Call this when the user says \"remember that ...\", \"note that ...\", \"from now on ...\", or shares a stable personal fact (preferences, names, places, routines, robot hardware like the camera/eyes the robot has). The store is shared across all AgenticROS adapters talking to this robot (OpenClaw, Claude Desktop, Claude Code, Gemini). Do NOT auto-store chat transcripts or transient state. Namespace defaults to the robot namespace.",
+    parameters: Type.Object({
+      content: Type.String({ description: "The fact to remember, written as a self-contained sentence." }),
+      tags: Type.Optional(
+        Type.Array(Type.String(), {
+          description: "Optional list of tag strings for filtering later.",
+        }),
+      ),
+      path: Type.Optional(
+        Type.String({ description: "Optional hierarchical hint (e.g. 'preferences.movement.speed')." }),
+      ),
+      namespace: Type.Optional(Type.String({ description: "Optional namespace override; defaults to the robot namespace." })),
+    }),
+    async execute(_toolCallId, params) {
+      const memory = getMemory();
+      if (!memory) return memoryDisabled();
+      const content = String((params as any).content ?? "").trim();
+      if (!content) return errResult("memory_remember requires 'content'.");
+      const namespace = resolveMemoryNamespace(config, (params as any).namespace as string | undefined);
+      try {
+        const record = await memory.remember({
+          content,
+          namespace,
+          tags: Array.isArray((params as any).tags)
+            ? ((params as any).tags as unknown[]).map(String)
+            : undefined,
+          path: typeof (params as any).path === "string" ? ((params as any).path as string) : undefined,
+        });
+        const text = JSON.stringify({
+          success: true,
+          id: record.id,
+          namespace: record.namespace,
+          backend: memory.backend,
+        });
+        return { content: [{ type: "text", text }], details: record };
+      } catch (err) {
+        return errResult(`memory_remember failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  });
+
+  api.registerTool({
+    name: "memory_recall",
+    label: "Memory: recall",
+    description:
+      "Semantic search of long-term memory. ALWAYS call this BEFORE answering a personal-context question, including: \"what do I have for X?\", \"what's my Y?\", \"where is the Z?\", \"what did I tell you about ...?\", \"do you remember ...?\". The store is shared across every adapter for this robot — a fact saved from Claude Desktop or Claude Code lives in the same store. Returns the top matches ranked by relevance.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Free-text query describing what you want to recall." }),
+      limit: Type.Optional(Type.Number({ description: "Max matches to return (default 5)." })),
+      namespace: Type.Optional(Type.String({ description: "Optional namespace override; defaults to the robot namespace." })),
+    }),
+    async execute(_toolCallId, params) {
+      const memory = getMemory();
+      if (!memory) return memoryDisabled();
+      const query = String((params as any).query ?? "").trim();
+      if (!query) return errResult("memory_recall requires 'query'.");
+      const namespace = resolveMemoryNamespace(config, (params as any).namespace as string | undefined);
+      const limit = typeof (params as any).limit === "number" ? ((params as any).limit as number) : 5;
+      try {
+        const hits = await memory.recall({ query, namespace, limit });
+        const text = JSON.stringify({
+          success: true,
+          namespace,
+          backend: memory.backend,
+          count: hits.length,
+          results: hits,
+        });
+        return { content: [{ type: "text", text }], details: hits };
+      } catch (err) {
+        return errResult(`memory_recall failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  });
+
+  api.registerTool({
+    name: "memory_forget",
+    label: "Memory: forget",
+    description:
+      "Delete memories. Provide an id (delete one), a query (delete matches in the namespace), or just namespace (delete all in that namespace). Irreversible.",
+    parameters: Type.Object({
+      id: Type.Optional(Type.String({ description: "Record id returned by memory_remember." })),
+      query: Type.Optional(
+        Type.String({ description: "Free-text query; deletes every matching memory in the namespace." }),
+      ),
+      namespace: Type.Optional(Type.String({ description: "Namespace to delete from." })),
+    }),
+    async execute(_toolCallId, params) {
+      const memory = getMemory();
+      if (!memory) return memoryDisabled();
+      const namespace = resolveMemoryNamespace(config, (params as any).namespace as string | undefined);
+      try {
+        const result = await memory.forget({
+          id: typeof (params as any).id === "string" ? ((params as any).id as string) : undefined,
+          query: typeof (params as any).query === "string" ? ((params as any).query as string) : undefined,
+          namespace,
+        });
+        const text = JSON.stringify({ success: true, ...result, namespace, backend: memory.backend });
+        return { content: [{ type: "text", text }], details: result };
+      } catch (err) {
+        return errResult(`memory_forget failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  });
+
+  api.registerTool({
+    name: "memory_status",
+    label: "Memory: status",
+    description:
+      "Health check for the memory subsystem: enabled state, backend, record count for the current namespace, last write timestamp, and embedder info (when applicable).",
+    parameters: Type.Object({
+      namespace: Type.Optional(Type.String({ description: "Optional namespace override; defaults to the robot namespace." })),
+    }),
+    async execute(_toolCallId, params) {
+      const memory = getMemory();
+      if (!memory) return memoryDisabled();
+      const namespace = resolveMemoryNamespace(config, (params as any).namespace as string | undefined);
+      try {
+        const status = await memory.status(namespace);
+        const text = JSON.stringify({ success: true, ...status });
+        return { content: [{ type: "text", text }], details: status };
+      } catch (err) {
+        return errResult(`memory_status failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  });
+}
+
+function memoryDisabled() {
+  return errResult(
+    "Memory is not enabled. Set memory.enabled=true in ~/.agenticros/config.json (backend: 'local' for zero deps, 'mem0' for semantic search). See docs/memory.md.",
+  );
+}
+
+function errResult(text: string) {
+  const content: ToolContent[] = [{ type: "text", text }];
+  return { content, details: { error: text } };
+}

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

@@ -0,0 +1,87 @@
+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";
+
+/**
+ * Register ros2_param_get and ros2_param_set tools with the AI agent.
+ */
+export function registerParamTools(api: OpenClawPluginApi, config: AgenticROSConfig): void {
+  api.registerTool({
+    name: "ros2_param_get",
+    label: "ROS2 Get Parameter",
+    description:
+      "Get the value of a ROS2 parameter from a node. " +
+      "Use this to check robot configuration values.",
+    parameters: Type.Object({
+      node: Type.String({ description: "The fully qualified node name (e.g., '/turtlebot3/controller')" }),
+      parameter: Type.String({ description: "The parameter name (e.g., 'max_velocity')" }),
+    }),
+
+    async execute(_toolCallId, params) {
+      const rawNode = params["node"] as string;
+      const node = toNamespacedTopic(config, rawNode);
+      const parameter = params["parameter"] as string;
+
+      const transport = getTransport();
+      const response = await transport.callService({
+        service: `${node}/get_parameters`,
+        type: "rcl_interfaces/srv/GetParameters",
+        args: { names: [parameter] },
+      });
+
+      const result = {
+        success: response.result,
+        node,
+        parameter,
+        value: response.values,
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        details: result,
+      };
+    },
+  });
+
+  api.registerTool({
+    name: "ros2_param_set",
+    label: "ROS2 Set Parameter",
+    description:
+      "Set the value of a ROS2 parameter on a node. " +
+      "Use this to change robot configuration at runtime.",
+    parameters: Type.Object({
+      node: Type.String({ description: "The fully qualified node name" }),
+      parameter: Type.String({ description: "The parameter name" }),
+      value: Type.Unknown({ description: "The new parameter value" }),
+    }),
+
+    async execute(_toolCallId, params) {
+      const rawNode = params["node"] as string;
+      const node = toNamespacedTopic(config, rawNode);
+      const parameter = params["parameter"] as string;
+      const value = params["value"];
+
+      const transport = getTransport();
+      const response = await transport.callService({
+        service: `${node}/set_parameters`,
+        type: "rcl_interfaces/srv/SetParameters",
+        args: {
+          parameters: [
+            { name: parameter, value },
+          ],
+        },
+      });
+
+      const result = {
+        success: response.result,
+        node,
+        parameter,
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        details: result,
+      };
+    },
+  });
+}