@sumicom/quicksave 0.8.2 → 0.8.4

package/dist/ai/codexAppServer/cardAdapter.js

@@ -0,0 +1,707 @@
+import { TokenAccounting } from './tokenAccounting.js';
+/** Debounce window for assistant text streaming — matches the SDK
+ * provider's `FLUSH_INTERVAL_MS` so the user-visible "typing" cadence
+ * stays identical between backends. */
+const FLUSH_INTERVAL_MS = 150;
+const TOOL_RESULT_TRUNCATE_LENGTH = 500; // matches cardBuilder.ts
+/** How long to wait at `turn/completed` time for a matching
+ * `thread/tokenUsage/updated` notification before giving up and emitting
+ * an empty usage block. 250 ms matches plan §5.2. */
+const TURN_USAGE_GRACE_MS = 250;
+function emptyState() {
+    return {
+        textBuffer: '',
+        textTimer: null,
+        agentMessageEmittedChars: new Map(),
+        reasoningEmittedChars: new Map(),
+        commandOutputBuffers: new Map(),
+        seenErrors: new Set(),
+        fileChangeCardsAdded: new Set(),
+        planCardId: null,
+        turnEnded: false,
+    };
+}
+/**
+ * Subscribe to the RPC client's notification stream and translate v2
+ * notifications into `StreamCardBuilder` mutator calls.
+ *
+ * Returns once `turn/completed` arrives for `ctx.turnId`. The caller
+ * (provider's `runTurn`) handles user-cancel via `turn/interrupt`.
+ *
+ * IMPORTANT: this function is provider-only. It MUST NOT change the
+ * `Card` / `CardEvent` shapes the cardBuilder emits — those are the
+ * red-line contract. The dispatch table here matches plan §11's
+ * resolved mapping; if a v2 notification needs a new card variant,
+ * stop and add it to the cardBuilder API additively, then come back.
+ */
+export async function consumeAppServerStream(rpc, cb, ctx, callbacks) {
+    const state = emptyState();
+    const emit = (event) => {
+        if (event)
+            callbacks.emitCardEvent(event);
+    };
+    const flushText = () => {
+        if (state.textBuffer) {
+            emit(cb.assistantText(state.textBuffer));
+            state.textBuffer = '';
+        }
+        if (state.textTimer) {
+            clearTimeout(state.textTimer);
+            state.textTimer = null;
+        }
+    };
+    const bufferText = (delta) => {
+        if (!delta)
+            return;
+        state.textBuffer += delta;
+        if (!state.textTimer) {
+            state.textTimer = setTimeout(flushText, FLUSH_INTERVAL_MS);
+        }
+    };
+    const errorKey = (err) => `${stringifyErrorInfo(err.codexErrorInfo ?? null)}|${err.message ?? ''}`;
+    const emitErrorOnce = (err) => {
+        const key = errorKey(err);
+        if (state.seenErrors.has(key))
+            return;
+        state.seenErrors.add(key);
+        const message = err.message ?? '(no message)';
+        const event = cb.systemMessage(`Error: ${message}`, 'error');
+        emit(event);
+    };
+    // Resolution promise — settled when turn/completed for our turnId arrives.
+    let resolveResult;
+    const result = new Promise((resolve) => {
+        resolveResult = resolve;
+    });
+    const dispatch = (notification) => {
+        if (state.turnEnded)
+            return;
+        try {
+            handleNotification(notification);
+        }
+        catch (err) {
+            // Adapter must not crash the provider's run loop. Log and continue.
+            emit(cb.systemMessage(`Internal adapter error on ${notification.method}: ${err instanceof Error ? err.message : String(err)}`, 'error'));
+        }
+    };
+    const handleNotification = (notification) => {
+        switch (notification.method) {
+            case 'turn/started':
+                // No-op; provider already created the user card.
+                return;
+            case 'turn/completed': {
+                const params = notification.params;
+                if (params.turn.id !== ctx.turnId)
+                    return;
+                void finalize(params.turn.status, params.turn.error ?? undefined);
+                return;
+            }
+            case 'thread/tokenUsage/updated': {
+                const params = notification.params;
+                ctx.tokens.observe(params);
+                return;
+            }
+            case 'item/started': {
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                handleItemStarted(params.item);
+                return;
+            }
+            case 'item/completed': {
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                handleItemCompleted(params.item);
+                return;
+            }
+            case 'item/agentMessage/delta': {
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                if (!params.delta)
+                    return;
+                const prev = state.agentMessageEmittedChars.get(params.itemId) ?? 0;
+                state.agentMessageEmittedChars.set(params.itemId, prev + params.delta.length);
+                bufferText(params.delta);
+                return;
+            }
+            case 'item/reasoning/summaryTextDelta':
+            case 'item/reasoning/textDelta': {
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                const trimmed = params.delta?.trim();
+                if (!trimmed)
+                    return;
+                const prev = state.reasoningEmittedChars.get(params.itemId) ?? 0;
+                state.reasoningEmittedChars.set(params.itemId, prev + params.delta.length);
+                emit(cb.thinkingBlock(params.delta));
+                return;
+            }
+            case 'item/reasoning/summaryPartAdded':
+                // Boundary marker — flushing the current text buffer ensures
+                // any in-flight assistant text is committed before the next
+                // reasoning section opens.
+                flushText();
+                return;
+            case 'item/commandExecution/outputDelta': {
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                const accumulated = (state.commandOutputBuffers.get(params.itemId) ?? '') + (params.delta ?? '');
+                state.commandOutputBuffers.set(params.itemId, accumulated);
+                // Don't emit on every chunk — that would cause O(N²) work in
+                // the cardBuilder's truncation logic for long output. Instead
+                // emit a debounced result update.
+                emit(cb.toolResult(params.itemId, accumulated, false));
+                return;
+            }
+            case 'turn/plan/updated': {
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                handlePlanUpdated(params);
+                return;
+            }
+            case 'serverRequest/resolved': {
+                const params = notification.params;
+                const requestIdStr = String(params.requestId);
+                emit(cb.clearPendingInput(requestIdStr));
+                return;
+            }
+            case 'error': {
+                const params = notification.params;
+                if (params.turnId && params.turnId !== ctx.turnId)
+                    return;
+                if (params.willRetry)
+                    return; // server is retrying transparently
+                emitErrorOnce(params.error);
+                return;
+            }
+            case 'warning':
+            case 'configWarning':
+            case 'deprecationNotice': {
+                const params = notification.params;
+                const text = params?.message ?? `(${notification.method})`;
+                emit(cb.systemMessage(text, 'warning'));
+                return;
+            }
+            case 'guardianWarning': {
+                // Guardian flagged the turn (safety / policy). Surface as a
+                // warning system card so the user sees why an action was rejected.
+                const params = notification.params;
+                if (params.threadId !== ctx.threadId)
+                    return;
+                emit(cb.systemMessage(`Guardian: ${params.message ?? '(no message)'}`, 'warning'));
+                return;
+            }
+            case 'model/rerouted': {
+                // Backend rerouted the request to a different model (cyber-safety
+                // policy). Surface as info so the user understands why the model
+                // running differs from the one they picked.
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                emit(cb.systemMessage(`Model rerouted: ${params.fromModel} → ${params.toModel} (${params.reason})`, 'info'));
+                return;
+            }
+            case 'model/verification': {
+                // Backend asks for additional account verification (e.g.
+                // trustedAccessForCyber). Surface as warning — the user has to
+                // act on this outside the chat.
+                const params = notification.params;
+                if (params.turnId !== ctx.turnId)
+                    return;
+                const messages = params.verifications
+                    .map((v) => v.message ?? v.kind ?? 'verification required')
+                    .join('; ');
+                emit(cb.systemMessage(`Account verification: ${messages}`, 'warning'));
+                return;
+            }
+            case 'mcpServer/startupStatus/updated': {
+                // The user configured an MCP server that fails to start — they
+                // need to know so they can fix it. `ready` and `starting` are
+                // routine; we only surface the bad terminal states.
+                const params = notification.params;
+                if (params.status === 'failed') {
+                    emit(cb.systemMessage(`MCP server "${params.name}" failed to start${params.error ? `: ${params.error}` : ''}`, 'error'));
+                }
+                return;
+            }
+            case 'item/autoApprovalReview/started':
+            case 'item/autoApprovalReview/completed': {
+                // Phase 2: drop. Phase 5+ may render the auto-review subagent's
+                // decision inline. Schema doesn't carry user-visible text yet,
+                // so a system message would just say "review started" — noise.
+                return;
+            }
+            case 'thread/closed':
+            case 'thread/status/changed':
+            case 'thread/name/updated':
+            case 'thread/started':
+            case 'thread/archived':
+            case 'thread/unarchived':
+            case 'thread/compacted':
+            case 'item/fileChange/patchUpdated':
+            case 'item/fileChange/outputDelta':
+            case 'item/mcpToolCall/progress':
+            case 'item/plan/delta':
+            case 'turn/diff/updated':
+            case 'rawResponseItem/completed':
+            case 'item/commandExecution/terminalInteraction':
+                // Phase 2: drop. Phase 5+ may surface some of these as new
+                // card variants — see plan §1 N1.
+                return;
+            // Out-of-band notifications that don't pertain to a single turn:
+            // account-level, fs watching, fuzzy file search, voice/realtime,
+            // marketplace events, hook lifecycle, MCP OAuth completion. Silent
+            // drop — surfacing them mid-turn would be noisy and they're better
+            // routed via dedicated app-level subscriptions if a feature ever
+            // needs them.
+            case 'account/login/completed':
+            case 'account/rateLimits/updated':
+            case 'account/updated':
+            case 'app/list/updated':
+            case 'command/exec/outputDelta':
+            case 'externalAgentConfig/import/completed':
+            case 'fs/changed':
+            case 'fuzzyFileSearch/sessionCompleted':
+            case 'fuzzyFileSearch/sessionUpdated':
+            case 'hook/started':
+            case 'hook/completed':
+            case 'mcpServer/oauthLogin/completed':
+            case 'skills/changed':
+            case 'thread/realtime/closed':
+            case 'thread/realtime/error':
+            case 'thread/realtime/itemAdded':
+            case 'thread/realtime/outputAudio/delta':
+            case 'thread/realtime/sdp':
+            case 'thread/realtime/started':
+            case 'thread/realtime/transcript/delta':
+            case 'thread/realtime/transcript/done':
+            case 'windows/worldWritableWarning':
+            case 'windowsSandbox/setupCompleted':
+                return;
+            default:
+                // Unknown notification — count, don't crash.
+                return;
+        }
+    };
+    const handleItemStarted = (item) => {
+        switch (item.type) {
+            case 'userMessage':
+            case 'hookPrompt':
+                // Provider already emitted the user card via cb.userMessage.
+                return;
+            case 'agentMessage': {
+                // First chunk is usually empty; if non-empty it counts as a
+                // delta we haven't yet seen.
+                if (item.text) {
+                    state.agentMessageEmittedChars.set(item.id, item.text.length);
+                    bufferText(item.text);
+                }
+                return;
+            }
+            case 'reasoning': {
+                // Reasoning summary/content arrives as deltas; nothing to do
+                // at started.
+                return;
+            }
+            case 'commandExecution': {
+                flushText();
+                emit(cb.toolUse('Bash', { command: item.command }, item.id));
+                return;
+            }
+            case 'fileChange': {
+                flushText();
+                emitFileChangeCards(item, false);
+                return;
+            }
+            case 'mcpToolCall': {
+                flushText();
+                emit(cb.toolUse(`${item.server}:${item.tool}`, item.arguments, item.id));
+                return;
+            }
+            case 'webSearch': {
+                // item/started fires with `item.query` empty (action is usually
+                // `{ type: "other" }` at this stage) — Codex populates the real
+                // query on item/completed. Use the structured `action` as a
+                // best-effort fallback so the placeholder card shows SOMETHING
+                // meaningful instead of "Search ?".
+                flushText();
+                emit(cb.toolUse('WebSearch', { query: extractWebSearchQuery(item) }, item.id));
+                return;
+            }
+            case 'dynamicToolCall': {
+                flushText();
+                const toolName = item.namespace ? `${item.namespace}:${item.tool}` : item.tool;
+                emit(cb.toolUse(toolName, item.arguments ?? {}, item.id));
+                return;
+            }
+            case 'plan': {
+                // Free-text plan item — drop to system info per plan R2 decision.
+                emit(cb.systemMessage(`[plan] ${item.text || '(empty)'}`, 'info'));
+                return;
+            }
+            case 'imageView': {
+                // Codex showed an image to the model. Surface as system info with
+                // the path so the user knows what was shared.
+                emit(cb.systemMessage(`[image: ${item.path}]`, 'info'));
+                return;
+            }
+            case 'imageGeneration': {
+                // Started item — image not yet rendered. Show the prompt the
+                // model is generating from. Result fields populate on completed.
+                const prompt = item.revisedPrompt ?? '';
+                emit(cb.systemMessage(`[generating image: ${prompt || '(no prompt)'}]`, 'info'));
+                return;
+            }
+            case 'enteredReviewMode': {
+                emit(cb.systemMessage(`Entered review mode: ${item.review}`, 'info'));
+                return;
+            }
+            case 'exitedReviewMode': {
+                emit(cb.systemMessage(`Exited review mode: ${item.review}`, 'info'));
+                return;
+            }
+            case 'collabAgentToolCall': {
+                // A sub-agent collaboration. Render as a tool_call card so the
+                // PWA's existing tool view picks it up; the toolName is
+                // `collab:${tool}` to namespace it away from real tools.
+                flushText();
+                const toolName = `collab:${item.tool}`;
+                emit(cb.toolUse(toolName, {
+                    prompt: item.prompt ?? '',
+                    model: item.model ?? undefined,
+                    receiverThreadIds: item.receiverThreadIds,
+                }, item.id));
+                return;
+            }
+            case 'contextCompaction':
+                emit(cb.systemMessage('Context compacted', 'compacted'));
+                return;
+        }
+    };
+    const handleItemCompleted = (item) => {
+        switch (item.type) {
+            case 'agentMessage': {
+                flushText();
+                const alreadyEmitted = state.agentMessageEmittedChars.get(item.id) ?? 0;
+                const finalText = item.text ?? '';
+                if (finalText.length > alreadyEmitted) {
+                    emit(cb.assistantText(finalText.slice(alreadyEmitted)));
+                    state.agentMessageEmittedChars.set(item.id, finalText.length);
+                }
+                const fin = cb.finalizeAssistantText();
+                if (fin)
+                    emit(fin);
+                return;
+            }
+            case 'reasoning': {
+                // Defensive: if the deltas didn't fire, surface the final summary.
+                // Fall back to `content` when summary is empty — some models emit
+                // the raw chain-of-thought without producing the bullet summary.
+                const alreadyEmitted = state.reasoningEmittedChars.get(item.id) ?? 0;
+                if (alreadyEmitted > 0)
+                    return;
+                const summary = (item.summary ?? []).join('\n').trim();
+                if (summary) {
+                    emit(cb.thinkingBlock(summary));
+                    return;
+                }
+                const content = (item.content ?? []).join('\n').trim();
+                if (content) {
+                    emit(cb.thinkingBlock(content));
+                }
+                return;
+            }
+            case 'commandExecution': {
+                // Ensure the tool_use card exists (server might have skipped item/started).
+                if (!cb.hasToolCard(item.id)) {
+                    emit(cb.toolUse('Bash', { command: item.command }, item.id));
+                }
+                const accumulated = state.commandOutputBuffers.get(item.id) ?? item.aggregatedOutput ?? '';
+                const exitCodeSuffix = item.exitCode != null ? `\n[exit code: ${item.exitCode}]` : '';
+                emit(cb.toolResult(item.id, accumulated + exitCodeSuffix, item.status === 'failed'));
+                state.commandOutputBuffers.delete(item.id);
+                return;
+            }
+            case 'fileChange': {
+                emitFileChangeCards(item, true);
+                return;
+            }
+            case 'mcpToolCall': {
+                if (!cb.hasToolCard(item.id)) {
+                    emit(cb.toolUse(`${item.server}:${item.tool}`, item.arguments, item.id));
+                }
+                const failed = item.status === 'failed' || item.error != null;
+                const text = mcpResultText(item);
+                emit(cb.toolResult(item.id, text, failed));
+                return;
+            }
+            case 'webSearch': {
+                // ALWAYS re-emit toolUse on completion — `item.query` is empty at
+                // item/started and only populated here, so a `hasToolCard` skip
+                // would leave the placeholder card stuck on "Search ?". cardBuilder
+                // dedups by toolUseId so re-emitting just patches the toolInput.
+                const finalQuery = extractWebSearchQuery(item);
+                emit(cb.toolUse('WebSearch', { query: finalQuery }, item.id));
+                emit(cb.toolResult(item.id, `Search: ${finalQuery}`, false));
+                return;
+            }
+            case 'dynamicToolCall': {
+                const toolName = item.namespace ? `${item.namespace}:${item.tool}` : item.tool;
+                if (!cb.hasToolCard(item.id)) {
+                    emit(cb.toolUse(toolName, item.arguments ?? {}, item.id));
+                }
+                const text = stringifyDynamicToolResult(item);
+                const failed = item.success === false;
+                emit(cb.toolResult(item.id, text, failed));
+                return;
+            }
+            case 'plan': {
+                // No-op on completed (we already rendered as system info on started).
+                return;
+            }
+            case 'imageGeneration': {
+                // The status / savedPath only become real on completed; emit an
+                // info system card linking to the saved file when present.
+                const where = item.savedPath ? ` → ${item.savedPath}` : '';
+                const failed = item.status !== 'completed' && item.status !== 'success';
+                emit(cb.systemMessage(`[image ${failed ? 'generation failed' : 'generated'}: ${item.revisedPrompt ?? '(no prompt)'}]${where}`, failed ? 'error' : 'info'));
+                return;
+            }
+            case 'collabAgentToolCall': {
+                // Mirror mcpToolCall: ensure the card exists, then surface the
+                // final state. Schema doesn't expose a result body so we
+                // synthesize a one-liner from status + receivers.
+                if (!cb.hasToolCard(item.id)) {
+                    emit(cb.toolUse(`collab:${item.tool}`, {
+                        prompt: item.prompt ?? '',
+                        model: item.model ?? undefined,
+                        receiverThreadIds: item.receiverThreadIds,
+                    }, item.id));
+                }
+                const failed = item.status === 'failed';
+                emit(cb.toolResult(item.id, `${item.tool} → ${item.status}${item.receiverThreadIds.length ? ` (agents: ${item.receiverThreadIds.length})` : ''}`, failed));
+                return;
+            }
+            case 'userMessage':
+            case 'hookPrompt':
+            case 'imageView':
+            case 'enteredReviewMode':
+            case 'exitedReviewMode':
+            case 'contextCompaction':
+                return;
+        }
+    };
+    const emitFileChangeCards = (item, emitResults) => {
+        const changes = item.changes ?? [];
+        for (let i = 0; i < changes.length; i++) {
+            const change = changes[i];
+            const cardId = changes.length > 1 ? `${item.id}#${i}` : item.id;
+            const filePath = extractFileChangePath(change) ?? '(unknown)';
+            const kind = extractFileChangeKind(change);
+            if (!state.fileChangeCardsAdded.has(cardId) && !cb.hasToolCard(cardId)) {
+                emit(cb.toolUse(kind, { file_path: filePath }, cardId));
+                state.fileChangeCardsAdded.add(cardId);
+            }
+            if (emitResults) {
+                const failed = item.status === 'failed';
+                emit(cb.toolResult(cardId, `${kind}: ${filePath}`.slice(0, TOOL_RESULT_TRUNCATE_LENGTH), failed));
+            }
+        }
+    };
+    const handlePlanUpdated = (params) => {
+        const todos = params.plan.map((step) => ({
+            content: step.step,
+            status: planStatusToTodoStatus(step.status),
+        }));
+        const cardId = `plan:${params.turnId}`;
+        state.planCardId = cardId;
+        emit(cb.toolUse('TodoWrite', { todos }, cardId));
+        if (params.explanation) {
+            emit(cb.systemMessage(params.explanation, 'info'));
+        }
+    };
+    const finalize = async (status, error) => {
+        if (state.turnEnded)
+            return;
+        state.turnEnded = true;
+        flushText();
+        const fin = cb.finalizeAssistantText();
+        if (fin)
+            emit(fin);
+        let usage;
+        if (status === 'completed' || status === 'failed') {
+            const observed = await ctx.tokens.awaitTurnUsage(ctx.turnId, TURN_USAGE_GRACE_MS);
+            usage = TokenAccounting.toCardStreamEndUsage(observed);
+        }
+        if (status === 'failed' && error) {
+            emitErrorOnce(error);
+        }
+        const streamEnd = {
+            streamId: ctx.streamId,
+            sessionId: ctx.sessionId,
+            success: status === 'completed',
+            ...(status === 'interrupted' ? { interrupted: true } : {}),
+            ...(status === 'failed' && error
+                ? { error: formatError(error) }
+                : {}),
+            ...(usage ? { tokenUsage: usage } : {}),
+        };
+        callbacks.emitStreamEnd(streamEnd);
+        ctx.tokens.releaseTurn(ctx.turnId);
+        resolveResult({ status, error });
+    };
+    const unsubscribe = rpc.onNotification(dispatch);
+    const unsubClose = rpc.onNotification(() => {
+        /* noop placeholder for symmetry */
+    });
+    // Tear-down on transport close — emit a synthetic interrupted end if
+    // the run wasn't already finalized.
+    const closeFallback = () => {
+        if (state.turnEnded)
+            return;
+        void finalize('interrupted', undefined);
+    };
+    // Note: we don't have a dedicated close listener API on RpcClient
+    // for adapter-scoped lifecycle, so the provider drives this via its
+    // own try/finally.
+    void unsubClose; // placeholder; kept for future symmetry.
+    try {
+        return await result;
+    }
+    finally {
+        unsubscribe();
+        if (state.textTimer)
+            clearTimeout(state.textTimer);
+        void closeFallback;
+    }
+}
+// ── helpers ──
+function extractFileChangePath(change) {
+    if (typeof change !== 'object' || change === null)
+        return null;
+    const c = change;
+    return c.path ?? c.filePath ?? c.file_path ?? null;
+}
+function extractFileChangeKind(change) {
+    if (typeof change !== 'object' || change === null)
+        return 'Edit';
+    const c = change;
+    const k = (extractChangeDiscriminator(c.kind) || extractChangeDiscriminator(c.type)).toLowerCase();
+    if (k === 'add' || k === 'create' || k === 'create_file' || k === 'write')
+        return 'Write';
+    return 'Edit';
+}
+function extractChangeDiscriminator(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value !== 'object' || value === null)
+        return '';
+    const record = value;
+    for (const key of ['kind', 'type', 'tag']) {
+        const nested = record[key];
+        if (typeof nested === 'string')
+            return nested;
+    }
+    const keys = Object.keys(record);
+    return keys.length === 1 ? keys[0] : '';
+}
+/** Codex emits webSearch with `item.query` empty at item/started — the
+ *  flat `query` field is only populated on item/completed. Even at completed
+ *  it can stay empty when the model used a sub-action (`openPage` /
+ *  `findInPage`). Fall back to whatever the structured `action` carries so
+ *  the card never renders the bare "Search ?" placeholder. */
+function extractWebSearchQuery(item) {
+    if (item.query)
+        return item.query;
+    const action = item.action;
+    if (!action)
+        return '';
+    switch (action.type) {
+        case 'search': {
+            if (action.query)
+                return action.query;
+            if (action.queries && action.queries.length > 0)
+                return action.queries.join(', ');
+            return '';
+        }
+        case 'openPage':
+            return action.url ?? '';
+        case 'findInPage':
+            return action.pattern
+                ? (action.url ? `${action.pattern} (in ${action.url})` : action.pattern)
+                : (action.url ?? '');
+        case 'other':
+            return '';
+    }
+}
+function mcpResultText(item) {
+    if (item.error) {
+        if (typeof item.error === 'object' && 'message' in item.error) {
+            return String(item.error.message ?? 'MCP tool error');
+        }
+        return JSON.stringify(item.error);
+    }
+    const result = item.result;
+    if (!result)
+        return '(no result)';
+    if (typeof result === 'string')
+        return result;
+    if (typeof result === 'object' && 'content' in result) {
+        const content = result.content;
+        if (Array.isArray(content)) {
+            const parts = content
+                .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                .map((c) => c.text);
+            if (parts.length > 0)
+                return parts.join('\n');
+        }
+        const structured = result.structuredContent;
+        if (structured !== undefined)
+            return JSON.stringify(structured);
+    }
+    return JSON.stringify(result);
+}
+function stringifyDynamicToolResult(item) {
+    const items = item.contentItems ?? [];
+    if (items.length === 0)
+        return '(no result)';
+    const parts = [];
+    for (const ci of items) {
+        if (typeof ci === 'object' && ci !== null && 'text' in ci) {
+            const text = ci.text;
+            if (typeof text === 'string')
+                parts.push(text);
+        }
+    }
+    if (parts.length > 0)
+        return parts.join('\n');
+    return JSON.stringify(items);
+}
+function planStatusToTodoStatus(status) {
+    switch (status) {
+        case 'pending':
+            return 'pending';
+        case 'inProgress':
+            return 'in_progress';
+        case 'completed':
+            return 'completed';
+    }
+}
+function stringifyErrorInfo(info) {
+    if (info == null)
+        return '';
+    if (typeof info === 'string')
+        return info;
+    return Object.keys(info)[0] ?? '';
+}
+function formatError(error) {
+    const info = stringifyErrorInfo(error.codexErrorInfo ?? null);
+    const prefix = info ? `[${info}] ` : '';
+    return `${prefix}${error.message}${error.additionalDetails ? `\n${error.additionalDetails}` : ''}`;
+}
+//# sourceMappingURL=cardAdapter.js.map