@abitat_reece/host-daemon 0.1.10 → 0.1.13

package/dist/local-control/codex-bridge.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { basename, normalize } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, normalize } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import WebSocket from "ws";
 import { attachmentDiagnostics, errorDiagnostics, logDiagnostics, promptDiagnostics } from "./diagnostics-log.js";
@@ -37,6 +38,7 @@ export function createLocalCodexBridge(options = {}) {
     const queuedTurnsByThread = new Map();
     const queueDrainTimers = new Map();
     const threadListCache = new Map();
+    const messageHistoryCache = new Map();
     async function listAllThreads(params = {}) {
         const cacheKey = threadListCacheKey(params);
         const cached = threadListCache.get(cacheKey);
@@ -115,11 +117,56 @@ export function createLocalCodexBridge(options = {}) {
         }));
     }
     function enqueueTurn(threadId, input, options = { front: false }) {
+        invalidateMessageHistoryCache(threadId);
         const existing = queuedTurnsByThread.get(threadId) ?? [];
+        if (input.clientMessageId &&
+            existing.some((turn) => turn.clientMessageId === input.clientMessageId)) {
+            scheduleQueueDrain(threadId);
+            return;
+        }
         const next = options.front ? [input, ...existing] : [...existing, input];
         queuedTurnsByThread.set(threadId, next);
         scheduleQueueDrain(threadId);
     }
