claude-code-rust 0.12.0 → 0.12.2

package/agent-sdk/dist/bridge/logger.js

@@ -130,6 +130,7 @@ function eventToolCallId(event) {
         case "elicitation_complete":
         case "mcp_auth_redirect":
         case "mcp_operation_error":
+        case "mcp_set_servers_result":
         case "turn_complete":
         case "turn_error":
         case "slash_error":
@@ -173,6 +174,7 @@ function protocolEventLevel(event) {
         case "session_update":
         case "permission_request":
         case "question_request":
+        case "user_dialog_request":
         case "elicitation_request":
         case "elicitation_complete":
         case "mcp_auth_redirect":
@@ -182,6 +184,7 @@ function protocolEventLevel(event) {
         case "status_snapshot":
         case "context_usage":
         case "runtime_reload_completed":
+        case "mcp_set_servers_result":
         case "mcp_snapshot":
             return "debug";
     }

package/agent-sdk/dist/bridge/mcp.js

@@ -1,5 +1,6 @@
 import { emitMcpOperationError, slashError, writeEvent } from "./events.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { bridgeMcpServersToSdk, mapMcpServerStatus, summarizeMcpServersForDiagnostics, } from "./mcp_metadata.js";
 export const MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS = 30_000;
 const knownConnectedMcpServers = new Set();
 function logMcpSuccess(eventName, message, sessionId, requestId, fields) {
@@ -30,6 +31,22 @@ function logMcpFailure(eventName, message, sessionId, errorMessage, requestId, f
 function queryWithMcpAuth(session) {
     return session.query;
 }
+function mapMcpSetServersResult(result) {
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+        return { added: [], removed: [], errors: {} };
+    }
+    const record = result;
+    const added = Array.isArray(record.added)
+        ? record.added.filter((value) => typeof value === "string")
+        : [];
+    const removed = Array.isArray(record.removed)
+        ? record.removed.filter((value) => typeof value === "string")
+        : [];
+    const errors = record.errors && typeof record.errors === "object" && !Array.isArray(record.errors)
+        ? Object.fromEntries(Object.entries(record.errors).filter((entry) => typeof entry[1] === "string"))
+        : {};
+    return { added, removed, errors };
+}
 async function callMcpAuthMethod(session, methodName, args) {
     const query = queryWithMcpAuth(session);
     switch (methodName) {
@@ -72,17 +89,31 @@ function emitMcpCommandError(sessionId, operation, message, requestId, serverNam
         message,
     }, requestId);
 }
-export async function emitMcpSnapshotEvent(session, requestId) {
+export async function emitMcpSnapshotEvent(session, requestId, source = "mcp_status") {
     const servers = await session.query.mcpServerStatus();
     let mapped = servers.map(mapMcpServerStatus);
     mapped = await reconcileSuspiciousMcpStatuses(session, mapped);
+    return emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId);
+}
+export function emitMcpSnapshotFromStatuses(session, servers, source, requestId) {
+    return emitMcpSnapshotFromMappedStatuses(session, servers.map(mapMcpServerStatus), source, requestId);
+}
+export async function emitReconciledMcpSnapshotFromStatuses(session, servers, source, requestId) {
+    let mapped = servers.map(mapMcpServerStatus);
+    mapped = await reconcileSuspiciousMcpStatuses(session, mapped);
+    return emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId);
+}
+function emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId) {
     rememberKnownConnectedMcpServers(mapped);
     logMcpSuccess("mcp_snapshot_emitted", "MCP snapshot emitted", session.sessionId, requestId, {
+        source,
         server_count: mapped.length,
+        servers: summarizeMcpServersForDiagnostics(mapped),
     });
     writeEvent({
         event: "mcp_snapshot",
         session_id: session.sessionId,
+        source,
         servers: mapped,
     }, requestId);
     return mapped;
@@ -181,9 +212,9 @@ async function monitorMcpAuthSnapshot(session, serverName, attempt, maxAttempts,
         }
     }
 }
