claude-code-rust 0.14.1 → 0.14.2

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

@@ -48,7 +48,7 @@ function shouldAcceptAvailableCommandsSnapshot(session, source, commands) {
     if (source === "supportedCommands" && current.commands.length > 0) {
         return {
             accept: false,
-            reason: "supportedCommands is an initialize-time fallback and current snapshot already exists",
+            reason: "supportedCommands bootstrap cannot replace an existing snapshot",
         };
     }
     if (commands.length === 0) {

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

@@ -0,0 +1,16 @@
+import { handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, handleUserDialogResponse, } from "./session_lifecycle.js";
+export function handleInteractionCommand(command) {
+    switch (command.command) {
+        case "permission_response":
+            handlePermissionResponse(command);
+            return;
+        case "question_response":
+            handleQuestionResponse(command);
+            return;
+        case "user_dialog_response":
+            handleUserDialogResponse(command);
+            return;
+        case "elicitation_response":
+            handleElicitationResponse(command);
+    }
+}

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

@@ -0,0 +1,184 @@
+import { getSessionMessages, listSessions, } from "@anthropic-ai/claude-agent-sdk";
+import { currentSessionListOptions, emitSessionsList, failConnection, setSessionListingDir, slashError, writeEvent, } from "./events.js";
+import { mapSessionMessagesToUpdates } from "./history.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { closeAllSessions, createSession, sessions, } from "./session_lifecycle.js";
+export async function handleLifecycleCommand(command, requestId, sdkVersionError) {
+    switch (command.command) {
+        case "initialize":
+            await initialize(command, requestId, sdkVersionError);
+            return;
+        case "create_session":
+            await create(command, requestId);
+            return;
+        case "resume_session":
+            await resume(command, requestId);
+            return;
+        case "new_session":
+            await replace(command, requestId);
+            return;
+        case "shutdown":
+            await shutdown(requestId);
+    }
+}
+async function initialize(command, requestId, sdkVersionError) {
+    if (sdkVersionError) {
+        bridgeLogger.error({
+            target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+            eventName: "bridge_initialize_failed",
+            message: "bridge initialization failed due to unsupported SDK version",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            fields: { error_message: sdkVersionError },
+        });
+        failConnection(sdkVersionError, requestId);
+        return;
+    }
+    setSessionListingDir(command.cwd);
+    writeEvent({
+        event: "initialized",
+        result: {
+            agent_name: "claude-rs-agent-bridge",
+            agent_version: "0.1.0",
+            auth_methods: [
+                {
+                    id: "claude-login",
+                    name: "Log in with Claude",
+                    description: "Run `claude /login` in a terminal",
+                },
+            ],
+            capabilities: {
+                prompt_image: true,
+                prompt_embedded_context: true,
+                supports_session_listing: true,
+                supports_resume_session: true,
+            },
+        },
+    }, requestId);
+    await emitSessionsList(requestId);
+}
+async function create(command, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_create_requested",
+        message: "session creation requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        fields: {
+            cwd: command.cwd,
+            resume_requested: command.resume !== undefined,
+        },
+    });
+    setSessionListingDir(command.cwd);
+    await createSession({
+        cwd: command.cwd,
+        resume: command.resume,
+        launchSettings: command.launch_settings,
+        connectEvent: "connected",
+        requestId,
+    });
+}
+async function resume(command, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_resume_requested",
+        message: "session resume requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        sessionId: command.session_id,
+    });
+    try {
+        const sdkSessions = await listSessions(currentSessionListOptions());
+        const matched = sdkSessions.find((entry) => entry.sessionId === command.session_id);
+        if (!matched) {
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_resume_lookup_failed",
+                message: "session resume requested for an unknown session",
+                outcome: "failure",
+                ...(requestId ? { requestId } : {}),
+                sessionId: command.session_id,
+                fields: { reason: "unknown_session" },
+            });
+            slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+            return;
+        }
+        setSessionListingDir(matched.cwd ?? process.cwd());
+        const historyMessages = await getSessionMessages(command.session_id, matched.cwd
+            ? { dir: matched.cwd, includeSystemMessages: true }
+            : { includeSystemMessages: true });
+        const resumeUpdates = mapSessionMessagesToUpdates(historyMessages);
+        const staleSessions = Array.from(sessions.values());
+        const hadActiveSession = staleSessions.length > 0;
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_resume_history_loaded",
+            message: "session resume history loaded",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            sessionId: command.session_id,
+            fields: {
+                history_update_count: resumeUpdates.length,
+                stale_session_count: staleSessions.length,
+            },
+        });
+        await createSession({
+            cwd: matched.cwd ?? process.cwd(),
+            resume: command.session_id,
+            launchSettings: command.launch_settings,
+            ...(resumeUpdates.length > 0 ? { resumeUpdates } : {}),
+            connectEvent: hadActiveSession ? "session_replaced" : "connected",
+            requestId,
+            ...(hadActiveSession ? { sessionsToCloseAfterConnect: staleSessions } : {}),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_resume_failed",
+            message: "session resume failed",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: command.session_id,
+            fields: { error_message: message },
+        });
+        slashError(command.session_id, `failed to resume session: ${message}`, requestId);
+    }
+}
+async function replace(command, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_new_requested",
+        message: "replacement session requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        fields: { cwd: command.cwd },
+    });
+    await closeAllSessions({ reason: "new_session_requested", requestId });
+    setSessionListingDir(command.cwd);
+    await createSession({
+        cwd: command.cwd,
+        launchSettings: command.launch_settings,
+        connectEvent: "session_replaced",
+        requestId,
+    });
+}
+async function shutdown(requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+        eventName: "bridge_shutdown_requested",
+        message: "bridge shutdown requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+    });
+    await closeAllSessions({ reason: "bridge_shutdown_requested", requestId });
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+        eventName: "bridge_shutdown_completed",
+        message: "bridge shutdown completed",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+    });
+    process.exit(0);
+}

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

