@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/hitl.mjs

@@ -0,0 +1,134 @@
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizeString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map(normalizeString).filter(Boolean);
+}
+function normalizePermissionOptionIds(request) {
+    const options = Array.isArray(request.options) ? request.options : [];
+    return options
+        .map((option) => isRecord(option) ? normalizeString(option.optionId || option.id) : "")
+        .filter(Boolean);
+}
+export function selectPermissionOptionId(request, preferredOptionId = "allow_once") {
+    const optionIds = normalizePermissionOptionIds(request);
+    return (optionIds.find((id) => id === preferredOptionId) ||
+        optionIds.find((id) => id.includes(preferredOptionId)) ||
+        optionIds.find((id) => id.includes("allow_once")) ||
+        optionIds.find((id) => id.includes("allow")) ||
+        optionIds[0] ||
+        preferredOptionId);
+}
+export function createPermissionBypassResponse(request) {
+    return {
+        outcome: {
+            outcome: "selected",
+            optionId: selectPermissionOptionId(request),
+        },
+    };
+}
+export function createElicitationFallbackResponse(request) {
+    return {
+        action: request.mode === "url" ? "cancel" : "decline",
+        _meta: {
+            reason: "acp-ui-elicitations-require-explicit-ui",
+        },
+    };
+}
+function normalizeFieldType(schema) {
+    if (schema.type === "array")
+        return "array";
+    if (Array.isArray(schema.enum) || Array.isArray(schema.oneOf))
+        return "enum";
+    if (schema.type === "number")
+        return "number";
+    if (schema.type === "integer")
+        return "integer";
+    if (schema.type === "boolean")
+        return "boolean";
+    return "string";
+}
+function normalizeEnumOptions(schema) {
+    if (Array.isArray(schema.enum))
+        return normalizeStringArray(schema.enum);
+    const options = Array.isArray(schema.oneOf)
+        ? schema.oneOf
+        : Array.isArray(schema.anyOf)
+            ? schema.anyOf
+            : [];
+    return options
+        .map((option) => {
+        var _a, _b;
+        return isRecord(option)
+            ? normalizeString((_b = (_a = option.const) !== null && _a !== void 0 ? _a : option.value) !== null && _b !== void 0 ? _b : option.title)
+            : normalizeString(option);
+    })
+        .filter(Boolean);
+}
+function normalizeArrayOptions(schema) {
+    const items = isRecord(schema.items) ? schema.items : {};
+    const itemOptions = normalizeEnumOptions(items);
+    return itemOptions.length > 0 ? itemOptions : normalizeEnumOptions(schema);
+}
+export function normalizeElicitationFormSchema(request) {
+    const schema = isRecord(request.requestedSchema)
+        ? request.requestedSchema
+        : {};
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    const required = new Set(normalizeStringArray(schema.required));
+    return Object.entries(properties).flatMap(([name, value]) => {
+        if (!isRecord(value))
+            return [];
+        const fieldType = normalizeFieldType(value);
+        return [
+            {
+                name,
+                type: fieldType,
+                title: normalizeString(value.title) || name,
+                description: normalizeString(value.description),
+                required: required.has(name),
+                options: fieldType === "enum" || fieldType === "array"
+                    ? fieldType === "array"
+                        ? normalizeArrayOptions(value)
+                        : normalizeEnumOptions(value)
+                    : [],
+            },
+        ];
+    });
+}
+function coerceFieldValue(field, value) {
+    if (value === undefined || value === null || value === "") {
+        return field.required ? "" : undefined;
+    }
+    if (field.type === "boolean")
+        return Boolean(value);
+    if (field.type === "number") {
+        const numberValue = Number(value);
+        return Number.isFinite(numberValue) ? numberValue : undefined;
+    }
+    if (field.type === "integer") {
+        const numberValue = Number(value);
+        return Number.isInteger(numberValue) ? numberValue : undefined;
+    }
+    if (field.type === "array") {
+        return Array.isArray(value)
+            ? value.map(normalizeString).filter(Boolean)
+            : normalizeStringArray(String(value).split(","));
+    }
+    return String(value).trim();
+}
+export function coerceElicitationFormContent(request, rawContent) {
+    const fields = normalizeElicitationFormSchema(request);
+    const content = {};
+    for (const field of fields) {
+        const value = coerceFieldValue(field, rawContent[field.name]);
+        if (value !== undefined)
+            content[field.name] = value;
+    }
+    return content;
+}

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

