@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/prompt-history.mjs

@@ -0,0 +1,168 @@
+import process from "node:process";
+import { formatDynamicContextPrompt, hasContextItems, } from "./context.mjs";
+const DEFAULT_FALLBACK_HISTORY_MAX_MESSAGES = 24;
+const DEFAULT_FALLBACK_HISTORY_MAX_CHARS = 64000;
+function readPositiveIntegerEnv(name, fallback) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+export function selectMessagesForAcpPrompt(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role === "user")
+            return [message];
+    }
+    return [];
+}
+function isUsefulFallbackPromptPart(message, part) {
+    if (part.type === "text")
+        return part.text.trim().length > 0;
+    if (message.role === "user" && part.type === "file")
+        return !!part.url;
+    return false;
+}
+function sanitizeFallbackPromptMessage(message) {
+    const parts = message.parts.filter((part) => isUsefulFallbackPromptPart(message, part));
+    if (parts.length === 0)
+        return null;
+    return Object.assign(Object.assign({}, message), { parts });
+}
+function estimateFallbackPromptMessageChars(message) {
+    let total = message.role.length;
+    for (const part of message.parts) {
+        if (part.type === "text")
+            total += part.text.length;
+        if (part.type === "file") {
+            total += part.mediaType.length + part.url.length;
+            if (part.filename)
+                total += part.filename.length;
+        }
+    }
+    return total;
+}
+function trimLeadingAssistantMessages(messages) {
+    const firstNonAssistantIndex = messages.findIndex((message) => message.role !== "assistant");
+    if (firstNonAssistantIndex <= 0)
+        return messages;
+    if (firstNonAssistantIndex === -1)
+        return [];
+    return messages.slice(firstNonAssistantIndex);
+}
+function getFallbackPromptText(message) {
+    return message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text.trim())
+        .filter(Boolean)
+        .join("\n\n");
+}
+function formatFallbackContextMessage(message) {
+    const text = getFallbackPromptText(message);
+    if (!text)
+        return null;
+    const label = message.role === "assistant"
+        ? "Assistant"
+        : message.role === "system"
+            ? "System"
+            : "User";
+    return `${label}: ${text}`;
+}
+function createFreshSessionHandoffMessage(messages) {
+    const latestUserIndex = messages.findLastIndex((message) => message.role === "user");
+    if (latestUserIndex === -1)
+        return null;
+    const latestUserMessage = messages[latestUserIndex];
+    const context = messages
+        .slice(0, latestUserIndex)
+        .map(formatFallbackContextMessage)
+        .filter((text) => Boolean(text));
+    const currentRequest = getFallbackPromptText(latestUserMessage);
+    const text = [
+        context.length > 0
+            ? [
+                "Previous conversation context for continuity only:",
+                ...context,
+                "Current user request:",
+            ].join("\n\n")
+            : "",
+        currentRequest,
+    ]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+    const fileParts = latestUserMessage.parts.filter((part) => part.type === "file");
+    const parts = [
+        ...(text ? [{ type: "text", text }] : []),
+        ...fileParts,
+    ];
+    if (parts.length === 0)
+        return null;
+    return Object.assign(Object.assign({}, latestUserMessage), { role: "user", parts });
+}
+function getUserMessageText(message) {
+    return message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n\n")
+        .trim();
+}
+export function wrapLatestUserMessageWithDynamicContext(messages, context) {
+    if (!hasContextItems(context))
+        return messages;
+    const latestUserIndex = messages.findLastIndex((message) => message.role === "user");
+    if (latestUserIndex === -1)
+        return messages;
+    return messages.map((message, index) => {
+        if (index !== latestUserIndex)
+            return message;
+        const fileParts = message.parts.filter((part) => part.type === "file");
+        return Object.assign(Object.assign({}, message), { parts: [
+                {
+                    type: "text",
+                    text: formatDynamicContextPrompt(context, getUserMessageText(message)),
+                },
+                ...fileParts,
+            ] });
+    });
+}
+export function selectMessagesForFreshAcpSessionPrompt(messages) {
+    const maxMessages = readPositiveIntegerEnv("ACP_UI_FALLBACK_HISTORY_MAX_MESSAGES", DEFAULT_FALLBACK_HISTORY_MAX_MESSAGES);
+    const maxChars = readPositiveIntegerEnv("ACP_UI_FALLBACK_HISTORY_MAX_CHARS", DEFAULT_FALLBACK_HISTORY_MAX_CHARS);
+    const sanitized = messages.flatMap((message) => {
+        const sanitizedMessage = sanitizeFallbackPromptMessage(message);
+        return sanitizedMessage ? [sanitizedMessage] : [];
+    });
+    const windowed = sanitized.slice(-maxMessages);
+    const latestUserMessage = windowed.findLast((message) => message.role === "user");
+    const selected = [];
+    let selectedChars = 0;
+    for (let index = windowed.length - 1; index >= 0; index--) {
+        const message = windowed[index];
+        const messageChars = estimateFallbackPromptMessageChars(message);
+        const isLatestUserMessage = message === latestUserMessage;
+        if (!isLatestUserMessage &&
+            selected.length > 0 &&
+            selectedChars + messageChars > maxChars) {
+            break;
+        }
+        selected.unshift(message);
+        selectedChars += messageChars;
+    }
+    const promptMessages = trimLeadingAssistantMessages(selected);
+    const handoffMessage = createFreshSessionHandoffMessage(promptMessages);
+    if (handoffMessage) {
+        const warning = promptMessages.length < messages.length || promptMessages.length > 1
+            ? `Fresh ACP session prompt history was condensed into one handoff message from ${promptMessages.length} useful messages and ${messages.length} UI messages. Tool, reasoning, data, source, and step parts were not replayed.`
+            : undefined;
+        return { messages: [handoffMessage], warning };
+    }
+    const latestUserPrompt = selectMessagesForAcpPrompt(messages);
+    return {
+        messages: latestUserPrompt,
+        warning: latestUserPrompt.length > 0
+            ? "Fresh ACP session prompt history had no text/file history after filtering; replayed only the latest user message."
+            : undefined,
+    };
+}

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

