@axhub/acp 0.1.0

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

@@ -0,0 +1,329 @@
+"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 { lastAssistantMessageIsCompleteWithToolCalls, } from "ai";
+import { createAssistantStream } from "assistant-stream";
+import { 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 { getEnabledBuiltinToolIds } from "../../tools/client-registry.mjs";
+const DEFAULT_PROVIDER = "codex";
+const LOCAL_THREAD_ID_PREFIX = "__LOCALID_";
+const THREAD_LIST_PAGE_SIZE = 50;
+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 toRemoteMetadata(thread) {
+    var _a, _b;
+    return {
+        remoteId: thread.threadId,
+        status: thread.status === "archived" ? "archived" : "regular",
+        title: (_a = thread.title) !== null && _a !== void 0 ? _a : undefined,
+        custom: {
+            provider: thread.provider,
+            model: thread.model,
+            modeId: thread.modeId,
+            thoughtLevel: thread.thoughtLevel,
+            workspacePath: thread.workspacePath,
+            providerSessionId: (_b = thread.providerSessionId) !== null && _b !== void 0 ? _b : null,
+        },
+    };
+}
+function getTextFromThreadMessage(message) {
+    return message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join(" ")
+        .trim();
+}
+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() : "";
+    return (maxLength ? title.slice(0, maxLength) : title).trim();
+}
+function normalizeStoredTitle(value) {
+    const title = normalizeTitleText(value);
+    return title === "新对话" ? "" : title;
+}
+function getAcpSessionTitle(message) {
+    var _a;
+    const custom = isRecord((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.custom)
+        ? message.metadata.custom
+        : undefined;
+    const acpSessionUpdate = isRecord(custom === null || custom === void 0 ? void 0 : custom.acpSessionUpdate)
+        ? custom.acpSessionUpdate
+        : undefined;
+    const sessionInfo = isRecord(acpSessionUpdate === null || acpSessionUpdate === void 0 ? void 0 : acpSessionUpdate.session_info_update)
+        ? acpSessionUpdate.session_info_update
+        : undefined;
+    return normalizeTitleText(sessionInfo === null || sessionInfo === void 0 ? void 0 : sessionInfo.title);
+}
+function getLatestAcpSessionTitle(messages) {
+    for (const message of [...messages].reverse()) {
+        const title = getAcpSessionTitle(message);
+        if (title)
+            return title;
+    }
+    return "";
+}
+function createTitle(messages) {
+    var _a;
+    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;
+}
+const AcpSessionTitleSync = () => {
+    const aui = useAui();
+    const remoteId = useAuiState((state) => state.threadListItem.remoteId);
+    const currentTitle = useAuiState((state) => state.threadListItem.title);
+    const acpSessionTitle = useAuiState((state) => getLatestAcpSessionTitle(state.thread.messages));
+    const lastSyncedRef = useRef(null);
+    useEffect(() => {
+        if (!remoteId || !acpSessionTitle || acpSessionTitle === currentTitle) {
+            return;
+        }
+        const syncKey = `${remoteId}:${acpSessionTitle}`;
+        if (lastSyncedRef.current === syncKey)
+            return;
+        if (aui.threadListItem().getState().remoteId !== remoteId)
+            return;
+        lastSyncedRef.current = syncKey;
+        void Promise.resolve()
+            .then(() => aui.threadListItem().rename(acpSessionTitle))
+            .catch(() => {
+            lastSyncedRef.current = null;
+        });
+    }, [acpSessionTitle, aui, currentTitle, remoteId]);
+    return null;
+};
+class RemoteConversationHistoryAdapter {
+    constructor(aui, workspacePath, ensureConversation) {
+        this.aui = aui;
+        this.workspacePath = workspacePath;
+        this.ensureConversation = ensureConversation;
+    }
+    async load() {
+        return { messages: [] };
+    }
+    async append() { }
+    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,
+            });
+        };
+        return {
+            async load() {
+                const remoteId = getRemoteId();
+                if (!remoteId)
+                    return { messages: [] };
+                const repo = await acpApiClient.loadConversationMessages(remoteId, workspacePath, formatAdapter.format);
+                if (repo.messages.length === 0) {
+                    return null;
+                }
+                return {
+                    headId: repo.headId,
+                    messages: repo.messages.map((message) => formatAdapter.decode({
+                        id: message.id,
+                        parent_id: message.parent_id,
+                        format: message.format,
+                        content: message.content,
+                    })),
+                };
+            },
+            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));
+            },
+            async update(item, localMessageId) {
+                const remoteId = getRemoteId();
+                if (!remoteId)
+                    return;
+                await saveItem(remoteId, item, localMessageId);
+            },
+        };
+    }
+}
+function createHistoryProvider(workspacePath, ensureConversation) {
+    const Provider = ({ children }) => {
+        const aui = useAui();
+        const history = useMemo(() => new RemoteConversationHistoryAdapter(aui, workspacePath, ensureConversation), [aui]);
+        const adapters = useMemo(() => ({ history }), [history]);
+        return (_jsxs(RuntimeAdapterProvider, { adapters: adapters, children: [_jsx(AcpSessionTitleSync, {}), children] }));
+    };
+    return Provider;
+}
+function createConversationThreadListAdapter(context = {}) {
+    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 : {};
+        return {
+            threadId,
+            provider: (_c = context.provider) !== null && _c !== void 0 ? _c : DEFAULT_PROVIDER,
+            model: (_d = metadata.model) !== null && _d !== void 0 ? _d : null,
+            modeId: (_e = metadata.modeId) !== null && _e !== void 0 ? _e : null,
+            thoughtLevel: (_f = metadata.thoughtLevel) !== null && _f !== void 0 ? _f : null,
+            permissionMode: context.permissionMode,
+            workspacePath: (_g = context.workspacePath) !== null && _g !== void 0 ? _g : undefined,
+        };
+    };
+    const ensureConversation = async (threadId, patch = {}) => {
+        await acpApiClient.upsertConversation(Object.assign(Object.assign(Object.assign({}, conversationBody(threadId)), patch), { threadId }), context.workspacePath);
+    };
+    return {
+        unstable_Provider: createHistoryProvider(context.workspacePath, ensureConversation),
+        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,
+            });
+            return {
+                threads: threads.map(toRemoteMetadata),
+                nextCursor,
+            };
+        },
+        async initialize(threadId) {
+            var _a;
+            const provider = (_a = context.provider) !== null && _a !== void 0 ? _a : DEFAULT_PROVIDER;
+            const remoteId = threadId.startsWith(LOCAL_THREAD_ID_PREFIX)
+                ? createConversationThreadId(provider)
+                : threadId;
+            // Keep empty local threads out of the persistent store. The record is
+            // created once a real message/run is started.
+            return { remoteId, externalId: undefined };
+        },
+        async rename(remoteId, newTitle) {
+            await acpApiClient.renameConversation(remoteId, newTitle, context.workspacePath);
+        },
+        async archive(remoteId) {
+            await acpApiClient.archiveConversation(remoteId, true, context.workspacePath);
+        },
+        async unarchive(remoteId) {
+            await acpApiClient.archiveConversation(remoteId, false, context.workspacePath);
+        },
+        async delete(remoteId) {
+            await acpApiClient.deleteConversation(remoteId, context.workspacePath);
+        },
+        async fetch(threadId) {
+            const { thread } = await acpApiClient.getConversation(threadId, context.workspacePath);
+            return toRemoteMetadata(thread);
+        },
+        async generateTitle(remoteId, messages) {
+            const acpSessionTitle = getLatestAcpSessionTitle(messages);
+            const storedTitle = acpSessionTitle
+                ? ""
+                : await acpApiClient
+                    .getConversation(remoteId, context.workspacePath)
+                    .then(({ thread }) => normalizeStoredTitle(thread.title))
+                    .catch(() => "");
+            const title = acpSessionTitle || storedTitle || createTitle(messages);
+            if (!title)
+                return createAssistantStream(() => { });
+            await ensureConversation(remoteId, { title });
+            return createAssistantStream((controller) => {
+                controller.appendText(title);
+            });
+        },
+    };
+}
+function dispatchCapabilityRefresh({ provider, threadId, workspacePath, }) {
+    window.dispatchEvent(new CustomEvent(ACP_CAPABILITY_REFRESH_EVENT, {
+        detail: {
+            provider,
+            threadId,
+            workspacePath: workspacePath !== null && workspacePath !== void 0 ? workspacePath : null,
+        },
+    }));
+}
+export function useConversationChatRuntime({ context, threadId, } = {}) {
+    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;
+    const thoughtLevel = context === null || context === void 0 ? void 0 : context.thoughtLevel;
+    const explicitModel = context === null || context === void 0 ? void 0 : context.explicitModel;
+    const explicitModeId = context === null || context === void 0 ? void 0 : context.explicitModeId;
+    const requestModeId = explicitModeId !== null && explicitModeId !== void 0 ? explicitModeId : getAcpProviderDefaultModeId(provider);
+    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 consumeContextBundle = context === null || context === void 0 ? void 0 : context.consumeContextBundle;
+    const conversationMetadataRef = useRef({});
+    conversationMetadataRef.current = {
+        model,
+        modeId,
+        thoughtLevel,
+    };
+    const adapterContext = useMemo(() => ({
+        provider,
+        permissionMode,
+        workspacePath,
+        getConversationMetadata: () => conversationMetadataRef.current,
+    }), [provider, permissionMode, workspacePath]);
+    const adapter = useMemo(() => createConversationThreadListAdapter(adapterContext), [adapterContext]);
+    return useRemoteThreadListRuntime({
+        adapter,
+        allowNesting: true,
+        threadId,
+        runtimeHook: function RuntimeHook() {
+            // biome-ignore lint/correctness/useHookAtTopLevel: assistant-ui calls runtimeHook as a runtime component hook.
+            return useChatRuntime({
+                sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithToolCalls,
+                transport: new AssistantChatTransport({
+                    api: acpApiClient.chatUrl(),
+                    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 decodedThreadId = responseThreadId
+                            ? decodeURIComponent(responseThreadId)
+                            : null;
+                        if (decodedThreadId) {
+                            dispatchCapabilityRefresh({
+                                provider: responseProvider,
+                                threadId: decodedThreadId,
+                                workspacePath,
+                            });
+                        }
+                        return response;
+                    },
+                    body: () => {
+                        var _a;
+                        return ({
+                            provider: provider !== null && provider !== void 0 ? provider : DEFAULT_PROVIDER,
+                            model: explicitModel !== null && explicitModel !== void 0 ? explicitModel : null,
+                            modeId: requestModeId,
+                            thoughtLevel: explicitThoughtLevel !== null && explicitThoughtLevel !== void 0 ? explicitThoughtLevel : null,
+                            permissionMode,
+                            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,
+                        });
+                    },
+                }),
+            });
+        },
+    });
+}

