@axhub/acp 0.1.0 → 0.1.1

package/dist/lib/acp2aisdk/index.d.ts

@@ -2,11 +2,18 @@ import type { AcpChatRequest, AcpRuntimeMetadata, AcpSessionLookupRequest, AcpSt
 export type { AcpBuiltinToolSettings, AcpCapabilitySnapshot, AcpChatRequest, AcpCleanupResult, AcpPermissionMode, AcpProviderKey, AcpRunState, AcpRuntimeMetadata, AcpSessionLookupRequest, } from "./types";
 export declare function getAcpSessionMetadata(request: AcpSessionLookupRequest): AcpRuntimeMetadata | null;
 export declare function listAcpSessionMetadata(): AcpRuntimeMetadata[];
+export declare function reconcileAcpSessionWithRuntimeMessages(request: AcpSessionLookupRequest): Promise<AcpRuntimeMetadata | null>;
 export declare function cleanupAcpSession(request: AcpSessionLookupRequest): Promise<{
     cleaned: boolean;
     metadata: AcpRuntimeMetadata | null;
     remainingSessions: AcpRuntimeMetadata[];
 }>;
+export declare function cancelAcpSession(request: AcpSessionLookupRequest): Promise<{
+    cancelled: boolean;
+    cleaned: boolean;
+    metadata: AcpRuntimeMetadata | null;
+    remainingSessions: AcpRuntimeMetadata[];
+}>;
 export declare function streamAcpChat(request: AcpChatRequest, options?: {
     abortSignal?: AbortSignal;
 }): Promise<AcpStreamChatResult>;

package/dist/lib/acp2aisdk/index.mjs

@@ -1,15 +1,15 @@
 import { frontendTools } from "@assistant-ui/react-ai-sdk";
 import { consumeStream, convertToModelMessages, streamText, } from "ai";
-import { closeConversationSession, touchConversationFromRuntime, upsertConversation, } from "../conversations/store.mjs";
-import { sanitizePersistedBuiltinToolSettingsPatch } from "../../tools/registry.mjs";
+import { closeConversationSession, loadConversationMessages, touchConversationFromRuntime, } from "../conversations/store.mjs";
 import { ACP_ELICITATION_OPTION_LIST_TOOL_NAME, ACP_ELICITATION_OPTION_LIST_TOOL_SCHEMA, } from "./elicitation.mjs";
+import { acpErrorToMessage } from "./errors.mjs";
 import { selectMessagesForAcpPrompt, selectMessagesForFreshAcpSessionPrompt, wrapLatestUserMessageWithDynamicContext, } from "./prompt-history.mjs";
 import { closeAcpProviderSession, stageAcpElicitationResultFromMessages, } from "./provider-compat.mjs";
-import { normalizeAcpProvider } from "./provider-registry.mjs";
 import { createDirectMessageResponse, createRuntimeHeaders } from "./response.mjs";
-import { normalizePermissionMode } from "./runtime-options.mjs";
+import { createResumableUIMessageStreamResponse } from "./resumable-ui-stream.mjs";
+import { persistRequestRuntimeMessages, persistRuntimeMessages, } from "./runtime-persistence.mjs";
 import { applyRequestedModelAndMode, getOrCreateSession, getSessionKeyForLookup, updateMetadataFromProvider, } from "./session-runtime.mjs";
-import { getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, } from "./session-store.mjs";
+import { getGlobalAcpSessionStore } from "./session-store.mjs";
 import { createAcpMessageMetadata } from "./stream-metadata.mjs";
 import { acpTools } from "./vendor/acp-ai-provider/index.mjs";
 const INTERNAL_FRONTEND_TOOLS = {
@@ -18,31 +18,7 @@ const INTERNAL_FRONTEND_TOOLS = {
         parameters: ACP_ELICITATION_OPTION_LIST_TOOL_SCHEMA,
     },
 };
-async function persistBuiltinToolSettingsPatch(request) {
-    var _a, _b, _c, _d;
-    const builtinToolSettings = sanitizePersistedBuiltinToolSettingsPatch(request.builtinToolSettings);
-    if (!builtinToolSettings)
-        return;
-    const patch = {
-        threadId: normalizeThreadId((_a = request.threadId) !== null && _a !== void 0 ? _a : request.id),
-        workspacePath: normalizeWorkspacePath(request.workspacePath),
-        builtinToolSettings,
-    };
-    if (request.provider !== undefined) {
-        patch.provider = normalizeAcpProvider(request.provider);
-    }
-    if (request.model !== undefined)
-        patch.model = (_b = request.model) !== null && _b !== void 0 ? _b : null;
-    if (request.modeId !== undefined)
-        patch.modeId = (_c = request.modeId) !== null && _c !== void 0 ? _c : null;
-    if (request.thoughtLevel !== undefined) {
-        patch.thoughtLevel = (_d = request.thoughtLevel) !== null && _d !== void 0 ? _d : null;
-    }
-    if (request.permissionMode !== undefined) {
-        patch.permissionMode = normalizePermissionMode(request.permissionMode);
-    }
-    await upsertConversation(patch);
-}
+const ORPHAN_RUNNING_SESSION_MS = 5 * 60 * 1000;
 export function getAcpSessionMetadata(request) {
     var _a, _b;
     const store = getGlobalAcpSessionStore();
@@ -54,6 +30,42 @@ export function listAcpSessionMetadata() {
     store.cleanupIdle();
     return store.list();
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function hasFreshRunningRuntimeMessage(messages, nowMs = Date.now()) {
+    return messages.some((message) => {
+        var _a;
+        const content = isRecord(message.content) ? message.content : null;
+        const metadata = isRecord(content === null || content === void 0 ? void 0 : content.metadata) ? content.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;
+        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 : ""));
+        return (Number.isFinite(updatedAtMs) &&
+            updatedAtMs >= nowMs - ORPHAN_RUNNING_SESSION_MS);
+    });
+}
+export async function reconcileAcpSessionWithRuntimeMessages(request) {
+    var _a;
+    const store = getGlobalAcpSessionStore();
+    store.cleanupIdle();
+    const sessionKey = getSessionKeyForLookup(request);
+    const entry = store.get(sessionKey);
+    const metadata = (_a = entry === null || entry === void 0 ? void 0 : entry.metadata) !== null && _a !== void 0 ? _a : null;
+    if (!entry || (metadata === null || metadata === void 0 ? void 0 : metadata.runState) !== "running")
+        return metadata;
+    const runtimeRepo = await loadConversationMessages(metadata.threadId, "ai-sdk/v6", metadata.workspacePath, "runtime");
+    if (hasFreshRunningRuntimeMessage(runtimeRepo.messages))
+        return entry.metadata;
+    entry.metadata.runState = "aborted";
+    updateMetadataFromProvider(entry);
+    void touchConversationFromRuntime(entry.metadata);
+    store.cleanup(sessionKey);
+    void closeConversationSession(entry.metadata);
+    return null;
+}
 export async function cleanupAcpSession(request) {
     var _a;
     const store = getGlobalAcpSessionStore();
@@ -72,9 +84,31 @@ export async function cleanupAcpSession(request) {
         remainingSessions: store.list(),
     };
 }
+export async function cancelAcpSession(request) {
+    var _a;
+    const store = getGlobalAcpSessionStore();
+    store.cleanupIdle();
+    const sessionKey = getSessionKeyForLookup(request);
+    const entry = store.get(sessionKey);
+    const metadata = (_a = entry === null || entry === void 0 ? void 0 : entry.metadata) !== null && _a !== void 0 ? _a : null;
+    if (entry) {
+        entry.metadata.runState = "aborted";
+        updateMetadataFromProvider(entry);
+        void touchConversationFromRuntime(entry.metadata);
+        await closeAcpProviderSession(entry.provider, entry.metadata);
+    }
+    const cleaned = store.cleanup(sessionKey);
+    void closeConversationSession(metadata);
+    return {
+        cancelled: Boolean(entry),
+        cleaned,
+        metadata,
+        remainingSessions: store.list(),
+    };
+}
 export async function streamAcpChat(request, options = {}) {
     var _a, _b, _c;
-    await persistBuiltinToolSettingsPatch(request);
+    await persistRequestRuntimeMessages(request);
     const externalFrontendTools = Object.assign({}, ((_a = request.tools) !== null && _a !== void 0 ? _a : {}));
     delete externalFrontendTools[ACP_ELICITATION_OPTION_LIST_TOOL_NAME];
     const tools = Object.assign(Object.assign({}, acpTools(frontendTools(externalFrontendTools))), frontendTools(INTERNAL_FRONTEND_TOOLS));
@@ -90,6 +124,16 @@ export async function streamAcpChat(request, options = {}) {
         entry.metadata.runState = "error";
         entry.metadata.warnings.push(elicitationStage.reason);
         updateMetadataFromProvider(entry);
+        await persistRuntimeMessages({
+            request,
+            messages: request.messages,
+            runState: "error",
+            acpSessionId: entry.metadata.acpSessionId,
+            error: elicitationStage.reason,
+        }).catch((error) => {
+            entry.metadata.warnings.push(`Failed to persist stale elicitation runtime messages: ${error instanceof Error ? error.message : String(error)}`);
+            updateMetadataFromProvider(entry);
+        });
         void touchConversationFromRuntime(entry.metadata);
         return {
             response: createDirectMessageResponse(entry.metadata, "ACP 选项请求已经失效，无法继续这次选择。"),
@@ -146,12 +190,26 @@ export async function streamAcpChat(request, options = {}) {
         abortSignal: options.abortSignal,
     });
     const response = result.toUIMessageStreamResponse({
+        originalMessages: request.messages,
+        generateMessageId: () => `assistant-${Date.now().toString(36)}-${Math.random()
+            .toString(36)
+            .slice(2)}`,
         headers: createRuntimeHeaders(entry.metadata),
         consumeSseStream: consumeStream,
         messageMetadata: ({ part }) => createAcpMessageMetadata(part, entry),
-        onFinish: ({ isAborted }) => {
+        onFinish: async ({ isAborted, responseMessage }) => {
             var _a;
             entry.metadata.runState = isAborted ? "aborted" : "completed";
+            await persistRuntimeMessages({
+                request,
+                messages: [...request.messages, responseMessage],
+                runState: entry.metadata.runState,
+                acpSessionId: entry.metadata.acpSessionId,
+                runMetadataMessageId: responseMessage.id,
+            }).catch((error) => {
+                entry.metadata.warnings.push(`Failed to persist ${entry.metadata.runState} runtime messages: ${error instanceof Error ? error.message : String(error)}`);
+                updateMetadataFromProvider(entry);
+            });
             updateMetadataFromProvider(entry);
             void touchConversationFromRuntime(entry.metadata);
             if (isAborted) {
@@ -166,17 +224,35 @@ export async function streamAcpChat(request, options = {}) {
         },
         onError: (error) => {
             var _a;
+            const message = acpErrorToMessage(error);
             if (entry.metadata.runState !== "aborted") {
                 entry.metadata.runState = "error";
             }
+            void persistRuntimeMessages({
+                request,
+                messages: request.messages,
+                runState: entry.metadata.runState,
+                acpSessionId: entry.metadata.acpSessionId,
+                error: message,
+            }).catch((persistError) => {
+                entry.metadata.warnings.push(`Failed to persist errored runtime messages: ${persistError instanceof Error
+                    ? persistError.message
+                    : String(persistError)}`);
+                updateMetadataFromProvider(entry);
+            });
             updateMetadataFromProvider(entry);
             void touchConversationFromRuntime(entry.metadata);
             (_a = options.abortSignal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", markAborted);
-            return error instanceof Error ? error.message : String(error);
+            return message;
         },
     });
-    return {
+    const resumableResponse = await createResumableUIMessageStreamResponse({
+        request,
+        metadata: entry.metadata,
         response,
+    });
+    return {
+        response: resumableResponse,
         metadata: updateMetadataFromProvider(entry),
     };
 }

package/dist/lib/acp2aisdk/provider-compat.mjs

@@ -345,11 +345,13 @@ function patchPromptTracking(model) {
     model.promptWithLazyAuthRetry = (request) => {
         const promptPromise = originalPromptWithLazyAuthRetry(request);
         model.__acpUiPromptPromise = promptPromise;
-        void promptPromise.finally(() => {
+        void promptPromise
+            .finally(() => {
             if (model.__acpUiPromptPromise === promptPromise) {
                 model.__acpUiPromptPromise = null;
             }
-        });
+        })
+            .catch(() => { });
         return promptPromise;
     };
 }

package/dist/lib/acp2aisdk/resumable-ui-stream.d.ts

@@ -0,0 +1,11 @@
+import type { AcpChatRequest, AcpRuntimeMetadata } from "./types";
+type ResumableUIStreamOptions = {
+    request: AcpChatRequest;
+    metadata: AcpRuntimeMetadata;
+    response: Response;
+};
+export declare function createResumableUIMessageStreamResponse({ request, metadata, response, }: ResumableUIStreamOptions): Promise<Response>;
+export declare function resumeUIMessageStream(streamId: string, metadata?: AcpRuntimeMetadata | null): Promise<Response>;
+export declare function deleteResumableUIMessageStream(streamId: string): Promise<void>;
+export declare function hasResumableUIMessageStream(streamId: string): Promise<boolean>;
+export {};

package/dist/lib/acp2aisdk/resumable-ui-stream.mjs

@@ -0,0 +1,323 @@
+import { randomUUID } from "node:crypto";
+import { createInMemoryResumableStreamStore, createResumableStreamContext, RESUMABLE_STREAM_ID_HEADER, } from "assistant-stream/resumable";
+import { createRuntimeHeaders } from "./response.mjs";
+import { persistPartialAssistantMessage } from "./runtime-persistence.mjs";
+const RESUMABLE_STREAM_TTL_MS = 15 * 60 * 1000;
+const PARTIAL_PERSIST_MIN_INTERVAL_MS = 750;
+const PARTIAL_PERSIST_MIN_TEXT_DELTA = 24;
+const MAX_SSE_EVENT_BYTES = 1024 * 1024;
+const globalForResumableUIMessageStream = globalThis;
+function getResumableRuntime() {
+    const existing = globalForResumableUIMessageStream.__acpUiResumableUIMessageStreamRuntime;
+    if (existing)
+        return existing;
+    const store = createInMemoryResumableStreamStore({
+        defaultTtlMs: RESUMABLE_STREAM_TTL_MS,
+        gcIntervalMs: RESUMABLE_STREAM_TTL_MS,
+        maxEntriesPerStream: 20000,
+        maxStreams: 200,
+    });
+    const runtime = {
+        context: createResumableStreamContext({
+            store,
+            ttlMs: RESUMABLE_STREAM_TTL_MS,
+        }),
+    };
+    globalForResumableUIMessageStream.__acpUiResumableUIMessageStreamRuntime =
+        runtime;
+    return runtime;
+}
+function createStreamId(metadata) {
+    return ["acp", metadata.provider, Date.now().toString(36), randomUUID()].join(":");
+}
+function mergeResponseHeaders(response, metadata, streamId) {
+    const headers = new Headers(response.headers);
+    for (const [key, value] of new Headers(createRuntimeHeaders(metadata))) {
+        headers.set(key, value);
+    }
+    headers.set(RESUMABLE_STREAM_ID_HEADER, streamId);
+    return headers;
+}
+function createMissingStreamResponse() {
+    return new Response(null, {
+        status: 204,
+        headers: {
+            "cache-control": "no-cache",
+        },
+    });
+}
+function createInitialAssistantMessage(request, metadata, streamId) {
+    const lastMessage = request.messages.at(-1);
+    if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === "assistant") {
+        return structuredClone(lastMessage);
+    }
+    return {
+        id: `assistant-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`,
+        role: "assistant",
+        metadata: {
+            custom: {
+                acpRun: {
+                    status: "running",
+                    threadId: metadata.threadId,
+                    acpSessionId: metadata.acpSessionId,
+                    error: null,
+                    streamId,
+                    updatedAt: Date.now(),
+                },
+            },
+        },
+        parts: [],
+    };
+}
+function createPartialState(request, metadata, streamId) {
+    return {
+        message: createInitialAssistantMessage(request, metadata, streamId),
+        streamId,
+        activeTextParts: {},
+        activeReasoningParts: {},
+        lastPersistedAt: 0,
+        lastPersistedTextLength: 0,
+        pendingPersist: Promise.resolve(),
+        dirty: false,
+    };
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function mergeObjects(left, right) {
+    return Object.assign(Object.assign({}, left), right);
+}
+function mergeMessageMetadata(message, metadata) {
+    if (!isRecord(metadata))
+        return;
+    message.metadata = isRecord(message.metadata)
+        ? mergeObjects(message.metadata, metadata)
+        : metadata;
+}
+function getTextLength(message) {
+    return message.parts.reduce((total, part) => {
+        if (part.type !== "text" && part.type !== "reasoning")
+            return total;
+        return total + part.text.length;
+    }, 0);
+}
+async function persistIfDue(state, request, metadata, force = false) {
+    if (!state.dirty && !force) {
+        await state.pendingPersist;
+        return;
+    }
+    const now = Date.now();
+    const textLength = getTextLength(state.message);
+    const shouldPersist = force ||
+        now - state.lastPersistedAt >= PARTIAL_PERSIST_MIN_INTERVAL_MS ||
+        textLength - state.lastPersistedTextLength >=
+            PARTIAL_PERSIST_MIN_TEXT_DELTA;
+    if (!shouldPersist || textLength === 0) {
+        await state.pendingPersist;
+        return;
+    }
+    const snapshot = structuredClone(state.message);
+    state.dirty = false;
+    state.lastPersistedAt = now;
+    state.lastPersistedTextLength = textLength;
+    state.pendingPersist = state.pendingPersist
+        .then(() => persistPartialAssistantMessage({
+        request,
+        message: snapshot,
+        acpSessionId: metadata.acpSessionId,
+        streamId: state.streamId,
+    }))
+        .catch((error) => {
+        metadata.warnings.push(`Failed to persist partial runtime message: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    await state.pendingPersist;
+}
+async function flushPersist(state) {
+    await state.pendingPersist.catch(() => { });
+}
+function applyUIMessageChunk(state, chunk) {
+    switch (chunk.type) {
+        case "start":
+            if (chunk.messageId)
+                state.message.id = chunk.messageId;
+            mergeMessageMetadata(state.message, chunk.messageMetadata);
+            state.dirty = true;
+            break;
+        case "text-start": {
+            const part = Object.assign({ type: "text", text: "", state: "streaming" }, (chunk.providerMetadata
+                ? { providerMetadata: chunk.providerMetadata }
+                : {}));
+            state.activeTextParts[chunk.id] = part;
+            state.message.parts.push(part);
+            state.dirty = true;
+            break;
+        }
+        case "text-delta": {
+            let part = state.activeTextParts[chunk.id];
+            if (!part) {
+                part = { type: "text", text: "", state: "streaming" };
+                state.activeTextParts[chunk.id] = part;
+                state.message.parts.push(part);
+            }
+            part.text += chunk.delta;
+            if (chunk.providerMetadata)
+                part.providerMetadata = chunk.providerMetadata;
+            state.dirty = true;
+            break;
+        }
+        case "text-end": {
+            const part = state.activeTextParts[chunk.id];
+            if (part) {
+                part.state = "done";
+                if (chunk.providerMetadata)
+                    part.providerMetadata = chunk.providerMetadata;
+                delete state.activeTextParts[chunk.id];
+                state.dirty = true;
+            }
+            break;
+        }
+        case "reasoning-start": {
+            const part = Object.assign({ type: "reasoning", text: "", state: "streaming" }, (chunk.providerMetadata
+                ? { providerMetadata: chunk.providerMetadata }
+                : {}));
+            state.activeReasoningParts[chunk.id] = part;
+            state.message.parts.push(part);
+            state.dirty = true;
+            break;
+        }
+        case "reasoning-delta": {
+            let part = state.activeReasoningParts[chunk.id];
+            if (!part) {
+                part = { type: "reasoning", text: "", state: "streaming" };
+                state.activeReasoningParts[chunk.id] = part;
+                state.message.parts.push(part);
+            }
+            part.text += chunk.delta;
+            if (chunk.providerMetadata)
+                part.providerMetadata = chunk.providerMetadata;
+            state.dirty = true;
+            break;
+        }
+        case "reasoning-end": {
+            const part = state.activeReasoningParts[chunk.id];
+            if (part) {
+                part.state = "done";
+                if (chunk.providerMetadata)
+                    part.providerMetadata = chunk.providerMetadata;
+                delete state.activeReasoningParts[chunk.id];
+                state.dirty = true;
+            }
+            break;
+        }
+        case "message-metadata":
+            mergeMessageMetadata(state.message, chunk.messageMetadata);
+            state.dirty = true;
+            break;
+        case "finish":
+            mergeMessageMetadata(state.message, chunk.messageMetadata);
+            for (const part of Object.values(state.activeTextParts)) {
+                part.state = "done";
+            }
+            for (const part of Object.values(state.activeReasoningParts)) {
+                part.state = "done";
+            }
+            state.activeTextParts = {};
+            state.activeReasoningParts = {};
+            state.dirty = true;
+            break;
+        case "finish-step":
+            for (const part of Object.values(state.activeTextParts)) {
+                part.state = "done";
+            }
+            for (const part of Object.values(state.activeReasoningParts)) {
+                part.state = "done";
+            }
+            state.activeTextParts = {};
+            state.activeReasoningParts = {};
+            state.dirty = true;
+            break;
+        default:
+            break;
+    }
+}
+function createSsePartialPersistenceTap(request, metadata, streamId) {
+    const state = createPartialState(request, metadata, streamId);
+    const decoder = new TextDecoder();
+    let buffer = "";
+    async function processEvent(rawEvent) {
+        for (const line of rawEvent.split(/\r?\n/)) {
+            if (!line.startsWith("data:"))
+                continue;
+            const rawData = line.slice("data:".length).trim();
+            if (!rawData || rawData === "[DONE]")
+                continue;
+            try {
+                applyUIMessageChunk(state, JSON.parse(rawData));
+                await persistIfDue(state, request, metadata);
+            }
+            catch (error) {
+                metadata.warnings.push(`Failed to observe runtime stream chunk: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async function drainEvents() {
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex !== -1) {
+            await processEvent(buffer.slice(0, separatorIndex));
+            buffer = buffer.slice(separatorIndex + 2);
+            if (buffer.length > MAX_SSE_EVENT_BYTES) {
+                buffer = buffer.slice(-MAX_SSE_EVENT_BYTES);
+            }
+            separatorIndex = buffer.indexOf("\n\n");
+        }
+    }
+    return new TransformStream({
+        async transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            await drainEvents();
+            controller.enqueue(chunk);
+        },
+        async flush() {
+            buffer += decoder.decode();
+            if (buffer.trim())
+                await processEvent(buffer);
+            await persistIfDue(state, request, metadata, true);
+            await flushPersist(state);
+        },
+    });
+}
+export async function createResumableUIMessageStreamResponse({ request, metadata, response, }) {
+    if (!response.body)
+        return response;
+    const streamId = createStreamId(metadata);
+    const sourceStream = response.body.pipeThrough(createSsePartialPersistenceTap(request, metadata, streamId));
+    const stream = await getResumableRuntime().context.run(streamId, () => sourceStream);
+    return new Response(stream, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: mergeResponseHeaders(response, metadata, streamId),
+    });
+}
+export async function resumeUIMessageStream(streamId, metadata) {
+    const stream = await getResumableRuntime().context.resume(streamId);
+    if (!stream)
+        return createMissingStreamResponse();
+    const headers = metadata
+        ? new Headers(createRuntimeHeaders(metadata))
+        : new Headers();
+    headers.set("content-type", "text/event-stream");
+    headers.set("cache-control", "no-cache");
+    headers.set("connection", "keep-alive");
+    headers.set("x-vercel-ai-ui-message-stream", "v1");
+    headers.set("x-accel-buffering", "no");
+    headers.set(RESUMABLE_STREAM_ID_HEADER, streamId);
+    return new Response(stream, { headers });
+}
+export async function deleteResumableUIMessageStream(streamId) {
+    await getResumableRuntime().context.delete(streamId);
+}
+export async function hasResumableUIMessageStream(streamId) {
+    return ((await getResumableRuntime()
+        .context.status(streamId)
+        .catch(() => "missing")) !== "missing");
+}

package/dist/lib/acp2aisdk/runtime-message-filter.d.ts

@@ -0,0 +1,6 @@
+import type { ConversationMessageRepository } from "../conversations/types";
+type RuntimeMessageFilterOptions = {
+    hideResumable?: boolean;
+};
+export declare function hideLivePartialAssistantMessages<TContent extends Record<string, unknown>>(repository: ConversationMessageRepository<TContent>, options?: RuntimeMessageFilterOptions): Promise<ConversationMessageRepository<TContent>>;
+export {};

package/dist/lib/acp2aisdk/runtime-message-filter.mjs

@@ -0,0 +1,22 @@
+import { getLivePartialStreamId, recoverStaleRunningRuntimeMessages, } from "../conversations/runtime-message-recovery.mjs";
+import { hasResumableUIMessageStream } from "./resumable-ui-stream.mjs";
+export async function hideLivePartialAssistantMessages(repository, options = {}) {
+    var _a, _b;
+    const messages = [];
+    let changed = false;
+    const hideResumable = options.hideResumable !== false;
+    const recovered = recoverStaleRunningRuntimeMessages(repository);
+    for (const message of recovered.repository.messages) {
+        const streamId = getLivePartialStreamId(message.content);
+        if (hideResumable &&
+            streamId &&
+            (await hasResumableUIMessageStream(streamId))) {
+            changed = true;
+            continue;
+        }
+        messages.push(message);
+    }
+    if (!changed && !recovered.changed)
+        return repository;
+    return Object.assign(Object.assign({}, recovered.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/acp2aisdk/runtime-persistence.d.ts

@@ -0,0 +1,21 @@
+import type { UIMessage } from "ai";
+import type { AcpChatRequest, AcpRunState } from "./types";
+type PersistRuntimeMessagesOptions = {
+    request: AcpChatRequest;
+    messages: UIMessage[];
+    runState: AcpRunState;
+    acpSessionId?: string | null;
+    error?: string | null;
+    runMetadataMessageId?: string | null;
+    streamId?: string | null;
+};
+type PersistPartialAssistantMessageOptions = {
+    request: AcpChatRequest;
+    message: UIMessage;
+    acpSessionId?: string | null;
+    streamId?: string | null;
+};
+export declare function persistRuntimeMessages({ request, messages, runState, acpSessionId, error, runMetadataMessageId, streamId, }: PersistRuntimeMessagesOptions): Promise<void>;
+export declare function persistRequestRuntimeMessages(request: AcpChatRequest): Promise<void>;
+export declare function persistPartialAssistantMessage({ request, message, acpSessionId, streamId, }: PersistPartialAssistantMessageOptions): Promise<void>;
+export {};