@@ -0,0 +1,85 @@
+import type { UIMessage } from "ai";
+import { type AcpElicitationOptionListToolResult } from "./elicitation";
+import type { AcpProviderInstance, AcpRuntimeMetadata } from "./types";
+type AcpConnectionWithLifecycle = {
+    loadSession?: (request: Record<string, unknown>) => Promise<unknown>;
+    resumeSession?: (request: Record<string, unknown>) => Promise<unknown>;
+    closeSession?: (request: {
+        sessionId: string;
+    }) => Promise<unknown>;
+};
+type AcpClientWithHitl = {
+    setSessionUpdateHandler?: (handler: (notification: Record<string, unknown>) => void) => void;
+    setPermissionRequestHandler?: (handler: (request: Record<string, unknown>) => Promise<unknown>) => void;
+    unstable_createElicitation?: (request: Record<string, unknown>) => Promise<unknown>;
+};
+type AcpStreamController = {
+    enqueue: (part: unknown) => void;
+    close?: () => void;
+};
+type AcpClientToolAbort = {
+    controller: AcpStreamController;
+    resolve: () => void;
+};
+type AcpPendingElicitation = {
+    toolCallId: string;
+    request: Record<string, unknown>;
+    promptPromise: Promise<unknown>;
+    resolve: (response: unknown) => void;
+    reject: (error: unknown) => void;
+};
+type AcpDoStreamResult = {
+    stream: ReadableStream<unknown>;
+    warnings?: unknown;
+};
+type AcpLanguageModelWithInternals = {
+    __acpUiCompatInstalled?: boolean;
+    __acpUiElicitationSequence?: number;
+    __acpUiOriginalDoStream?: (options: unknown) => Promise<AcpDoStreamResult>;
+    __acpUiOriginalPromptWithLazyAuthRetry?: (request: unknown) => Promise<unknown>;
+    __acpUiPendingElicitation?: AcpPendingElicitation | null;
+    __acpUiPromptPromise?: Promise<unknown> | null;
+    __acpUiResumeElicitationResponse?: AcpElicitationOptionListToolResult | null;
+    __acpUiResumeResponse?: Record<string, unknown> | null;
+    agentProcess?: unknown;
+    cleanup?: () => void;
+    client?: AcpClientWithHitl | null;
+    clientToolAbort?: AcpClientToolAbort | null;
+    config?: {
+        existingSessionId?: string | null;
+        session?: {
+            cwd?: string;
+            mcpServers?: unknown[];
+            additionalDirectories?: string[];
+        };
+    };
+    connection?: AcpConnectionWithLifecycle | null;
+    forceCleanup?: () => void;
+    handleStreamNotification?: (controller: {
+        enqueue: (part: unknown) => void;
+    }, notification: Record<string, unknown>) => void;
+    currentTextId?: string | null;
+    currentThinkingId?: string | null;
+    doStream?: (options: unknown) => Promise<AcpDoStreamResult>;
+    promptWithLazyAuthRetry?: (request: unknown) => Promise<unknown>;
+    resetStreamState?: () => void;
+    sessionId?: string | null;
+    sessionResponse?: Record<string, unknown> | null;
+    startSession?: (...args: unknown[]) => Promise<unknown>;
+    connectClient?: (...args: unknown[]) => Promise<unknown>;
+};
+export declare function getAcpLanguageModelInternals(provider: AcpProviderInstance): AcpLanguageModelWithInternals | null;
+export declare function installAcpProviderCompatibility(provider: AcpProviderInstance, metadata: AcpRuntimeMetadata): void;
+export type AcpElicitationStageResult = {
+    status: "none";
+} | {
+    status: "staged";
+    toolCallId: string;
+} | {
+    status: "stale";
+    toolCallId: string;
+    reason: string;
+};
+export declare function stageAcpElicitationResultFromMessages(provider: AcpProviderInstance, messages: UIMessage[]): AcpElicitationStageResult;
+export declare function closeAcpProviderSession(provider: AcpProviderInstance, metadata?: AcpRuntimeMetadata | null): Promise<boolean>;
+export {};