@@ -0,0 +1,12 @@
+import type { AcpChatRequest, AcpRuntimeMetadata, AcpSessionLookupRequest, AcpStreamChatResult } from "./types";
+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 cleanupAcpSession(request: AcpSessionLookupRequest): Promise<{
+    cleaned: boolean;
+    metadata: AcpRuntimeMetadata | null;
+    remainingSessions: AcpRuntimeMetadata[];
+}>;
+export declare function streamAcpChat(request: AcpChatRequest, options?: {
+    abortSignal?: AbortSignal;
+}): Promise<AcpStreamChatResult>;

package/dist/lib/acp2aisdk/index.mjs

@@ -0,0 +1,182 @@
+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 { ACP_ELICITATION_OPTION_LIST_TOOL_NAME, ACP_ELICITATION_OPTION_LIST_TOOL_SCHEMA, } from "./elicitation.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 { applyRequestedModelAndMode, getOrCreateSession, getSessionKeyForLookup, updateMetadataFromProvider, } from "./session-runtime.mjs";
+import { getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, } from "./session-store.mjs";
+import { createAcpMessageMetadata } from "./stream-metadata.mjs";
+import { acpTools } from "./vendor/acp-ai-provider/index.mjs";
+const INTERNAL_FRONTEND_TOOLS = {
+    [ACP_ELICITATION_OPTION_LIST_TOOL_NAME]: {
+        description: "Collect a user's ACP elicitation choice from an option list.",
+        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);
+}
+export function getAcpSessionMetadata(request) {
+    var _a, _b;
+    const store = getGlobalAcpSessionStore();
+    store.cleanupIdle();
+    return (_b = (_a = store.get(getSessionKeyForLookup(request))) === null || _a === void 0 ? void 0 : _a.metadata) !== null && _b !== void 0 ? _b : null;
+}
+export function listAcpSessionMetadata() {
+    const store = getGlobalAcpSessionStore();
+    store.cleanupIdle();
+    return store.list();
+}
+export async function cleanupAcpSession(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) {
+        await closeAcpProviderSession(entry.provider, metadata);
+    }
+    const cleaned = store.cleanup(sessionKey);
+    void closeConversationSession(metadata);
+    return {
+        cleaned,
+        metadata,
+        remainingSessions: store.list(),
+    };
+}
+export async function streamAcpChat(request, options = {}) {
+    var _a, _b, _c;
+    await persistBuiltinToolSettingsPatch(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));
+    const entry = await getOrCreateSession(request, tools);
+    const store = getGlobalAcpSessionStore();
+    const elicitationStage = stageAcpElicitationResultFromMessages(entry.provider, request.messages);
+    entry.metadata.runState = "running";
+    await touchConversationFromRuntime(entry.metadata);
+    if (elicitationStage.status !== "staged") {
+        await applyRequestedModelAndMode(entry);
+    }
+    if (elicitationStage.status === "stale") {
+        entry.metadata.runState = "error";
+        entry.metadata.warnings.push(elicitationStage.reason);
+        updateMetadataFromProvider(entry);
+        void touchConversationFromRuntime(entry.metadata);
+        return {
+            response: createDirectMessageResponse(entry.metadata, "ACP 选项请求已经失效，无法继续这次选择。"),
+            metadata: entry.metadata,
+        };
+    }
+    const markAborted = () => {
+        entry.metadata.runState = "aborted";
+        updateMetadataFromProvider(entry);
+        void closeAcpProviderSession(entry.provider, entry.metadata).finally(() => {
+            store.cleanup(entry.metadata.sessionKey);
+        });
+    };
+    if ((_b = options.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) {
+        markAborted();
+    }
+    else {
+        (_c = options.abortSignal) === null || _c === void 0 ? void 0 : _c.addEventListener("abort", markAborted, { once: true });
+    }
+    const requestMessages = elicitationStage.status === "staged"
+        ? []
+        : wrapLatestUserMessageWithDynamicContext(request.messages, request.context);
+    const promptSelection = elicitationStage.status === "staged"
+        ? { messages: [] }
+        : entry.promptHistoryStrategy === "session"
+            ? { messages: selectMessagesForAcpPrompt(requestMessages) }
+            : selectMessagesForFreshAcpSessionPrompt(requestMessages);
+    const promptMessages = promptSelection.messages;
+    if (promptSelection.warning) {
+        entry.metadata.warnings.push(promptSelection.warning);
+    }
+    entry.promptHistoryStrategy = "session";
+    // The patched ACP model intercepts staged elicitation resumes before this
+    // placeholder can reach the provider, but AI SDK still requires a non-empty
+    // prompt shape to start the stream.
+    const modelMessages = elicitationStage.status === "staged"
+        ? [
+            {
+                role: "user",
+                content: "Continue after ACP elicitation.",
+            },
+        ]
+        : await convertToModelMessages(promptMessages);
+    const result = streamText({
+        includeRawChunks: true,
+        model: entry.provider.languageModel(entry.metadata.model || undefined, entry.metadata.modeId || undefined),
+        // ACP sessions keep their own history. Replaying assistant-ui history here
+        // flattens role prefixes like "Assistant:" into the next user prompt.
+        // On a brand-new ACP session there is no agent-side history yet, so use
+        // a bounded, tool-free slice of UI history as a fallback.
+        messages: modelMessages,
+        system: request.system,
+        tools,
+        abortSignal: options.abortSignal,
+    });
+    const response = result.toUIMessageStreamResponse({
+        headers: createRuntimeHeaders(entry.metadata),
+        consumeSseStream: consumeStream,
+        messageMetadata: ({ part }) => createAcpMessageMetadata(part, entry),
+        onFinish: ({ isAborted }) => {
+            var _a;
+            entry.metadata.runState = isAborted ? "aborted" : "completed";
+            updateMetadataFromProvider(entry);
+            void touchConversationFromRuntime(entry.metadata);
+            if (isAborted) {
+                void closeAcpProviderSession(entry.provider, entry.metadata).finally(() => {
+                    store.cleanup(entry.metadata.sessionKey);
+                });
+            }
+            else {
+                store.touch(entry.metadata.sessionKey);
+            }
+            (_a = options.abortSignal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", markAborted);
+        },
+        onError: (error) => {
+            var _a;
+            if (entry.metadata.runState !== "aborted") {
+                entry.metadata.runState = "error";
+            }
+            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 {
+        response,
+        metadata: updateMetadataFromProvider(entry),
+    };
+}

package/dist/lib/acp2aisdk/mcp-servers.d.ts

@@ -0,0 +1,17 @@
+import type { ContextBundleV2 } from "./context";
+import type { AcpMcpServer } from "./types";
+type NormalizedMcpServers = {
+    servers: AcpMcpServer[];
+    warnings: string[];
+};
+export declare function acpMcpServerKey(server: AcpMcpServer): string;
+export declare function normalizeMcpServers(value?: unknown): NormalizedMcpServers;
+export declare function normalizeAdditionalDirectories({ additionalDirectories, workspacePath, context, }: {
+    additionalDirectories?: unknown;
+    workspacePath: string;
+    context?: ContextBundleV2 | null;
+}): {
+    directories: string[];
+    warnings: string[];
+};
+export {};

package/dist/lib/acp2aisdk/mcp-servers.mjs

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizeString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const normalized = value
+        .map((item) => normalizeString(item))
+        .filter((item) => item.length > 0);
+    return normalized.length ? normalized : undefined;
+}
+function normalizeEnv(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const env = value
+        .map((item) => {
+        if (!isRecord(item))
+            return null;
+        const name = normalizeString(item.name);
+        const rawValue = normalizeString(item.value);
+        if (!name)
+            return null;
+        return { name, value: rawValue };
+    })
+        .filter((item) => Boolean(item));
+    return env.length ? env : undefined;
+}
+function normalizeMcpServer(value, index) {
+    if (!isRecord(value)) {
+        return {
+            server: null,
+            warning: `Skipped MCP server ${index}: not an object.`,
+        };
+    }
+    const type = normalizeString(value.type) || "stdio";
+    const name = normalizeString(value.name);
+    if (!name) {
+        return {
+            server: null,
+            warning: `Skipped MCP server ${index}: missing name.`,
+        };
+    }
+    if (type === "http" || type === "sse") {
+        const url = normalizeString(value.url);
+        if (!url) {
+            return {
+                server: null,
+                warning: `Skipped MCP server "${name}": missing ${type} url.`,
+            };
+        }
+        return { server: Object.assign(Object.assign({}, value), { type, name, url }) };
+    }
+    if (type === "acp") {
+        const id = normalizeString(value.id);
+        if (!id) {
+            return {
+                server: null,
+                warning: `Skipped MCP server "${name}": missing ACP id.`,
+            };
+        }
+        return { server: Object.assign(Object.assign({}, value), { type, name, id }) };
+    }
+    if (type && type !== "stdio") {
+        return {
+            server: null,
+            warning: `Skipped MCP server "${name}": unsupported transport "${type}".`,
+        };
+    }
+    const command = normalizeString(value.command);
+    if (!command) {
+        return {
+            server: null,
+            warning: `Skipped MCP server "${name}": missing stdio command.`,
+        };
+    }
+    return {
+        server: Object.assign(Object.assign(Object.assign(Object.assign({}, value), { name,
+            command }), (normalizeStringArray(value.args)
+            ? { args: normalizeStringArray(value.args) }
+            : {})), (normalizeEnv(value.env) ? { env: normalizeEnv(value.env) } : {})),
+    };
+}
+export function acpMcpServerKey(server) {
+    const record = server;
+    const type = normalizeString(record.type) || "stdio";
+    return `${type}:${normalizeString(record.name).toLowerCase()}`;
+}
+export function normalizeMcpServers(value) {
+    if (!Array.isArray(value))
+        return { servers: [], warnings: [] };
+    const warnings = [];
+    const servers = [];
+    const seen = new Set();
+    value.forEach((item, index) => {
+        const { server, warning } = normalizeMcpServer(item, index);
+        if (warning)
+            warnings.push(warning);
+        if (!server)
+            return;
+        const key = acpMcpServerKey(server);
+        if (seen.has(key)) {
+            warnings.push(`Skipped duplicate MCP server "${server.name}".`);
+            return;
+        }
+        seen.add(key);
+        servers.push(server);
+    });
+    return { servers, warnings };
+}
+function normalizeDirectory(value) {
+    const raw = normalizeString(value);
+    if (!raw)
+        return null;
+    const resolved = path.resolve(/* turbopackIgnore: true */ raw);
+    try {
+        return fs.statSync(/* turbopackIgnore: true */ resolved).isDirectory()
+            ? resolved
+            : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export function normalizeAdditionalDirectories({ additionalDirectories, workspacePath, context, }) {
+    const warnings = [];
+    const seen = new Set([workspacePath]);
+    const directories = [];
+    const candidates = Array.isArray(additionalDirectories)
+        ? additionalDirectories
+        : [];
+    for (const candidate of candidates) {
+        const directory = normalizeDirectory(candidate);
+        if (!directory) {
+            warnings.push(`Skipped additional directory "${String(candidate)}".`);
+            continue;
+        }
+        if (seen.has(directory))
+            continue;
+        seen.add(directory);
+        directories.push(directory);
+    }
+    if (context === null || context === void 0 ? void 0 : context.items.some((item) => item.kind === "file")) {
+        // Context file paths stay in the prompt for now. Mapping them to
+        // additionalDirectories changes provider filesystem scope, so keep it
+        // explicit until hosts opt into directory roots.
+    }
+    return { directories, warnings };
+}

package/dist/lib/acp2aisdk/model-selection.d.ts

@@ -0,0 +1,16 @@
+import type { AcpCapabilityOption, AcpProviderKey } from "./types";
+export type ComposerModelOption = Pick<AcpCapabilityOption, "value" | "label" | "description">;
+export declare function formatComposerModelOption(option: ComposerModelOption, provider?: AcpProviderKey | string | null): ComposerModelOption;
+export declare function chooseComposerModel({ provider, sessionPinnedModel, acpCurrentModel, selectedProviderModel, }?: {
+    provider?: AcpProviderKey | string | null;
+    sessionPinnedModel?: string | null;
+    acpCurrentModel?: string | null;
+    selectedProviderModel?: string | null;
+}): string;
+export declare function chooseComposerModelOptions({ provider, acpModelOptions, runtimeModelOptions, fallbackModelOptions, sessionPinnedModel, }?: {
+    provider?: AcpProviderKey | string | null;
+    acpModelOptions?: ComposerModelOption[];
+    runtimeModelOptions?: ComposerModelOption[];
+    fallbackModelOptions?: ComposerModelOption[];
+    sessionPinnedModel?: string | null;
+}): ComposerModelOption[];

package/dist/lib/acp2aisdk/model-selection.mjs

@@ -0,0 +1,65 @@
+const CODEX_REASONING_SUFFIXES = new Set(["low", "medium", "high", "xhigh"]);
+function normalizeProvider(provider) {
+    return String(provider !== null && provider !== void 0 ? provider : "")
+        .trim()
+        .toLowerCase();
+}
+function formatReasoningLabel(value) {
+    switch (value) {
+        case "low":
+            return "低";
+        case "medium":
+            return "中";
+        case "high":
+            return "高";
+        case "xhigh":
+            return "极高";
+        default:
+            return value;
+    }
+}
+export function formatComposerModelOption(option, provider) {
+    var _a, _b;
+    const normalizedProvider = normalizeProvider(provider);
+    const value = String((_a = option.value) !== null && _a !== void 0 ? _a : "").trim();
+    if (normalizedProvider !== "codex" || !value.includes("/"))
+        return option;
+    const [model, reasoning, ...rest] = value.split("/");
+    if (!model ||
+        !reasoning ||
+        rest.length ||
+        !CODEX_REASONING_SUFFIXES.has(reasoning)) {
+        return option;
+    }
+    const label = String((_b = option.label) !== null && _b !== void 0 ? _b : "").trim();
+    return Object.assign(Object.assign({}, option), { label: !label || label === value
+            ? `${model} / ${formatReasoningLabel(reasoning)}`
+            : label });
+}
+export function chooseComposerModel({ provider = "codex", sessionPinnedModel = "", acpCurrentModel = "", selectedProviderModel = "", } = {}) {
+    const normalizedProvider = normalizeProvider(provider);
+    const pinned = String(sessionPinnedModel !== null && sessionPinnedModel !== void 0 ? sessionPinnedModel : "").trim();
+    const current = String(acpCurrentModel !== null && acpCurrentModel !== void 0 ? acpCurrentModel : "").trim();
+    const selected = String(selectedProviderModel !== null && selectedProviderModel !== void 0 ? selectedProviderModel : "").trim();
+    if (normalizedProvider === "codex") {
+        return pinned || current || "";
+    }
+    return pinned || current || selected || "";
+}
+export function chooseComposerModelOptions({ provider = "codex", acpModelOptions = [], runtimeModelOptions = [], fallbackModelOptions = [], sessionPinnedModel = "", } = {}) {
+    const normalizedProvider = normalizeProvider(provider);
+    const baseOptions = acpModelOptions.length
+        ? acpModelOptions
+        : runtimeModelOptions.length
+            ? runtimeModelOptions
+            : normalizedProvider === "codex"
+                ? []
+                : fallbackModelOptions;
+    const pinned = String(sessionPinnedModel !== null && sessionPinnedModel !== void 0 ? sessionPinnedModel : "").trim();
+    if (normalizedProvider === "codex" && baseOptions.length === 0)
+        return [];
+    if (!pinned || baseOptions.some((option) => option.value === pinned)) {
+        return baseOptions.map((option) => formatComposerModelOption(option, provider));
+    }
+    return [{ value: pinned, label: pinned }, ...baseOptions].map((option) => formatComposerModelOption(option, provider));
+}

package/dist/lib/acp2aisdk/prompt-history.d.ts

@@ -0,0 +1,9 @@
+import { type ContextBundleV2 } from "./context";
+import type { AcpChatRequest } from "./types";
+export type AcpPromptHistorySelection = {
+    messages: AcpChatRequest["messages"];
+    warning?: string;
+};
+export declare function selectMessagesForAcpPrompt(messages: AcpChatRequest["messages"]): AcpChatRequest["messages"];
+export declare function wrapLatestUserMessageWithDynamicContext(messages: AcpChatRequest["messages"], context?: ContextBundleV2 | null): AcpChatRequest["messages"];
+export declare function selectMessagesForFreshAcpSessionPrompt(messages: AcpChatRequest["messages"]): AcpPromptHistorySelection;