@axhub/acp 0.1.0

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

@@ -0,0 +1,501 @@
+import { buildAcpCapabilitySnapshot } from "./capabilities.mjs";
+import { ACP_ELICITATION_OPTION_LIST_TOOL_NAME, createElicitationOptionListPayload, findLatestElicitationOptionListToolOutput, normalizeElicitationOptionListToolResult, } from "./elicitation.mjs";
+import { createElicitationFallbackResponse, createPermissionBypassResponse, } from "./hitl.mjs";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export function getAcpLanguageModelInternals(provider) {
+    const model = provider.model;
+    if (!isRecord(model))
+        return null;
+    return model;
+}
+function normalizeString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function hasStructuredToolContent(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.type === "content")
+        return true;
+    if (value.type === "resource" || value.type === "resource_link")
+        return true;
+    return false;
+}
+function normalizeToolContentRawPart(item, toolCallId) {
+    if (item.type === "content" && isRecord(item.content)) {
+        return Object.assign(Object.assign({}, item.content), { type: item.content.type, toolCallId, wrapper: "content", raw: item });
+    }
+    return Object.assign(Object.assign({}, item), { toolCallId, raw: item });
+}
+function emitRawSessionUpdate(controller, update) {
+    controller.enqueue({
+        type: "raw",
+        rawValue: JSON.stringify(update),
+    });
+}
+function createEmptyUsage() {
+    return {
+        inputTokens: {
+            total: undefined,
+            noCache: undefined,
+            cacheRead: undefined,
+            cacheWrite: undefined,
+        },
+        outputTokens: {
+            total: undefined,
+            text: undefined,
+            reasoning: undefined,
+        },
+    };
+}
+function mapAcpStopReasonToAiSdk(stopReason) {
+    switch (stopReason) {
+        case "end_turn":
+            return "stop";
+        case "max_tokens":
+        case "max_turn_requests":
+            return "length";
+        default:
+            return "other";
+    }
+}
+function createAcpProviderMetadata(response) {
+    try {
+        return { acp: JSON.parse(JSON.stringify(response)) };
+    }
+    catch (_a) {
+        return { acp: response };
+    }
+}
+function nextElicitationToolCallId(model) {
+    var _a;
+    const sequence = ((_a = model.__acpUiElicitationSequence) !== null && _a !== void 0 ? _a : 0) + 1;
+    model.__acpUiElicitationSequence = sequence;
+    return `acp-elicitation-${sequence}`;
+}
+function safelyEnqueue(controller, part) {
+    try {
+        controller.enqueue(part);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function safelyClose(controller) {
+    var _a;
+    try {
+        (_a = controller.close) === null || _a === void 0 ? void 0 : _a.call(controller);
+    }
+    catch (_b) {
+        // The stream may already be closed after an abort.
+    }
+}
+function closeOpenTextBlocks(model, controller) {
+    if (model.currentTextId) {
+        safelyEnqueue(controller, {
+            type: "text-end",
+            id: model.currentTextId,
+        });
+        model.currentTextId = null;
+    }
+    if (model.currentThinkingId) {
+        safelyEnqueue(controller, {
+            type: "reasoning-end",
+            id: model.currentThinkingId,
+        });
+        model.currentThinkingId = null;
+    }
+}
+function readStreamPartId(part) {
+    return typeof part.id === "string" ? part.id : null;
+}
+function emitOpenTextBlockEnds(openTextIds, openThinkingIds, model, controller) {
+    for (const id of openTextIds) {
+        safelyEnqueue(controller, { type: "text-end", id });
+    }
+    for (const id of openThinkingIds) {
+        safelyEnqueue(controller, { type: "reasoning-end", id });
+    }
+    openTextIds.clear();
+    openThinkingIds.clear();
+    model.currentTextId = null;
+    model.currentThinkingId = null;
+}
+function createFinalizedStream(model, stream) {
+    const openTextIds = new Set();
+    const openThinkingIds = new Set();
+    return stream.pipeThrough(new TransformStream({
+        transform(part, controller) {
+            if (isRecord(part)) {
+                const partType = part.type;
+                const partId = readStreamPartId(part);
+                if (partType === "finish" ||
+                    partType === "error" ||
+                    partType === "tool-call" ||
+                    partType === "tool-result" ||
+                    partType === "tool-input-start") {
+                    emitOpenTextBlockEnds(openTextIds, openThinkingIds, model, controller);
+                }
+                if (partType === "text-start" && partId) {
+                    openTextIds.add(partId);
+                    model.currentTextId = partId;
+                }
+                else if (partType === "text-end" && partId) {
+                    if (!openTextIds.has(partId)) {
+                        if (model.currentTextId === partId)
+                            model.currentTextId = null;
+                        return;
+                    }
+                    openTextIds.delete(partId);
+                    if (model.currentTextId === partId)
+                        model.currentTextId = null;
+                }
+                else if (partType === "reasoning-start" && partId) {
+                    openThinkingIds.add(partId);
+                    model.currentThinkingId = partId;
+                }
+                else if (partType === "reasoning-end" && partId) {
+                    if (!openThinkingIds.has(partId)) {
+                        if (model.currentThinkingId === partId) {
+                            model.currentThinkingId = null;
+                        }
+                        return;
+                    }
+                    openThinkingIds.delete(partId);
+                    if (model.currentThinkingId === partId) {
+                        model.currentThinkingId = null;
+                    }
+                }
+            }
+            controller.enqueue(part);
+        },
+        flush(controller) {
+            emitOpenTextBlockEnds(openTextIds, openThinkingIds, model, controller);
+        },
+    }));
+}
+function emitElicitationToolCall(model, payload) {
+    const clientToolAbort = model.clientToolAbort;
+    const controller = clientToolAbort === null || clientToolAbort === void 0 ? void 0 : clientToolAbort.controller;
+    if (!clientToolAbort || !controller)
+        return false;
+    closeOpenTextBlocks(model, controller);
+    if (!safelyEnqueue(controller, {
+        type: "tool-call",
+        toolCallId: payload.toolCallId,
+        toolName: ACP_ELICITATION_OPTION_LIST_TOOL_NAME,
+        input: JSON.stringify(payload),
+    })) {
+        return false;
+    }
+    safelyEnqueue(controller, {
+        type: "finish",
+        finishReason: {
+            unified: "tool-calls",
+            raw: undefined,
+        },
+        usage: createEmptyUsage(),
+    });
+    safelyClose(controller);
+    clientToolAbort.resolve();
+    return true;
+}
+function createElicitationContinuationStream(model, pending, response) {
+    const stream = new ReadableStream({
+        start: async (controller) => {
+            var _a, _b, _c, _d, _e, _f;
+            safelyEnqueue(controller, {
+                type: "stream-start",
+                warnings: [],
+            });
+            (_a = model.resetStreamState) === null || _a === void 0 ? void 0 : _a.call(model);
+            const streamHandler = (_b = model.handleStreamNotification) === null || _b === void 0 ? void 0 : _b.bind(model);
+            if (model.client && streamHandler) {
+                (_d = (_c = model.client).setSessionUpdateHandler) === null || _d === void 0 ? void 0 : _d.call(_c, (notification) => {
+                    streamHandler(controller, notification);
+                });
+            }
+            const clientToolPromise = new Promise((resolve) => {
+                model.clientToolAbort = {
+                    controller,
+                    resolve: () => resolve("client-tool"),
+                };
+            });
+            try {
+                model.__acpUiPendingElicitation = null;
+                pending.resolve(response);
+                const result = await Promise.race([
+                    pending.promptPromise.then((promptResponse) => ({
+                        type: "response",
+                        response: promptResponse,
+                    })),
+                    clientToolPromise.then((type) => ({ type })),
+                ]);
+                if (result.type === "client-tool")
+                    return;
+                const promptResponse = isRecord(result.response) ? result.response : {};
+                safelyEnqueue(controller, {
+                    type: "finish",
+                    finishReason: {
+                        unified: mapAcpStopReasonToAiSdk(promptResponse.stopReason),
+                        raw: promptResponse.stopReason,
+                    },
+                    providerMetadata: createAcpProviderMetadata(result.response),
+                    usage: createEmptyUsage(),
+                });
+                safelyClose(controller);
+                (_e = model.cleanup) === null || _e === void 0 ? void 0 : _e.call(model);
+            }
+            catch (error) {
+                model.__acpUiPendingElicitation = null;
+                (_f = model.cleanup) === null || _f === void 0 ? void 0 : _f.call(model);
+                safelyEnqueue(controller, { type: "error", error });
+                safelyClose(controller);
+            }
+        },
+        cancel: () => {
+            var _a;
+            (_a = model.cleanup) === null || _a === void 0 ? void 0 : _a.call(model);
+        },
+    });
+    return {
+        stream: createFinalizedStream(model, stream),
+        warnings: undefined,
+    };
+}
+function patchStreamNotifications(model) {
+    var _a;
+    const originalHandleStreamNotification = (_a = model.handleStreamNotification) === null || _a === void 0 ? void 0 : _a.bind(model);
+    if (!originalHandleStreamNotification)
+        return;
+    model.handleStreamNotification = (controller, notification) => {
+        const update = isRecord(notification.update) ? notification.update : null;
+        const sessionUpdate = update === null || update === void 0 ? void 0 : update.sessionUpdate;
+        originalHandleStreamNotification(controller, notification);
+        if (!update)
+            return;
+        if (sessionUpdate === "plan_update" ||
+            sessionUpdate === "plan_removed" ||
+            sessionUpdate === "available_commands_update" ||
+            sessionUpdate === "current_mode_update" ||
+            sessionUpdate === "config_option_update" ||
+            sessionUpdate === "session_info_update" ||
+            sessionUpdate === "usage_update") {
+            emitRawSessionUpdate(controller, update);
+            return;
+        }
+        if (sessionUpdate !== "tool_call_update")
+            return;
+        const toolCallId = normalizeString(update.toolCallId);
+        if (!toolCallId || !Array.isArray(update.content))
+            return;
+        for (const item of update.content) {
+            if (!hasStructuredToolContent(item))
+                continue;
+            emitRawSessionUpdate(controller, normalizeToolContentRawPart(item, toolCallId));
+        }
+    };
+}
+function installHitlFallbacks(model) {
+    var _a;
+    const client = model.client;
+    if (!client)
+        return;
+    (_a = client.setPermissionRequestHandler) === null || _a === void 0 ? void 0 : _a.call(client, async (request) => createPermissionBypassResponse(request));
+    client.unstable_createElicitation = async (request) => {
+        const promptPromise = model.__acpUiPromptPromise;
+        const payload = promptPromise
+            ? createElicitationOptionListPayload(request, nextElicitationToolCallId(model))
+            : null;
+        if (!promptPromise || !payload || model.__acpUiPendingElicitation) {
+            return createElicitationFallbackResponse(request);
+        }
+        const toolCallId = payload.toolCallId;
+        let resolvePending;
+        let rejectPending;
+        const responsePromise = new Promise((resolve, reject) => {
+            resolvePending = resolve;
+            rejectPending = reject;
+        });
+        model.__acpUiPendingElicitation = {
+            toolCallId,
+            request,
+            promptPromise,
+            resolve: resolvePending,
+            reject: rejectPending,
+        };
+        if (!emitElicitationToolCall(model, payload)) {
+            model.__acpUiPendingElicitation = null;
+            return createElicitationFallbackResponse(request);
+        }
+        return responsePromise;
+    };
+}
+function patchPromptTracking(model) {
+    var _a;
+    const originalPromptWithLazyAuthRetry = (_a = model.promptWithLazyAuthRetry) === null || _a === void 0 ? void 0 : _a.bind(model);
+    if (!originalPromptWithLazyAuthRetry)
+        return;
+    if (model.__acpUiOriginalPromptWithLazyAuthRetry)
+        return;
+    model.__acpUiOriginalPromptWithLazyAuthRetry =
+        originalPromptWithLazyAuthRetry;
+    model.promptWithLazyAuthRetry = (request) => {
+        const promptPromise = originalPromptWithLazyAuthRetry(request);
+        model.__acpUiPromptPromise = promptPromise;
+        void promptPromise.finally(() => {
+            if (model.__acpUiPromptPromise === promptPromise) {
+                model.__acpUiPromptPromise = null;
+            }
+        });
+        return promptPromise;
+    };
+}
+function patchElicitationContinuation(model) {
+    var _a;
+    const originalDoStream = (_a = model.doStream) === null || _a === void 0 ? void 0 : _a.bind(model);
+    if (!originalDoStream)
+        return;
+    if (model.__acpUiOriginalDoStream)
+        return;
+    model.__acpUiOriginalDoStream = originalDoStream;
+    model.doStream = async (options) => {
+        const response = model.__acpUiResumeElicitationResponse;
+        const pending = model.__acpUiPendingElicitation;
+        if (response && pending) {
+            model.__acpUiResumeElicitationResponse = null;
+            return createElicitationContinuationStream(model, pending, response);
+        }
+        const result = await originalDoStream(options);
+        return Object.assign(Object.assign({}, result), { stream: createFinalizedStream(model, result.stream) });
+    };
+}
+function patchConnectClient(model) {
+    var _a;
+    const originalConnectClient = (_a = model.connectClient) === null || _a === void 0 ? void 0 : _a.bind(model);
+    if (!originalConnectClient)
+        return;
+    model.connectClient = async (...args) => {
+        const result = await originalConnectClient(...args);
+        installHitlFallbacks(model);
+        return result;
+    };
+}
+function patchResumeSession(model, metadata) {
+    var _a;
+    const originalStartSession = (_a = model.startSession) === null || _a === void 0 ? void 0 : _a.bind(model);
+    if (!originalStartSession)
+        return;
+    model.startSession = async (...args) => {
+        var _a, _b, _c, _d;
+        const existingSessionId = normalizeString((_a = model.config) === null || _a === void 0 ? void 0 : _a.existingSessionId);
+        const connection = model.connection;
+        const originalLoadSession = (_b = connection === null || connection === void 0 ? void 0 : connection.loadSession) === null || _b === void 0 ? void 0 : _b.bind(connection);
+        const additionalDirectories = Array.isArray((_d = (_c = model.config) === null || _c === void 0 ? void 0 : _c.session) === null || _d === void 0 ? void 0 : _d.additionalDirectories)
+            ? model.config.session.additionalDirectories
+            : [];
+        if (existingSessionId && (connection === null || connection === void 0 ? void 0 : connection.resumeSession) && originalLoadSession) {
+            connection.loadSession = async (request) => {
+                var _a;
+                const lifecycleRequest = Object.assign(Object.assign({}, request), (additionalDirectories.length > 0
+                    ? { additionalDirectories }
+                    : {}));
+                if (request.sessionId !== existingSessionId) {
+                    return originalLoadSession(lifecycleRequest);
+                }
+                try {
+                    const response = await ((_a = connection.resumeSession) === null || _a === void 0 ? void 0 : _a.call(connection, lifecycleRequest));
+                    model.__acpUiResumeResponse = isRecord(response) ? response : {};
+                    return response;
+                }
+                catch (error) {
+                    metadata.warnings.push(`Failed to resume ACP session "${existingSessionId}" via session/resume; falling back to session/load: ${error instanceof Error ? error.message : String(error)}`);
+                    model.__acpUiResumeResponse = null;
+                    return originalLoadSession(lifecycleRequest);
+                }
+            };
+        }
+        try {
+            const result = await originalStartSession(...args);
+            if (existingSessionId &&
+                model.__acpUiResumeResponse &&
+                model.sessionId === existingSessionId) {
+                model.sessionResponse = Object.assign({ sessionId: existingSessionId }, model.__acpUiResumeResponse);
+                metadata.capabilitySnapshot = buildAcpCapabilitySnapshot({
+                    provider: metadata.provider,
+                    sessionResponse: model.sessionResponse,
+                });
+            }
+            return result;
+        }
+        finally {
+            if (connection && originalLoadSession) {
+                connection.loadSession = originalLoadSession;
+            }
+        }
+    };
+}
+export function installAcpProviderCompatibility(provider, metadata) {
+    const model = getAcpLanguageModelInternals(provider);
+    if (!model || model.__acpUiCompatInstalled)
+        return;
+    model.__acpUiCompatInstalled = true;
+    patchPromptTracking(model);
+    patchElicitationContinuation(model);
+    patchConnectClient(model);
+    patchResumeSession(model, metadata);
+    patchStreamNotifications(model);
+    installHitlFallbacks(model);
+}
+function stageElicitationOutput(model, output) {
+    const pending = model.__acpUiPendingElicitation;
+    if (!pending) {
+        return {
+            status: "stale",
+            toolCallId: output.toolCallId,
+            reason: "No pending ACP elicitation is waiting for this result.",
+        };
+    }
+    if (pending.toolCallId !== output.toolCallId) {
+        return {
+            status: "stale",
+            toolCallId: output.toolCallId,
+            reason: `Pending ACP elicitation "${pending.toolCallId}" does not match result "${output.toolCallId}".`,
+        };
+    }
+    model.__acpUiResumeElicitationResponse =
+        normalizeElicitationOptionListToolResult(pending.request, output.result);
+    return { status: "staged", toolCallId: output.toolCallId };
+}
+export function stageAcpElicitationResultFromMessages(provider, messages) {
+    const output = findLatestElicitationOptionListToolOutput(messages);
+    if (!output)
+        return { status: "none" };
+    const model = getAcpLanguageModelInternals(provider);
+    if (!model) {
+        return {
+            status: "stale",
+            toolCallId: output.toolCallId,
+            reason: "ACP provider model is not initialized.",
+        };
+    }
+    return stageElicitationOutput(model, output);
+}
+export async function closeAcpProviderSession(provider, metadata) {
+    var _a;
+    const model = getAcpLanguageModelInternals(provider);
+    const connection = model === null || model === void 0 ? void 0 : model.connection;
+    const sessionId = normalizeString((_a = model === null || model === void 0 ? void 0 : model.sessionId) !== null && _a !== void 0 ? _a : provider.getSessionId());
+    if (!(connection === null || connection === void 0 ? void 0 : connection.closeSession) || !sessionId)
+        return false;
+    try {
+        await connection.closeSession({ sessionId });
+        return true;
+    }
+    catch (error) {
+        metadata === null || metadata === void 0 ? void 0 : metadata.warnings.push(`Failed to close ACP session "${sessionId}" via session/close: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}

package/dist/lib/acp2aisdk/provider-registry.d.ts

@@ -0,0 +1,15 @@
+import type { AcpProviderKey, AcpProviderOverride, AcpProviderRegistryEntry } from "./types";
+export declare const ACP_PROVIDER_KEYS: readonly ["claude", "codex", "gemini", "opencode"];
+export declare const ACP_PROVIDER_DEFAULT_MODE_IDS: {
+    readonly claude: "bypassPermissions";
+    readonly codex: "full-access";
+    readonly gemini: "bypassPermissions";
+    readonly opencode: "build";
+};
+export declare const ACP_PROVIDER_ALIASES: Record<string, AcpProviderKey>;
+export declare const ACP_PROVIDER_REGISTRY: Record<AcpProviderKey, AcpProviderRegistryEntry>;
+export declare function isAcpProviderKey(value: string): value is AcpProviderKey;
+export declare function normalizeAcpProvider(value?: string | null): AcpProviderKey;
+export declare function getAcpProviderDefaultModeId(value?: string | null): string | null;
+export declare function readProviderOverridesFromEnv(env?: Record<string, string | undefined>): Partial<Record<AcpProviderKey, AcpProviderOverride>>;
+export declare function resolveAcpProviderConfig(providerInput?: string | null, overrides?: Partial<Record<AcpProviderKey, AcpProviderOverride>>): AcpProviderRegistryEntry;