+    function deleteQueuedTurn(threadId, clientMessageId) {
+        const existing = queuedTurnsByThread.get(threadId);
+        if (!existing?.length) {
+            return false;
+        }
+        const next = existing.filter((turn) => turn.clientMessageId !== clientMessageId);
+        if (next.length === existing.length) {
+            return false;
+        }
+        invalidateMessageHistoryCache(threadId);
+        if (next.length > 0) {
+            queuedTurnsByThread.set(threadId, next);
+        }
+        else {
+            queuedTurnsByThread.delete(threadId);
+            const timer = queueDrainTimers.get(threadId);
+            if (timer) {
+                clearTimeout(timer);
+                queueDrainTimers.delete(threadId);
+            }
+        }
+        return true;
+    }
+    function updateQueuedTurn(threadId, clientMessageId, prompt) {
+        const existing = queuedTurnsByThread.get(threadId);
+        if (!existing?.length) {
+            return false;
+        }
+        const index = existing.findIndex((turn) => turn.clientMessageId === clientMessageId);
+        if (index < 0) {
+            return false;
+        }
+        invalidateMessageHistoryCache(threadId);
+        queuedTurnsByThread.set(threadId, existing.map((turn, turnIndex) => (turnIndex === index ? { ...turn, prompt } : turn)));
+        return true;
+    }
+    function invalidateMessageHistoryCache(threadId) {
+        messageHistoryCache.delete(threadId);
+    }
     function scheduleQueueDrain(threadId, delayMs = QUEUED_TURN_POLL_INTERVAL_MS) {
         if (queueDrainTimers.has(threadId)) {
             return;
@@ -157,21 +204,31 @@ export function createLocalCodexBridge(options = {}) {
         if (queue.length === 0) {
             queuedTurnsByThread.delete(threadId);
         }
-        await startConversationTurn(threadId, thread, nextInput);
+        try {
+            await startConversationTurn(threadId, thread, nextInput);
+        }
+        catch (error) {
+            logDiagnostics(diagnostics, "error", "conversation.queue.start_failure", {
+                error: errorDiagnostics(error),
+                threadId
+            });
+        }
         if ((queuedTurnsByThread.get(threadId)?.length ?? 0) > 0) {
             scheduleQueueDrain(threadId);
         }
     }
     async function startConversationTurn(threadId, thread, input) {
+        invalidateMessageHistoryCache(threadId);
         let activeThread = thread;
         if (threadStatusType(activeThread.status) !== "active") {
             activeThread = (await client.resumeThread({ excludeTurns: false, threadId })).thread;
         }
-        await client.startTurn(threadId, userInput(input.prompt, input.attachments), {
+        const response = await client.startTurn(threadId, userInput(input.prompt, input.attachments), {
             ...PHONE_FULL_ACCESS_TURN_OPTIONS,
             cwd: activeThread.cwd,
             ...turnModelSettings(input.modelSettings)
         });
+        return startedTurnStatusOrThrow(threadId, response.turn, diagnostics);
     }
     return {
         async bootstrap() {
@@ -196,7 +253,17 @@ export function createLocalCodexBridge(options = {}) {
             const delivery = input.delivery ?? "queue";
             if (isCodexThreadBusy(thread)) {
                 if (delivery === "steer") {
-                    await client.injectItems(threadId, steerItems(input.prompt, input.attachments));
+                    const activeTurn = latestActiveTurn(thread);
+                    if (!activeTurn) {
+                        throw Object.assign(new Error("No active Codex turn is available to steer"), {
+                            statusCode: 409
+                        });
+                    }
+                    invalidateMessageHistoryCache(threadId);
+                    await client.steerTurn(threadId, userInput(input.prompt, input.attachments), activeTurn.id);
+                    if (input.clientMessageId) {
+                        deleteQueuedTurn(threadId, input.clientMessageId);
+                    }
                     return {
                         conversationId: externalCodexConversationId(threadId),
                         status: "running"
@@ -215,46 +282,73 @@ export function createLocalCodexBridge(options = {}) {
                     status: "queued"
                 };
             }
-            await startConversationTurn(threadId, thread, input);
+            const startedStatus = await startConversationTurn(threadId, thread, input);
+            return {
+                conversationId: externalCodexConversationId(threadId),
+                status: startedStatus
+            };
+        },
+        async deleteQueuedTurn(conversationId, input) {
+            const threadId = toCodexThreadId(conversationId);
+            const removed = deleteQueuedTurn(threadId, input.clientMessageId);
             return {
                 conversationId: externalCodexConversationId(threadId),
-                status: "running"
+                removed,
+                status: (queuedTurnsByThread.get(threadId)?.length ?? 0) > 0 ? "queued" : "running"
+            };
+        },
+        async updateQueuedTurn(conversationId, input) {
+            const threadId = toCodexThreadId(conversationId);
+            const updated = updateQueuedTurn(threadId, input.clientMessageId, input.prompt);
+            return {
+                conversationId: externalCodexConversationId(threadId),
+                status: (queuedTurnsByThread.get(threadId)?.length ?? 0) > 0 ? "queued" : "running",
+                updated
             };
         },
         async listCompletionStates() {
             const threads = await readThreadsWithTurns(await loadAllThreads());
+            const states = threads.map((thread) => codexThreadToCompletionState(thread, workspaceId));
             logDiagnostics(diagnostics, "info", "completion.states.result", {
-                stateCount: threads.length
+                activeCount: states.filter((state) => isActiveMobileConversationStatus(state.status))
+                    .length,
+                stateCount: states.length
             });
-            return threads
-                .sort((left, right) => right.updatedAt - left.updatedAt)
-                .map((thread) => codexThreadToCompletionState(thread, workspaceId));
+            return states.sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
         },
         async listMessages(conversationId, messageOptions = {}) {
             const threadId = toCodexThreadId(conversationId);
-            const messages = flattenThreadMessages(await client.readThread(threadId, true), externalCodexConversationId(threadId), diagnostics);
-            const filtered = messageOptions.includeRuntime
-                ? messages
-                : messages.filter((message) => message.role !== "runtime");
-            const returned = typeof messageOptions.afterSequence === "number"
-                ? messageOptions.afterSequence >
-                    filtered.reduce((max, message) => Math.max(max, message.sequence), 0)
-                    ? filtered
-                    : filtered.filter((message) => message.sequence > messageOptions.afterSequence)
-                : filtered;
+            const messages = await readCachedThreadMessages(threadId, {
+                afterSequence: messageOptions.afterSequence,
+                forceRefresh: messageOptions.forceRefresh === true
+            });
+            const returned = filterThreadMessages(messages, messageOptions);
             logDiagnostics(diagnostics, "info", "messages.list.bridge_result", {
                 ...messageCounts(messages),
                 afterSequence: messageOptions.afterSequence,
                 conversationId: externalCodexConversationId(threadId),
+                forceRefresh: messageOptions.forceRefresh === true,
                 includeRuntime: messageOptions.includeRuntime === true,
                 returned: returned.length,
                 total: messages.length
             });
-            if (typeof messageOptions.afterSequence !== "number") {
-                return returned;
-            }
             return returned;
         },
+        async listGeneratedFiles(conversationId) {
+            return generatedFilesForThread(await client.readThread(toCodexThreadId(conversationId), true));
+        },
+        async downloadGeneratedFile(conversationId, fileId) {
+            const files = await generatedFilesForThread(await client.readThread(toCodexThreadId(conversationId), true));
+            const file = files.find((candidate) => candidate.id === fileId);
+            if (!file) {
+                throw Object.assign(new Error("Generated file not found"), { statusCode: 404 });
+            }
+            const data = await readFile(file.path);
+            return {
+                ...file,
+                dataBase64: data.toString("base64")
+            };
+        },
         listModelOptions() {
             return client.listModels();
         },
@@ -274,14 +368,16 @@ export function createLocalCodexBridge(options = {}) {
                 experimentalRawEvents: false,
                 persistExtendedHistory: true
             });
-            await client.startTurn(thread.id, userInput(input.prompt, input.attachments), {
+            invalidateMessageHistoryCache(thread.id);
+            const response = await client.startTurn(thread.id, userInput(input.prompt, input.attachments), {
                 ...PHONE_FULL_ACCESS_TURN_OPTIONS,
                 cwd,
                 ...turnModelSettings(input.modelSettings)
             });
+            const startedStatus = startedTurnStatusOrThrow(thread.id, response.turn, diagnostics);
             return {
                 conversationId: externalCodexConversationId(thread.id),
-                status: "running"
+                status: startedStatus
             };
         }
     };
@@ -300,6 +396,33 @@ export function createLocalCodexBridge(options = {}) {
             return mergeCodexThreadSnapshots(readThread, thread);
         }));
     }
+    async function readCachedThreadMessages(threadId, options) {
+        const cached = messageHistoryCache.get(threadId);
+        if (!options.forceRefresh && typeof options.afterSequence === "number" && cached) {
+            const summary = await client.readThread(threadId, false).catch(() => null);
+            if (summary && canUseCachedMessageHistory(cached, summary)) {
+                return cached.messages;
+            }
+        }
+        const thread = await client.readThread(threadId, true);
+        const messages = flattenThreadMessages(thread, externalCodexConversationId(threadId), diagnostics);
+        if (isCodexThreadMessageHistoryStable(thread)) {
+            messageHistoryCache.set(threadId, {
+                messages,
+                statusType: threadStatusType(thread.status),
+                updatedAt: safeSeconds(thread.updatedAt, thread.createdAt)
+            });
+        }
+        else {
+            invalidateMessageHistoryCache(threadId);
+        }
+        return messages;
+    }
+    function canUseCachedMessageHistory(cached, summary) {
+        return (!isCodexThreadBusy(summary) &&
+            cached.statusType === threadStatusType(summary.status) &&
+            cached.updatedAt === safeSeconds(summary.updatedAt, summary.createdAt));
+    }
 }
 function createCodexAppClient(options) {
     const serverUrl = options.serverUrl ?? process.env.CODEX_APP_SERVER_URL ?? DEFAULT_SERVER_URL;
@@ -320,10 +443,6 @@ function createCodexAppClient(options) {
             } while (cursor);
             return models;
         },
-        injectItems: (threadId, items) => callCodexApp(serverUrl, codexBinaryPath, "thread/inject_items", {
-            items,
-            threadId
-        }),
         async listLoadedThreads() {
             const threadIds = [];
             let cursor = null;
@@ -373,7 +492,8 @@ function createCodexAppClient(options) {
             persistExtendedHistory: true,
             ...params
         }, diagnostics),
-        startTurn: (threadId, input, turnOptions) => startTurnWithKeepAlive(serverUrl, codexBinaryPath, threadId, input, turnOptions, diagnostics)
+        startTurn: (threadId, input, turnOptions) => startTurnWithKeepAlive(serverUrl, codexBinaryPath, threadId, input, turnOptions, diagnostics),
+        steerTurn: (threadId, input, expectedTurnId) => steerTurnWithKeepAlive(serverUrl, codexBinaryPath, threadId, input, expectedTurnId, diagnostics)
     };
 }
 async function callCodexApp(serverUrl, codexBinaryPath, method, params, diagnostics) {
@@ -478,6 +598,75 @@ async function startTurnWithKeepAliveOnce(serverUrl, threadId, input, options) {
         }
     }
 }
