letagents 0.12.25 → 0.12.26

package/dist/mcp/server/daemon-tool-executor.js

@@ -7,7 +7,7 @@ import { durableCompletionResult, supervisedToolIsMutation } from "./supervised-
 const handlersByProvider = new Map();
 const SUPERVISED_PROVIDERS = new Set(["claude-code", "cursor", "codex", "open-model"]);
 const WORKSPACE_SCOPED_TOOLS = new Set(["check_repo", "check_repo_visibility", "initialize_repo"]);
-function handlersForProvider(provider) {
+function handlersForProvider(provider, apiUrl) {
     const normalizedProvider = provider.trim().toLowerCase();
     const existing = handlersByProvider.get(normalizedProvider);
     if (existing)
@@ -26,7 +26,7 @@ function handlersForProvider(provider) {
             return {};
         },
     };
-    registerTools(recorder, "supervised_room_turn", normalizedProvider || null, { executionOwner: "daemon" });
+    registerTools(recorder, "supervised_room_turn", normalizedProvider || null, { executionOwner: "daemon", apiUrl });
     handlersByProvider.set(normalizedProvider, handlers);
     return handlers;
 }
@@ -73,7 +73,7 @@ function validateExecutionContext(input) {
  */
 export async function executeDaemonTool(input) {
     const context = validateExecutionContext(input);
-    const tool = handlersForProvider(context.provider).get(context.toolName);
+    const tool = handlersForProvider(context.provider, context.apiUrl).get(context.toolName);
     if (!tool)
         throw new Error(`Unsupported supervised tool: ${context.toolName}`);
     const parsedInput = tool.inputSchema

package/dist/mcp/server/register-tools.js

@@ -1,3 +1,5 @@
+import { localSupervisedRoomToolAvailable } from "../../../shared/local-supervised-tools.mjs";
+import { isLocalRoomApi } from "../../../shared/room-api-origin.mjs";
 import { registerRoomKnowledgeTools } from "./tools/knowledge.js";
 import { registerAgentSessionTools } from "./tools/agent-sessions.js";
 import { registerMessageTools, registerStatusTools } from "./tools/messages.js";
@@ -11,9 +13,25 @@ import { profileAwareToolServer } from "./supervised-tool-facade.js";
 import { workerAwareToolServer } from "./worker-tool-facade.js";
 import { registerWorkspaceTools } from "./tools/workspace.js";
 export function registerTools(server, profile = "autonomous_mcp_worker", supervisedProvider = process.env.LETAGENTS_SUPERVISOR_PROVIDER?.trim() || null, options = {}) {
+    const localRoom = profile === "supervised_room_turn" && isLocalRoomApi(options.apiUrl ?? process.env.LETAGENTS_API_URL);
+    const routedServer = localRoom ? new Proxy(server, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (property !== "tool")
+                return typeof value === "function" ? value.bind(target) : value;
+            return (name, ...registration) => {
+                if (!localSupervisedRoomToolAvailable(name))
+                    return undefined;
+                if (name === "update_task" && typeof registration[0] === "string") {
+                    registration[0] += " In local rooms, close verified merged work with status 'done'; no close intent or replacement work lease is needed.";
+                }
+                return target.tool.call(target, name, ...registration);
+            };
+        },
+    }) : server;
     const profileTools = options.executionOwner === "daemon"
-        ? server
-        : profileAwareToolServer(server, profile, undefined, supervisedProvider);
+        ? routedServer
+        : profileAwareToolServer(routedServer, profile, undefined, supervisedProvider);
     const tools = profile === "autonomous_mcp_worker" || profile === "interactive_desktop"
         ? workerAwareToolServer(profileTools) : profileTools;
     const surface = toolSurfaceForExecutionProfile(profile);

package/dist/mcp/server/runtime-contract.js

@@ -4,7 +4,7 @@ export const LETAGENTS_RUNTIME_CONTRACT_ARG = "--letagents-runtime-contract";
  * Discover through the production registration path rather than maintaining a
  * second capability list that can drift from the MCP server.
  */
-export function registeredToolNames(profile, supervisedProvider = null) {
+export function registeredToolNames(profile, supervisedProvider = null, apiUrl = process.env.LETAGENTS_API_URL) {
     const names = new Set();
     const recorder = {
         tool(name) {
@@ -12,16 +12,16 @@ export function registeredToolNames(profile, supervisedProvider = null) {
             return {};
         },
     };
-    registerTools(recorder, profile, supervisedProvider);
+    registerTools(recorder, profile, supervisedProvider, { apiUrl });
     return [...names].sort();
 }
-export function letAgentsRuntimeContract() {
+export function letAgentsRuntimeContract(apiUrl = process.env.LETAGENTS_API_URL) {
     return {
         format: 1,
         profiles: {
-            supervised_mcp_polling: { contract: "custodial_polling_v1", tools: registeredToolNames("supervised_mcp_polling", "codex") },
+            supervised_mcp_polling: { contract: "custodial_polling_v1", tools: registeredToolNames("supervised_mcp_polling", "codex", apiUrl) },
             cursor_supervised_room_turn: {
-                tools: registeredToolNames("supervised_room_turn", "cursor"),
+                tools: registeredToolNames("supervised_room_turn", "cursor", apiUrl),
             },
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.25",
+  "version": "0.12.26",
   "description": "Let Agents Chat \u2014 MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",

package/shared/local-supervised-tools.d.mts

@@ -0,0 +1,3 @@
+export function localSupervisedRoomToolOperation(name: string): string | null;
+export function localSupervisedRoomToolAvailable(name: string): boolean;
+export function defineLocalSupervisedToolHandlers<T>(handlers: Record<string, (context: T) => Promise<unknown>>): Readonly<Record<string, (context: T) => Promise<unknown>>>;

package/shared/local-supervised-tools.mjs

@@ -0,0 +1,31 @@
+// One catalog for supervised local discovery and storage dispatch. Aliases share
+// an operation; handler completeness is checked when the local executor loads.
+const operations = Object.freeze({
+  get_current_room: "get_current_room", read_messages: "read_messages",
+  send_message: "send_message", send_thread_message: "send_message",
+  post_status: "send_message", post_reasoning: "send_message",
+  get_board: "get_board", create_task: "add_task", add_task: "add_task",
+  claim_task: "claim_task", complete_task: "update_task", update_task: "update_task",
+  release_task_lease: "change_task_lease", handoff_task_lease: "change_task_lease",
+  claim_task_review: "claim_task_review", get_room_artifacts: "get_room_artifacts",
+  publish_room_artifact: "publish_room_artifact", get_message_thread: "get_message_thread",
+});
+
+export function localSupervisedRoomToolOperation(name) {
+  return Object.hasOwn(operations, name) ? operations[name] : null;
+}
+
+export function localSupervisedRoomToolAvailable(name) {
+  // Cursor completion is handled by the daemon. Local room moves are unsupported.
+  return name === "complete_room_turn" || localSupervisedRoomToolOperation(name) !== null;
+}
+
+export function defineLocalSupervisedToolHandlers(handlers) {
+  const required = new Set(Object.values(operations));
+  if (Object.keys(handlers).length !== required.size
+    || Object.keys(handlers).some(name => !required.has(name))
+    || [...required].some(name => typeof handlers[name] !== "function")) {
+    throw new Error("Local room handlers do not match the advertised tool contract.");
+  }
+  return Object.freeze(handlers);
+}