@axhub/acp 0.1.0

package/dist/tools/registry.mjs

@@ -0,0 +1,142 @@
+import { acpMcpServerKey } from "../lib/acp2aisdk/mcp-servers.mjs";
+import { imageGenerationBuiltinTool } from "./image-generation/registry.mjs";
+import { IMAGE_GENERATION_TOOL_ID } from "./image-generation/shared.mjs";
+import { userChoiceBuiltinTool } from "./user-choice/registry.mjs";
+const BUILTIN_TOOLS = [
+    imageGenerationBuiltinTool,
+    userChoiceBuiltinTool,
+];
+const BUILTIN_TOOL_COMPAT_SETTING_KEYS = {
+    [IMAGE_GENERATION_TOOL_ID]: ["imageGeneration"],
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function normalizeBuiltinToolIds(toolIds) {
+    if (!Array.isArray(toolIds))
+        return [];
+    const requested = new Set(toolIds);
+    return BUILTIN_TOOLS.map((tool) => tool.id).filter((toolId) => requested.has(toolId));
+}
+function hasToolSetting(settings, toolId) {
+    var _a;
+    if (toolId in settings)
+        return true;
+    return ((_a = BUILTIN_TOOL_COMPAT_SETTING_KEYS[toolId]) !== null && _a !== void 0 ? _a : []).some((key) => key in settings);
+}
+function getToolSetting(settings, toolId) {
+    var _a;
+    if (!isRecord(settings))
+        return undefined;
+    if (toolId in settings)
+        return settings[toolId];
+    for (const key of (_a = BUILTIN_TOOL_COMPAT_SETTING_KEYS[toolId]) !== null && _a !== void 0 ? _a : []) {
+        if (key in settings)
+            return settings[key];
+    }
+    return undefined;
+}
+export function getBuiltinToolRegistrations() {
+    return [...BUILTIN_TOOLS];
+}
+export function getBuiltinToolRuntimeKey(options) {
+    const builtinTools = normalizeBuiltinToolIds(options.toolIds).sort();
+    const settings = {};
+    for (const tool of BUILTIN_TOOLS) {
+        if (!builtinTools.includes(tool.id))
+            continue;
+        settings[tool.id] = tool.getRuntimeKey(getToolSetting(options.builtinToolSettings, tool.id));
+    }
+    return stableStringify({
+        builtinTools,
+        builtinToolSettings: settings,
+    });
+}
+export function sanitizePersistedBuiltinToolSettingsPatch(settings) {
+    if (!isRecord(settings))
+        return null;
+    const patch = {};
+    for (const tool of BUILTIN_TOOLS) {
+        if (!hasToolSetting(settings, tool.id))
+            continue;
+        const rawSettings = getToolSetting(settings, tool.id);
+        patch[tool.id] =
+            rawSettings === null ? null : tool.sanitizePersistedSettings(rawSettings);
+    }
+    return Object.keys(patch).length > 0 ? patch : null;
+}
+export function normalizePersistedBuiltinToolSettings(settings) {
+    if (!isRecord(settings))
+        return null;
+    const normalized = {};
+    for (const tool of BUILTIN_TOOLS) {
+        const rawSettings = getToolSetting(settings, tool.id);
+        if (rawSettings === undefined || rawSettings === null)
+            continue;
+        const sanitized = tool.sanitizePersistedSettings(rawSettings);
+        if (sanitized)
+            normalized[tool.id] = sanitized;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : null;
+}
+export function mergePersistedBuiltinToolSettings(current, patch) {
+    var _a;
+    if (patch === null)
+        return null;
+    const currentSettings = (_a = normalizePersistedBuiltinToolSettings(current)) !== null && _a !== void 0 ? _a : {};
+    if (!isRecord(patch)) {
+        return Object.keys(currentSettings).length > 0 ? currentSettings : null;
+    }
+    const merged = Object.assign({}, currentSettings);
+    for (const tool of BUILTIN_TOOLS) {
+        if (!hasToolSetting(patch, tool.id))
+            continue;
+        const rawPatch = getToolSetting(patch, tool.id);
+        if (rawPatch === null) {
+            delete merged[tool.id];
+            continue;
+        }
+        const nextSettings = tool.mergePersistedSettings(merged[tool.id], rawPatch);
+        if (nextSettings) {
+            merged[tool.id] = nextSettings;
+        }
+        else {
+            delete merged[tool.id];
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : null;
+}
+export function getBuiltinToolMcpServers(options = {}) {
+    const enabledToolIds = normalizeBuiltinToolIds(options.toolIds);
+    return BUILTIN_TOOLS.filter((tool) => enabledToolIds.includes(tool.id))
+        .map((tool) => tool.getMcpServer({
+        workspacePath: options.workspacePath,
+        threadId: options.threadId,
+        settings: getToolSetting(options.builtinToolSettings, tool.id),
+    }))
+        .filter((server) => Boolean(server));
+}
+export function mergeToolMcpServers(requestedServers, options = {}) {
+    const merged = new Map();
+    const builtinServers = getBuiltinToolMcpServers(options);
+    for (const server of builtinServers) {
+        merged.set(acpMcpServerKey(server), server);
+    }
+    for (const server of requestedServers) {
+        merged.set(acpMcpServerKey(server), server);
+    }
+    return [...merged.values()];
+}

package/dist/tools/ui-registry.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCallMessagePartProps } from "@assistant-ui/react";
+import type { ReactNode } from "react";
+export declare function renderRegisteredToolCallPart(part: ToolCallMessagePartProps): ReactNode | null;

package/dist/tools/ui-registry.mjs

@@ -0,0 +1,20 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ImageGenerationToolCard, isImageGenerationToolPart, } from "./image-generation/ui.mjs";
+import { isUserChoiceToolPart, UserChoiceToolCard } from "./user-choice/ui.mjs";
+const TOOL_UI_REGISTRY = [
+    {
+        id: "image-generation",
+        canRender: isImageGenerationToolPart,
+        render: (part) => _jsx(ImageGenerationToolCard, Object.assign({}, part)),
+    },
+    {
+        id: "user-choice",
+        canRender: isUserChoiceToolPart,
+        render: (part) => _jsx(UserChoiceToolCard, Object.assign({}, part)),
+    },
+];
+export function renderRegisteredToolCallPart(part) {
+    const registration = TOOL_UI_REGISTRY.find((tool) => tool.canRender(part));
+    return registration ? registration.render(part) : null;
+}

package/dist/tools/user-choice/client.d.ts

@@ -0,0 +1,10 @@
+import { type UserChoiceRuntimeSettings } from "./shared";
+export type UserChoiceToolSettings = Required<UserChoiceRuntimeSettings>;
+export declare const DEFAULT_USER_CHOICE_TOOL_SETTINGS: UserChoiceToolSettings;
+export declare function normalizeUserChoiceToolSettings(value: unknown): UserChoiceToolSettings;
+export declare const userChoiceClientTool: {
+    id: string;
+    defaultSettings: Required<UserChoiceRuntimeSettings>;
+    normalizeSettings: typeof normalizeUserChoiceToolSettings;
+    isEnabled(settings: unknown): boolean;
+};

package/dist/tools/user-choice/client.mjs

@@ -0,0 +1,18 @@
+import { normalizeUserChoiceRuntimeSettings, USER_CHOICE_DEFAULT_CUSTOM_INPUT_LABEL, USER_CHOICE_DEFAULT_TIMEOUT_MS, USER_CHOICE_TOOL_ID, } from "./shared.mjs";
+export const DEFAULT_USER_CHOICE_TOOL_SETTINGS = {
+    enabled: true,
+    waitTimeoutMs: USER_CHOICE_DEFAULT_TIMEOUT_MS,
+    allowCustomInput: true,
+    customInputLabel: USER_CHOICE_DEFAULT_CUSTOM_INPUT_LABEL,
+};
+export function normalizeUserChoiceToolSettings(value) {
+    return Object.assign(Object.assign({}, DEFAULT_USER_CHOICE_TOOL_SETTINGS), normalizeUserChoiceRuntimeSettings(value));
+}
+export const userChoiceClientTool = {
+    id: USER_CHOICE_TOOL_ID,
+    defaultSettings: DEFAULT_USER_CHOICE_TOOL_SETTINGS,
+    normalizeSettings: normalizeUserChoiceToolSettings,
+    isEnabled(settings) {
+        return normalizeUserChoiceToolSettings(settings).enabled;
+    },
+};

package/dist/tools/user-choice/registry.d.ts

@@ -0,0 +1,12 @@
+import type { AcpMcpServer } from "../../lib/acp2aisdk/types";
+export declare const userChoiceBuiltinTool: {
+    id: string;
+    getMcpServer(options: {
+        workspacePath?: string | null;
+        threadId?: string | null;
+        settings?: unknown;
+    }): AcpMcpServer | null;
+    getRuntimeKey(settings: unknown): unknown;
+    sanitizePersistedSettings(settings: unknown): unknown;
+    mergePersistedSettings(current: unknown, patch: unknown): unknown;
+};

package/dist/tools/user-choice/registry.mjs

@@ -0,0 +1,21 @@
+import { getUserChoiceMcpServer } from "./server.mjs";
+import { mergeUserChoiceRuntimeSettings, normalizeUserChoiceRuntimeSettings, sanitizePersistedUserChoiceSettings, USER_CHOICE_TOOL_ID, } from "./shared.mjs";
+export const userChoiceBuiltinTool = {
+    id: USER_CHOICE_TOOL_ID,
+    getMcpServer(options) {
+        return getUserChoiceMcpServer({
+            workspacePath: options.workspacePath,
+            threadId: options.threadId,
+            runtimeSettings: options.settings,
+        });
+    },
+    getRuntimeKey(settings) {
+        return normalizeUserChoiceRuntimeSettings(settings);
+    },
+    sanitizePersistedSettings(settings) {
+        return sanitizePersistedUserChoiceSettings(settings);
+    },
+    mergePersistedSettings(current, patch) {
+        return mergeUserChoiceRuntimeSettings(current, sanitizePersistedUserChoiceSettings(patch));
+    },
+};

package/dist/tools/user-choice/server.d.ts

@@ -0,0 +1,6 @@
+import type { AcpMcpServer } from "../../lib/acp2aisdk/types";
+export declare function getUserChoiceMcpServer(options?: {
+    workspacePath?: string | null;
+    threadId?: string | null;
+    runtimeSettings?: unknown;
+}): AcpMcpServer | null;

package/dist/tools/user-choice/server.mjs

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { normalizeUserChoiceRuntimeSettings, USER_CHOICE_MCP_NAME, USER_CHOICE_TOOL_ID, } from "./shared.mjs";
+export function getUserChoiceMcpServer(options = {}) {
+    const serverPath = path.join(process.cwd(), "tools/user-choice/mcp-server.mjs");
+    if (!fs.existsSync(serverPath))
+        return null;
+    const runtimeSettings = normalizeUserChoiceRuntimeSettings(options.runtimeSettings);
+    if (runtimeSettings.enabled === false)
+        return null;
+    return {
+        name: USER_CHOICE_MCP_NAME,
+        command: process.execPath,
+        args: [serverPath],
+        env: [
+            {
+                name: "ACP_UI_TOOL_ID",
+                value: USER_CHOICE_TOOL_ID,
+            },
+            ...(options.workspacePath
+                ? [
+                    {
+                        name: "ACP_UI_WORKSPACE_PATH",
+                        value: options.workspacePath,
+                    },
+                ]
+                : []),
+            ...(options.threadId
+                ? [
+                    {
+                        name: "ACP_UI_THREAD_ID",
+                        value: options.threadId,
+                    },
+                ]
+                : []),
+            {
+                name: "ACP_UI_USER_CHOICE_RUNTIME_SETTINGS",
+                value: JSON.stringify(runtimeSettings),
+            },
+        ],
+    };
+}

package/dist/tools/user-choice/shared.d.ts

@@ -0,0 +1,79 @@
+export declare const USER_CHOICE_TOOL_ID = "user-choice";
+export declare const USER_CHOICE_MCP_NAME = "acp-ui-user-choice";
+export declare const USER_CHOICE_TOOL_NAME = "ask_user_choice";
+export declare const USER_CHOICE_MCP_TOOL_TITLE = "Tool: acp-ui-user-choice/ask_user_choice";
+export declare const USER_CHOICE_DEFAULT_TIMEOUT_MS = 120000;
+export declare const USER_CHOICE_MAX_TIMEOUT_MS = 180000;
+export declare const USER_CHOICE_MIN_TIMEOUT_MS = 5000;
+export declare const USER_CHOICE_DEFAULT_CUSTOM_INPUT_LABEL = "\u81EA\u5B9A\u4E49";
+export declare const USER_CHOICE_RESULT_MESSAGE_PREFIX = "USER_CHOICE_RESULT";
+export type UserChoiceSelectionMode = "single" | "multi";
+export type UserChoiceOption = {
+    id: string;
+    label: string;
+    title?: string;
+    description?: string;
+    disabled?: boolean;
+    recommended?: boolean;
+};
+export type UserChoiceQuestion = {
+    fieldName: string;
+    fieldTitle: string;
+    title?: string;
+    fieldDescription?: string;
+    selectionMode: UserChoiceSelectionMode;
+    options: UserChoiceOption[];
+    defaultValue?: string | string[] | null;
+    minSelections?: number;
+    maxSelections?: number;
+    required?: boolean;
+    allowCustomInput?: boolean;
+    customInputLabel?: string;
+};
+export type UserChoiceInput = {
+    message?: string;
+    question?: UserChoiceQuestion;
+    questions?: UserChoiceQuestion[];
+    waitTimeoutMs?: number;
+    allowCustomInput?: boolean;
+    customInputLabel?: string;
+};
+export type UserChoiceRuntimeSettings = {
+    enabled?: boolean;
+    waitTimeoutMs?: number;
+    allowCustomInput?: boolean;
+    customInputLabel?: string;
+};
+export type UserChoiceToolResult = {
+    status: "answered";
+    requestId: string;
+    action: "accept";
+    content: Record<string, string | string[] | null>;
+} | {
+    status: "cancelled";
+    requestId: string;
+    action: "cancel";
+} | {
+    status: "user_no_response";
+    requestId: string;
+    instruction: string;
+};
+export type UserChoicePendingRequest = {
+    requestId: string;
+    workspacePath: string;
+    threadId: string | null;
+    toolCallId: string | null;
+    message: string;
+    questions: UserChoiceQuestion[];
+    waitTimeoutMs: number;
+    status: "pending" | "answered" | "cancelled" | "expired";
+    answer?: UserChoiceToolResult;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function normalizeUserChoiceRuntimeSettings(value: unknown): UserChoiceRuntimeSettings;
+export declare function sanitizePersistedUserChoiceSettings(value: unknown): UserChoiceRuntimeSettings | null;
+export declare function mergeUserChoiceRuntimeSettings(current: unknown, patch: unknown): UserChoiceRuntimeSettings;
+export declare function isUserChoiceResultMessageText(value: unknown): boolean;

package/dist/tools/user-choice/shared.mjs

@@ -0,0 +1,56 @@
+export const USER_CHOICE_TOOL_ID = "user-choice";
+export const USER_CHOICE_MCP_NAME = "acp-ui-user-choice";
+export const USER_CHOICE_TOOL_NAME = "ask_user_choice";
+export const USER_CHOICE_MCP_TOOL_TITLE = `Tool: ${USER_CHOICE_MCP_NAME}/${USER_CHOICE_TOOL_NAME}`;
+export const USER_CHOICE_DEFAULT_TIMEOUT_MS = 120000;
+export const USER_CHOICE_MAX_TIMEOUT_MS = 180000;
+export const USER_CHOICE_MIN_TIMEOUT_MS = 5000;
+export const USER_CHOICE_DEFAULT_CUSTOM_INPUT_LABEL = "自定义";
+export const USER_CHOICE_RESULT_MESSAGE_PREFIX = "USER_CHOICE_RESULT";
+export function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function clampTimeoutMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    const integer = Math.floor(value);
+    return Math.min(USER_CHOICE_MAX_TIMEOUT_MS, Math.max(USER_CHOICE_MIN_TIMEOUT_MS, integer));
+}
+export function normalizeUserChoiceRuntimeSettings(value) {
+    var _a, _b;
+    if (!isRecord(value)) {
+        return {
+            enabled: true,
+            waitTimeoutMs: USER_CHOICE_DEFAULT_TIMEOUT_MS,
+            allowCustomInput: true,
+            customInputLabel: USER_CHOICE_DEFAULT_CUSTOM_INPUT_LABEL,
+        };
+    }
+    return {
+        enabled: value.enabled !== false,
+        waitTimeoutMs: (_a = clampTimeoutMs(value.waitTimeoutMs)) !== null && _a !== void 0 ? _a : USER_CHOICE_DEFAULT_TIMEOUT_MS,
+        allowCustomInput: value.allowCustomInput !== false,
+        customInputLabel: (_b = readString(value.customInputLabel)) !== null && _b !== void 0 ? _b : USER_CHOICE_DEFAULT_CUSTOM_INPUT_LABEL,
+    };
+}
+export function sanitizePersistedUserChoiceSettings(value) {
+    if (!isRecord(value))
+        return null;
+    const settings = normalizeUserChoiceRuntimeSettings(value);
+    return {
+        enabled: settings.enabled,
+        waitTimeoutMs: settings.waitTimeoutMs,
+        allowCustomInput: settings.allowCustomInput,
+        customInputLabel: settings.customInputLabel,
+    };
+}
+export function mergeUserChoiceRuntimeSettings(current, patch) {
+    return normalizeUserChoiceRuntimeSettings(Object.assign(Object.assign({}, normalizeUserChoiceRuntimeSettings(current)), (isRecord(patch) ? patch : {})));
+}
+export function isUserChoiceResultMessageText(value) {
+    return (typeof value === "string" &&
+        value.trimStart().startsWith(USER_CHOICE_RESULT_MESSAGE_PREFIX));
+}

package/dist/tools/user-choice/store.d.ts

@@ -0,0 +1,19 @@
+import type { UserChoicePendingRequest, UserChoiceToolResult } from "./shared";
+export declare function createUserChoicePendingRequest(request: Omit<UserChoicePendingRequest, "createdAt" | "updatedAt" | "status">): Promise<UserChoicePendingRequest>;
+export declare function getUserChoicePendingRequest(workspacePath: string | null | undefined, requestId: string): Promise<UserChoicePendingRequest | null>;
+export declare function findUserChoicePendingRequest(options: {
+    workspacePath?: string | null;
+    threadId?: string | null;
+    toolCallId?: string | null;
+    statuses?: UserChoicePendingRequest["status"][];
+}): Promise<UserChoicePendingRequest | null>;
+export declare function answerUserChoicePendingRequest(options: {
+    workspacePath?: string | null;
+    requestId: string;
+    answer: UserChoiceToolResult;
+}): Promise<UserChoicePendingRequest | null>;
+export declare function expireUserChoicePendingRequest(options: {
+    workspacePath?: string | null;
+    requestId: string;
+    answer: UserChoiceToolResult;
+}): Promise<UserChoicePendingRequest | null>;

package/dist/tools/user-choice/store.mjs

@@ -0,0 +1,95 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeWorkspacePath } from "../../lib/acp2aisdk/session-store.mjs";
+const STORE_DIR = path.join(".axhub", "sessions", "user-choice");
+function safeSegment(value) {
+    return encodeURIComponent(value).replace(/%/g, "_");
+}
+function getStoreDir(workspacePath) {
+    return path.join(
+    /* turbopackIgnore: true */ normalizeWorkspacePath(workspacePath), STORE_DIR);
+}
+function getRequestPath(workspacePath, requestId) {
+    return path.join(getStoreDir(workspacePath), `${safeSegment(requestId)}.json`);
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+async function writeJsonFile(filePath, value) {
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.mkdir(/* turbopackIgnore: true */ path.dirname(filePath), {
+        recursive: true,
+    });
+    await fs.writeFile(
+    /* turbopackIgnore: true */ tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await fs.rename(
+    /* turbopackIgnore: true */ tempPath, 
+    /* turbopackIgnore: true */ filePath);
+}
+async function readRequestByPath(filePath) {
+    try {
+        const raw = await fs.readFile(/* turbopackIgnore: true */ filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed.requestId === "string" ? parsed : null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function createUserChoicePendingRequest(request) {
+    const timestamp = nowIso();
+    const pending = Object.assign(Object.assign({}, request), { status: "pending", createdAt: timestamp, updatedAt: timestamp });
+    await writeJsonFile(getRequestPath(request.workspacePath, request.requestId), pending);
+    return pending;
+}
+export async function getUserChoicePendingRequest(workspacePath, requestId) {
+    return readRequestByPath(getRequestPath(workspacePath, requestId));
+}
+export async function findUserChoicePendingRequest(options) {
+    var _a, _b;
+    const dir = getStoreDir(options.workspacePath);
+    let entries;
+    try {
+        entries = await fs.readdir(/* turbopackIgnore: true */ dir);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const matches = [];
+    const statuses = new Set((_a = options.statuses) !== null && _a !== void 0 ? _a : ["pending"]);
+    for (const entry of entries) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const request = await readRequestByPath(path.join(dir, entry));
+        if (!request)
+            continue;
+        if (!statuses.has(request.status))
+            continue;
+        if (options.threadId && request.threadId !== options.threadId)
+            continue;
+        if (options.toolCallId && request.toolCallId !== options.toolCallId)
+            continue;
+        matches.push(request);
+    }
+    return ((_b = matches.sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0]) !== null && _b !== void 0 ? _b : null);
+}
+export async function answerUserChoicePendingRequest(options) {
+    const filePath = getRequestPath(options.workspacePath, options.requestId);
+    const request = await readRequestByPath(filePath);
+    if (!request)
+        return null;
+    const next = Object.assign(Object.assign({}, request), { status: options.answer.status === "answered"
+            ? "answered"
+            : options.answer.status === "cancelled"
+                ? "cancelled"
+                : "expired", answer: options.answer, updatedAt: nowIso() });
+    await writeJsonFile(filePath, next);
+    return next;
+}
+export async function expireUserChoicePendingRequest(options) {
+    return answerUserChoicePendingRequest(options);
+}

package/dist/tools/user-choice/ui.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCallMessagePartProps } from "@assistant-ui/react";
+export declare function isUserChoiceToolPart(part: ToolCallMessagePartProps): boolean;
+export declare function UserChoiceToolCard(part: ToolCallMessagePartProps): import("react/jsx-runtime").JSX.Element;