@axhub/acp 0.1.0 → 0.1.2-beta.0

package/dist/lib/acp2aisdk/runtime-persistence.mjs

@@ -0,0 +1,135 @@
+import { loadConversationMessages, saveConversationMessage, upsertConversation, } from "../conversations/store.mjs";
+import { sanitizePersistedBuiltinToolSettingsPatch } from "../../tools/registry.mjs";
+import { normalizeAcpProvider } from "./provider-registry.mjs";
+import { normalizePermissionMode } from "./runtime-options.mjs";
+import { normalizeThreadId, normalizeWorkspacePath } from "./session-store.mjs";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function createConversationPatch(request) {
+    var _a, _b, _c, _d;
+    const builtinToolSettings = sanitizePersistedBuiltinToolSettingsPatch(request.builtinToolSettings);
+    const patch = {
+        threadId: normalizeThreadId((_a = request.threadId) !== null && _a !== void 0 ? _a : request.id),
+        workspacePath: normalizeWorkspacePath(request.workspacePath),
+    };
+    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);
+    }
+    if (builtinToolSettings) {
+        patch.builtinToolSettings = builtinToolSettings;
+    }
+    return patch;
+}
+function ensureMessageId(threadId, message, index) {
+    const fallbackId = `${threadId}:${message.role || "message"}:${index}`;
+    return String((message === null || message === void 0 ? void 0 : message.id) || fallbackId);
+}
+function withAcpRunMetadata({ message, runState, threadId, acpSessionId, error, streamId, }) {
+    const metadata = isRecord(message.metadata)
+        ? message.metadata
+        : undefined;
+    const custom = isRecord(metadata === null || metadata === void 0 ? void 0 : metadata.custom) ? metadata.custom : {};
+    return Object.assign(Object.assign({}, message), { metadata: Object.assign(Object.assign({}, (metadata !== null && metadata !== void 0 ? metadata : {})), { custom: Object.assign(Object.assign({}, custom), { acpRun: Object.assign(Object.assign({ status: runState, threadId, acpSessionId: acpSessionId !== null && acpSessionId !== void 0 ? acpSessionId : null, error: error !== null && error !== void 0 ? error : null }, (streamId ? { streamId } : {})), { updatedAt: Date.now() }) }) }) });
+}
+function mergeStoredMetadata(message, existing) {
+    if (!existing || !isRecord(existing.metadata))
+        return message;
+    const existingMetadata = existing.metadata;
+    const nextMetadata = isRecord(message.metadata)
+        ? message.metadata
+        : undefined;
+    const existingCustom = isRecord(existingMetadata.custom)
+        ? existingMetadata.custom
+        : {};
+    const nextCustom = isRecord(nextMetadata === null || nextMetadata === void 0 ? void 0 : nextMetadata.custom) ? nextMetadata.custom : {};
+    return Object.assign(Object.assign({}, message), { metadata: Object.assign(Object.assign(Object.assign({}, existingMetadata), (nextMetadata !== null && nextMetadata !== void 0 ? nextMetadata : {})), { custom: Object.assign(Object.assign({}, existingCustom), nextCustom) }) });
+}
+function getAcpRunStatus(message) {
+    const metadata = isRecord(message === null || message === void 0 ? void 0 : message.metadata)
+        ? message.metadata
+        : undefined;
+    const custom = isRecord(metadata === null || metadata === void 0 ? void 0 : metadata.custom) ? metadata.custom : {};
+    const acpRun = isRecord(custom.acpRun) ? custom.acpRun : {};
+    const status = acpRun.status;
+    return status === "completed" || status === "aborted" || status === "error"
+        ? status
+        : null;
+}
+export async function persistRuntimeMessages({ request, messages, runState, acpSessionId, error, runMetadataMessageId, streamId, }) {
+    var _a, _b, _c, _d;
+    const threadId = normalizeThreadId((_a = request.threadId) !== null && _a !== void 0 ? _a : request.id);
+    const workspacePath = normalizeWorkspacePath(request.workspacePath);
+    await upsertConversation(createConversationPatch(request));
+    const existingMessages = await loadConversationMessages(threadId, "ai-sdk/v6", workspacePath, "runtime").catch(() => null);
+    const existingById = new Map(((_b = existingMessages === null || existingMessages === void 0 ? void 0 : existingMessages.messages) !== null && _b !== void 0 ? _b : []).flatMap((entry) => {
+        const content = entry.content;
+        return isRecord(content) && typeof content.id === "string"
+            ? [[content.id, content]]
+            : [];
+    }));
+    const persistedMessages = messages.map((message, index) => {
+        const id = ensureMessageId(threadId, message, index);
+        const existing = existingById.get(id);
+        if (runState === "running" && getAcpRunStatus(existing)) {
+            return Object.assign(Object.assign({}, existing), { id });
+        }
+        const shouldAttachRunMetadata = runMetadataMessageId !== undefined
+            ? id === runMetadataMessageId
+            : index === messages.length - 1;
+        const nextMessage = shouldAttachRunMetadata
+            ? withAcpRunMetadata({
+                message,
+                runState,
+                threadId,
+                acpSessionId,
+                error,
+                streamId,
+            })
+            : message;
+        return Object.assign(Object.assign({}, mergeStoredMetadata(nextMessage, existing)), { id });
+    });
+    for (let index = 0; index < persistedMessages.length; index += 1) {
+        const message = persistedMessages[index];
+        await saveConversationMessage(threadId, {
+            parentId: index > 0 ? ((_d = (_c = persistedMessages[index - 1]) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : null) : null,
+            message: {
+                id: message.id,
+                content: Object.assign({}, message),
+            },
+            format: "ai-sdk/v6",
+        }, workspacePath);
+    }
+}
+export async function persistRequestRuntimeMessages(request) {
+    await persistRuntimeMessages({
+        request,
+        messages: request.messages,
+        runState: "running",
+    });
+}
+export async function persistPartialAssistantMessage({ request, message, acpSessionId, streamId, }) {
+    const lastRequestMessage = request.messages.at(-1);
+    const baseMessages = (lastRequestMessage === null || lastRequestMessage === void 0 ? void 0 : lastRequestMessage.role) === "assistant" &&
+        lastRequestMessage.id === message.id
+        ? request.messages.slice(0, -1)
+        : request.messages;
+    await persistRuntimeMessages({
+        request,
+        messages: [...baseMessages, message],
+        runState: "running",
+        acpSessionId,
+        runMetadataMessageId: message.id,
+        streamId,
+    });
+}

package/dist/lib/acp2aisdk/session-store.mjs

@@ -110,7 +110,13 @@ function cleanupAcpProvider(provider) {
     const agentProcess = getAgentProcess(provider);
     const pid = agentProcess === null || agentProcess === void 0 ? void 0 : agentProcess.pid;
     const descendantPids = pid ? collectDescendantPids(pid) : [];
-    provider.cleanup();
+    try {
+        provider.cleanup();
+    }
+    catch (_a) {
+        // Cleanup happens on request paths such as runtime polling. A provider
+        // teardown failure should not take down the Next dev server.
+    }
     for (const childPid of descendantPids) {
         forceKillProcess(childPid);
     }

package/dist/lib/acp2aisdk/skill-command-cache.mjs

@@ -1,6 +1,6 @@
 "use client";
 import { safeLocalStorage } from "./capability-cache.mjs";
-const SKILL_COMMAND_CACHE_PREFIX = "skill-commands:v1";
+const SKILL_COMMAND_CACHE_PREFIX = "skill-commands:v2";
 export const SKILL_COMMAND_CACHE_TTL_MS = 30 * 60 * 1000;
 function normalizeText(value) {
     return typeof value === "string" ? value.trim() : "";

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

@@ -19,7 +19,6 @@ export type AcpProviderRegistryEntry = {
     defaultModel?: string | null;
     defaultModeId?: string | null;
     supportsImages: boolean;
-    enabledInP0: boolean;
 };
 export type AcpProviderOverride = Partial<Pick<AcpProviderRegistryEntry, "command" | "args" | "authMethodId" | "sessionDelayMs" | "persistSession" | "defaultModel" | "defaultModeId">>;
 export type AcpChatRequest = {

package/dist/lib/api/client.d.ts

@@ -1,7 +1,7 @@
+import type { AcpOutputArtifact } from "../../components/assistant-ui/addons/output-artifacts";
 import type { AcpCapabilitySnapshot, AcpChatRequest } from "../acp2aisdk";
 import type { AcpUiCommand } from "../acp2aisdk/commands";
-import type { AcpOutputArtifact } from "../../components/assistant-ui/addons/output-artifacts";
-import type { ConversationInitializeResponse, ConversationListResponse, ConversationMessagesResponse, ConversationMessageUpsertRequest, ConversationRecord, ConversationUpsertRequest } from "../conversations/types";
+import type { ConversationInitializeResponse, ConversationListResponse, ConversationMessageSource, ConversationMessagesResponse, ConversationMessageUpsertRequest, ConversationRecord, ConversationRuntimeResponse, ConversationUpsertRequest } from "../conversations/types";
 import type { ImageGenerationRecord } from "../../tools/image-generation/shared";
 import type { UserChoicePendingRequest, UserChoiceToolResult } from "../../tools/user-choice/shared";
 export type AcpUiRuntimeConfig = {
@@ -27,6 +27,13 @@ type CommandsResponse = {
 type WorkspaceOutputArtifactsResponse = {
     artifacts: AcpOutputArtifact[];
 };
+type ThreadOutputArtifactsResponse = {
+    messages: ConversationMessagesResponse["messages"];
+    artifacts: AcpOutputArtifact[];
+    imageGenerationRecords: ImageGenerationRecord[];
+    workspaceArtifacts: AcpOutputArtifact[];
+    diagnostic?: ConversationMessagesResponse["diagnostic"];
+};
 declare global {
     interface Window {
         __ACP_UI_RUNTIME_CONFIG__?: AcpUiRuntimeConfig;
@@ -36,9 +43,17 @@ export declare function configureAcpUiRuntime(config: AcpUiRuntimeConfig): void;
 export declare function readAcpUiRuntimeConfig(): AcpUiRuntimeConfig;
 export declare const acpApiEndpoints: {
     chat: () => string;
+    chatCancel: () => string;
+    chatResume: (streamId: string, query?: {
+        id?: string | null;
+        threadId?: string | null;
+        provider?: string | null;
+        workspacePath?: string | null;
+    }) => string;
     conversations: (workspacePath?: string | null, options?: ConversationListOptions) => string;
     conversation: (threadId: string, workspacePath?: string | null) => string;
-    conversationMessages: (threadId: string, workspacePath?: string | null, format?: string | null) => string;
+    conversationMessages: (threadId: string, workspacePath?: string | null, format?: string | null, source?: ConversationMessageSource | null, hideResumable?: boolean | null) => string;
+    conversationRuntime: (threadId: string, workspacePath?: string | null) => string;
     imageGenerationRecords: (workspacePath?: string | null, threadId?: string | null, limit?: number) => string;
     userChoice: (query?: {
         workspacePath?: string | null;
@@ -47,16 +62,39 @@ export declare const acpApiEndpoints: {
         requestId?: string | null;
     }) => string;
     workspaceOutputArtifacts: (workspacePath?: string | null, threadId?: string | null, sinceMs?: number) => string;
+    threadOutputArtifacts: (query: {
+        workspacePath?: string | null;
+        threadId?: string | null;
+        format?: string | null;
+        source?: ConversationMessageSource | null;
+        sinceMs?: number | null;
+    }) => string;
     capabilities: ({ provider, threadId, workspacePath }: AcpQuery) => string;
     commands: ({ provider, threadId, workspacePath }: AcpQuery) => string;
 };
 export declare const acpApiClient: {
     chatUrl(): string;
+    chatResumeUrl(streamId: string, query?: {
+        id?: string | null;
+        threadId?: string | null;
+        provider?: string | null;
+        workspacePath?: string | null;
+    }): string;
+    cancelChat(body: {
+        id?: string | null;
+        threadId?: string | null;
+        provider?: string | null;
+        workspacePath?: string | null;
+    }): Promise<{
+        cancelled: boolean;
+        cleaned: boolean;
+    }>;
     listConversations(workspacePath?: string | null, options?: ConversationListOptions): Promise<ConversationListResponse>;
     upsertConversation(body: ConversationUpsertRequest, workspacePath?: string | null): Promise<ConversationInitializeResponse>;
     getConversation(threadId: string, workspacePath?: string | null): Promise<{
         thread: ConversationRecord;
     }>;
+    getConversationRuntime(threadId: string, workspacePath?: string | null): Promise<ConversationRuntimeResponse>;
     renameConversation(threadId: string, title: string, workspacePath?: string | null): Promise<{
         thread: ConversationRecord;
     }>;
@@ -64,7 +102,9 @@ export declare const acpApiClient: {
         thread: ConversationRecord;
     }>;
     deleteConversation(threadId: string, workspacePath?: string | null): Promise<void>;
-    loadConversationMessages<TContent extends Record<string, unknown>>(threadId: string, workspacePath: string | null | undefined, format: string): Promise<ConversationMessagesResponse<TContent>>;
+    loadConversationMessages<TContent extends Record<string, unknown>>(threadId: string, workspacePath: string | null | undefined, format: string, source?: ConversationMessageSource, options?: {
+        hideResumable?: boolean;
+    }): Promise<ConversationMessagesResponse<TContent>>;
     saveConversationMessage<TContent extends Record<string, unknown>>(threadId: string, workspacePath: string | null | undefined, body: ConversationMessageUpsertRequest<TContent>): Promise<{
         message: unknown;
     }>;
@@ -87,6 +127,13 @@ export declare const acpApiClient: {
         request: UserChoicePendingRequest;
     }>;
     listWorkspaceOutputArtifacts(workspacePath: string | null | undefined, threadId: string | null | undefined, sinceMs: number): Promise<WorkspaceOutputArtifactsResponse>;
+    collectThreadOutputArtifacts(query: {
+        workspacePath?: string | null;
+        threadId?: string | null;
+        format?: string | null;
+        source?: ConversationMessageSource | null;
+        sinceMs?: number | null;
+    }): Promise<ThreadOutputArtifactsResponse>;
     getCapabilities(query: AcpQuery): Promise<CapabilityResponse>;
     listCommands(query: AcpQuery): Promise<CommandsResponse>;
 };

package/dist/lib/api/client.mjs

@@ -106,6 +106,12 @@ function conversationPath(threadId) {
 function conversationMessagesPath(threadId) {
     return `${conversationPath(threadId)}/messages`;
 }
+function conversationRuntimePath(threadId) {
+    return `${conversationPath(threadId)}/runtime`;
+}
+function chatResumePath(streamId) {
+    return `/chat/resume/${encodeURIComponent(streamId)}`;
+}
 function imageGenerationRecordsPath() {
     return "/tools/image-generation/records";
 }
@@ -114,19 +120,29 @@ function userChoicePath() {
 }
 export const acpApiEndpoints = {
     chat: () => buildApiUrl("/chat"),
+    chatCancel: () => buildApiUrl("/chat/cancel"),
+    chatResume: (streamId, query) => buildApiUrl(chatResumePath(streamId), query),
     conversations: (workspacePath, options) => buildApiUrl("/conversations", conversationQuery(workspacePath, options)),
     conversation: (threadId, workspacePath) => buildApiUrl(conversationPath(threadId), { workspacePath }),
-    conversationMessages: (threadId, workspacePath, format) => buildApiUrl(conversationMessagesPath(threadId), {
+    conversationMessages: (threadId, workspacePath, format, source, hideResumable) => buildApiUrl(conversationMessagesPath(threadId), {
         workspacePath,
         format,
+        source,
+        hideResumable,
     }),
+    conversationRuntime: (threadId, workspacePath) => buildApiUrl(conversationRuntimePath(threadId), { workspacePath }),
     imageGenerationRecords: (workspacePath, threadId, limit) => buildApiUrl(imageGenerationRecordsPath(), {
         workspacePath,
         threadId,
         limit,
     }),
     userChoice: (query) => buildApiUrl(userChoicePath(), query),
-    workspaceOutputArtifacts: (workspacePath, threadId, sinceMs) => buildApiUrl("/output-artifacts/workspace", { workspacePath, threadId, sinceMs }),
+    workspaceOutputArtifacts: (workspacePath, threadId, sinceMs) => buildApiUrl("/output-artifacts/workspace", {
+        workspacePath,
+        threadId,
+        sinceMs,
+    }),
+    threadOutputArtifacts: (query) => buildApiUrl("/output-artifacts/thread", query),
     capabilities: ({ provider, threadId, workspacePath }) => buildApiUrl("/acp/capabilities", { provider, threadId, workspacePath }),
     commands: ({ provider, threadId, workspacePath }) => buildApiUrl("/acp/commands", { provider, threadId, workspacePath }),
 };
@@ -134,6 +150,15 @@ export const acpApiClient = {
     chatUrl() {
         return acpApiEndpoints.chat();
     },
+    chatResumeUrl(streamId, query) {
+        return acpApiEndpoints.chatResume(streamId, query);
+    },
+    async cancelChat(body) {
+        return requestJson(acpApiEndpoints.chatCancel(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    },
     async listConversations(workspacePath, options) {
         return requestJson(acpApiEndpoints.conversations(workspacePath, options));
     },
@@ -146,6 +171,9 @@ export const acpApiClient = {
     async getConversation(threadId, workspacePath) {
         return requestJson(acpApiEndpoints.conversation(threadId, workspacePath));
     },
+    async getConversationRuntime(threadId, workspacePath) {
+        return requestJson(acpApiEndpoints.conversationRuntime(threadId, workspacePath));
+    },
     async renameConversation(threadId, title, workspacePath) {
         return requestJson(acpApiEndpoints.conversation(threadId, workspacePath), {
             method: "PATCH",
@@ -166,8 +194,8 @@ export const acpApiClient = {
             throw new Error(`${response.status} ${response.statusText}`);
         }
     },
-    async loadConversationMessages(threadId, workspacePath, format) {
-        return requestJson(acpApiEndpoints.conversationMessages(threadId, workspacePath, format));
+    async loadConversationMessages(threadId, workspacePath, format, source, options) {
+        return requestJson(acpApiEndpoints.conversationMessages(threadId, workspacePath, format, source, options === null || options === void 0 ? void 0 : options.hideResumable));
     },
     async saveConversationMessage(threadId, workspacePath, body) {
         return requestJson(acpApiEndpoints.conversationMessages(threadId, workspacePath, body.format), {
@@ -190,6 +218,9 @@ export const acpApiClient = {
     async listWorkspaceOutputArtifacts(workspacePath, threadId, sinceMs) {
         return requestJson(acpApiEndpoints.workspaceOutputArtifacts(workspacePath, threadId, sinceMs));
     },
+    async collectThreadOutputArtifacts(query) {
+        return requestJson(acpApiEndpoints.threadOutputArtifacts(query));
+    },
     async getCapabilities(query) {
         return requestJson(acpApiEndpoints.capabilities(query));
     },

package/dist/lib/api/cors.mjs

@@ -1,3 +1,4 @@
+import { hasNullBodyStatus } from "./http-response.mjs";
 const ALLOWED_METHODS = "GET,POST,PATCH,DELETE,OPTIONS";
 const DEFAULT_ALLOWED_HEADERS = "Content-Type, Authorization, X-Requested-With, Accept";
 function configuredOrigins() {
@@ -36,7 +37,12 @@ export function withCors(request, response) {
     headers.set("Access-Control-Allow-Headers", (_a = request.headers.get("access-control-request-headers")) !== null && _a !== void 0 ? _a : DEFAULT_ALLOWED_HEADERS);
     headers.set("Access-Control-Max-Age", "86400");
     appendVaryOrigin(headers);
-    return new Response(response.body, {
+    const body = hasNullBodyStatus(response.status) ? null : response.body;
+    if (body === null) {
+        headers.delete("content-length");
+        headers.delete("transfer-encoding");
+    }
+    return new Response(body, {
         headers,
         status: response.status,
         statusText: response.statusText,

package/dist/lib/api/http-response.d.ts

@@ -0,0 +1,2 @@
+export declare function hasNullBodyStatus(status: number): boolean;
+export declare function withoutBodyForNullBodyStatus(response: Response): Response;

package/dist/lib/api/http-response.mjs

@@ -0,0 +1,22 @@
+const NULL_BODY_STATUS_CODES = new Set([204, 205, 304]);
+export function hasNullBodyStatus(status) {
+    return NULL_BODY_STATUS_CODES.has(status);
+}
+export function withoutBodyForNullBodyStatus(response) {
+    if (!hasNullBodyStatus(response.status) || !response.body)
+        return response;
+    try {
+        void response.body.cancel().catch(() => { });
+    }
+    catch (_a) {
+        // The body may already be locked by the time a defensive wrapper sees it.
+    }
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.delete("transfer-encoding");
+    return new Response(null, {
+        headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
+}

package/dist/lib/conversations/client-adapter.d.ts

@@ -11,6 +11,7 @@ type AcpThreadContext = {
     permissionMode?: string;
     workspacePath?: string | null;
     builtinToolSettings?: AcpBuiltinToolSettings;
+    runtimeBuiltinToolSettings?: AcpBuiltinToolSettings;
     consumeContextBundle?: () => ContextBundleV2 | null;
 };
 type ConversationRuntimeOptions = {