+async function steerTurnWithKeepAlive(serverUrl, codexBinaryPath, threadId, input, expectedTurnId, diagnostics) {
+    logDiagnostics(diagnostics, "info", "codex.turn_steer.call", {
+        ...turnInputDiagnostics(input),
+        expectedTurnId,
+        threadId
+    });
+    try {
+        const response = await steerTurnWithKeepAliveOnce(serverUrl, threadId, input, expectedTurnId);
+        logDiagnostics(diagnostics, "info", "codex.turn_steer.result", {
+            expectedTurnId,
+            threadId,
+            turnId: response.turnId
+        });
+        return response;
+    }
+    catch (error) {
+        if (!isConnectionFailure(error) || !canStartLocalServer(serverUrl)) {
+            logDiagnostics(diagnostics, "error", "codex.turn_steer.failure", {
+                error: errorDiagnostics(error),
+                expectedTurnId,
+                threadId
+            });
+            throw error;
+        }
+        logDiagnostics(diagnostics, "warn", "codex.app_server.connect_failure", {
+            error: errorDiagnostics(error),
+            method: "turn/steer",
+            serverUrl
+        });
+        await ensureLocalAppServer(serverUrl, codexBinaryPath, diagnostics);
+        try {
+            const response = await steerTurnWithKeepAliveOnce(serverUrl, threadId, input, expectedTurnId);
+            logDiagnostics(diagnostics, "info", "codex.turn_steer.result", {
+                expectedTurnId,
+                threadId,
+                turnId: response.turnId
+            });
+            return response;
+        }
+        catch (retryError) {
+            logDiagnostics(diagnostics, "error", "codex.turn_steer.failure", {
+                error: errorDiagnostics(retryError),
+                expectedTurnId,
+                threadId
+            });
+            throw retryError;
+        }
+    }
+}
+async function steerTurnWithKeepAliveOnce(serverUrl, threadId, input, expectedTurnId) {
+    const connection = await JsonRpcConnection.connect(serverUrl);
+    let keepAliveStarted = false;
+    try {
+        await initializeConnection(connection);
+        const response = await connection.call("turn/steer", {
+            expectedTurnId,
+            input,
+            threadId
+        });
+        keepAliveStarted = true;
+        keepTurnConnectionAlive(connection, threadId, response.turnId);
+        return response;
+    }
+    finally {
+        if (!keepAliveStarted) {
+            connection.close();
+        }
+    }
+}
 async function initializeConnection(connection) {
     await connection.call("initialize", {
         capabilities: {
@@ -733,7 +922,7 @@ function mergeCodexThreadSnapshots(baseThread, nextThread) {
             threadListActivityAt: abitatThreadListActivityAt
         })
             ? { activeFlags: [], type: "active" }
-            : preferredThreadStatus(baseThread.status, nextThread.status),
+            : preferredMergedThreadStatus(baseThread, nextThread),
         turns: nextThread.turns.length > 0 ? nextThread.turns : baseThread.turns,
         updatedAt: Math.max(safeSeconds(baseThread.updatedAt, baseThread.createdAt), safeSeconds(nextThread.updatedAt, nextThread.createdAt))
     };
@@ -744,6 +933,14 @@ function preferredThreadStatus(baseStatus, nextStatus) {
     }
     return threadStatusRank(nextStatus) > threadStatusRank(baseStatus) ? nextStatus : baseStatus;
 }
+function preferredMergedThreadStatus(baseThread, nextThread) {
+    const baseLatestTurn = baseThread.turns.at(-1) ?? null;
+    const nextIsActiveSummary = threadStatusType(nextThread.status) === "active" && nextThread.turns.length === 0;
+    if (nextIsActiveSummary && baseLatestTurn && isTurnTerminal(baseLatestTurn)) {
+        return baseThread.status;
+    }
+    return preferredThreadStatus(baseThread.status, nextThread.status);
+}
 function threadStatusRank(status) {
     switch (threadStatusType(status)) {
         case "active":
@@ -790,10 +987,14 @@ function isThreadListActivitySummaryStatus(status) {
     return statusType === "idle" || statusType === "notLoaded";
 }
 function needsConversationStatusHydration(thread) {
-    return thread.turns.length === 0 && isThreadListActivitySummaryStatus(thread.status);
+    return (thread.turns.length === 0 &&
+        (isThreadListActivitySummaryStatus(thread.status) ||
+            threadStatusType(thread.status) === "active"));
 }
 function threadListActivitySeconds(thread) {
-    const currentActivity = thread.turns.length === 0 && isThreadListActivitySummaryStatus(thread.status)
+    const currentActivity = thread.turns.length === 0 &&
+        (isThreadListActivitySummaryStatus(thread.status) ||
+            threadStatusType(thread.status) === "active")
         ? safeSeconds(thread.updatedAt, thread.createdAt)
         : null;
     return maxOptionalSeconds(thread.abitatThreadListActivityAt ?? null, currentActivity);
@@ -847,6 +1048,32 @@ function codexThreadToCompletionState(thread, workspaceId) {
         workspaceId
     };
 }
+function startedTurnStatusOrThrow(threadId, turn, diagnostics) {
+    if (isTurnInProgress(turn)) {
+        return "running";
+    }
+    if (turnHasVisibleAssistantMessage(turn)) {
+        return "approved";
+    }
+    const message = codexTurnDidNotStartMessage(turn);
+    logDiagnostics(diagnostics, "error", "codex.turn_start.unstarted", {
+        error: message,
+        status: turnStatusType(turn),
+        threadId,
+        turnId: turn.id
+    });
+    throw Object.assign(new Error(message), { statusCode: 502 });
+}
+function codexTurnDidNotStartMessage(turn) {
+    const turnError = codexTurnErrorMessage(turn.error);
+    if (turnError) {
+        return `Codex turn did not start: ${turnError}`;
+    }
+    const status = turnStatusType(turn);
+    return status
+        ? `Codex turn did not start; Codex returned status ${status} without a visible reply.`
+        : "Codex turn did not start; Codex returned without a visible reply.";
+}
 export function flattenThreadMessages(thread, conversationId = externalCodexConversationId(thread.id), diagnostics) {
     const messages = [];
     const itemOccurrences = new Map();
@@ -896,6 +1123,28 @@ export function flattenThreadMessages(thread, conversationId = externalCodexConv
             }
             sequence += 1;
         }
+        if (turn.error && (assistantMessagesByTurn.get(turn.id) ?? 0) === 0) {
+            const errorContent = codexTurnVisibleErrorContent(turn.error);
+            if (errorContent) {
+                messages.push({
+                    content: errorContent,
+                    conversationId,
+                    createdAt: itemCreatedAt(thread, turn, sequence),
+                    id: `${conversationId}_${encodeURIComponent(turn.id)}_turn_error`,
+                    metadata: {
+                        codexItemId: "turn_error",
+                        codexItemType: "turnError",
+                        codexThreadId: thread.id,
+                        codexTurnId: turn.id
+                    },
+                    role: "assistant",
+                    sequence,
+                    sourceDeviceId: null
+                });
+                assistantMessagesByTurn.set(turn.id, 1);
+                sequence += 1;
+            }
+        }
         if (isTurnCompleted(turn) && (assistantMessagesByTurn.get(turn.id) ?? 0) === 0) {
             logDiagnostics(diagnostics, "warn", "codex.turn.completed_without_visible_assistant", {
                 conversationId,
@@ -916,6 +1165,91 @@ export function flattenThreadMessages(thread, conversationId = externalCodexConv
     });
     return messages;
 }
+async function generatedFilesForThread(thread) {
+    const paths = new Set();
+    for (const turn of thread.turns) {
+        for (const item of turn.items) {
+            if (item.type !== "fileChange") {
+                continue;
+            }
+            const fileChange = item;
+            for (const change of fileChange.changes ?? []) {
+                const path = generatedFilePath(thread.cwd, change);
+                if (path) {
+                    paths.add(path);
+                }
+            }
+        }
+    }
+    const files = await Promise.all(Array.from(paths)
+        .sort()
+        .map(async (path) => {
+        const stats = await stat(path).catch(() => null);
+        if (!stats?.isFile()) {
+            return null;
+        }
+        return {
+            id: generatedFileId(thread.id, path),
+            mimeType: mimeTypeForPath(path),
+            name: basename(path),
+            path,
+            size: stats.size
+        };
+    }));
+    return files.filter((file) => Boolean(file));
+}
+function generatedFilePath(cwd, change) {
+    if (!change || typeof change !== "object") {
+        return null;
+    }
+    const candidate = change;
+    const value = stringField(candidate, "path") ??
+        stringField(candidate, "filePath") ??
+        stringField(candidate, "absolutePath") ??
+        stringField(candidate, "relativePath");
+    if (!value) {
+        return null;
+    }
+    return isAbsolute(value) ? normalize(value) : normalize(join(cwd, value));
+}
+function generatedFileId(threadId, path) {
+    return `file_${createHash("sha256")
+        .update(`${threadId}\0${normalize(path)}`)
+        .digest("hex")
+        .slice(0, 24)}`;
+}
+function stringField(value, key) {
+    const field = value[key];
+    return typeof field === "string" && field.trim() ? field.trim() : null;
+}
+function mimeTypeForPath(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".html":
+            return "text/html";
+        case ".md":
+        case ".markdown":
+            return "text/markdown";
+        case ".mp4":
+            return "video/mp4";
+        case ".mov":
+            return "video/quicktime";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".pdf":
+            return "application/pdf";
+        case ".json":
+            return "application/json";
+        case ".txt":
+            return "text/plain";
+        default:
+            return "application/octet-stream";
+    }
+}
 function codexThreadToConversationStatus(thread) {
     const latestTurn = thread.turns.at(-1) ?? null;
     if (threadStatusType(thread.status) === "active") {
@@ -936,7 +1270,19 @@ function codexThreadToConversationStatus(thread) {
     return "approved";
 }
 function isCodexThreadBusy(thread) {
-    return threadStatusType(thread.status) === "active";
+    return threadStatusType(thread.status) === "active" || thread.turns.some(isTurnInProgress);
+}
+function isCodexThreadMessageHistoryStable(thread) {
+    return !isCodexThreadBusy(thread) && !thread.turns.some(isTurnInProgress);
+}
+function latestActiveTurn(thread) {
+    for (let index = thread.turns.length - 1; index >= 0; index -= 1) {
+        const turn = thread.turns[index];
+        if (turn && isTurnInProgress(turn)) {
+            return turn;
+        }
+    }
+    return null;
 }
 function isActiveMobileConversationStatus(status) {
     return status === "running" || status === "awaiting_approval";
@@ -991,6 +1337,14 @@ function isKnownCodexItemType(type) {
         type === "fileChange" ||
         HIDDEN_CODEX_ITEM_TYPES.has(type));
 }
+function filterThreadMessages(messages, options) {
+    const filtered = options.includeRuntime
+        ? messages
+        : messages.filter((message) => message.role !== "runtime");
+    return typeof options.afterSequence === "number"
+        ? filtered.filter((message) => message.sequence > options.afterSequence)
+        : filtered;
+}
 function messageCounts(messages) {
     const counts = {
         assistant: 0,
@@ -1021,6 +1375,37 @@ function turnInputDiagnostics(input) {
         ...attachmentDiagnostics(attachments)
     };
 }
+function turnHasVisibleAssistantMessage(turn) {
+    return turn.items.some((item) => threadItemToMessageContent(item)?.role === "assistant");
+}
+function codexTurnVisibleErrorContent(error) {
+    const message = codexTurnErrorMessage(error);
+    return message ? `Codex could not complete this turn: ${message}` : null;
+}
+function codexTurnErrorMessage(error) {
+    if (!error) {
+        return null;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error.trim() || null;
+    }
+    if (typeof error === "object") {
+        const message = error.message;
+        if (typeof message === "string" && message.trim()) {
+            return message.trim();
+        }
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
 function userInput(prompt, attachments = []) {
     return [
         { text: normalizedPrompt(prompt), text_elements: [], type: "text" },
@@ -1049,16 +1434,6 @@ function userInputToText(input) {
             return `[Mention: ${input.name}]`;
     }
 }
-function steerItems(prompt, attachments = []) {
-    const text = userInput(prompt, attachments).map(userInputToText).filter(Boolean).join("\n");
-    return [
-        {
-            content: [{ text, type: "input_text" }],
-            role: "user",
-            type: "message"
-        }
-    ];
-}
 function turnModelSettings(modelSettings) {
     return modelSettings ? { effort: modelSettings.effort, model: modelSettings.model } : {};
 }