@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/skill-command-cache.mjs

@@ -0,0 +1,122 @@
+"use client";
+import { safeLocalStorage } from "./capability-cache.mjs";
+const SKILL_COMMAND_CACHE_PREFIX = "skill-commands:v1";
+export const SKILL_COMMAND_CACHE_TTL_MS = 30 * 60 * 1000;
+function normalizeText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeProvider(provider) {
+    return normalizeText(provider).toLowerCase() || "unknown";
+}
+function normalizeWorkspacePath(workspacePath) {
+    return normalizeText(workspacePath);
+}
+function normalizeSlashName(value) {
+    const normalized = normalizeText(value).replace(/^\/+/, "");
+    return normalized ? `/${normalized}` : "";
+}
+function cloneJsonValue(value) {
+    if (value === undefined)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeCommand(command) {
+    if (!command || typeof command !== "object" || Array.isArray(command)) {
+        return null;
+    }
+    const record = command;
+    const name = normalizeSlashName(record.name);
+    if (!name)
+        return null;
+    const scope = normalizeText(record.scope);
+    const source = normalizeText(record.source) === "acp" ? "acp" : "skill";
+    const namespace = normalizeText(record.namespace) === "acp" || source === "acp"
+        ? "acp"
+        : "skill";
+    return Object.assign(Object.assign({ name, description: normalizeText(record.description) ||
+            (source === "acp" ? "ACP command" : "Codex 技能"), namespace,
+        source }, (source === "skill" && normalizeText(record.path)
+        ? { path: normalizeText(record.path) }
+        : {})), (source === "skill" &&
+        (scope === "project" || scope === "system" || scope === "user")
+        ? { scope }
+        : {}));
+}
+function normalizeCommands(value) {
+    const seen = new Set();
+    return (Array.isArray(value) ? value : [])
+        .map(normalizeCommand)
+        .filter((command) => {
+        if (!command)
+            return false;
+        const key = command.name.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function normalizeSkillCommandSnapshot(provider, workspacePath, snapshotOrCommands) {
+    if (Array.isArray(snapshotOrCommands)) {
+        return {
+            provider: normalizeProvider(provider),
+            workspacePath: normalizeWorkspacePath(workspacePath) || null,
+            updatedAt: new Date().toISOString(),
+            ttl: SKILL_COMMAND_CACHE_TTL_MS,
+            commands: normalizeCommands(snapshotOrCommands),
+        };
+    }
+    if (!snapshotOrCommands ||
+        typeof snapshotOrCommands !== "object" ||
+        Array.isArray(snapshotOrCommands)) {
+        return null;
+    }
+    const record = snapshotOrCommands;
+    return Object.assign(Object.assign({}, cloneJsonValue(record)), { provider: normalizeProvider(record.provider || provider), workspacePath: normalizeWorkspacePath(record.workspacePath) ||
+            normalizeWorkspacePath(workspacePath) ||
+            null, updatedAt: normalizeText(record.updatedAt) || new Date().toISOString(), ttl: Number.isFinite(Number(record.ttl)) && Number(record.ttl) > 0
+            ? Number(record.ttl)
+            : SKILL_COMMAND_CACHE_TTL_MS, commands: normalizeCommands(record.commands) });
+}
+export function getSkillCommandCacheKey(provider, workspacePath) {
+    const normalizedProvider = encodeURIComponent(normalizeProvider(provider));
+    const normalizedWorkspacePath = normalizeWorkspacePath(workspacePath);
+    return `${SKILL_COMMAND_CACHE_PREFIX}:${normalizedProvider}:${normalizedWorkspacePath
+        ? encodeURIComponent(normalizedWorkspacePath)
+        : "global"}`;
+}
+export function readSkillCommandCache(provider, workspacePath, storage = safeLocalStorage) {
+    const key = getSkillCommandCacheKey(provider, workspacePath);
+    const raw = storage.getItem(key);
+    if (!raw)
+        return null;
+    try {
+        return normalizeSkillCommandSnapshot(provider, workspacePath, JSON.parse(raw));
+    }
+    catch (_a) {
+        storage.removeItem(key);
+        return null;
+    }
+}
+export function persistSkillCommandCache(provider, workspacePath, commands, storage = safeLocalStorage) {
+    const normalized = normalizeSkillCommandSnapshot(provider, workspacePath, commands);
+    const key = getSkillCommandCacheKey(provider, workspacePath);
+    if (!normalized) {
+        storage.removeItem(key);
+        return null;
+    }
+    storage.setItem(key, JSON.stringify(normalized));
+    return normalized;
+}
+export function isSkillCommandCacheFresh(snapshot, now = Date.now()) {
+    if (!snapshot)
+        return false;
+    const updatedAtMs = Date.parse(snapshot.updatedAt || "");
+    if (!Number.isFinite(updatedAtMs))
+        return false;
+    const ttl = Number(snapshot.ttl || SKILL_COMMAND_CACHE_TTL_MS);
+    return Number.isFinite(ttl) && ttl > 0 && now - updatedAtMs < ttl;
+}
+export function shouldFetchSkillCommands(snapshot, { force = false, now = Date.now() } = {}) {
+    return force || !isSkillCommandCacheFresh(snapshot, now);
+}

package/dist/lib/acp2aisdk/stream-metadata.d.ts

@@ -0,0 +1,10 @@
+import type { AcpSessionEntry } from "./types";
+type RawStreamPart = {
+    type: string;
+    rawValue?: unknown;
+};
+type AcpMessageMetadata = {
+    custom: Record<string, unknown>;
+};
+export declare function createAcpMessageMetadata(part: RawStreamPart, entry?: AcpSessionEntry): AcpMessageMetadata | undefined;
+export {};

package/dist/lib/acp2aisdk/stream-metadata.mjs

@@ -0,0 +1,251 @@
+import { buildAcpCapabilitySnapshot } from "./capabilities.mjs";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizeString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function parseAcpRawStreamPart(rawValue) {
+    if (typeof rawValue !== "string")
+        return rawValue;
+    try {
+        return JSON.parse(rawValue);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function hashValue(value) {
+    var _a;
+    const text = (_a = JSON.stringify(value)) !== null && _a !== void 0 ? _a : "";
+    let hash = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        hash = (hash * 31 + text.charCodeAt(index)) | 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+function normalizeAvailableCommands(rawValue) {
+    const availableCommands = Array.isArray(rawValue) ? rawValue : [];
+    return availableCommands.flatMap((command) => {
+        if (!isRecord(command))
+            return [];
+        const name = normalizeString(command.name || command.command || command.id).replace(/^\/+/, "");
+        if (!name)
+            return [];
+        return [
+            {
+                name,
+                description: normalizeString(command.description),
+                input: command.input,
+                source: "acp",
+            },
+        ];
+    });
+}
+function mergeAvailableCommands(previous, next) {
+    const merged = new Map();
+    for (const command of previous)
+        merged.set(command.name, command);
+    for (const command of next)
+        merged.set(command.name, command);
+    return [...merged.values()];
+}
+function createLegacyPlanMetadata(entries) {
+    return {
+        custom: {
+            acpPlan: entries,
+            acpPlans: {
+                latestId: "legacy",
+                byId: {
+                    legacy: {
+                        id: "legacy",
+                        type: "items",
+                        entries,
+                        updatedAt: Date.now(),
+                    },
+                },
+            },
+        },
+    };
+}
+function createPlanUpdateMetadata(plan) {
+    const id = normalizeString(plan.id);
+    const type = normalizeString(plan.type) || "items";
+    if (!id)
+        return undefined;
+    return {
+        custom: Object.assign(Object.assign({}, (type === "items" && Array.isArray(plan.entries)
+            ? { acpPlan: plan.entries }
+            : {})), { acpPlans: {
+                latestId: id,
+                byId: {
+                    [id]: Object.assign(Object.assign({}, plan), { id,
+                        type, updatedAt: Date.now() }),
+                },
+                removed: {
+                    [id]: false,
+                },
+            } }),
+    };
+}
+function createPlanRemovedMetadata(id) {
+    return {
+        custom: {
+            acpPlans: {
+                removed: {
+                    [id]: true,
+                },
+                byId: {
+                    [id]: {
+                        id,
+                        type: "removed",
+                        removed: true,
+                        updatedAt: Date.now(),
+                    },
+                },
+            },
+        },
+    };
+}
+function createToolContentMetadata(data, kind) {
+    const toolCallId = normalizeString(data.toolCallId);
+    if (!toolCallId)
+        return undefined;
+    const keyBase = kind === "diff"
+        ? `${normalizeString(data.path)}:${hashValue(data)}`
+        : kind === "terminal"
+            ? `${normalizeString(data.terminalId) || "terminal"}:${hashValue(data)}`
+            : kind === "resource" || kind === "resource_link"
+                ? `${normalizeString(data.uri) || normalizeString(data.name) || kind}:${hashValue(data)}`
+                : hashValue(data);
+    const key = keyBase || hashValue(data);
+    const collection = kind === "diff"
+        ? "diffs"
+        : kind === "terminal"
+            ? "terminals"
+            : kind === "resource"
+                ? "resources"
+                : kind === "resource_link"
+                    ? "resourceLinks"
+                    : "unknown";
+    return {
+        custom: {
+            acpToolContent: {
+                byToolCallId: {
+                    [toolCallId]: {
+                        [collection]: {
+                            [key]: Object.assign(Object.assign({}, data), { type: kind, toolCallId, updatedAt: Date.now() }),
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+function createAvailableCommandsMetadata(commands) {
+    const byName = Object.fromEntries(commands.map((command) => [command.name, command]));
+    return {
+        custom: {
+            acpAvailableCommands: {
+                byName,
+                updatedAt: Date.now(),
+            },
+        },
+    };
+}
+function createSessionUpdateMetadata(data) {
+    return {
+        custom: {
+            acpSessionUpdate: {
+                [normalizeString(data.sessionUpdate) || "unknown"]: data,
+                updatedAt: Date.now(),
+            },
+        },
+    };
+}
+function updateRuntimeMetadata(entry, data) {
+    var _a;
+    if (!entry)
+        return;
+    const metadata = entry.metadata;
+    switch (data.sessionUpdate) {
+        case "available_commands_update": {
+            const nextCommands = normalizeAvailableCommands(data.availableCommands);
+            if (!metadata.capabilitySnapshot)
+                break;
+            metadata.capabilitySnapshot = Object.assign(Object.assign({}, metadata.capabilitySnapshot), { updatedAt: new Date().toISOString(), metadata: Object.assign(Object.assign({}, metadata.capabilitySnapshot.metadata), { availableCommands: mergeAvailableCommands(metadata.capabilitySnapshot.metadata.availableCommands, nextCommands) }) });
+            break;
+        }
+        case "session_info_update": {
+            const title = normalizeString(data.title);
+            if (title)
+                metadata.sessionTitle = title;
+            break;
+        }
+        case "config_option_update": {
+            const model = entry.provider.model;
+            if (!(model === null || model === void 0 ? void 0 : model.sessionResponse))
+                break;
+            metadata.capabilitySnapshot = buildAcpCapabilitySnapshot({
+                provider: metadata.provider,
+                sessionResponse: model.sessionResponse,
+            });
+            break;
+        }
+        case "usage_update": {
+            if (!metadata.capabilitySnapshot)
+                break;
+            metadata.capabilitySnapshot = Object.assign(Object.assign({}, metadata.capabilitySnapshot), { updatedAt: new Date().toISOString(), metadata: Object.assign(Object.assign({}, metadata.capabilitySnapshot.metadata), { tokenUsage: (_a = data.usage) !== null && _a !== void 0 ? _a : data }) });
+            break;
+        }
+    }
+}
+export function createAcpMessageMetadata(part, entry) {
+    if (part.type !== "raw")
+        return undefined;
+    const data = parseAcpRawStreamPart(part.rawValue);
+    if (!isRecord(data))
+        return undefined;
+    if (data.type === "plan" && Array.isArray(data.entries)) {
+        return createLegacyPlanMetadata(data.entries);
+    }
+    if (data.sessionUpdate === "plan_update" && isRecord(data.plan)) {
+        return createPlanUpdateMetadata(data.plan);
+    }
+    if (data.sessionUpdate === "plan_removed") {
+        const id = normalizeString(data.id);
+        return id ? createPlanRemovedMetadata(id) : undefined;
+    }
+    if (data.sessionUpdate === "available_commands_update") {
+        updateRuntimeMetadata(entry, data);
+        return createAvailableCommandsMetadata(normalizeAvailableCommands(data.availableCommands));
+    }
+    if (data.sessionUpdate === "config_option_update" ||
+        data.sessionUpdate === "session_info_update" ||
+        data.sessionUpdate === "usage_update") {
+        updateRuntimeMetadata(entry, data);
+        return createSessionUpdateMetadata(data);
+    }
+    if (data.type === "diff") {
+        return createToolContentMetadata(data, "diff");
+    }
+    if (data.type === "terminal") {
+        return createToolContentMetadata(data, "terminal");
+    }
+    if (data.type === "resource") {
+        return createToolContentMetadata(data, "resource");
+    }
+    if (data.type === "resource_link") {
+        return createToolContentMetadata(data, "resource_link");
+    }
+    if (normalizeString(data.toolCallId)) {
+        return createToolContentMetadata(data, "unknown");
+    }
+    return {
+        custom: {
+            acpRaw: {
+                [hashValue(data)]: data,
+            },
+        },
+    };
+}

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

@@ -0,0 +1,129 @@
+import type { JSONSchema7, UIMessage } from "ai";
+import type { ContextBundleV2 } from "./context";
+import type { ACPProviderSettings, createACPProvider, NewSessionResponse } from "./vendor/acp-ai-provider";
+export type AcpProviderKey = "claude" | "codex" | "gemini" | "opencode";
+export type AcpPermissionMode = "default" | "acceptEdits" | "bypassPermissions" | "plan";
+export type AcpMcpServer = ACPProviderSettings["session"]["mcpServers"][number];
+export type AcpBuiltinToolId = string;
+export type AcpBuiltinToolSettings = Record<string, unknown>;
+export type AcpProviderInstance = ReturnType<typeof createACPProvider>;
+export type AcpToolsInput = Parameters<AcpProviderInstance["initSession"]>[0];
+export type AcpProviderRegistryEntry = {
+    provider: AcpProviderKey;
+    label: string;
+    command: string;
+    args?: string[];
+    authMethodId?: string | null;
+    sessionDelayMs?: number | null;
+    persistSession?: boolean;
+    defaultModel?: string | null;
+    defaultModeId?: string | null;
+    supportsImages: boolean;
+    enabledInP0: boolean;
+};
+export type AcpProviderOverride = Partial<Pick<AcpProviderRegistryEntry, "command" | "args" | "authMethodId" | "sessionDelayMs" | "persistSession" | "defaultModel" | "defaultModeId">>;
+export type AcpChatRequest = {
+    id?: string;
+    threadId?: string;
+    provider?: string;
+    model?: string | null;
+    modeId?: string | null;
+    thoughtLevel?: string | null;
+    permissionMode?: AcpPermissionMode;
+    workspacePath?: string | null;
+    additionalDirectories?: string[];
+    mcpServers?: AcpMcpServer[];
+    builtinTools?: AcpBuiltinToolId[];
+    builtinToolSettings?: AcpBuiltinToolSettings | null;
+    context?: ContextBundleV2 | null;
+    messages: UIMessage[];
+    system?: string;
+    tools?: Record<string, {
+        description?: string;
+        parameters: JSONSchema7;
+    }>;
+};
+export type AcpSessionKeyParts = {
+    threadId: string;
+    provider: AcpProviderKey;
+    workspacePath: string;
+};
+export type AcpCapabilityOption = {
+    value: string;
+    label: string;
+    description?: string;
+    order: number;
+};
+export type AcpCapability = {
+    key: "model" | "mode" | "thought_level";
+    currentValue: string | null;
+    options: AcpCapabilityOption[];
+    configId?: string | null;
+    configKey?: string | null;
+    source: "session" | "config-option" | "fallback";
+};
+export type AcpAvailableCommand = {
+    name: string;
+    description: string;
+    input?: unknown;
+    source: "acp";
+};
+export type AcpCapabilitySnapshot = {
+    provider: AcpProviderKey;
+    sessionId: string | null;
+    updatedAt: string;
+    ttl?: number;
+    source?: string | null;
+    agentVersion?: string | null;
+    capabilities: Partial<Record<AcpCapability["key"], AcpCapability>>;
+    metadata: {
+        availableCommands: AcpAvailableCommand[];
+        agentCapabilities?: unknown;
+        sessionCapabilities?: unknown;
+        mcpCapabilities?: unknown;
+        planCapabilities?: unknown;
+        clientCapabilities?: unknown;
+        tokenUsage?: unknown;
+        rawSession?: NewSessionResponse | null;
+    };
+};
+export type AcpRunState = "queued" | "running" | "completed" | "aborted" | "error";
+export type AcpRuntimeMetadata = {
+    sessionKey: string;
+    threadId: string;
+    provider: AcpProviderKey;
+    workspacePath: string;
+    acpSessionId: string | null;
+    resumedAcpSessionId: string | null;
+    sessionTitle: string | null;
+    model: string | null;
+    modeId: string | null;
+    thoughtLevel: string | null;
+    permissionMode: AcpPermissionMode;
+    runState: AcpRunState;
+    coldStart: boolean;
+    warnings: string[];
+    lastUsedAt: number;
+    capabilitySnapshot: AcpCapabilitySnapshot | null;
+    builtinToolRuntimeKey?: string | null;
+};
+export type AcpSessionEntry = {
+    provider: AcpProviderInstance;
+    metadata: AcpRuntimeMetadata;
+    promptHistoryStrategy: "session" | "full";
+};
+export type AcpStreamChatResult = {
+    response: Response;
+    metadata: AcpRuntimeMetadata;
+};
+export type AcpSessionLookupRequest = {
+    id?: string | null;
+    threadId?: string | null;
+    provider?: string | null;
+    workspacePath?: string | null;
+};
+export type AcpCleanupResult = {
+    cleaned: boolean;
+    metadata: AcpRuntimeMetadata | null;
+    remainingSessions: AcpRuntimeMetadata[];
+};

package/dist/lib/acp2aisdk/vendor/acp-ai-provider/index.d.ts

@@ -0,0 +1,10 @@
+export type { ACPProviderSettings, ModelInfo, NewSessionResponse, ProviderAgentDynamicToolInput, SessionMode, SessionModelState, SessionModeState, } from "./package/types/mod";
+import * as runtime from "./package/index.mjs";
+export declare const ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME: "acp.acp_provider_agent_dynamic_tool";
+export declare const ACPLanguageModel: typeof runtime.ACPLanguageModel;
+export declare const ACPProvider: typeof runtime.ACPProvider;
+export declare const acpTools: typeof runtime.acpTools;
+export declare const createACPProvider: typeof runtime.createACPProvider;
+export declare const getExecuteByName: typeof runtime.getExecuteByName;
+export declare const hasRegisteredExecute: typeof runtime.hasRegisteredExecute;
+export declare const providerAgentDynamicToolSchema: import("zod").ZodType<runtime.ProviderAgentDynamicToolInput, unknown, import("zod/v4/core").$ZodTypeInternals<runtime.ProviderAgentDynamicToolInput, unknown>>;

package/dist/lib/acp2aisdk/vendor/acp-ai-provider/index.mjs

@@ -0,0 +1,10 @@
+import * as runtime from "./package/index.mjs";
+const typedRuntime = runtime;
+export const ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME = typedRuntime.ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME;
+export const ACPLanguageModel = typedRuntime.ACPLanguageModel;
+export const ACPProvider = typedRuntime.ACPProvider;
+export const acpTools = typedRuntime.acpTools;
+export const createACPProvider = typedRuntime.createACPProvider;
+export const getExecuteByName = typedRuntime.getExecuteByName;
+export const hasRegisteredExecute = typedRuntime.hasRegisteredExecute;
+export const providerAgentDynamicToolSchema = typedRuntime.providerAgentDynamicToolSchema;