claude-code-rust 0.7.0 → 0.8.0

package/README.md

@@ -5,7 +5,7 @@ A native Rust terminal interface for Claude Code. Drop-in replacement for Anthro
 [![npm version](https://img.shields.io/npm/v/claude-code-rust)](https://www.npmjs.com/package/claude-code-rust)
 [![npm downloads](https://img.shields.io/npm/dm/claude-code-rust)](https://www.npmjs.com/package/claude-code-rust)
 [![CI](https://github.com/srothgan/claude-code-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/srothgan/claude-code-rust/actions/workflows/ci.yml)
-[![License: AGPL-3.0-or-later](https://img.shields.io/badge/License-AGPL--3.0--or--later-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-green.svg)](https://nodejs.org/)
 
 ## About
@@ -19,14 +19,17 @@ Claude Code Rust replaces the stock Claude Code terminal interface with a native
 
 ## Install
 
-### pnpm (global, recommended)
+### npm (global, recommended)
 
 ```bash
-pnpm add -g claude-code-rust
+npm install -g claude-code-rust
 ```
 
-The published package installs a `claude-rs` command and downloads the matching
-prebuilt release binary for your platform during `postinstall`.
+The published package installs a `claude-rs` command and fetches the matching
+prebuilt release binary for your platform during install.
+
+If `claude-rs` resolves to an older global shim, ensure your npm global bin
+directory comes first on `PATH` or remove the stale shim before retrying.
 
 ## Usage
 
@@ -56,20 +59,14 @@ Three-layer design:
 
 **Agent Runtime** (Anthropic Agent SDK) - The TypeScript bridge drives `@anthropic-ai/claude-agent-sdk`, which manages authentication, session/query lifecycle, and tool execution.
 
-## Known Limitations
-
-- The config view includes the Settings tab but the Status, Usage, and MCP tabs are not yet implemented.
-
 ## Status
 
 This project is pre-1.0 and under active development. See [CONTRIBUTING.md](CONTRIBUTING.md) for how to get involved.
 
 ## License
 
-This project is licensed under the [GNU Affero General Public License v3.0 or later](LICENSE).
-This license was chosen because Claude Code is not open-source and this license allows everyone to use it while stopping Anthropic from implementing it in their closed-source version.
-
-By using this software, you agree to the terms of the AGPL-3.0. If you modify this software and make it available over a network, you must offer the source code to users of that service.
+This project is licensed under the [Apache License 2.0](LICENSE).
+Apache-2.0 was chosen to keep usage and redistribution straightforward for individual users, downstream packagers, and commercial adopters.
 
 ## Disclaimer
 

package/agent-sdk/README.md

@@ -0,0 +1,17 @@
+# claude-rs agent-sdk bridge
+
+Initial scaffold for the NDJSON stdio bridge that will connect Rust (`claude-code-rust`) with `@anthropic-ai/claude-agent-sdk`.
+
+## Local build
+
+```bash
+npm install
+npm run build
+```
+
+Build output is written to `dist/bridge.mjs`.
+
+## License
+
+This bridge is part of the `claude-code-rust` project and is licensed under
+the Apache License 2.0. See the repository root [LICENSE](../LICENSE).

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

@@ -48,38 +48,43 @@ function optionalLaunchSettings(record, key, context) {
         return {};
     }
     const parsed = asRecord(value, `${context}.${key}`);
-    const model = optionalString(parsed, "model", `${context}.${key}`);
     const language = optionalString(parsed, "language", `${context}.${key}`);
-    const permissionMode = optionalString(parsed, "permission_mode", `${context}.${key}`);
-    const thinkingMode = optionalThinkingMode(parsed, "thinking_mode", `${context}.${key}`);
-    const effortLevel = optionalEffortLevel(parsed, "effort_level", `${context}.${key}`);
+    const settings = optionalJsonObject(parsed, "settings", `${context}.${key}`);
+    const agentProgressSummaries = optionalBoolean(parsed, "agent_progress_summaries", `${context}.${key}`);
     return {
-        ...(model ? { model } : {}),
         ...(language ? { language } : {}),
-        ...(permissionMode ? { permission_mode: permissionMode } : {}),
-        ...(thinkingMode ? { thinking_mode: thinkingMode } : {}),
-        ...(effortLevel ? { effort_level: effortLevel } : {}),
+        ...(settings ? { settings } : {}),
+        ...(agentProgressSummaries !== undefined
+            ? { agent_progress_summaries: agentProgressSummaries }
+            : {}),
     };
 }
-function optionalThinkingMode(record, key, context) {
-    const value = optionalString(record, key, context);
-    if (value === undefined) {
+function optionalBoolean(record, key, context) {
+    const value = record[key];
+    if (value === undefined || value === null) {
         return undefined;
     }
-    if (value === "adaptive" || value === "disabled") {
-        return value;
+    if (typeof value !== "boolean") {
+        throw new Error(`${context}.${key} must be a boolean when provided`);
     }
-    throw new Error(`${context}.${key} must be "adaptive" or "disabled" when provided`);
+    return value;
 }
-function optionalEffortLevel(record, key, context) {
-    const value = optionalString(record, key, context);
-    if (value === undefined) {
+function optionalJsonObject(record, key, context) {
+    const value = record[key];
+    if (value === undefined || value === null) {
         return undefined;
     }
-    if (value === "low" || value === "medium" || value === "high") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${context}.${key} must be an object when provided`);
+    }
+    return value;
+}
+function expectElicitationAction(record, key, context) {
+    const value = expectString(record, key, context);
+    if (value === "accept" || value === "decline" || value === "cancel") {
         return value;
     }
-    throw new Error(`${context}.${key} must be "low", "medium", or "high" when provided`);
+    throw new Error(`${context}.${key} must be one of accept, decline, cancel`);
 }
 function parsePromptChunks(record, context) {
     const rawChunks = record.chunks;
@@ -92,6 +97,41 @@ function parsePromptChunks(record, context) {
         return { kind, value: (parsed.value ?? null) };
     });
 }
+function expectBoolean(record, key, context) {
+    const value = record[key];
+    if (typeof value !== "boolean") {
+        throw new Error(`${context}.${key} must be a boolean`);
+    }
+    return value;
+}
+function parseMcpServerConfig(value, context) {
+    const record = asRecord(value, context);
+    const type = expectString(record, "type", context);
+    switch (type) {
+        case "stdio":
+            return {
+                type,
+                command: expectString(record, "command", context),
+                ...(record.args === undefined ? {} : { args: expectStringArray(record, "args", context) }),
+                ...(record.env === undefined ? {} : { env: expectStringMap(record, "env", context) }),
+            };
+        case "sse":
+        case "http":
+            return {
+                type,
+                url: expectString(record, "url", context),
+                ...(record.headers === undefined
+                    ? {}
+                    : { headers: expectStringMap(record, "headers", context) }),
+            };
+        default:
+            throw new Error(`${context}.type must be one of stdio, sse, http`);
+    }
+}
+function parseMcpServersRecord(value, context) {
+    const record = asRecord(value, context);
+    return Object.fromEntries(Object.entries(record).map(([key, entry]) => [key, parseMcpServerConfig(entry, `${context}.${key}`)]));
+}
 export function parseCommandEnvelope(line) {
     const raw = asRecord(JSON.parse(line), "command envelope");
     const requestId = typeof raw.request_id === "string" ? raw.request_id : undefined;
@@ -148,6 +188,48 @@ export function parseCommandEnvelope(line) {
                     session_id: expectString(raw, "session_id", "set_mode"),
                     mode: expectString(raw, "mode", "set_mode"),
                 };
+            case "generate_session_title":
+                return {
+                    command: "generate_session_title",
+                    session_id: expectString(raw, "session_id", "generate_session_title"),
+                    description: expectString(raw, "description", "generate_session_title"),
+                };
+            case "rename_session":
+                return {
+                    command: "rename_session",
+                    session_id: expectString(raw, "session_id", "rename_session"),
+                    title: expectString(raw, "title", "rename_session"),
+                };
+            case "get_status_snapshot":
+                return {
+                    command: "get_status_snapshot",
+                    session_id: expectString(raw, "session_id", "get_status_snapshot"),
+                };
+            case "mcp_status":
+            case "get_mcp_snapshot":
+                return {
+                    command: "mcp_status",
+                    session_id: expectString(raw, "session_id", commandName),
+                };
+            case "mcp_reconnect":
+                return {
+                    command: "mcp_reconnect",
+                    session_id: expectString(raw, "session_id", "mcp_reconnect"),
+                    server_name: expectString(raw, "server_name", "mcp_reconnect"),
+                };
+            case "mcp_toggle":
+                return {
+                    command: "mcp_toggle",
+                    session_id: expectString(raw, "session_id", "mcp_toggle"),
+                    server_name: expectString(raw, "server_name", "mcp_toggle"),
+                    enabled: expectBoolean(raw, "enabled", "mcp_toggle"),
+                };
+            case "mcp_set_servers":
+                return {
+                    command: "mcp_set_servers",
+                    session_id: expectString(raw, "session_id", "mcp_set_servers"),
+                    servers: parseMcpServersRecord(raw.servers ?? {}, "mcp_set_servers.servers"),
+                };
             case "permission_response": {
                 const outcome = asRecord(raw.outcome, "permission_response.outcome");
                 const outcomeType = expectString(outcome, "outcome", "permission_response.outcome");
@@ -167,6 +249,57 @@ export function parseCommandEnvelope(line) {
                     outcome: parsedOutcome,
                 };
             }
+            case "question_response": {
+                const outcome = asRecord(raw.outcome, "question_response.outcome");
+                const outcomeType = expectString(outcome, "outcome", "question_response.outcome");
+                if (outcomeType !== "answered" && outcomeType !== "cancelled") {
+                    throw new Error("question_response.outcome.outcome must be 'answered' or 'cancelled'");
+                }
+                const parsedOutcome = outcomeType === "answered"
+                    ? {
+                        outcome: "answered",
+                        selected_option_ids: expectStringArray(outcome, "selected_option_ids", "question_response.outcome"),
+                        ...(outcome.annotation === undefined || outcome.annotation === null
+                            ? {}
+                            : { annotation: parseQuestionAnnotation(outcome.annotation) }),
+                    }
+                    : { outcome: "cancelled" };
+                return {
+                    command: "question_response",
+                    session_id: expectString(raw, "session_id", "question_response"),
+                    tool_call_id: expectString(raw, "tool_call_id", "question_response"),
+                    outcome: parsedOutcome,
+                };
+            }
+            case "elicitation_response":
+                return {
+                    command: "elicitation_response",
+                    session_id: expectString(raw, "session_id", "elicitation_response"),
+                    elicitation_request_id: expectString(raw, "elicitation_request_id", "elicitation_response"),
+                    action: expectElicitationAction(raw, "action", "elicitation_response"),
+                    ...(optionalJsonObject(raw, "content", "elicitation_response")
+                        ? { content: optionalJsonObject(raw, "content", "elicitation_response") }
+                        : {}),
+                };
+            case "mcp_authenticate":
+                return {
+                    command: "mcp_authenticate",
+                    session_id: expectString(raw, "session_id", "mcp_authenticate"),
+                    server_name: expectString(raw, "server_name", "mcp_authenticate"),
+                };
+            case "mcp_clear_auth":
+                return {
+                    command: "mcp_clear_auth",
+                    session_id: expectString(raw, "session_id", "mcp_clear_auth"),
+                    server_name: expectString(raw, "server_name", "mcp_clear_auth"),
+                };
+            case "mcp_oauth_callback_url":
+                return {
+                    command: "mcp_oauth_callback_url",
+                    session_id: expectString(raw, "session_id", "mcp_oauth_callback_url"),
+                    server_name: expectString(raw, "server_name", "mcp_oauth_callback_url"),
+                    callback_url: expectString(raw, "callback_url", "mcp_oauth_callback_url"),
+                };
             case "shutdown":
                 return { command: "shutdown" };
             default:
@@ -175,6 +308,37 @@ export function parseCommandEnvelope(line) {
     })();
     return { requestId, command };
 }
+function expectStringArray(record, key, context) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}.${key} must be an array`);
+    }
+    return value.map((entry, index) => {
+        if (typeof entry !== "string") {
+            throw new Error(`${context}.${key}[${index}] must be a string`);
+        }
+        return entry;
+    });
+}
+function expectStringMap(record, key, context) {
+    const value = record[key];
+    const parsed = asRecord(value, `${context}.${key}`);
+    return Object.fromEntries(Object.entries(parsed).map(([entryKey, entryValue]) => {
+        if (typeof entryValue !== "string") {
+            throw new Error(`${context}.${key}.${entryKey} must be a string`);
+        }
+        return [entryKey, entryValue];
+    }));
+}
+function parseQuestionAnnotation(value) {
+    const record = asRecord(value, "question_response.outcome.annotation");
+    const preview = optionalString(record, "preview", "question_response.outcome.annotation");
+    const notes = optionalString(record, "notes", "question_response.outcome.annotation");
+    return {
+        ...(preview !== undefined ? { preview } : {}),
+        ...(notes !== undefined ? { notes } : {}),
+    };
+}
 export function toPermissionMode(mode) {
     if (mode === "default" ||
         mode === "acceptEdits" ||

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

@@ -2,6 +2,16 @@ import { listSessions } from "@anthropic-ai/claude-agent-sdk";
 import { buildModeState } from "./commands.js";
 import { mapSdkSessions } from "./history.js";
 const SESSION_LIST_LIMIT = 50;
+let sessionListingDir;
+export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
+    return dir ? { dir, includeWorktrees: true, limit } : { limit };
+}
+export function setSessionListingDir(dir) {
+    sessionListingDir = dir;
+}
+export function currentSessionListOptions() {
+    return buildSessionListOptions(sessionListingDir);
+}
 export function writeEvent(event, requestId) {
     const envelope = {
         ...(requestId ? { request_id: requestId } : {}),
@@ -15,6 +25,9 @@ export function failConnection(message, requestId) {
 export function slashError(sessionId, message, requestId) {
     writeEvent({ event: "slash_error", session_id: sessionId, message }, requestId);
 }
+export function emitMcpOperationError(sessionId, error, requestId) {
+    writeEvent({ event: "mcp_operation_error", session_id: sessionId, error }, requestId);
+}
 export function emitSessionUpdate(sessionId, update) {
     writeEvent({ event: "session_update", session_id: sessionId, update });
 }
@@ -67,7 +80,7 @@ export function emitConnectEvent(session) {
 }
 export async function emitSessionsList(requestId) {
     try {
-        const sdkSessions = await listSessions({ limit: SESSION_LIST_LIMIT });
+        const sdkSessions = await listSessions(currentSessionListOptions());
         writeEvent({ event: "sessions_listed", sessions: mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT) }, requestId);
     }
     catch (error) {

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

@@ -48,7 +48,7 @@ function pushResumeToolResult(updates, toolCalls, block) {
     }
     const isError = Boolean(block.is_error);
     const base = toolCalls.get(toolUseId);
-    const fields = buildToolResultFields(isError, block.content, base);
+    const fields = buildToolResultFields(isError, block.content, base, block);
     updates.push({ type: "tool_call_update", tool_call_update: { tool_call_id: toolUseId, fields } });
     if (!base) {
         return;
@@ -60,6 +60,9 @@ function pushResumeToolResult(updates, toolCalls, block) {
     if (fields.content) {
         base.content = fields.content;
     }
+    if (fields.output_metadata) {
+        base.output_metadata = fields.output_metadata;
+    }
 }
 function summaryFromSession(info) {
     return (nonEmptyTrimmed(info.summary) ??

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

@@ -0,0 +1,289 @@
+import { emitMcpOperationError, slashError, writeEvent } from "./events.js";
+export const MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS = 30_000;
+const knownConnectedMcpServers = new Set();
+function queryWithMcpAuth(session) {
+    return session.query;
+}
+async function callMcpAuthMethod(session, methodName, args) {
+    const query = queryWithMcpAuth(session);
+    switch (methodName) {
+        case "mcpAuthenticate":
+            if (typeof query.mcpAuthenticate !== "function") {
+                throw new Error("installed SDK does not support mcpAuthenticate");
+            }
+            return await query.mcpAuthenticate(args[0] ?? "");
+        case "mcpClearAuth":
+            if (typeof query.mcpClearAuth !== "function") {
+                throw new Error("installed SDK does not support mcpClearAuth");
+            }
+            return await query.mcpClearAuth(args[0] ?? "");
+        case "mcpSubmitOAuthCallbackUrl":
+            if (typeof query.mcpSubmitOAuthCallbackUrl !== "function") {
+                throw new Error("installed SDK does not support mcpSubmitOAuthCallbackUrl");
+            }
+            return await query.mcpSubmitOAuthCallbackUrl(args[0] ?? "", args[1] ?? "");
+    }
+}
+function extractMcpAuthRedirect(serverName, value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const authUrl = Reflect.get(value, "authUrl");
+    if (typeof authUrl !== "string" || authUrl.trim().length === 0) {
+        return null;
+    }
+    const requiresUserAction = Reflect.get(value, "requiresUserAction");
+    return {
+        server_name: serverName,
+        auth_url: authUrl,
+        requires_user_action: requiresUserAction === true,
+    };
+}
+function emitMcpCommandError(sessionId, operation, message, requestId, serverName) {
+    emitMcpOperationError(sessionId, {
+        ...(serverName ? { server_name: serverName } : {}),
+        operation,
+        message,
+    }, requestId);
+}
+export async function emitMcpSnapshotEvent(session, requestId) {
+    const servers = await session.query.mcpServerStatus();
+    let mapped = servers.map(mapMcpServerStatus);
+    mapped = await reconcileSuspiciousMcpStatuses(session, mapped);
+    rememberKnownConnectedMcpServers(mapped);
+    writeEvent({
+        event: "mcp_snapshot",
+        session_id: session.sessionId,
+        servers: mapped,
+    }, requestId);
+    return mapped;
+}
+export function staleMcpAuthCandidates(servers, knownConnectedServerNames, lastRevalidatedAt, now = Date.now(), cooldownMs = MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS) {
+    return servers
+        .filter((server) => {
+        if (server.status !== "needs-auth") {
+            return false;
+        }
+        if (!knownConnectedServerNames.has(server.name)) {
+            return false;
+        }
+        const lastAttempt = lastRevalidatedAt.get(server.name) ?? 0;
+        return now - lastAttempt >= cooldownMs;
+    })
+        .map((server) => server.name);
+}
+function rememberKnownConnectedMcpServers(servers) {
+    for (const server of servers) {
+        if (server.status === "connected") {
+            knownConnectedMcpServers.add(server.name);
+        }
+    }
+}
+function forgetKnownConnectedMcpServer(serverName) {
+    knownConnectedMcpServers.delete(serverName);
+}
+async function reconcileSuspiciousMcpStatuses(session, servers) {
+    const candidates = staleMcpAuthCandidates(servers, knownConnectedMcpServers, session.mcpStatusRevalidatedAt);
+    if (candidates.length === 0) {
+        return servers;
+    }
+    const now = Date.now();
+    for (const serverName of candidates) {
+        session.mcpStatusRevalidatedAt.set(serverName, now);
+        console.error(`[sdk mcp reconcile] session=${session.sessionId} server=${serverName} ` +
+            `status=needs-auth reason=previously-connected action=reconnect`);
+        try {
+            await session.query.reconnectMcpServer(serverName);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[sdk mcp reconcile] session=${session.sessionId} server=${serverName} ` +
+                `action=reconnect failed=${message}`);
+        }
+    }
+    return (await session.query.mcpServerStatus()).map(mapMcpServerStatus);
+}
+function shouldKeepMonitoringMcpAuth(server) {
+    return server?.status === "needs-auth" || server?.status === "pending";
+}
+function scheduleMcpAuthSnapshotMonitor(session, serverName, attempt = 0) {
+    const maxAttempts = 180;
+    const delayMs = 1000;
+    setTimeout(() => {
+        void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
+    }, delayMs);
+}
+async function monitorMcpAuthSnapshot(session, serverName, attempt, maxAttempts, delayMs) {
+    try {
+        const servers = await emitMcpSnapshotEvent(session);
+        const server = servers.find((candidate) => candidate.name === serverName);
+        if (attempt < maxAttempts && shouldKeepMonitoringMcpAuth(server)) {
+            setTimeout(() => {
+                void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
+            }, delayMs);
+        }
+    }
+    catch {
+        if (attempt < maxAttempts) {
+            setTimeout(() => {
+                void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
+            }, delayMs);
+        }
+    }
+}
+export async function handleMcpStatusCommand(session, requestId) {
+    try {
+        await emitMcpSnapshotEvent(session, requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writeEvent({
+            event: "mcp_snapshot",
+            session_id: session.sessionId,
+            servers: [],
+            error: message,
+        }, requestId);
+    }
+}
+export async function handleMcpReconnectCommand(session, command, requestId) {
+    try {
+        await session.query.reconnectMcpServer(command.server_name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMcpCommandError(command.session_id, "reconnect", message, requestId, command.server_name);
+    }
+}
+export async function handleMcpToggleCommand(session, command, requestId) {
+    try {
+        await session.query.toggleMcpServer(command.server_name, command.enabled);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMcpCommandError(command.session_id, "toggle", message, requestId, command.server_name);
+    }
+}
+export async function handleMcpSetServersCommand(session, command, requestId) {
+    try {
+        await session.query.setMcpServers(command.servers);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to set MCP servers: ${message}`, requestId);
+    }
+}
+export async function handleMcpAuthenticateCommand(session, command, requestId) {
+    try {
+        const result = await callMcpAuthMethod(session, "mcpAuthenticate", [command.server_name]);
+        const redirect = extractMcpAuthRedirect(command.server_name, result);
+        if (redirect) {
+            writeEvent({
+                event: "mcp_auth_redirect",
+                session_id: command.session_id,
+                redirect,
+            });
+        }
+        scheduleMcpAuthSnapshotMonitor(session, command.server_name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMcpCommandError(command.session_id, "authenticate", message, requestId, command.server_name);
+    }
+}
+export async function handleMcpClearAuthCommand(session, command, requestId) {
+    try {
+        await callMcpAuthMethod(session, "mcpClearAuth", [command.server_name]);
+        forgetKnownConnectedMcpServer(command.server_name);
+        session.mcpStatusRevalidatedAt.delete(command.server_name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMcpCommandError(command.session_id, "clear-auth", message, requestId, command.server_name);
+    }
+}
+export async function handleMcpOauthCallbackUrlCommand(session, command, requestId) {
+    try {
+        await callMcpAuthMethod(session, "mcpSubmitOAuthCallbackUrl", [
+            command.server_name,
+            command.callback_url,
+        ]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        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)}`);
+    }
+}