@tangle-network/agent-profile-materialize 0.27.0 → 0.27.2

package/dist/mcp.js

@@ -1,59 +1,14 @@
 export function materializeMcp(h, mcp, plan, add, unsupported) {
     switch (h) {
-        case "claude-code": {
-            // Claude applies one MCP tool-call timeout to every server, so the
-            // longest declared one wins and is what each declaring server is told.
-            const timeouts = mcpToolTimeouts(mcp, h, unsupported);
-            const toolTimeoutMs = timeouts.size > 0 ? Math.max(...timeouts.values()) : undefined;
-            if (toolTimeoutMs !== undefined) {
-                setPlanEnvironment(plan, "MCP_TOOL_TIMEOUT", String(toolTimeoutMs));
-            }
-            const servers = {};
-            for (const [name, server] of Object.entries(mcp)) {
-                if (server.url) {
-                    const headers = withAppliedToolTimeout(server.headers, timeouts.has(name) ? toolTimeoutMs : undefined);
-                    servers[name] = {
-                        type: server.transport ?? "http",
-                        url: server.url,
-                        ...(headers ? { headers } : {}),
-                    };
-                    continue;
-                }
-                if (server.cwd !== undefined) {
-                    unsupported("mcp", `${h}: local MCP server "${name}" does not support a cwd field`);
-                }
-                servers[name] = {
-                    type: "stdio",
-                    command: server.command,
-                    ...(server.args ? { args: server.args } : {}),
-                    ...(server.env ? { env: server.env } : {}),
-                };
-            }
-            const relPath = ".tangle/claude-mcp.json";
-            add(relPath, serializeWorkspacePlanJson({ mcpServers: servers }));
-            plan.flags.push("--mcp-config", relPath, "--strict-mcp-config");
+        case "claude-code":
+            materializeClaudeMcp(h, mcp, plan, add, unsupported);
             break;
-        }
         case "nanoclaw":
             unsupported("mcp", "nanoclaw MCP must be injected through options.mcpServers by its SDK adapter");
             break;
-        case "codex": {
-            const timeouts = mcpToolTimeouts(mcp, h, unsupported);
-            const servers = [];
-            for (const [name, server] of Object.entries(mcp).sort(([left], [right]) => compareStrings(left, right))) {
-                if (server.url && server.transport === "sse") {
-                    unsupported("mcp", `codex: remote MCP server "${name}" uses unsupported SSE transport`);
-                    continue;
-                }
-                servers.push(concatWorkspacePlanArguments(`${tomlStr(name)} = `, codexMcpServerToml(name, server, plan, timeouts.get(name))));
-            }
-            if (servers.length > 0) {
-                // Runtime overrides do not require persisted project trust. Header values
-                // ride environment variables so credentials never appear in argv.
-                plan.flags.push("-c", concatWorkspacePlanArguments("mcp_servers={ ", joinWorkspacePlanArguments(servers, ", "), " }"));
-            }
+        case "codex":
+            materializeCodexMcp(h, mcp, plan, unsupported);
             break;
-        }
         case "opencode":
             // opencode.json "mcp" block (local|remote).
             add(OPENCODE_CONFIG_FILE, serializeWorkspacePlanJson({
@@ -61,70 +16,30 @@ export function materializeMcp(h, mcp, plan, add, unsupported) {
                 mcp: openCodeMcpConfig(mcp, mcpToolTimeouts(mcp, h, unsupported)),
             }));
             break;
-        case "gemini": {
-            const servers = {};
-            for (const [name, server] of Object.entries(mcp)) {
-                if (server.url) {
-                    servers[name] = {
-                        [server.transport === "sse" ? "url" : "httpUrl"]: server.url,
-                        ...(server.headers ? { headers: server.headers } : {}),
-                    };
-                    continue;
-                }
-                servers[name] = {
-                    command: server.command,
-                    ...(server.args ? { args: server.args } : {}),
-                    ...(server.env ? { env: server.env } : {}),
-                    ...(server.cwd ? { cwd: server.cwd } : {}),
-                };
-            }
-            add(".gemini/settings.json", serializeWorkspacePlanJson({ mcpServers: servers }));
+        case "gemini":
+            materializeGeminiMcp(mcp, add);
             break;
-        }
         case "kimi-code": {
-            // NO cwd auto-discovery — kimi needs an explicit --mcp-config-file FLAG.
-            const rel = ".kimi/mcp.json";
+            // kimi-code 2.x auto-discovers project MCP config from
+            // <cwd>/.kimi-code/mcp.json (2.3.0 dist/main.mjs:
+            // `project: join(input.cwd, ".kimi-code", "mcp.json")`; live-probed on
+            // 2.2.0). The previous lowering — .kimi/mcp.json plus a
+            // --mcp-config-file flag — targeted the legacy Python kimi-cli:
+            // kimi-code 2.x exits 1 with `error: unknown option '--mcp-config-file'`
+            // and never reads that file. Project MCP is gated behind workspace
+            // trust; an unattended executor exports KIMI_CODE_TRUST_WORKSPACE=1
+            // itself — the plan never forces trust, that posture is the launcher's.
+            const rel = ".kimi-code/mcp.json";
             const servers = Object.fromEntries(Object.entries(mcp).map(([name, server]) => [
                 name,
                 kimiMcpServer(server),
             ]));
             add(rel, serializeWorkspacePlanJson({ mcpServers: servers }));
-            plan.flags.push("--mcp-config-file", rel);
             break;
         }
-        case "pi": {
-            // pi ships NO MCP. It arrives from the `pi-mcp-adapter` extension, which discovers
-            // `<cwd>/.pi/mcp.json` (adapter 2.17.0 config.ts:17) and also registers a `--mcp-config`
-            // flag (index.ts:252). The flag is registered BY the extension, so passing it when the
-            // extension is absent is not a fallback — it is an unknown flag.
-            //
-            // This was previously marked unsupported because a workspace file cannot install an
-            // extension. That reasoning was right about the constraint and wrong about the conclusion:
-            // the file half is perfectly materializable, and the half that is not becomes a declared
-            // requirement the executor enforces. Marking the whole dimension unsupported pushed both
-            // halves onto every consumer, and two of them independently rebuilt it.
-            const rel = ".pi/mcp.json";
-            const servers = Object.fromEntries(Object.entries(mcp).map(([name, server]) => [
-                name,
-                // `directTools` promotes this server's verbs to first-class pi tools. Without it the
-                // agent gets one generic `mcp` tool and must connect, then describe, then call — three
-                // round trips of discovery before it can do anything. Per-server, because the adapter
-                // lets a per-server value override the global `settings.directTools` (direct-tools.ts:135).
-                { ...piMcpServer(server), directTools: true },
-            ]));
-            // serializeWorkspacePlanJson, NOT JSON.stringify: it unwraps public config values to their
-            // bytes and lifts any secret-ref into a tracked slot the applier resolves. Stringifying
-            // straight would write `{"kind":"public","value":"..."}` into the file as an argv entry.
-            add(rel, serializeWorkspacePlanJson({ mcpServers: servers }));
-            plan.requires?.push({
-                kind: "harness-extension",
-                dimension: "mcp",
-                id: "npm:pi-mcp-adapter",
-                reason: "pi has no built-in MCP; without this extension the servers in .pi/mcp.json are never read and the agent starts with none of their tools",
-                remedy: "pi install npm:pi-mcp-adapter",
-            });
+        case "pi":
+            materializePiMcp(mcp, plan, add);
             break;
-        }
         case "prime":
             // The fork's MCP config surface (`mcpServers` in <agentDir>/settings.json,
             // fork settings-manager.ts:98-120,219) IS read at startup, but a
@@ -146,59 +61,111 @@ export function materializeMcp(h, mcp, plan, add, unsupported) {
             break;
     }
 }
-function tomlInlineStringTable(values) {
-    return `{ ${Object.entries(values)
-        .sort(([left], [right]) => compareStrings(left, right))
-        .map(([key, value]) => `${tomlStr(key)} = ${tomlStr(value)}`)
-        .join(", ")} }`;
+function materializeClaudeMcp(h, mcp, plan, add, unsupported) {
+    // Claude applies one MCP tool-call timeout to every server, so the
+    // longest declared one wins and is what each declaring server is told.
+    const timeouts = mcpToolTimeouts(mcp, h, unsupported);
+    const toolTimeoutMs = timeouts.size > 0 ? Math.max(...timeouts.values()) : undefined;
+    if (toolTimeoutMs !== undefined) {
+        setPlanEnvironment(plan, "MCP_TOOL_TIMEOUT", String(toolTimeoutMs));
+    }
+    const servers = {};
+    for (const [name, server] of Object.entries(mcp)) {
+        if (server.url) {
+            const headers = withAppliedToolTimeout(server.headers, timeouts.has(name) ? toolTimeoutMs : undefined);
+            servers[name] = {
+                type: server.transport ?? "http",
+                url: server.url,
+                ...(headers ? { headers } : {}),
+            };
+            continue;
+        }
+        if (server.cwd !== undefined) {
+            unsupported("mcp", `${h}: local MCP server "${name}" does not support a cwd field`);
+        }
+        servers[name] = {
+            type: "stdio",
+            command: server.command,
+            ...(server.args ? { args: server.args } : {}),
+            ...(server.env ? { env: server.env } : {}),
+        };
+    }
+    const relPath = ".tangle/claude-mcp.json";
+    add(relPath, serializeWorkspacePlanJson({ mcpServers: servers }));
+    plan.flags.push("--mcp-config", relPath, "--strict-mcp-config");
 }
-/**
- * The header a harness sends to a remote MCP server whose tool-call timeout it
- * raised, carrying the timeout it applied in milliseconds. A server may hold a
- * call for nearly that long. A server that does not see the header must assume
- * the harness default, 60 s for Claude Code, Codex and OpenCode.
- */
-export const MCP_TOOL_TIMEOUT_HEADER = "X-Mcp-Tool-Timeout-Ms";
-const MIN_MCP_TOOL_TIMEOUT_MS = 1_000;
-const MAX_MCP_TOOL_TIMEOUT_MS = 3_600_000;
-/**
- * The tool-call timeout a profile asks the harness to give one MCP server,
- * from `metadata.toolTimeoutMs`. Profile metadata is open in every published
- * schema, so a profile carrying it validates against older consumers, which
- * ignore it. A malformed value is reported, never guessed.
- */
-function mcpToolTimeoutMs(server, name, h, unsupported) {
-    const value = server.metadata?.toolTimeoutMs;
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "number" ||
-        !Number.isSafeInteger(value) ||
-        value < MIN_MCP_TOOL_TIMEOUT_MS ||
-        value > MAX_MCP_TOOL_TIMEOUT_MS) {
-        unsupported("mcp", `${h}: MCP server "${name}" metadata.toolTimeoutMs must be an integer from ${MIN_MCP_TOOL_TIMEOUT_MS} to ${MAX_MCP_TOOL_TIMEOUT_MS}`);
-        return undefined;
+function materializeCodexMcp(h, mcp, plan, unsupported) {
+    const timeouts = mcpToolTimeouts(mcp, h, unsupported);
+    const servers = [];
+    for (const [name, server] of Object.entries(mcp).sort(([left], [right]) => compareStrings(left, right))) {
+        if (server.url && server.transport === "sse") {
+            unsupported("mcp", `codex: remote MCP server "${name}" uses unsupported SSE transport`);
+            continue;
+        }
+        servers.push(concatWorkspacePlanArguments(`${tomlStr(name)} = `, codexMcpServerToml(name, server, plan, timeouts.get(name))));
+    }
+    if (servers.length > 0) {
+        // Runtime overrides do not require persisted project trust. Header values
+        // ride environment variables so credentials never appear in argv.
+        plan.flags.push("-c", concatWorkspacePlanArguments("mcp_servers={ ", joinWorkspacePlanArguments(servers, ", "), " }"));
     }
-    return value;
 }
-function mcpToolTimeouts(mcp, h, unsupported) {
-    const timeouts = new Map();
+function materializeGeminiMcp(mcp, add) {
+    const servers = {};
     for (const [name, server] of Object.entries(mcp)) {
-        const value = mcpToolTimeoutMs(server, name, h, unsupported);
-        if (value !== undefined)
-            timeouts.set(name, value);
+        if (server.url) {
+            servers[name] = {
+                [server.transport === "sse" ? "url" : "httpUrl"]: server.url,
+                ...(server.headers ? { headers: server.headers } : {}),
+            };
+            continue;
+        }
+        servers[name] = {
+            command: server.command,
+            ...(server.args ? { args: server.args } : {}),
+            ...(server.env ? { env: server.env } : {}),
+            ...(server.cwd ? { cwd: server.cwd } : {}),
+        };
     }
-    return timeouts;
+    add(".gemini/settings.json", serializeWorkspacePlanJson({ mcpServers: servers }));
 }
-function withAppliedToolTimeout(headers, appliedTimeoutMs) {
-    if (appliedTimeoutMs === undefined)
-        return headers;
-    return {
-        ...headers,
-        [MCP_TOOL_TIMEOUT_HEADER]: {
-            kind: "public",
-            value: String(appliedTimeoutMs),
-        },
-    };
+function materializePiMcp(mcp, plan, add) {
+    // pi ships NO MCP. It arrives from the `pi-mcp-adapter` extension, which discovers
+    // `<cwd>/.pi/mcp.json` (adapter 2.17.0 config.ts:17) and also registers a `--mcp-config`
+    // flag (index.ts:252). The flag is registered BY the extension, so passing it when the
+    // extension is absent is not a fallback — it is an unknown flag.
+    //
+    // This was previously marked unsupported because a workspace file cannot install an
+    // extension. That reasoning was right about the constraint and wrong about the conclusion:
+    // the file half is perfectly materializable, and the half that is not becomes a declared
+    // requirement the executor enforces. Marking the whole dimension unsupported pushed both
+    // halves onto every consumer, and two of them independently rebuilt it.
+    const rel = ".pi/mcp.json";
+    const servers = Object.fromEntries(Object.entries(mcp).map(([name, server]) => [
+        name,
+        // `directTools` promotes this server's verbs to first-class pi tools. Without it the
+        // agent gets one generic `mcp` tool and must connect, then describe, then call — three
+        // round trips of discovery before it can do anything. Per-server, because the adapter
+        // lets a per-server value override the global `settings.directTools` (direct-tools.ts:135).
+        { ...piMcpServer(server), directTools: true },
+    ]));
+    // serializeWorkspacePlanJson, NOT JSON.stringify: it unwraps public config values to their
+    // bytes and lifts any secret-ref into a tracked slot the applier resolves. Stringifying
+    // straight would write `{"kind":"public","value":"..."}` into the file as an argv entry.
+    add(rel, serializeWorkspacePlanJson({ mcpServers: servers }));
+    plan.requires?.push({
+        kind: "harness-extension",
+        dimension: "mcp",
+        id: "npm:pi-mcp-adapter",
+        reason: "pi has no built-in MCP; without this extension the servers in .pi/mcp.json are never read and the agent starts with none of their tools",
+        remedy: "pi install npm:pi-mcp-adapter",
+    });
+}
+function tomlInlineStringTable(values) {
+    return `{ ${Object.entries(values)
+        .sort(([left], [right]) => compareStrings(left, right))
+        .map(([key, value]) => `${tomlStr(key)} = ${tomlStr(value)}`)
+        .join(", ")} }`;
 }
 function codexMcpServerToml(name, server, plan, toolTimeoutMs) {
     const fields = [];
@@ -270,58 +237,9 @@ function kimiMcpServer(server) {
         ...(server.cwd ? { cwd: server.cwd } : {}),
     };
 }
-const carriesAuthorization = (headers) => Object.keys(headers ?? {}).some((header) => header.toLowerCase() === "authorization");
-/**
- * Lower canonical MCP definitions to OpenCode's native startup configuration.
- * `toolTimeouts` holds the validated `metadata.toolTimeoutMs` of each server
- * that declared one; without it OpenCode applies the MCP SDK's 60 s default to
- * every tool call.
- */
-export function openCodeMcpConfig(mcp, toolTimeouts = new Map()) {
-    const out = {};
-    for (const [name, s] of Object.entries(mcp)) {
-        if (s.enabled === false)
-            continue;
-        // OpenCode also bounds connect and tool listing by this value, so a server
-        // that hangs on connect holds startup that long; a refused connection still
-        // fails at once.
-        const timeout = toolTimeouts.get(name);
-        if (s.url) {
-            if (s.transport === "sse") {
-                throw new Error(`OpenCode MCP server "${name}" uses unsupported SSE transport`);
-            }
-            const headers = withAppliedToolTimeout(s.headers, timeout);
-            out[name] = {
-                type: "remote",
-                url: s.url,
-                enabled: true,
-                ...(headers ? { headers } : {}),
-                ...(timeout !== undefined ? { timeout } : {}),
-                // A server that takes its credential from these headers has no OAuth
-                // flow. With OAuth on, OpenCode answers its 401 with OAuth discovery at
-                // the server's origin, and the agent sees that discovery's failure
-                // instead of the server's refusal.
-                ...(carriesAuthorization(s.headers) ? { oauth: false } : {}),
-            };
-            continue;
-        }
-        if (!s.command) {
-            throw new Error(`OpenCode MCP server "${name}" must define either url or command`);
-        }
-        if (s.cwd !== undefined) {
-            throw new Error(`OpenCode MCP server "${name}" does not support a cwd field`);
-        }
-        out[name] = {
-            type: "local",
-            command: [s.command, ...(s.args ?? [])],
-            enabled: true,
-            ...(s.env ? { environment: s.env } : {}),
-            ...(timeout !== undefined ? { timeout } : {}),
-        };
-    }
-    return out;
-}
 import { OPENCODE_CONFIG_FILE, OPENCODE_CONFIG_SCHEMA } from "./harness.js";
+import { openCodeMcpConfig } from "./mcp-opencode.js";
+import { mcpToolTimeouts, withAppliedToolTimeout, } from "./mcp-timeouts.js";
 import { sha256 } from "./plan-digest.js";
 import { concatWorkspacePlanArguments, joinWorkspacePlanArguments, serializeWorkspacePlanJson, tomlProfileConfigValue, tomlStr, } from "./plan-json.js";
 import { setPlanEnvironment } from "./profile-plan.js";

package/dist/plan-json.d.ts

@@ -4,15 +4,10 @@ export interface SerializedPlanFileContent {
     secretSlots?: PlanFileSecretSlot[];
 }
 export type AddPlanFile = (path: string, content: string | SerializedPlanFileContent, mode?: number) => void;
-export declare function isProfilePublicConfigValue(value: unknown): value is Extract<AgentProfileConfigValue, {
-    kind: "public";
-}>;
-export declare function isProfileSecretRef(value: unknown): value is AgentProfileSecretRef;
 export declare function workspacePlanConfigValue(value: AgentProfileConfigValue): WorkspacePlanConfigValue;
 export declare function serializeWorkspacePlanJson(value: unknown): SerializedPlanFileContent;
-export declare function workspacePlanArgumentSegments(value: WorkspacePlanArgument): Array<string | WorkspacePlanSecretSegment>;
 export declare function concatWorkspacePlanArguments(...values: WorkspacePlanArgument[]): WorkspacePlanArgument;
 export declare function joinWorkspacePlanArguments(values: WorkspacePlanArgument[], separator: string): WorkspacePlanArgument;
 export declare function tomlProfileConfigValue(value: AgentProfileConfigValue): WorkspacePlanArgument;
-import type { AgentProfileConfigValue, AgentProfileSecretRef } from "@tangle-network/agent-interface";
-import type { PlanFileSecretSlot, WorkspacePlanArgument, WorkspacePlanConfigValue, WorkspacePlanSecretSegment } from "./plan-types.js";
+import type { AgentProfileConfigValue } from "@tangle-network/agent-interface";
+import type { PlanFileSecretSlot, WorkspacePlanArgument, WorkspacePlanConfigValue } from "./plan-types.js";

package/dist/plan-json.js

@@ -1,12 +1,12 @@
 export const tomlStr = (s) => JSON.stringify(s); // valid TOML basic string
-export function isProfilePublicConfigValue(value) {
+function isProfilePublicConfigValue(value) {
     return (typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
         value.kind === "public" &&
         typeof value.value === "string");
 }
-export function isProfileSecretRef(value) {
+function isProfileSecretRef(value) {
     return (typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
@@ -54,7 +54,7 @@ export function serializeWorkspacePlanJson(value) {
         ...(secretSlots.length === 0 ? {} : { secretSlots }),
     };
 }
-export function workspacePlanArgumentSegments(value) {
+function workspacePlanArgumentSegments(value) {
     return typeof value === "string" ? [value] : [...value.segments];
 }
 export function concatWorkspacePlanArguments(...values) {

package/dist/plan-normalize.d.ts

@@ -7,9 +7,6 @@ export interface NormalizedPlanFile {
     ownership: NonNullable<PlanFile["ownership"]>;
     secretSlots: PlanFileSecretSlot[];
 }
-export type JsonValue = null | boolean | number | string | JsonValue[] | {
-    [key: string]: JsonValue;
-};
 export declare function normalizePlanFiles(files: PlanFile[]): NormalizedPlanFile[];
 export declare function normalizeWorkspacePlanArgument(value: WorkspacePlanArgument): WorkspacePlanArgument;
 import type { PlanFile, PlanFileRoot, PlanFileSecretSlot, WorkspacePlanArgument } from "./plan-types.js";

package/dist/plan-types.d.ts

@@ -174,7 +174,7 @@ export interface WorkspacePlan {
     files: PlanFile[];
     /** Env vars to set on the spawned process (for harnesses needing them). */
     env: Record<string, WorkspacePlanConfigValue>;
-    /** Extra CLI flags to pass (e.g. kimi --mcp-config-file <path>). */
+    /** Extra CLI flags to pass (e.g. claude --mcp-config <path>). */
     flags: WorkspacePlanArgument[];
     /**
      * Exact text that REPLACES the harness's own system prompt, for harnesses