@@ -0,0 +1,32 @@
+import { slashError } from "./events.js";
+import { handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, } from "./mcp.js";
+import { sessionById } from "./session_lifecycle.js";
+export async function handleMcpCommand(command, requestId) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+        return;
+    }
+    switch (command.command) {
+        case "mcp_status":
+            await handleMcpStatusCommand(session, requestId);
+            return;
+        case "mcp_reconnect":
+            await handleMcpReconnectCommand(session, command, requestId);
+            return;
+        case "mcp_toggle":
+            await handleMcpToggleCommand(session, command, requestId);
+            return;
+        case "mcp_set_servers":
+            await handleMcpSetServersCommand(session, command, requestId);
+            return;
+        case "mcp_authenticate":
+            await handleMcpAuthenticateCommand(session, command, requestId);
+            return;
+        case "mcp_clear_auth":
+            await handleMcpClearAuthCommand(session, command, requestId);
+            return;
+        case "mcp_oauth_callback_url":
+            await handleMcpOauthCallbackUrlCommand(session, command, requestId);
+    }
+}

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

@@ -0,0 +1,136 @@
+const LIFECYCLE_COMMANDS = new Set([
+    "initialize",
+    "create_session",
+    "resume_session",
+    "new_session",
+    "rewind",
+    "shutdown",
+]);
+const UNBLOCKING_COMMANDS = new Set([
+    "cancel_turn",
+    "permission_response",
+    "question_response",
+    "user_dialog_response",
+    "elicitation_response",
+    "mcp_oauth_callback_url",
+]);
+function commandLane(command) {
+    if (UNBLOCKING_COMMANDS.has(command.command)) {
+        return { kind: "unblocking" };
+    }
+    if (LIFECYCLE_COMMANDS.has(command.command)) {
+        return { kind: "lifecycle" };
+    }
+    if ("session_id" in command) {
+        return { kind: "session", sessionId: command.session_id };
+    }
+    return { kind: "lifecycle" };
+}
+function settle(task) {
+    return task.then(() => undefined, () => undefined);
+}
+export class BridgeCommandScheduler {
+    lifecycleTail;
+    sessionTails = new Map();
+    activeTasks = new Set();
+    shutdownState = "accepting";
+    schedule(command, task) {
+        const lane = commandLane(command);
+        if (!this.accepts(command, lane)) {
+            return undefined;
+        }
+        let scheduledTask = task;
+        if (command.command === "shutdown") {
+            this.shutdownState = "queued";
+            scheduledTask = async () => {
+                this.shutdownState = "running";
+                try {
+                    await task();
+                }
+                finally {
+                    this.shutdownState = "complete";
+                }
+            };
+        }
+        const operation = this.scheduleInLane(lane, scheduledTask);
+        this.track(operation);
+        return operation;
+    }
+    stopAccepting() {
+        if (this.shutdownState === "accepting") {
+            this.shutdownState = "complete";
+        }
+    }
+    async whenIdle() {
+        while (this.activeTasks.size > 0) {
+            await Promise.all(this.activeTasks);
+        }
+    }
+    accepts(command, lane) {
+        if (this.shutdownState === "accepting") {
+            return true;
+        }
+        return (this.shutdownState === "queued" &&
+            command.command !== "shutdown" &&
+            lane.kind === "unblocking");
+    }
+    scheduleInLane(lane, task) {
+        switch (lane.kind) {
+            case "unblocking":
+                return this.start(task);
+            case "lifecycle":
+                return this.scheduleLifecycle(task);
+            case "session":
+                return this.scheduleSession(lane.sessionId, task);
+        }
+    }
+    scheduleLifecycle(task) {
+        const dependencies = new Set(this.sessionTails.values());
+        if (this.lifecycleTail) {
+            dependencies.add(this.lifecycleTail);
+        }
+        const operation = dependencies.size === 0 ? this.start(task) : Promise.all(dependencies).then(task);
+        const tail = settle(operation);
+        this.lifecycleTail = tail;
+        void tail.then(() => {
+            if (this.lifecycleTail === tail) {
+                this.lifecycleTail = undefined;
+            }
+        });
+        return operation;
+    }
+    scheduleSession(sessionId, task) {
+        const dependencies = [];
+        if (this.lifecycleTail) {
+            dependencies.push(this.lifecycleTail);
+        }
+        const previousSessionTask = this.sessionTails.get(sessionId);
+        if (previousSessionTask) {
+            dependencies.push(previousSessionTask);
+        }
+        const operation = dependencies.length === 0 ? this.start(task) : Promise.all(dependencies).then(task);
+        const tail = settle(operation);
+        this.sessionTails.set(sessionId, tail);
+        void tail.then(() => {
+            if (this.sessionTails.get(sessionId) === tail) {
+                this.sessionTails.delete(sessionId);
+            }
+        });
+        return operation;
+    }
+    track(operation) {
+        const tracked = settle(operation);
+        this.activeTasks.add(tracked);
+        void tracked.then(() => {
+            this.activeTasks.delete(tracked);
+        });
+    }
+    start(task) {
+        try {
+            return task();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}

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

@@ -0,0 +1,269 @@
+import { buildModeState, markModeUnavailableForSession, permissionModeFailureLooksUnsupported, refreshSupportedModesForSession, toPermissionMode, } from "./commands.js";
+import { dispatchCancelTurnCommand } from "./command_dispatch.js";
+import { emitFastModeUpdate } from "./error_classification.js";
+import { emitSessionUpdate, slashError } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { emitCurrentModelUpdate, refreshCurrentModel, sessionById, shouldInvalidateResolvedRuntimeModel, } from "./session_lifecycle.js";
+export async function handleSessionControlCommand(command, requestId, deps) {
+    switch (command.command) {
+        case "prompt":
+            handlePrompt(command, requestId, deps);
+            return;
+        case "cancel_turn":
+            await dispatchCancelTurnCommand(command, { requestId, sessionById, slashError });
+            return;
+        case "set_model":
+            await setModel(command, requestId);
+            return;
+        case "set_mode":
+            await setMode(command, requestId);
+            return;
+        case "set_effort":
+            await setEffort(command, requestId, deps);
+            return;
+        case "set_agent":
+            await setAgent(command, requestId, deps);
+            return;
+        case "set_fast_mode":
+            await setFastMode(command, requestId, deps);
+            return;
+        case "reload_plugins":
+            await reloadPlugins(command, requestId, deps);
+    }
+}
+function handlePrompt(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    const message = deps.buildPromptUserMessage(command, session.sessionId);
+    if (message) {
+        session.input.enqueue(message);
+    }
+}
+async function setModel(command, requestId) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "set_model_started",
+        message: "set model started",
+        outcome: "start",
+        sessionId: session.sessionId,
+        requestId,
+        fields: {
+            requested_model: command.model,
+            previous_requested_model: session.requestedModelId,
+            previous_session_model: session.model,
+            previous_resolved_runtime_model: session.resolvedRuntimeModelId,
+            previous_current_model: session.currentModel?.resolved_id,
+        },
+    });
+    try {
+        const previousRequestedModel = session.requestedModelId;
+        const previousSessionModel = session.model;
+        await session.query.setModel(command.model);
+        session.requestedModelId = command.model;
+        session.model = command.model;
+        const invalidatedResolvedRuntimeModel = shouldInvalidateResolvedRuntimeModel(previousRequestedModel, previousSessionModel, command.model);
+        if (invalidatedResolvedRuntimeModel) {
+            session.resolvedRuntimeModelId = undefined;
+        }
+        const changed = refreshCurrentModel(session, true);
+        const forcedCurrentModelUpdate = !changed && emitCurrentModelUpdate(session);
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "set_model_succeeded",
+            message: "set model completed",
+            outcome: "success",
+            sessionId: session.sessionId,
+            requestId,
+            fields: {
+                requested_model: command.model,
+                session_model_after: session.model,
+                resolved_runtime_model_after: session.resolvedRuntimeModelId,
+                current_model_after: session.currentModel?.resolved_id,
+                current_model_display_short: session.currentModel?.display_name_short,
+                current_model_display_long: session.currentModel?.display_name_long,
+                current_model_update_emitted: changed || forcedCurrentModelUpdate,
+                current_model_update_forced: forcedCurrentModelUpdate,
+                resolved_runtime_model_invalidated: invalidatedResolvedRuntimeModel,
+            },
+        });
+        refreshSupportedModesForSession(session);
+        if (session.mode) {
+            emitSessionUpdate(session.sessionId, {
+                type: "mode_state_update",
+                mode: buildModeState(session, session.mode),
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "set_model_failed",
+            message: "set model failed",
+            outcome: "failure",
+            sessionId: session.sessionId,
+            requestId,
+            fields: {
+                requested_model: command.model,
+                error_message: message,
+                previous_requested_model: session.requestedModelId,
+                previous_session_model: session.model,
+                previous_resolved_runtime_model: session.resolvedRuntimeModelId,
+                previous_current_model: session.currentModel?.resolved_id,
+            },
+        });
+        slashError(command.session_id, `failed to set model: ${message}`, requestId);
+    }
+}
+async function setMode(command, requestId) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    const mode = toPermissionMode(command.mode);
+    if (!mode) {
+        slashError(command.session_id, `unsupported mode: ${command.mode}`, requestId);
+        return;
+    }
+    try {
+        await session.query.setPermissionMode(mode);
+        session.mode = mode;
+        refreshSupportedModesForSession(session);
+        emitSessionUpdate(session.sessionId, {
+            type: "current_mode_update",
+            current_mode_id: mode,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (permissionModeFailureLooksUnsupported(mode, message)) {
+            const changed = markModeUnavailableForSession(session, mode);
+            if (changed && session.mode) {
+                emitSessionUpdate(session.sessionId, {
+                    type: "mode_state_update",
+                    mode: buildModeState(session, session.mode),
+                });
+            }
+        }
+        slashError(command.session_id, `failed to set mode to ${mode}: ${message}`, requestId);
+    }
+}
+async function setEffort(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        await deps.applySessionEffort(session.query, command.effort);
+        deps.emitEffortConfigOptionUpdate(session.sessionId, command.effort);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to set effort: ${message}`, requestId);
+    }
+}
+async function setAgent(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        await deps.applySessionAgent(session.query, command.agent);
+        deps.emitAgentConfigOptionUpdate(session.sessionId, command.agent);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to set agent: ${message}`, requestId);
+    }
+}
+async function setFastMode(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "set_fast_mode_started",
+        message: "set fast mode started",
+        outcome: "start",
+        sessionId: session.sessionId,
+        requestId,
+        fields: {
+            requested_enabled: command.enabled,
+            previous_state: session.fastModeState,
+        },
+    });
+    try {
+        const snapshot = await deps.applySessionFastMode(session.query, command.enabled);
+        const state = snapshot.state;
+        session.fastModeState = state;
+        session.fastModeDisabledReason = snapshot.disabled_reason;
+        emitFastModeUpdate(session);
+        const reportedEnabled = state !== "off";
+        if (reportedEnabled !== command.enabled) {
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "set_fast_mode_mismatch",
+                message: "SDK reported a fast-mode state that did not match the request",
+                outcome: "failure",
+                sessionId: session.sessionId,
+                requestId,
+                fields: {
+                    requested_enabled: command.enabled,
+                    reported_state: state,
+                },
+            });
+            const action = command.enabled ? "enable" : "disable";
+            slashError(command.session_id, `failed to ${action} fast mode: SDK reported state ${state}`, requestId);
+            return;
+        }
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "set_fast_mode_succeeded",
+            message: "set fast mode completed",
+            outcome: "success",
+            sessionId: session.sessionId,
+            requestId,
+            fields: {
+                requested_enabled: command.enabled,
+                reported_state: state,
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "set_fast_mode_failed",
+            message: "set fast mode failed",
+            outcome: "failure",
+            sessionId: session.sessionId,
+            requestId,
+            fields: {
+                requested_enabled: command.enabled,
+                previous_state: session.fastModeState,
+                error_message: message,
+            },
+        });
+        slashError(command.session_id, `failed to set fast mode: ${message}`, requestId);
+    }
+}
+async function reloadPlugins(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (session) {
+        await deps.handleReloadPluginsCommand(session, requestId);
+    }
+}
+function requireSession(sessionId, requestId) {
+    const session = sessionById(sessionId);
+    if (!session) {
+        slashError(sessionId, `unknown session: ${sessionId}`, requestId);
+    }
+    return session;
+}