@byok-sdk/client 0.10.2 → 0.11.0

package/dist/bin/agent-memory-mcp-server.d.ts

@@ -1,5 +1,5 @@
-export declare const AGENT_MEMORY_RECALL_TOOL_NAME = "memory.recall";
-export declare const AGENT_MEMORY_SAVE_TOOL_NAME = "memory.save";
+export declare const AGENT_MEMORY_RECALL_TOOL_NAME = "memory_recall";
+export declare const AGENT_MEMORY_SAVE_TOOL_NAME = "memory_save";
 export interface AgentMemoryMcpDeps {
     recall(input: {
         path: string;

package/dist/bin/agent-message-mcp-server.d.ts

@@ -1,5 +1,4 @@
 import type { AgentMessageContentType } from '@byok-sdk/protocol';
-export declare const AGENT_MESSAGE_TOOL_NAME = "send_agent_message";
 export interface AgentMessageMcpDeps {
     publish(input: {
         contentType: AgentMessageContentType;

package/dist/bin/byok-agent-memory-mcp.js

@@ -334,8 +334,84 @@ function createControlClient(socket, reader, opts) {
     }
   };
 }
-var AGENT_MEMORY_RECALL_TOOL_NAME = "memory.recall";
-var AGENT_MEMORY_SAVE_TOOL_NAME = "memory.save";
+var AGENT_MESSAGE_TOOL_NAME = "send_agent_message";
+
+// src/bin/agent-message-mcp-server.ts
+async function handleAgentMessageMcpRequest(request, deps) {
+  const id = request.id;
+  if (request.method === "initialize") {
+    const params = request.params ?? {};
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "byok-agent-message-mcp", version: "0.0.1" }
+      }
+    };
+  }
+  if (request.method === "notifications/initialized") return void 0;
+  if (request.method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { tools: [{
+        name: AGENT_MESSAGE_TOOL_NAME,
+        description: "Send the single user-visible Agent reply for this exact task. Routing identity is supplied by the authenticated task context.",
+        inputSchema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["body"],
+          properties: {
+            body: { type: "string", minLength: 1 },
+            contentType: { type: "string", enum: ["text/plain", "text/markdown"] }
+          }
+        }
+      }] }
+    };
+  }
+  if (request.method === "tools/call") {
+    const params = request.params ?? {};
+    if (params.name !== AGENT_MESSAGE_TOOL_NAME) return { jsonrpc: "2.0", id, error: { code: -32602, message: "unknown Agent message tool" } };
+    const args = params.arguments;
+    if (args === null || typeof args !== "object" || Array.isArray(args)) return { jsonrpc: "2.0", id, error: { code: -32602, message: "message input must be an object" } };
+    const record3 = args;
+    if (Object.keys(record3).some((key) => key !== "body" && key !== "contentType") || typeof record3.body !== "string" || record3.body.length === 0) {
+      return { jsonrpc: "2.0", id, error: { code: -32602, message: "message input accepts only non-empty body and optional contentType" } };
+    }
+    const contentType = record3.contentType ?? "text/markdown";
+    if (contentType !== "text/plain" && contentType !== "text/markdown") return { jsonrpc: "2.0", id, error: { code: -32602, message: "unsupported contentType" } };
+    try {
+      const receipt = await deps.publish({ contentType, body: record3.body });
+      return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(receipt) }] } };
+    } catch (error) {
+      return { jsonrpc: "2.0", id, error: { code: -32e3, message: error instanceof Error ? error.message : String(error) } };
+    }
+  }
+  return id === void 0 ? void 0 : { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(request.method)}` } };
+}
+function serveAgentMessageMcpOverStdio(input) {
+  const reader = createInterface({ input: input.stdin ?? process.stdin, terminal: false });
+  const output = input.stdout ?? process.stdout;
+  reader.on("line", (line) => {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) return;
+    void (async () => {
+      let request;
+      try {
+        request = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      const response = await handleAgentMessageMcpRequest(request, input.deps);
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    })();
+  });
+}
+var AGENT_MEMORY_RECALL_TOOL_NAME = "memory_recall";
+var AGENT_MEMORY_SAVE_TOOL_NAME = "memory_save";
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -366,11 +442,11 @@ async function handleAgentMemoryMcpRequest(request, deps) {
   if (!params || !args || typeof params.name !== "string") return invalid(id, "memory tool input must be an object");
   try {
     if (params.name === AGENT_MEMORY_RECALL_TOOL_NAME) {
-      if (Object.keys(args).some((key) => key !== "path" && key !== "ifRevision") || typeof args.path !== "string" || args.ifRevision !== void 0 && typeof args.ifRevision !== "string") return invalid(id, "memory.recall accepts only path and optional ifRevision");
+      if (Object.keys(args).some((key) => key !== "path" && key !== "ifRevision") || typeof args.path !== "string" || args.ifRevision !== void 0 && typeof args.ifRevision !== "string") return invalid(id, "memory_recall accepts only path and optional ifRevision");
       return success(id, await deps.recall({ path: args.path, ...args.ifRevision === void 0 ? {} : { ifRevision: args.ifRevision } }));
     }
     if (params.name === AGENT_MEMORY_SAVE_TOOL_NAME) {
-      if (Object.keys(args).some((key) => key !== "op" && key !== "path" && key !== "expectedRevision" && key !== "content") || args.op !== "replace" && args.op !== "delete" || typeof args.path !== "string" || typeof args.expectedRevision !== "string" || args.op === "replace" && typeof args.content !== "string" || args.op === "delete" && args.content !== void 0) return invalid(id, "memory.save requires replace|delete, path, expectedRevision, and content only for replace");
+      if (Object.keys(args).some((key) => key !== "op" && key !== "path" && key !== "expectedRevision" && key !== "content") || args.op !== "replace" && args.op !== "delete" || typeof args.path !== "string" || typeof args.expectedRevision !== "string" || args.op === "replace" && typeof args.content !== "string" || args.op === "delete" && args.content !== void 0) return invalid(id, "memory_save requires replace|delete, path, expectedRevision, and content only for replace");
       const content = args.content;
       return success(id, await deps.save({ op: args.op, path: args.path, expectedRevision: args.expectedRevision, ...typeof content === "string" ? { content } : {} }));
     }
@@ -398,14 +474,199 @@ function serveAgentMemoryMcpOverStdio(input) {
     })();
   });
 }
+var TEAM_POST_TOOL_NAME = "post_team_message";
+var TEAM_READ_TOOL_NAME = "read_team_messages";
+var TEAM_ACK_TOOL_NAME = "ack_team_messages";
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var invalid2 = (id, message) => ({ jsonrpc: "2.0", id, error: { code: -32602, message } });
+var success2 = (id, value) => ({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(value) }] } });
+async function handleTeamMcpRequest(request, deps) {
+  const { id } = request;
+  if (request.method === "initialize") {
+    const params2 = record2(request.params) ?? {};
+    return { jsonrpc: "2.0", id, result: { protocolVersion: typeof params2.protocolVersion === "string" ? params2.protocolVersion : "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "byok-agent-team-mcp", version: "0.0.1" } } };
+  }
+  if (request.method === "notifications/initialized") return void 0;
+  if (request.method === "tools/list") return { jsonrpc: "2.0", id, result: { tools: [
+    { name: TEAM_POST_TOOL_NAME, description: "Post one broadcast message as this exact leased team member. Sender and workspace are daemon-owned.", inputSchema: { type: "object", additionalProperties: false, required: ["body"], properties: { body: { type: "string" }, contentType: { type: "string" } } } },
+    { name: TEAM_READ_TOOL_NAME, description: "Read ordered team messages visible to this exact leased member.", inputSchema: { type: "object", additionalProperties: false, properties: { afterSeq: { type: "integer", minimum: 0 } } } },
+    { name: TEAM_ACK_TOOL_NAME, description: "Durably acknowledge messages through an already delivered sequence for this exact leased member.", inputSchema: { type: "object", additionalProperties: false, required: ["throughSeq"], properties: { throughSeq: { type: "integer", minimum: 0 } } } }
+  ] } };
+  if (request.method !== "tools/call") return id === void 0 ? void 0 : { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(request.method)}` } };
+  const params = record2(request.params);
+  const args = record2(params?.arguments);
+  if (!params || !args || typeof params.name !== "string") return invalid2(id, "team tool input must be an object");
+  try {
+    if (params.name === TEAM_POST_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "body" && key !== "contentType") || typeof args.body !== "string" || args.contentType !== void 0 && typeof args.contentType !== "string") return invalid2(id, "post_team_message accepts body and optional contentType only");
+      return success2(id, await deps.post({ body: args.body, ...typeof args.contentType === "string" ? { contentType: args.contentType } : {} }));
+    }
+    if (params.name === TEAM_READ_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "afterSeq") || args.afterSeq !== void 0 && (!Number.isSafeInteger(args.afterSeq) || Number(args.afterSeq) < 0)) return invalid2(id, "read_team_messages accepts optional non-negative integer afterSeq only");
+      return success2(id, await deps.read(args.afterSeq === void 0 ? {} : { afterSeq: Number(args.afterSeq) }));
+    }
+    if (params.name === TEAM_ACK_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "throughSeq") || !Number.isSafeInteger(args.throughSeq) || Number(args.throughSeq) < 0) return invalid2(id, "ack_team_messages requires non-negative integer throughSeq only");
+      return success2(id, await deps.ack({ throughSeq: Number(args.throughSeq) }));
+    }
+    return invalid2(id, "unknown team tool");
+  } catch (error) {
+    return { jsonrpc: "2.0", id, error: { code: -32e3, message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+function serveTeamMcpOverStdio(input) {
+  const reader = createInterface({ input: input.stdin ?? process.stdin, terminal: false });
+  const output = input.stdout ?? process.stdout;
+  reader.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    void (async () => {
+      let request;
+      try {
+        request = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      const response = await handleTeamMcpRequest(request, input.deps);
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    })();
+  });
+}
+var APPROVAL_TOOL_NAME = "approval_prompt";
+var APPROVAL_SUMMARY_MAX_CHARS = 500;
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function summarizeToolCall(toolName, input) {
+  let inputStr;
+  try {
+    inputStr = JSON.stringify(input);
+  } catch (err) {
+    inputStr = `<unserializable input: ${errorMessage2(err)}>`;
+  }
+  const bounded = inputStr.length > APPROVAL_SUMMARY_MAX_CHARS ? `${inputStr.slice(0, APPROVAL_SUMMARY_MAX_CHARS)}\u2026 [truncated]` : inputStr;
+  return `${toolName}: ${bounded}`;
+}
+async function handleMcpRequest(req, deps, taskId) {
+  const id = req.id;
+  if (req.method === "initialize") {
+    const params = req.params ?? {};
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "byok-approval-mcp", version: "0.0.1" }
+      }
+    };
+  }
+  if (req.method === "notifications/initialized") {
+    return void 0;
+  }
+  if (req.method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        tools: [
+          {
+            name: APPROVAL_TOOL_NAME,
+            description: "Requests operator approval for a pending tool call. Blocks until a human (or this device's daemon) decides, or the configured timeout elapses (fail-closed deny on timeout).",
+            inputSchema: {
+              type: "object",
+              properties: {
+                tool_name: { type: "string" },
+                input: { type: "object" }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+  if (req.method === "tools/call") {
+    const params = req.params ?? {};
+    if (params.name !== APPROVAL_TOOL_NAME) {
+      return { jsonrpc: "2.0", id, error: { code: -32602, message: `unknown tool "${String(params.name)}"` } };
+    }
+    const args = params.arguments ?? {};
+    const toolName = typeof args.tool_name === "string" ? args.tool_name : "unknown tool";
+    const input = args.input ?? {};
+    const summary = summarizeToolCall(toolName, input);
+    let outcome;
+    try {
+      outcome = await deps.requestApproval(taskId, summary);
+    } catch (err) {
+      outcome = { approved: false, reason: `could not reach the approving device: ${errorMessage2(err)}` };
+    }
+    const payload = outcome.approved ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: outcome.reason ?? "denied" };
+    return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(payload) }] } };
+  }
+  if (id !== void 0) {
+    return { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(req.method)}` } };
+  }
+  return void 0;
+}
+function serveApprovalMcpOverStdio(opts) {
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  const rl = createInterface({ input, terminal: false });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    void handleMcpRequest(parsed, opts.deps, opts.taskId).then((response) => {
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    });
+  });
+}
 
-// src/bin/byok-agent-memory-mcp.ts
+// src/bin/sdk-reserved-helper-runners.ts
+var APPROVAL_REQUEST_TIMEOUT_SLOP_MS = 5e3;
 function required(name) {
   const value = process.env[name];
   if (!value) throw new Error(`missing required environment variable ${name}`);
   return value;
 }
-async function main() {
+function waitForInputClose(input = process.stdin) {
+  if (input.readableEnded || input.destroyed) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      input.off("end", done);
+      input.off("close", done);
+      resolve();
+    };
+    input.once("end", done);
+    input.once("close", done);
+  });
+}
+async function runAgentMessageMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const contextToken = required("BYOK_AGENT_MESSAGE_CONTEXT");
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({ storeDir, productId }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    publish: async (input) => (await client()).request("agent_messages.publish", { contextToken, ...input })
+  };
+  serveAgentMessageMcpOverStdio({ deps });
+  await waitForInputClose();
+}
+async function runAgentMemoryMcp() {
   const storeDir = required("BYOK_STORE_DIR");
   const productId = required("BYOK_PRODUCT_ID");
   const contextToken = required("BYOK_AGENT_MEMORY_CONTEXT");
@@ -422,8 +683,80 @@ async function main() {
     save: async (input) => (await client()).request("agent_memory.save", { contextToken, ...input })
   };
   serveAgentMemoryMcpOverStdio({ deps });
+  await waitForInputClose();
 }
-main().catch((error) => {
+async function runApprovalMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const taskId = required("BYOK_TASK_ID");
+  const timeoutMs = Number(process.env.BYOK_APPROVAL_TIMEOUT_MS ?? "600000");
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("invalid BYOK_APPROVAL_TIMEOUT_MS environment variable");
+  }
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({
+      storeDir,
+      productId,
+      requestTimeoutMs: timeoutMs + APPROVAL_REQUEST_TIMEOUT_SLOP_MS
+    }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    requestApproval: async (requestedTaskId, summary) => {
+      try {
+        return await (await client()).request("approvals.request", { taskId: requestedTaskId, summary });
+      } catch (error) {
+        clientPromise = void 0;
+        throw error;
+      }
+    }
+  };
+  serveApprovalMcpOverStdio({ taskId, deps });
+  await waitForInputClose();
+}
+async function runAgentTeamMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const lease = required("BYOK_TEAM_MEMBER_CONTEXT");
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({ storeDir, productId }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    post: async (input) => (await client()).request("team_messages.post", { context: lease, ...input }),
+    read: async (input) => (await client()).request("team_messages.read", { context: lease, ...input }),
+    ack: async (input) => (await client()).request("team_messages.ack", { context: lease, ...input })
+  };
+  serveTeamMcpOverStdio({ deps });
+  await waitForInputClose();
+}
+async function runSdkReservedHelper(kind) {
+  switch (kind) {
+    case "agent-message-mcp":
+      await runAgentMessageMcp();
+      return;
+    case "agent-memory-mcp":
+      await runAgentMemoryMcp();
+      return;
+    case "approval-mcp":
+      await runApprovalMcp();
+      return;
+    case "agent-team-mcp":
+      await runAgentTeamMcp();
+      return;
+  }
+}
+
+// src/bin/byok-agent-memory-mcp.ts
+runSdkReservedHelper("agent-memory-mcp").catch((error) => {
   process.stderr.write(`byok-agent-memory-mcp: ${error instanceof Error ? error.message : String(error)}
 `);
   process.exit(1);