-export async function handleMcpStatusCommand(session, requestId) {
+export async function handleMcpStatusCommand(session, requestId, source = "mcp_status") {
     try {
-        await emitMcpSnapshotEvent(session, requestId);
+        await emitMcpSnapshotEvent(session, requestId, source);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -191,6 +222,7 @@ export async function handleMcpStatusCommand(session, requestId) {
         writeEvent({
             event: "mcp_snapshot",
             session_id: session.sessionId,
+            source,
             servers: [],
             error: message,
         }, requestId);
@@ -222,12 +254,24 @@ export async function handleMcpToggleCommand(session, command, requestId) {
 }
 export async function handleMcpSetServersCommand(session, command, requestId) {
     try {
-        await session.query.setMcpServers(command.servers);
-        logMcpSuccess("mcp_servers_set_completed", "MCP server configuration updated", command.session_id, requestId, { server_count: Object.keys(command.servers).length });
+        const result = mapMcpSetServersResult(await session.query.setMcpServers(bridgeMcpServersToSdk(command.servers)));
+        logMcpSuccess("mcp_servers_set_completed", "MCP server configuration updated", command.session_id, requestId, {
+            server_count: Object.keys(command.servers).length,
+            added_count: result.added.length,
+            removed_count: result.removed.length,
+            error_count: Object.keys(result.errors).length,
+        });
+        writeEvent({
+            event: "mcp_set_servers_result",
+            session_id: command.session_id,
+            result,
+        }, requestId);
+        await handleMcpStatusCommand(session, requestId, "mcp_set_servers");
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         logMcpFailure("mcp_servers_set_failed", "failed to update MCP server configuration", command.session_id, message, requestId, { server_count: Object.keys(command.servers).length });
+        emitMcpOperationError(command.session_id, { operation: "set-servers", message }, requestId);
         slashError(command.session_id, `failed to set MCP servers: ${message}`, requestId);
     }
 }
@@ -289,77 +333,3 @@ export async function handleMcpOauthCallbackUrlCommand(session, command, request
         emitMcpCommandError(command.session_id, "submit-callback-url", message, requestId, command.server_name);
     }
 }
-function mapMcpServerStatus(status) {
-    return {
-        name: status.name,
-        status: status.status,
-        ...(status.serverInfo
-            ? {
-                server_info: {
-                    name: status.serverInfo.name,
-                    version: status.serverInfo.version,
-                },
-            }
-            : {}),
-        ...(status.error ? { error: status.error } : {}),
-        ...(status.config ? { config: mapMcpServerStatusConfig(status.config) } : {}),
-        ...(status.scope ? { scope: status.scope } : {}),
-        tools: Array.isArray(status.tools)
-            ? status.tools.map((tool) => ({
-                name: tool.name,
-                ...(tool.description ? { description: tool.description } : {}),
-                ...(tool.annotations
-                    ? {
-                        annotations: {
-                            ...(typeof tool.annotations.readOnly === "boolean"
-                                ? { read_only: tool.annotations.readOnly }
-                                : {}),
-                            ...(typeof tool.annotations.destructive === "boolean"
-                                ? { destructive: tool.annotations.destructive }
-                                : {}),
-                            ...(typeof tool.annotations.openWorld === "boolean"
-                                ? { open_world: tool.annotations.openWorld }
-                                : {}),
-                        },
-                    }
-                    : {}),
-            }))
-            : [],
-    };
-}
-function mapMcpServerStatusConfig(config) {
-    switch (config.type) {
-        case "stdio":
-            return {
-                type: "stdio",
-                command: config.command,
-                ...(Array.isArray(config.args) && config.args.length > 0 ? { args: config.args } : {}),
-                ...(config.env ? { env: config.env } : {}),
-            };
-        case "sse":
-            return {
-                type: "sse",
-                url: config.url,
-                ...(config.headers ? { headers: config.headers } : {}),
-            };
-        case "http":
-            return {
-                type: "http",
-                url: config.url,
-                ...(config.headers ? { headers: config.headers } : {}),
-            };
-        case "sdk":
-            return {
-                type: "sdk",
-                name: config.name,
-            };
-        case "claudeai-proxy":
-            return {
-                type: "claudeai-proxy",
-                url: config.url,
-                id: config.id,
-            };
-        default:
-            throw new Error(`unsupported MCP status config: ${JSON.stringify(config)}`);
-    }
-}

package/agent-sdk/dist/bridge/mcp_metadata.js

@@ -0,0 +1,369 @@
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+const TOOL_PERMISSION_POLICIES = new Set([
+    "always_allow",
+    "always_ask",
+    "always_deny",
+]);
+const ORG_MAX_PERMISSIONS = new Set([
+    "allow",
+    "ask",
+    "blocked",
+]);
+function asRecord(value, context) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${context} must be an object`);
+    }
+    return value;
+}
+function optionalStringArray(record, key, context) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+        throw new Error(`${context}.${key} must be an array of strings`);
+    }
+    return value;
+}
+function optionalStringMap(record, key, context) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    const map = asRecord(value, `${context}.${key}`);
+    for (const [entryKey, entryValue] of Object.entries(map)) {
+        if (typeof entryValue !== "string") {
+            throw new Error(`${context}.${key}.${entryKey} must be a string`);
+        }
+    }
+    return map;
+}
+function optionalTimeout(record, context) {
+    const value = record.timeout;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 1000) {
+        throw new Error(`${context}.timeout must be an integer >= 1000`);
+    }
+    return value;
+}
+function optionalAlwaysLoad(record, context) {
+    const value = record.always_load;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${context}.always_load must be a boolean`);
+    }
+    return value;
+}
+function optionalToolPolicies(record, context) {
+    const value = record.tools;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}.tools must be an array`);
+    }
+    return value.map((entry, index) => {
+        const item = asRecord(entry, `${context}.tools[${index}]`);
+        const name = item.name;
+        if (typeof name !== "string") {
+            throw new Error(`${context}.tools[${index}].name must be a string`);
+        }
+        const policy = { name };
+        const permissionPolicy = item.permission_policy;
+        if (permissionPolicy !== undefined) {
+            if (typeof permissionPolicy !== "string" || !TOOL_PERMISSION_POLICIES.has(permissionPolicy)) {
+                throw new Error(`${context}.tools[${index}].permission_policy must be one of always_allow, always_ask, always_deny`);
+            }
+            policy.permission_policy = permissionPolicy;
+        }
+        const orgMaxPermission = item.org_max_permission;
+        if (orgMaxPermission !== undefined) {
+            if (typeof orgMaxPermission !== "string" || !ORG_MAX_PERMISSIONS.has(orgMaxPermission)) {
+                throw new Error(`${context}.tools[${index}].org_max_permission must be one of allow, ask, blocked`);
+            }
+            policy.org_max_permission = orgMaxPermission;
+        }
+        return policy;
+    });
+}
+export function parseMcpServerConfig(value, context) {
+    const record = asRecord(value, context);
+    const rawType = record.type;
+    const type = rawType === undefined ? "stdio" : rawType;
+    if (typeof type !== "string") {
+        throw new Error(`${context}.type must be a string`);
+    }
+    const timeout = optionalTimeout(record, context);
+    const alwaysLoad = optionalAlwaysLoad(record, context);
+    switch (type) {
+        case "stdio": {
+            if (record.tools !== undefined) {
+                throw new Error(`${context}.tools is only supported for http and sse MCP servers`);
+            }
+            const command = record.command;
+            if (typeof command !== "string") {
+                throw new Error(`${context}.command must be a string`);
+            }
+            return {
+                type,
+                command,
+                ...(optionalStringArray(record, "args", context) ? { args: optionalStringArray(record, "args", context) } : {}),
+                ...(optionalStringMap(record, "env", context) ? { env: optionalStringMap(record, "env", context) } : {}),
+                ...(timeout === undefined ? {} : { timeout }),
+                ...(alwaysLoad === undefined ? {} : { always_load: alwaysLoad }),
+            };
+        }
+        case "sse":
+        case "http": {
+            const url = record.url;
+            if (typeof url !== "string") {
+                throw new Error(`${context}.url must be a string`);
+            }
+            const tools = optionalToolPolicies(record, context);
+            return {
+                type,
+                url,
+                ...(optionalStringMap(record, "headers", context) ? { headers: optionalStringMap(record, "headers", context) } : {}),
+                ...(tools === undefined ? {} : { tools }),
+                ...(timeout === undefined ? {} : { timeout }),
+                ...(alwaysLoad === undefined ? {} : { always_load: alwaysLoad }),
+            };
+        }
+        default:
+            throw new Error(`${context}.type must be one of stdio, sse, http`);
+    }
+}
+export function parseMcpServersRecord(value, context) {
+    const record = asRecord(value, context);
+    return Object.fromEntries(Object.entries(record).map(([key, entry]) => [key, parseMcpServerConfig(entry, `${context}.${key}`)]));
+}
+function toSdkToolPolicies(tools) {
+    return tools?.map((tool) => ({
+        name: tool.name,
+        ...(tool.permission_policy === undefined ? {} : { permission_policy: tool.permission_policy }),
+        ...(tool.org_max_permission === undefined ? {} : { org_max_permission: tool.org_max_permission }),
+    }));
+}
+export function bridgeMcpConfigToSdk(config) {
+    switch (config.type) {
+        case "stdio":
+            return {
+                type: "stdio",
+                command: config.command,
+                ...(config.args ? { args: config.args } : {}),
+                ...(config.env ? { env: config.env } : {}),
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(config.always_load === undefined ? {} : { alwaysLoad: config.always_load }),
+            };
+        case "sse":
+            return {
+                type: "sse",
+                url: config.url,
+                ...(config.headers ? { headers: config.headers } : {}),
+                ...(config.tools ? { tools: toSdkToolPolicies(config.tools) } : {}),
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(config.always_load === undefined ? {} : { alwaysLoad: config.always_load }),
+            };
+        case "http":
+            return {
+                type: "http",
+                url: config.url,
+                ...(config.headers ? { headers: config.headers } : {}),
+                ...(config.tools ? { tools: toSdkToolPolicies(config.tools) } : {}),
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(config.always_load === undefined ? {} : { alwaysLoad: config.always_load }),
+            };
+    }
+}
+export function bridgeMcpServersToSdk(servers) {
+    return Object.fromEntries(Object.entries(servers).map(([name, config]) => [name, bridgeMcpConfigToSdk(config)]));
+}
+function mapSdkToolPolicies(tools) {
+    if (!Array.isArray(tools)) {
+        return undefined;
+    }
+    return tools
+        .map((tool) => {
+        if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+            return null;
+        }
+        const raw = tool;
+        if (typeof raw.name !== "string") {
+            return null;
+        }
+        const policy = { name: raw.name };
+        if (raw.permission_policy !== undefined) {
+            if (typeof raw.permission_policy !== "string" || !TOOL_PERMISSION_POLICIES.has(raw.permission_policy)) {
+                return null;
+            }
+            policy.permission_policy = raw.permission_policy;
+        }
+        if (raw.org_max_permission !== undefined) {
+            if (typeof raw.org_max_permission !== "string" || !ORG_MAX_PERMISSIONS.has(raw.org_max_permission)) {
+                return null;
+            }
+            policy.org_max_permission = raw.org_max_permission;
+        }
+        return policy;
+    })
+        .filter((tool) => tool !== null);
+}
+export function mapMcpServerStatus(status) {
+    return {
+        name: status.name,
+        status: status.status,
+        ...(status.serverInfo
+            ? {
+                server_info: {
+                    name: status.serverInfo.name,
+                    version: status.serverInfo.version,
+                },
+            }
+            : {}),
+        ...(status.error ? { error: status.error } : {}),
+        ...(status.config ? { config: mapMcpServerStatusConfig(status.config) } : {}),
+        ...(status.scope ? { scope: status.scope } : {}),
+        tools: Array.isArray(status.tools)
+            ? status.tools.map((tool) => ({
+                name: tool.name,
+                ...(tool.description ? { description: tool.description } : {}),
+                ...(tool.annotations
+                    ? {
+                        annotations: {
+                            ...(typeof tool.annotations.readOnly === "boolean"
+                                ? { read_only: tool.annotations.readOnly }
+                                : {}),
+                            ...(typeof tool.annotations.destructive === "boolean"
+                                ? { destructive: tool.annotations.destructive }
+                                : {}),
+                            ...(typeof tool.annotations.openWorld === "boolean"
+                                ? { open_world: tool.annotations.openWorld }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            }))
+            : [],
+    };
+}
+export function mapMcpServerStatusConfig(config) {
+    switch (config.type) {
+        case "stdio":
+            return {
+                type: "stdio",
+                command: config.command,
+                ...(Array.isArray(config.args) && config.args.length > 0 ? { args: config.args } : {}),
+                ...(config.env ? { env: config.env } : {}),
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(config.alwaysLoad === undefined ? {} : { always_load: config.alwaysLoad }),
+            };
+        case "sse": {
+            const tools = mapSdkToolPolicies(config.tools);
+            return {
+                type: "sse",
+                url: config.url,
+                ...(config.headers ? { headers: config.headers } : {}),
+                ...(tools === undefined ? {} : { tools }),
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(config.alwaysLoad === undefined ? {} : { always_load: config.alwaysLoad }),
+            };
+        }
+        case "http": {
+            const tools = mapSdkToolPolicies(config.tools);
+            return {
+                type: "http",
+                url: config.url,
+                ...(config.headers ? { headers: config.headers } : {}),
+                ...(tools === undefined ? {} : { tools }),
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(config.alwaysLoad === undefined ? {} : { always_load: config.alwaysLoad }),
+            };
+        }
+        case "sdk":
+            return {
+                type: "sdk",
+                name: config.name,
+            };
+        case "claudeai-proxy":
+            return {
+                type: "claudeai-proxy",
+                url: config.url,
+                id: config.id,
+                ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+            };
+        default: {
+            const raw = config;
+            const rawType = typeof raw.type === "string" ? raw.type : "unknown";
+            bridgeLogger.warn({
+                target: LOG_TARGETS.BRIDGE_MCP,
+                eventName: "mcp_status_config_unknown",
+                message: "unknown MCP status config type",
+                outcome: "ignored",
+                fields: { config_type: rawType },
+            });
+            return { type: "unknown", raw_type: rawType };
+        }
+    }
+}
+function mcpStatusConfigDiagnostics(config) {
+    if (!config) {
+        return {
+            config_type: "missing",
+            configured_tool_policy_count: 0,
+        };
+    }
+    switch (config.type) {
+        case "stdio":
+            return {
+                config_type: "stdio",
+                ...(config.timeout === undefined ? {} : { timeout_ms: config.timeout }),
+                ...(config.always_load === undefined ? {} : { always_load: config.always_load }),
+                configured_tool_policy_count: 0,
+            };
+        case "sse":
+        case "http":
+            return {
+                config_type: config.type,
+                ...(config.timeout === undefined ? {} : { timeout_ms: config.timeout }),
+                ...(config.always_load === undefined ? {} : { always_load: config.always_load }),
+                configured_tool_policy_count: config.tools?.length ?? 0,
+            };
+        case "sdk":
+            return {
+                config_type: "sdk",
+                configured_tool_policy_count: 0,
+            };
+        case "claudeai-proxy":
+            return {
+                config_type: "claudeai-proxy",
+                ...(config.timeout === undefined ? {} : { timeout_ms: config.timeout }),
+                configured_tool_policy_count: 0,
+            };
+        case "unknown":
+            return {
+                config_type: `unknown:${config.raw_type}`,
+                configured_tool_policy_count: 0,
+            };
+    }
+}
+export function summarizeMcpServersForDiagnostics(servers) {
+    return servers.map((server) => {
+        const config = mcpStatusConfigDiagnostics(server.config);
+        return {
+            name: server.name,
+            status: server.status,
+            config_type: config.config_type,
+            ...(server.scope ? { scope: server.scope } : {}),
+            ...(config.timeout_ms === undefined ? {} : { timeout_ms: config.timeout_ms }),
+            ...(config.always_load === undefined ? {} : { always_load: config.always_load }),
+            tool_count: server.tools.length,
+            configured_tool_policy_count: config.configured_tool_policy_count,
+            has_error: typeof server.error === "string" && server.error.length > 0,
+            has_server_info: server.server_info !== undefined,
+        };
+    });
+}