@axhub/acp 0.1.0 → 0.1.1

package/dist/lib/conversations/client-adapter.mjs

@@ -1,25 +1,48 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { RuntimeAdapterProvider, useAui, useAuiState, useRemoteThreadListRuntime, } from "@assistant-ui/react";
-import { AssistantChatTransport, useChatRuntime, } from "@assistant-ui/react-ai-sdk";
+import { AssistantChatTransport, createResumableSessionStorage, useChatRuntime, } from "@assistant-ui/react-ai-sdk";
 import { lastAssistantMessageIsCompleteWithToolCalls, } from "ai";
 import { createAssistantStream } from "assistant-stream";
-import { useEffect, useMemo, useRef, } from "react";
+import { useCallback, useEffect, useMemo, useRef, } from "react";
 import { ACP_CAPABILITY_REFRESH_EVENT } from "../acp2aisdk/capability-cache.mjs";
 import { getAcpProviderDefaultModeId } from "../acp2aisdk/provider-registry.mjs";
 import { acpApiClient } from "../api/client.mjs";
+import { withoutBodyForNullBodyStatus } from "../api/http-response.mjs";
 import { getEnabledBuiltinToolIds } from "../../tools/client-registry.mjs";
+import { getUserFacingMessageText } from "./title-text.mjs";
 const DEFAULT_PROVIDER = "codex";
 const LOCAL_THREAD_ID_PREFIX = "__LOCALID_";
 const THREAD_LIST_PAGE_SIZE = 50;
+const RESUMABLE_STORAGE_PREFIX = "acp-ui:resumable";
 function createConversationThreadId(provider) {
     const random = typeof crypto !== "undefined" && "randomUUID" in crypto
         ? crypto.randomUUID()
         : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
     return `${provider}-${random}`;
 }