package/dist/lib/conversations/message-repository.d.ts

@@ -0,0 +1,8 @@
+import type { ConversationMessageRepository, ConversationMessageUpsertRequest, ConversationRecord, ConversationStoreData, StoredMessageEntry } from "./types";
+export declare const RUNTIME_MESSAGE_RETENTION_DAYS = 7;
+export declare const RUNTIME_MESSAGE_RETENTION_MS: number;
+export declare function getRuntimeMessageRepository(data: ConversationStoreData, threadId: string, format?: string | null): ConversationMessageRepository;
+export declare function isRuntimeMessageConversationExpired(conversation: Pick<ConversationRecord, "updatedAt">, nowMs?: number): boolean;
+export declare function pruneExpiredRuntimeMessages(data: ConversationStoreData, nowMs?: number): string[];
+export declare function upsertRuntimeMessage(data: ConversationStoreData, threadId: string, request: ConversationMessageUpsertRequest): StoredMessageEntry;
+export declare function deleteRuntimeMessages(data: ConversationStoreData, threadId: string): void;

package/dist/lib/conversations/message-repository.mjs

@@ -0,0 +1,87 @@
+export const RUNTIME_MESSAGE_RETENTION_DAYS = 7;
+export const RUNTIME_MESSAGE_RETENTION_MS = RUNTIME_MESSAGE_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+function nowIso() {
+    return new Date().toISOString();
+}
+function emptyRepository() {
+    return { messages: [] };
+}
+function ensureMessageMap(data) {
+    var _a;
+    (_a = data.messages) !== null && _a !== void 0 ? _a : (data.messages = {});
+    return data.messages;
+}
+function ensureRepository(data, threadId) {
+    var _a;
+    const messages = ensureMessageMap(data);
+    (_a = messages[threadId]) !== null && _a !== void 0 ? _a : (messages[threadId] = emptyRepository());
+    return messages[threadId];
+}
+export function getRuntimeMessageRepository(data, threadId, format) {
+    var _a;
+    const repo = (_a = data.messages) === null || _a === void 0 ? void 0 : _a[threadId];
+    if (!repo) {
+        return {
+            messages: [],
+            diagnostic: {
+                source: "runtime-store",
+                error: "Runtime message repository not found",
+            },
+        };
+    }
+    const messages = format
+        ? repo.messages.filter((message) => message.format === format)
+        : repo.messages;
+    return {
+        headId: repo.headId,
+        messages,
+        diagnostic: { source: "runtime-store" },
+    };
+}
+export function isRuntimeMessageConversationExpired(conversation, nowMs = Date.now()) {
+    const updatedAtMs = Date.parse(conversation.updatedAt);
+    if (!Number.isFinite(updatedAtMs))
+        return true;
+    return updatedAtMs < nowMs - RUNTIME_MESSAGE_RETENTION_MS;
+}
+export function pruneExpiredRuntimeMessages(data, nowMs = Date.now()) {
+    if (!data.messages)
+        return [];
+    const prunedThreadIds = [];
+    for (const conversation of data.conversations) {
+        if (data.messages[conversation.threadId] &&
+            isRuntimeMessageConversationExpired(conversation, nowMs)) {
+            delete data.messages[conversation.threadId];
+            prunedThreadIds.push(conversation.threadId);
+        }
+    }
+    return prunedThreadIds;
+}
+export function upsertRuntimeMessage(data, threadId, request) {
+    var _a;
+    const timestamp = nowIso();
+    const repo = ensureRepository(data, threadId);
+    const existingIndex = repo.messages.findIndex((message) => message.id === request.message.id);
+    const existing = existingIndex >= 0 ? repo.messages[existingIndex] : undefined;
+    const entry = {
+        id: request.message.id,
+        parent_id: request.parentId,
+        format: request.format,
+        content: request.message.content,
+        createdAt: (_a = existing === null || existing === void 0 ? void 0 : existing.createdAt) !== null && _a !== void 0 ? _a : timestamp,
+        updatedAt: timestamp,
+    };
+    if (existingIndex >= 0) {
+        repo.messages[existingIndex] = entry;
+    }
+    else {
+        repo.messages.push(entry);
+    }
+    repo.headId = entry.id;
+    return entry;
+}
+export function deleteRuntimeMessages(data, threadId) {
+    if (!data.messages)
+        return;
+    delete data.messages[threadId];
+}

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

@@ -0,0 +1,17 @@
+import type { AcpRuntimeMetadata } from "../acp2aisdk";
+import type { ConversationListOptions, ConversationListResponse, ConversationMessageRepository, 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, }: {
+    provider: string | null | undefined;
+    sessionId: string;
+    workspacePath?: string | null;
+}): Promise<ConversationSessionResolution | null>;
+export declare function upsertConversation(request: ConversationUpsertRequest): Promise<ConversationRecord>;
+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 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>;