letagents 0.12.25 → 0.12.27

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";
@@ -5,15 +7,31 @@ import { registerOnboardingTools } from "./tools/onboarding.js";
 import { registerRentalTools } from "./tools/rental.js";
 import { registerRepoInitializationTool, registerRepoVisibilityTool, registerRoomInspectionTools, registerRoomJoinTools, registerRoomResumeTool, } from "./tools/rooms.js";
 import { registerTaskTools } from "./tools/tasks.js";
-import { registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
+import { registerReplyThreadTool, registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
 import { toolSurfaceForExecutionProfile } from "./runtime/tool-surface-policy.js";
 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);
@@ -28,6 +46,8 @@ export function registerTools(server, profile = "autonomous_mcp_worker", supervi
     registerTaskTools(tools);
     registerRepoInitializationTool(tools);
     registerMessageTools(tools, { includeDeliveryLoop: surface.deliveryLoop });
+    if (profile === "supervised_room_turn")
+        registerReplyThreadTool(tools);
     if (profile === "supervised_room_turn" && supervisedProvider === "cursor")
         registerSupervisedRoomTurnTools(tools);
     if (surface.onboarding)

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/dist/mcp/server/tools/supervised-room-turn.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
 const MAX_ROOM_REPLY_BYTES = 32 * 1024;
+/** Select routing only; the daemon remains the sole final-answer publisher. */
+export function registerReplyThreadTool(server) {
+    const tool = server.tool("set_reply_thread", "Place your final answer in the activating room message's thread. Takes no arguments, sends no message, and does not finish the turn. Continue working and use your normal final completion when ready. Unavailable for synthetic task continuations or corrections.", {}, async () => { throw new Error("set_reply_thread requires the active daemon-owned room turn."); });
+    // The legacy raw-shape overload strips unknown keys. Preserve a strict schema
+    // so a caller cannot mistake ignored room/recipient/text arguments for authority.
+    tool.inputSchema = z.object({}).strict();
+}
 function completionResponse(outcome) {
     const payload = {
         accepted: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.25",
+  "version": "0.12.27",
   "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) {
+  // Turn controls are handled by the daemon. Local room moves are unsupported.
+  return name === "complete_room_turn" || name === "set_reply_thread" || 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);
+}