+function sanitizeResumableStoragePart(value) {
+    return encodeURIComponent(value || "default");
+}
+function createResumableStorageKey({ workspacePath, provider, threadId, }) {
+    return [
+        RESUMABLE_STORAGE_PREFIX,
+        sanitizeResumableStoragePart(workspacePath),
+        sanitizeResumableStoragePart(provider !== null && provider !== void 0 ? provider : DEFAULT_PROVIDER),
+        sanitizeResumableStoragePart(threadId),
+    ].join(":");
+}
+function hasLocalPendingResumableStream({ workspacePath, provider, threadId, }) {
+    if (typeof window === "undefined")
+        return false;
+    return Boolean(window.sessionStorage.getItem(createResumableStorageKey({
+        workspacePath,
+        provider: provider !== null && provider !== void 0 ? provider : DEFAULT_PROVIDER,
+        threadId,
+    })));
+}
 function toRemoteMetadata(thread) {
-    var _a, _b;
+    var _a, _b, _c;
     return {
         remoteId: thread.threadId,
         status: thread.status === "archived" ? "archived" : "regular",
@@ -30,22 +53,27 @@ function toRemoteMetadata(thread) {
             modeId: thread.modeId,
             thoughtLevel: thread.thoughtLevel,
             workspacePath: thread.workspacePath,
-            providerSessionId: (_b = thread.providerSessionId) !== null && _b !== void 0 ? _b : null,
+            updatedAt: thread.updatedAt,
+            lastActiveAt: (_b = thread.lastActiveAt) !== null && _b !== void 0 ? _b : null,
+            providerSessionId: (_c = thread.providerSessionId) !== null && _c !== void 0 ? _c : null,
         },
     };
 }
 function getTextFromThreadMessage(message) {
-    return message.content
+    const text = message.content
         .filter((part) => part.type === "text")
         .map((part) => part.text)
         .join(" ")
         .trim();
+    return getUserFacingMessageText(text);
 }
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function normalizeTitleText(value, maxLength) {
-    const title = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+    const title = typeof value === "string"
+        ? getUserFacingMessageText(value).replace(/\s+/g, " ").trim()
+        : "";
     return (maxLength ? title.slice(0, maxLength) : title).trim();
 }
 function normalizeStoredTitle(value) {
@@ -78,8 +106,38 @@ function createTitle(messages) {
     const firstUserMessage = messages.find((message) => message.role === "user" && getTextFromThreadMessage(message));
     const fallbackText = (firstUserMessage ? getTextFromThreadMessage(firstUserMessage) : "") ||
         getTextFromThreadMessage((_a = messages.find((message) => message.role !== "system")) !== null && _a !== void 0 ? _a : messages[0]);
-    const title = normalizeTitleText(fallbackText, 48);
-    return title;
+    return normalizeTitleText(fallbackText, 48);
+}
+function shouldStartRunFromAppendMessage(message) {
+    var _a;
+    return (_a = message.startRun) !== null && _a !== void 0 ? _a : message.role === "user";
+}
+function createAcpCreateMessage(message) {
+    var _a, _b;
+    const inputParts = [
+        ...message.content.filter((part) => part.type !== "file"),
+        ...((_b = (_a = message.attachments) === null || _a === void 0 ? void 0 : _a.flatMap((attachment) => attachment.content.map((part) => (Object.assign(Object.assign({}, part), { filename: attachment.name }))))) !== null && _b !== void 0 ? _b : []),
+    ];
+    const parts = inputParts.map((part) => {
+        switch (part.type) {
+            case "text":
+                return {
+                    type: "text",
+                    text: part.text,
+                };
+            case "image":
+                return Object.assign(Object.assign({ type: "file", url: part.image }, (part.filename ? { filename: part.filename } : {})), { mediaType: "image/png" });
+            case "file":
+                return Object.assign({ type: "file", url: part.data, mediaType: part.mimeType }, (part.filename ? { filename: part.filename } : {}));
+            default:
+                throw new Error(`Unsupported part type: ${part.type}`);
+        }
+    });
+    return {
+        role: message.role,
+        parts,
+        metadata: message.metadata,
+    };
 }
 const AcpSessionTitleSync = () => {
     const aui = useAui();
@@ -106,10 +164,11 @@ const AcpSessionTitleSync = () => {
     return null;
 };
 class RemoteConversationHistoryAdapter {
-    constructor(aui, workspacePath, ensureConversation) {
+    constructor(aui, workspacePath, fallbackThreadId, provider) {
         this.aui = aui;
         this.workspacePath = workspacePath;
-        this.ensureConversation = ensureConversation;
+        this.fallbackThreadId = fallbackThreadId;
+        this.provider = provider;
     }
     async load() {
         return { messages: [] };
@@ -118,61 +177,67 @@ class RemoteConversationHistoryAdapter {
     withFormat(formatAdapter) {
         const aui = this.aui;
         const workspacePath = this.workspacePath;
-        const ensureConversation = this.ensureConversation;
-        const getRemoteId = () => this.aui.threadListItem().getState().remoteId;
-        const saveItem = async (remoteId, item, messageId) => {
-            await acpApiClient.saveConversationMessage(remoteId, workspacePath, {
-                parentId: item.parentId,
-                message: {
-                    id: messageId,
-                    content: formatAdapter.encode(item),
-                },
-                format: formatAdapter.format,
-            });
+        const fallbackThreadId = this.fallbackThreadId;
+        const provider = this.provider;
+        const getRemoteId = async () => {
+            var _a;
+            const currentRemoteId = aui.threadListItem().getState().remoteId;
+            if (currentRemoteId)
+                return currentRemoteId;
+            await aui
+                .threadListItem()
+                .initialize()
+                .catch(() => null);
+            return (_a = aui.threadListItem().getState().remoteId) !== null && _a !== void 0 ? _a : fallbackThreadId;
         };
         return {
             async load() {
-                const remoteId = getRemoteId();
+                const remoteId = await getRemoteId();
                 if (!remoteId)
                     return { messages: [] };
-                const repo = await acpApiClient.loadConversationMessages(remoteId, workspacePath, formatAdapter.format);
-                if (repo.messages.length === 0) {
-                    return null;
-                }
-                return {
+                const repo = await acpApiClient.loadConversationMessages(remoteId, workspacePath, formatAdapter.format, undefined, {
+                    hideResumable: hasLocalPendingResumableStream({
+                        workspacePath,
+                        provider,
+                        threadId: remoteId,
+                    }),
+                });
+                const messages = repo.messages.map((message) => formatAdapter.decode({
+                    id: message.id,
+                    parent_id: message.parent_id,
+                    format: message.format,
+                    content: message.content,
+                }));
+                const externalRepo = {
                     headId: repo.headId,
-                    messages: repo.messages.map((message) => formatAdapter.decode({
-                        id: message.id,
-                        parent_id: message.parent_id,
-                        format: message.format,
-                        content: message.content,
-                    })),
+                    messages,
                 };
+                if (messages.length === 0) {
+                    aui.thread().import({ messages: [] });
+                }
+                return externalRepo;
             },
             async append(item) {
-                const { remoteId } = await aui.threadListItem().initialize();
-                await (ensureConversation === null || ensureConversation === void 0 ? void 0 : ensureConversation(remoteId));
-                await saveItem(remoteId, item, formatAdapter.getId(item.message));
+                await aui.threadListItem().initialize();
+                void item;
             },
             async update(item, localMessageId) {
-                const remoteId = getRemoteId();
-                if (!remoteId)
-                    return;
-                await saveItem(remoteId, item, localMessageId);
+                void item;
+                void localMessageId;
             },
         };
     }
 }
-function createHistoryProvider(workspacePath, ensureConversation) {
+function createHistoryProvider(workspacePath, threadId, provider) {
     const Provider = ({ children }) => {
         const aui = useAui();
-        const history = useMemo(() => new RemoteConversationHistoryAdapter(aui, workspacePath, ensureConversation), [aui]);
+        const history = useMemo(() => new RemoteConversationHistoryAdapter(aui, workspacePath, threadId, provider), [aui]);
         const adapters = useMemo(() => ({ history }), [history]);
         return (_jsxs(RuntimeAdapterProvider, { adapters: adapters, children: [_jsx(AcpSessionTitleSync, {}), children] }));
     };
     return Provider;
 }
-function createConversationThreadListAdapter(context = {}) {
+function createConversationThreadListAdapter(context = {}, threadId) {
     const conversationBody = (threadId) => {
         var _a, _b, _c, _d, _e, _f, _g;
         const metadata = (_b = (_a = context.getConversationMetadata) === null || _a === void 0 ? void 0 : _a.call(context)) !== null && _b !== void 0 ? _b : {};
@@ -190,15 +255,23 @@ function createConversationThreadListAdapter(context = {}) {
         await acpApiClient.upsertConversation(Object.assign(Object.assign(Object.assign({}, conversationBody(threadId)), patch), { threadId }), context.workspacePath);
     };
     return {
-        unstable_Provider: createHistoryProvider(context.workspacePath, ensureConversation),
+        unstable_Provider: createHistoryProvider(context.workspacePath, threadId, context.provider),
         async list(params) {
             const { threads, nextCursor } = await acpApiClient.listConversations(context.workspacePath, {
                 after: params === null || params === void 0 ? void 0 : params.after,
                 limit: THREAD_LIST_PAGE_SIZE,
                 refreshProvider: false,
             });
+            const hasRouteThread = threadId && threads.some((thread) => thread.threadId === threadId);
+            const routeThread = threadId && !hasRouteThread
+                ? await acpApiClient
+                    .getConversation(threadId, context.workspacePath)
+                    .then(({ thread }) => thread)
+                    .catch(() => null)
+                : null;
+            const allThreads = routeThread ? [routeThread, ...threads] : threads;
             return {
-                threads: threads.map(toRemoteMetadata),
+                threads: allThreads.map(toRemoteMetadata),
                 nextCursor,
             };
         },
@@ -256,6 +329,7 @@ function dispatchCapabilityRefresh({ provider, threadId, workspacePath, }) {
     }));
 }
 export function useConversationChatRuntime({ context, threadId, } = {}) {
+    var _a;
     const provider = context === null || context === void 0 ? void 0 : context.provider;
     const model = context === null || context === void 0 ? void 0 : context.model;
     const modeId = context === null || context === void 0 ? void 0 : context.modeId;
@@ -266,8 +340,18 @@ export function useConversationChatRuntime({ context, threadId, } = {}) {
     const explicitThoughtLevel = context === null || context === void 0 ? void 0 : context.explicitThoughtLevel;
     const permissionMode = context === null || context === void 0 ? void 0 : context.permissionMode;
     const workspacePath = context === null || context === void 0 ? void 0 : context.workspacePath;
-    const builtinToolSettings = context === null || context === void 0 ? void 0 : context.builtinToolSettings;
+    const builtinToolSettings = (_a = context === null || context === void 0 ? void 0 : context.runtimeBuiltinToolSettings) !== null && _a !== void 0 ? _a : context === null || context === void 0 ? void 0 : context.builtinToolSettings;
     const consumeContextBundle = context === null || context === void 0 ? void 0 : context.consumeContextBundle;
+    const stagedContextBundlesRef = useRef([]);
+    const toCreateMessage = useCallback((message) => {
+        if (shouldStartRunFromAppendMessage(message)) {
+            const contextBundle = consumeContextBundle === null || consumeContextBundle === void 0 ? void 0 : consumeContextBundle();
+            if (contextBundle) {
+                stagedContextBundlesRef.current.push(contextBundle);
+            }
+        }
+        return createAcpCreateMessage(message);
+    }, [consumeContextBundle]);
     const conversationMetadataRef = useRef({});
     conversationMetadataRef.current = {
         model,
@@ -280,22 +364,45 @@ export function useConversationChatRuntime({ context, threadId, } = {}) {
         workspacePath,
         getConversationMetadata: () => conversationMetadataRef.current,
     }), [provider, permissionMode, workspacePath]);
-    const adapter = useMemo(() => createConversationThreadListAdapter(adapterContext), [adapterContext]);
+    const adapter = useMemo(() => createConversationThreadListAdapter(adapterContext, threadId), [adapterContext, threadId]);
     return useRemoteThreadListRuntime({
         adapter,
         allowNesting: true,
         threadId,
         runtimeHook: function RuntimeHook() {
+            var _a;
+            // biome-ignore lint/correctness/useHookAtTopLevel: assistant-ui calls runtimeHook as a runtime component hook.
+            const runtimeThreadId = useAuiState((state) => state.threadListItem.id);
+            // biome-ignore lint/correctness/useHookAtTopLevel: assistant-ui calls runtimeHook as a runtime component hook.
+            const runtimeRemoteId = useAuiState((state) => state.threadListItem.remoteId);
+            const activeThreadId = (_a = runtimeRemoteId !== null && runtimeRemoteId !== void 0 ? runtimeRemoteId : threadId) !== null && _a !== void 0 ? _a : runtimeThreadId;
+            const activeProvider = provider !== null && provider !== void 0 ? provider : DEFAULT_PROVIDER;
             // biome-ignore lint/correctness/useHookAtTopLevel: assistant-ui calls runtimeHook as a runtime component hook.
             return useChatRuntime({
                 sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithToolCalls,
+                toCreateMessage,
                 transport: new AssistantChatTransport({
                     api: acpApiClient.chatUrl(),
+                    resumable: {
+                        storage: createResumableSessionStorage({
+                            key: createResumableStorageKey({
+                                workspacePath,
+                                provider: activeProvider,
+                                threadId: activeThreadId,
+                            }),
+                        }),
+                        resumeApi: (streamId) => acpApiClient.chatResumeUrl(streamId, {
+                            threadId: activeThreadId,
+                            provider: activeProvider,
+                            workspacePath: workspacePath !== null && workspacePath !== void 0 ? workspacePath : null,
+                        }),
+                    },
                     fetch: async (input, init) => {
                         var _a, _b;
                         const response = await fetch(input, init);
-                        const responseProvider = (_b = (_a = response.headers.get("x-acp-provider")) !== null && _a !== void 0 ? _a : provider) !== null && _b !== void 0 ? _b : DEFAULT_PROVIDER;
-                        const responseThreadId = response.headers.get("x-acp-thread-id");
+                        const normalizedResponse = withoutBodyForNullBodyStatus(response);
+                        const responseProvider = (_b = (_a = normalizedResponse.headers.get("x-acp-provider")) !== null && _a !== void 0 ? _a : provider) !== null && _b !== void 0 ? _b : DEFAULT_PROVIDER;
+                        const responseThreadId = normalizedResponse.headers.get("x-acp-thread-id");
                         const decodedThreadId = responseThreadId
                             ? decodeURIComponent(responseThreadId)
                             : null;
@@ -306,7 +413,7 @@ export function useConversationChatRuntime({ context, threadId, } = {}) {
                                 workspacePath,
                             });
                         }
-                        return response;
+                        return normalizedResponse;
                     },
                     body: () => {
                         var _a;
@@ -319,7 +426,7 @@ export function useConversationChatRuntime({ context, threadId, } = {}) {
                             workspacePath: workspacePath !== null && workspacePath !== void 0 ? workspacePath : null,
                             builtinTools: getEnabledBuiltinToolIds(builtinToolSettings),
                             builtinToolSettings,
-                            context: (_a = consumeContextBundle === null || consumeContextBundle === void 0 ? void 0 : consumeContextBundle()) !== null && _a !== void 0 ? _a : null,
+                            context: (_a = stagedContextBundlesRef.current.shift()) !== null && _a !== void 0 ? _a : null,
                         });
                     },
                 }),

package/dist/lib/conversations/provider-message-loader.d.ts

@@ -0,0 +1,7 @@
+import type { ConversationMessageRepository, ConversationRecord } from "./types";
+export declare function loadProviderMessageRepository({ threadId, format, workspacePath, conversation, }: {
+    threadId: string;
+    format: string | null | undefined;
+    workspacePath: string | null | undefined;
+    conversation: ConversationRecord | null;
+}): Promise<ConversationMessageRepository>;

package/dist/lib/conversations/provider-message-loader.mjs

@@ -0,0 +1,99 @@
+import { convertTranscriptToMessageRepository, findProviderSession, loadProviderTranscript, } from "../provider-history/index.mjs";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function filterMessagesByFormat(repo, format) {
+    return format
+        ? repo.messages.filter((message) => message.format === format)
+        : repo.messages;
+}
+export async function loadProviderMessageRepository({ threadId, format, workspacePath, conversation, }) {
+    var _a, _b;
+    let providerSession = null;
+    let providerSessionError = null;
+    const providerSessionId = (_a = conversation === null || conversation === void 0 ? void 0 : conversation.providerSessionId) !== null && _a !== void 0 ? _a : (threadId.includes(":") ? threadId.slice(threadId.indexOf(":") + 1) : null);
+    const provider = (_b = conversation === null || conversation === void 0 ? void 0 : conversation.provider) !== null && _b !== void 0 ? _b : threadId.split(":")[0];
+    if (!(conversation === null || conversation === void 0 ? void 0 : conversation.sourcePath) && providerSessionId) {
+        try {
+            providerSession = await findProviderSession(provider, providerSessionId, workspacePath);
+        }
+        catch (error) {
+            providerSessionError = errorMessage(error);
+        }
+    }
+    if (conversation === null || conversation === void 0 ? void 0 : conversation.sourcePath) {
+        try {
+            const transcript = await loadProviderTranscript({
+                provider: conversation.provider,
+                sessionId: conversation.providerSessionId,
+                sourcePath: conversation.sourcePath,
+            });
+            const repo = convertTranscriptToMessageRepository(transcript, format !== null && format !== void 0 ? format : "ai-sdk/v6");
+            const messages = filterMessagesByFormat(repo, format);
+            if (messages.length === 0) {
+                return {
+                    messages: [],
+                    diagnostic: {
+                        source: "provider-history",
+                        error: "Provider transcript had no messages",
+                    },
+                };
+            }
+            return {
+                headId: repo.headId,
+                messages,
+                diagnostic: { source: "provider-history" },
+            };
+        }
+        catch (error) {
+            return {
+                messages: [],
+                diagnostic: {
+                    source: "provider-history",
+                    error: errorMessage(error),
+                },
+            };
+        }
+    }
+    if (providerSession === null || providerSession === void 0 ? void 0 : providerSession.sourcePath) {
+        try {
+            const transcript = await loadProviderTranscript({
+                provider: providerSession.provider,
+                sessionId: providerSession.sessionId,
+                sourcePath: providerSession.sourcePath,
+            });
+            const repo = convertTranscriptToMessageRepository(transcript, format !== null && format !== void 0 ? format : "ai-sdk/v6");
+            const messages = filterMessagesByFormat(repo, format);
+            if (messages.length === 0) {
+                return {
+                    messages: [],
+                    diagnostic: {
+                        source: "provider-history",
+                        error: "Provider transcript had no messages",
+                    },
+                };
+            }
+            return {
+                headId: repo.headId,
+                messages,
+                diagnostic: { source: "provider-history" },
+            };
+        }
+        catch (error) {
+            return {
+                messages: [],
+                diagnostic: {
+                    source: "provider-history",
+                    error: errorMessage(error),
+                },
+            };
+        }
+    }
+    return {
+        messages: [],
+        diagnostic: {
+            source: "provider-history",
+            error: providerSessionError !== null && providerSessionError !== void 0 ? providerSessionError : "Provider transcript not found",
+        },
+    };
+}

package/dist/lib/conversations/runtime-message-recovery.d.ts

@@ -0,0 +1,9 @@
+import type { ConversationMessageRepository } from "./types";
+export declare const STALE_RUNNING_MESSAGE_MS = 30000;
+export declare const STALE_RUNNING_MESSAGE_ERROR = "Run was interrupted before a resumable assistant stream was available.";
+export declare function getAcpRun(message: unknown): Record<string, unknown> | null;
+export declare function getLivePartialStreamId(message: unknown): string | null;
+export declare function recoverStaleRunningRuntimeMessages<TContent extends Record<string, unknown>>(repository: ConversationMessageRepository<TContent>, nowMs?: number): {
+    repository: ConversationMessageRepository<TContent>;
+    changed: boolean;
+};

package/dist/lib/conversations/runtime-message-recovery.mjs

@@ -0,0 +1,95 @@
+export const STALE_RUNNING_MESSAGE_MS = 30000;
+export const STALE_RUNNING_MESSAGE_ERROR = "Run was interrupted before a resumable assistant stream was available.";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export function getAcpRun(message) {
+    if (!isRecord(message))
+        return null;
+    const metadata = isRecord(message.metadata) ? message.metadata : null;
+    const custom = isRecord(metadata === null || metadata === void 0 ? void 0 : metadata.custom) ? metadata.custom : null;
+    const acpRun = isRecord(custom === null || custom === void 0 ? void 0 : custom.acpRun) ? custom.acpRun : null;
+    return acpRun;
+}
+export function getLivePartialStreamId(message) {
+    if (!isRecord(message))
+        return null;
+    if (message.role !== "assistant")
+        return null;
+    const acpRun = getAcpRun(message);
+    if ((acpRun === null || acpRun === void 0 ? void 0 : acpRun.status) !== "running")
+        return null;
+    return typeof acpRun.streamId === "string" && acpRun.streamId.trim()
+        ? acpRun.streamId
+        : null;
+}
+function isStaleRunningMessage(message, nowMs) {
+    var _a;
+    const acpRun = getAcpRun(message.content);
+    if ((acpRun === null || acpRun === void 0 ? void 0 : acpRun.status) !== "running")
+        return false;
+    const updatedAtMs = Date.parse(String((_a = message.updatedAt) !== null && _a !== void 0 ? _a : ""));
+    if (!Number.isFinite(updatedAtMs))
+        return true;
+    return updatedAtMs < nowMs - STALE_RUNNING_MESSAGE_MS;
+}
+function isTerminalRunStatus(value) {
+    return value === "completed" || value === "aborted" || value === "error";
+}
+function finalizeTerminalStreamingParts(content) {
+    const acpRun = getAcpRun(content);
+    if (!isTerminalRunStatus(acpRun === null || acpRun === void 0 ? void 0 : acpRun.status) || !Array.isArray(content.parts)) {
+        return { content, changed: false };
+    }
+    let changed = false;
+    const parts = content.parts.map((part) => {
+        if (!isRecord(part) ||
+            (part.type !== "text" && part.type !== "reasoning") ||
+            part.state !== "streaming") {
+            return part;
+        }
+        changed = true;
+        return Object.assign(Object.assign({}, part), { state: "done" });
+    });
+    if (!changed)
+        return { content, changed: false };
+    return {
+        changed: true,
+        content: Object.assign(Object.assign({}, content), { parts }),
+    };
+}
+function markStaleRunningMessage(content, nowMs) {
+    const metadata = isRecord(content.metadata) ? content.metadata : {};
+    const custom = isRecord(metadata.custom) ? metadata.custom : {};
+    const acpRun = isRecord(custom.acpRun) ? custom.acpRun : {};
+    return Object.assign(Object.assign({}, content), { metadata: Object.assign(Object.assign({}, metadata), { custom: Object.assign(Object.assign({}, custom), { acpRun: Object.assign(Object.assign({}, acpRun), { status: "aborted", error: typeof acpRun.error === "string" && acpRun.error.trim()
+                        ? acpRun.error
+                        : STALE_RUNNING_MESSAGE_ERROR, updatedAt: nowMs }) }) }) });
+}
+function recoverRuntimeMessageContent(message, nowMs) {
+    const content = isStaleRunningMessage(message, nowMs)
+        ? markStaleRunningMessage(message.content, nowMs)
+        : message.content;
+    const finalized = finalizeTerminalStreamingParts(content);
+    return {
+        content: finalized.content,
+        changed: content !== message.content || finalized.changed,
+    };
+}
+export function recoverStaleRunningRuntimeMessages(repository, nowMs = Date.now()) {
+    var _a, _b;
+    let changed = false;
+    const messages = repository.messages.map((message) => {
+        const recovered = recoverRuntimeMessageContent(message, nowMs);
+        if (!recovered.changed)
+            return message;
+        changed = true;
+        return Object.assign(Object.assign({}, message), { content: recovered.content });
+    });
+    if (!changed)
+        return { repository, changed: false };
+    return {
+        changed: true,
+        repository: Object.assign(Object.assign({}, repository), { headId: (_b = (_a = messages.at(-1)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null, messages }),
+    };
+}

package/dist/lib/conversations/store.d.ts

@@ -1,5 +1,5 @@
 import type { AcpRuntimeMetadata } from "../acp2aisdk";
-import type { ConversationListOptions, ConversationListResponse, ConversationMessageRepository, ConversationMessageUpsertRequest, ConversationRecord, ConversationSessionResolution, ConversationUpsertRequest, StoredMessageEntry } from "./types";
+import type { ConversationListOptions, ConversationListResponse, ConversationMessageRepository, ConversationMessageSource, ConversationMessageUpsertRequest, ConversationRecord, ConversationSessionResolution, ConversationUpsertRequest, StoredMessageEntry } from "./types";
 export declare function listConversations(workspacePath?: string | null, options?: ConversationListOptions): Promise<ConversationListResponse>;
 export declare function getConversation(threadId: string, workspacePath?: string | null): Promise<ConversationRecord | null>;
 export declare function resolveConversationByProviderSession({ provider: providerInput, sessionId, workspacePath, }: {
@@ -11,7 +11,7 @@ export declare function upsertConversation(request: ConversationUpsertRequest):
 export declare function renameConversation(threadId: string, title: string, workspacePath?: string | null): Promise<ConversationRecord>;
 export declare function archiveConversation(threadId: string, archived: boolean, workspacePath?: string | null): Promise<ConversationRecord>;
 export declare function deleteConversation(threadId: string, workspacePath?: string | null): Promise<void>;
-export declare function loadConversationMessages(threadId: string, format?: string | null, workspacePath?: string | null): Promise<ConversationMessageRepository>;
+export declare function loadConversationMessages(threadId: string, format?: string | null, workspacePath?: string | null, source?: ConversationMessageSource): Promise<ConversationMessageRepository>;
 export declare function saveConversationMessage(threadId: string, request: ConversationMessageUpsertRequest, workspacePath?: string | null): Promise<StoredMessageEntry>;
 export declare function touchConversationFromRuntime(metadata: AcpRuntimeMetadata): Promise<void>;
 export declare function closeConversationSession(metadata: AcpRuntimeMetadata | null): Promise<void>;