@axhub/acp 0.1.2-beta.0 → 0.1.2-beta.2

package/README.md

@@ -19,7 +19,7 @@ npx -y @axhub/acp --port 32123
 npx -y @axhub/acp --cors-origin https://client.example.com
 ```
 
-`--cors-origin` configures the allowed browser Origin for `/api/*` routes. It also supports comma-separated origins and the aliases `--cors` and `--cor`.
+By default the CLI allows `/api/*` CORS requests from `http://localhost:53817` and `http://127.0.0.1:53817`. `--cors-origin` replaces that default with another allowed browser Origin list. It also supports comma-separated origins and the aliases `--cors` and `--cor`.
 
 ### External Integration
 
@@ -54,10 +54,10 @@ pnpm dev
 
 Open [http://localhost:32123](http://localhost:32123) with your browser to see the result.
 
-`npm run dev` uses the local source checkout and runs `next dev`. For a local host app on another origin, pass the same CORS option through npm:
+`npm run dev` uses the local source checkout and runs `next dev`. It allows the same default host-app origins on port `53817`. For a local host app on another origin, pass the CORS option through npm:
 
 ```bash
-npm run dev -- --cors-origin http://localhost:53817
+npm run dev -- --cors-origin http://localhost:3000
 ```
 
 For the common local host-app setup, use the host-aware development command. It binds the ACP UI dev server on `0.0.0.0`, allows the usual host app origins on port `53817`, and also lets Next.js dev assets/HMR accept those origins:
@@ -111,3 +111,9 @@ npm run refresh:default-capabilities -- --provider=codex
 
 Use `ACP_PROVIDER_COMMAND_OVERRIDES` or per-provider `ACP_<PROVIDER>_COMMAND`
 environment variables when refreshing defaults for a new or local provider.
+Provider startup recipes live in `lib/acp2aisdk/provider-registry.ts`; each
+entry can define `command`, `args`, and optional `fallbackCommands` without
+touching the shared session runtime. Cross-platform PATH/PATHEXT enrichment and
+Windows npm shim wrapping are centralized in `lib/acp2aisdk/provider-command.ts`,
+so new providers should only need a startup recipe unless they have protocol
+differences.

package/bin/acp.mjs

@@ -5,11 +5,11 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { DEFAULT_CORS_ORIGINS, DEFAULT_PORT } from "./defaults.mjs";
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 const launchCwd = process.cwd();
 const require = createRequire(import.meta.url);
-const DEFAULT_PORT = "32123";
 
 function printHelp() {
 	console.log(`Usage: acp [options]
@@ -19,7 +19,7 @@ Start the ACP Web UI.
 Options:
   -p, --port <port>              Port to listen on (default: ${DEFAULT_PORT})
   -H, --hostname <hostname>      Hostname to bind (default: 0.0.0.0)
-  --cors-origin <origin[,..]>    Allowed CORS Origin for /api/* routes
+  --cors-origin <origin[,..]>    Allowed CORS Origin for /api/* routes (default: ${DEFAULT_CORS_ORIGINS})
   --cors <origin[,..]>           Alias for --cors-origin
   --cor <origin[,..]>            Alias for --cors-origin
   -h, --help                     Show help
@@ -49,7 +49,7 @@ function parseArgs(args) {
 	const options = {
 		port: process.env.PORT || DEFAULT_PORT,
 		hostname: process.env.HOSTNAME || "0.0.0.0",
-		corsOrigins: process.env.ACP_UI_CORS_ORIGINS || "",
+		corsOrigins: process.env.ACP_UI_CORS_ORIGINS ?? DEFAULT_CORS_ORIGINS,
 	};
 
 	for (let index = 0; index < args.length; index += 1) {

package/bin/defaults.mjs

@@ -0,0 +1,3 @@
+export const DEFAULT_PORT = "32123";
+export const DEFAULT_CORS_ORIGINS =
+	"http://localhost:53817,http://127.0.0.1:53817";

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

@@ -0,0 +1,22 @@
+import type { AcpProviderCommand } from "./types";
+type ProviderCommandEnvInput = Record<string, string | undefined>;
+type ProviderCommandOptions = {
+    platform?: NodeJS.Platform;
+    execPath?: string;
+    env?: ProviderCommandEnvInput;
+};
+export declare function buildProviderCommandEnv(options?: ProviderCommandOptions): Record<string, string>;
+export declare function isProviderCommandAvailable(commandConfig: AcpProviderCommand, options?: NodeJS.Platform | ProviderCommandOptions): boolean;
+export declare function resolveProviderCommand(commandConfig: AcpProviderCommand, options?: NodeJS.Platform | ProviderCommandOptions): AcpProviderCommand;
+export declare function resolveProviderCommandCandidates({ command, args, fallbackCommands, platform, env, execPath, }: AcpProviderCommand & {
+    fallbackCommands?: AcpProviderCommand[];
+    platform?: NodeJS.Platform;
+    env?: ProviderCommandEnvInput;
+    execPath?: string;
+}): AcpProviderCommand[];
+export declare function formatProviderCommand(commandConfig: AcpProviderCommand): string;
+export declare function createProviderCommandNotFoundError(commandConfig: AcpProviderCommand): Error & {
+    code: string;
+};
+export declare function isProviderCommandStartupError(error: unknown): boolean;
+export {};

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

@@ -0,0 +1,268 @@
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, existsSync } from "node:fs";
+import path from "node:path";
+const WINDOWS_COMMAND_PROCESSOR = "cmd.exe";
+const POSIX_GUI_PATHS = [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+];
+const WINDOWS_NODE_PATHS = ["C:\\Program Files\\nodejs"];
+function normalizeProviderCommandOptions(options) {
+    var _a, _b, _c;
+    if (typeof options === "string") {
+        return {
+            platform: options,
+            execPath: process.execPath,
+            env: process.env,
+        };
+    }
+    return {
+        platform: (_a = options === null || options === void 0 ? void 0 : options.platform) !== null && _a !== void 0 ? _a : process.platform,
+        execPath: (_b = options === null || options === void 0 ? void 0 : options.execPath) !== null && _b !== void 0 ? _b : process.execPath,
+        env: (_c = options === null || options === void 0 ? void 0 : options.env) !== null && _c !== void 0 ? _c : process.env,
+    };
+}
+function getEnvValue(env, key) {
+    const direct = env[key];
+    if (typeof direct === "string" && direct.length > 0)
+        return direct;
+    const matchedKey = Object.keys(env).find((candidate) => candidate.toLowerCase() === key.toLowerCase());
+    if (!matchedKey)
+        return undefined;
+    const value = env[matchedKey];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function cloneDefinedEnv(env) {
+    const cloned = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === "string")
+            cloned[key] = value;
+    }
+    return cloned;
+}
+function appendUniquePathSegment(segments, nextSegment, platform) {
+    if (!nextSegment)
+        return;
+    const exists = segments.some((segment) => platform === "win32"
+        ? segment.toLowerCase() === nextSegment.toLowerCase()
+        : segment === nextSegment);
+    if (!exists)
+        segments.push(nextSegment);
+}
+function getWindowsPathExtList(env) {
+    const pathExt = getEnvValue(env, "PATHEXT") || ".COM;.EXE;.BAT;.CMD";
+    return pathExt
+        .split(";")
+        .map((extension) => extension.trim())
+        .filter(Boolean)
+        .map((extension) => extension.startsWith(".")
+        ? extension.toLowerCase()
+        : `.${extension.toLowerCase()}`);
+}
+export function buildProviderCommandEnv(options) {
+    const { platform, execPath, env: inputEnv, } = normalizeProviderCommandOptions(options);
+    const env = cloneDefinedEnv(inputEnv);
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    const delimiter = platform === "win32" ? ";" : ":";
+    const pathKey = platform === "win32" ? "Path" : "PATH";
+    const existingPath = getEnvValue(env, "PATH") || "";
+    const segments = existingPath.split(delimiter).filter(Boolean);
+    appendUniquePathSegment(segments, pathApi.dirname(execPath), platform);
+    if (platform === "win32") {
+        const appData = getEnvValue(env, "APPDATA");
+        if (appData) {
+            appendUniquePathSegment(segments, path.win32.join(appData, "npm"), platform);
+        }
+        for (const executablePath of WINDOWS_NODE_PATHS) {
+            appendUniquePathSegment(segments, executablePath, platform);
+        }
+        const pathExtSegments = getWindowsPathExtList(env);
+        for (const requiredExtension of [".com", ".exe", ".bat", ".cmd"]) {
+            if (!pathExtSegments.includes(requiredExtension)) {
+                pathExtSegments.push(requiredExtension);
+            }
+        }
+        env.PATHEXT = pathExtSegments
+            .map((extension) => extension.toUpperCase())
+            .join(";");
+        for (const key of Object.keys(env)) {
+            if (key.toLowerCase() === "path")
+                delete env[key];
+        }
+        const pathValue = segments.join(delimiter);
+        env[pathKey] = pathValue;
+        // acp-ai-provider merges config.env over process.env before spawning; set
+        // PATH too so a pre-existing uppercase key cannot shadow the enhanced Path.
+        env.PATH = pathValue;
+    }
+    else {
+        for (const executablePath of POSIX_GUI_PATHS) {
+            appendUniquePathSegment(segments, executablePath, platform);
+        }
+        delete env.Path;
+        env[pathKey] = segments.join(delimiter);
+    }
+    return env;
+}
+function hasPathSeparator(command) {
+    return /[\\/]/.test(command);
+}
+function canExecuteFile(filePath, platform) {
+    if (!existsSync(filePath))
+        return false;
+    if (platform === "win32")
+        return true;
+    try {
+        accessSync(filePath, constants.X_OK);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function resolveWindowsCommandPath(command, env) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return trimmed;
+    const hasCommandPathSeparator = hasPathSeparator(trimmed);
+    const extension = path.win32.extname(trimmed);
+    const pathExtensions = extension ? [""] : getWindowsPathExtList(env);
+    const candidateDirectories = hasCommandPathSeparator
+        ? [""]
+        : (getEnvValue(env, "PATH") || "")
+            .split(";")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    const baseCandidates = hasCommandPathSeparator
+        ? [trimmed]
+        : candidateDirectories.map((directory) => path.win32.join(directory, trimmed));
+    for (const baseCandidate of baseCandidates) {
+        for (const suffix of pathExtensions) {
+            const fullPath = suffix ? `${baseCandidate}${suffix}` : baseCandidate;
+            if (existsSync(fullPath))
+                return fullPath;
+        }
+    }
+    return trimmed;
+}
+export function isProviderCommandAvailable(commandConfig, options) {
+    const { platform, execPath, env: inputEnv, } = normalizeProviderCommandOptions(options);
+    const env = buildProviderCommandEnv({ platform, execPath, env: inputEnv });
+    const { command } = commandConfig;
+    if (platform === "win32") {
+        if (command.toLowerCase() === WINDOWS_COMMAND_PROCESSOR)
+            return true;
+        const resolvedCommand = resolveWindowsCommandPath(command, env);
+        if (canExecuteFile(resolvedCommand, platform))
+            return true;
+        if (hasPathSeparator(command))
+            return false;
+        try {
+            execFileSync("where.exe", [command], {
+                encoding: "utf8",
+                env: env,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    if (hasPathSeparator(command))
+        return canExecuteFile(command, platform);
+    try {
+        execFileSync("which", [command], {
+            encoding: "utf8",
+            env: env,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return true;
+    }
+    catch (_b) {
+        return false;
+    }
+}
+function shouldUseWindowsCommandProcessor(command, platform) {
+    if (platform !== "win32")
+        return false;
+    if (command.toLowerCase() === WINDOWS_COMMAND_PROCESSOR)
+        return false;
+    return /\.(cmd|bat)$/i.test(command) || !/\.(exe|com)$/i.test(command);
+}
+function quoteWindowsCommandLinePart(value) {
+    if (!value)
+        return '""';
+    if (!/[\s"&^|<>]/.test(value))
+        return value;
+    const escaped = value
+        .replace(/(\\*)"/g, '$1$1\\"')
+        .replace(/(\\+)$/g, "$1$1");
+    return `"${escaped}"`;
+}
+function buildWindowsCommandLine(command, args) {
+    return [command, ...args]
+        .map((part) => quoteWindowsCommandLinePart(String(part)))
+        .join(" ");
+}
+function resolveWindowsSpawnCommand(commandConfig, platform, env) {
+    var _a;
+    const command = platform === "win32"
+        ? resolveWindowsCommandPath(commandConfig.command, env)
+        : commandConfig.command;
+    if (!shouldUseWindowsCommandProcessor(command, platform)) {
+        if (command === commandConfig.command)
+            return commandConfig;
+        return {
+            command,
+            args: commandConfig.args,
+        };
+    }
+    if (command.toLowerCase() === WINDOWS_COMMAND_PROCESSOR) {
+        return commandConfig;
+    }
+    return {
+        command: WINDOWS_COMMAND_PROCESSOR,
+        args: [
+            "/d",
+            "/s",
+            "/c",
+            buildWindowsCommandLine(command, (_a = commandConfig.args) !== null && _a !== void 0 ? _a : []),
+        ],
+    };
+}
+export function resolveProviderCommand(commandConfig, options) {
+    const { platform, execPath, env: inputEnv, } = normalizeProviderCommandOptions(options);
+    const env = buildProviderCommandEnv({ platform, execPath, env: inputEnv });
+    return resolveWindowsSpawnCommand(commandConfig, platform, env);
+}
+export function resolveProviderCommandCandidates({ command, args, fallbackCommands, platform = process.platform, env, execPath, }) {
+    const candidates = [{ command, args }, ...(fallbackCommands !== null && fallbackCommands !== void 0 ? fallbackCommands : [])];
+    return candidates.map((candidate) => resolveProviderCommand(candidate, { platform, env, execPath }));
+}
+export function formatProviderCommand(commandConfig) {
+    var _a;
+    return [commandConfig.command, ...((_a = commandConfig.args) !== null && _a !== void 0 ? _a : [])]
+        .map((part) => (/\s/.test(part) ? JSON.stringify(part) : part))
+        .join(" ");
+}
+export function createProviderCommandNotFoundError(commandConfig) {
+    const error = new Error(`ACP provider command not found: ${formatProviderCommand(commandConfig)}`);
+    error.code = "ENOENT";
+    return error;
+}
+export function isProviderCommandStartupError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const code = error.code;
+    if (code === "ENOENT" || code === "EINVAL")
+        return true;
+    const message = error instanceof Error ? error.message : String(error.message);
+    return (/\bspawn\b.+\b(ENOENT|EINVAL)\b/i.test(message) ||
+        /\b(?:ACP\s+)?connection closed\b/i.test(message) ||
+        /(not recognized as an internal or external command|command not found)/i.test(message));
+}

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

@@ -34,8 +34,14 @@ export const ACP_PROVIDER_REGISTRY = {
     gemini: {
         provider: "gemini",
         label: "Gemini",
-        command: "npx",
-        args: ["-y", "@google/gemini-cli@^0.44.1", "--acp", "--skip-trust"],
+        command: "gemini",
+        args: ["--acp", "--skip-trust"],
+        fallbackCommands: [
+            {
+                command: "npx",
+                args: ["-y", "@google/gemini-cli@^0.44.1", "--acp", "--skip-trust"],
+            },
+        ],
         defaultModel: "gemini-3-pro-preview",
         defaultModeId: ACP_PROVIDER_DEFAULT_MODE_IDS.gemini,
         supportsImages: false,
@@ -91,6 +97,26 @@ function parseCommandLine(value) {
         args,
     };
 }
+function parseCommandObject(value) {
+    if (typeof value === "string") {
+        const commandLine = value.trim();
+        return commandLine ? parseCommandLine(commandLine) : null;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const command = typeof record.command === "string" && record.command.trim()
+        ? record.command.trim()
+        : null;
+    if (!command)
+        return null;
+    const args = Array.isArray(record.args)
+        ? record.args
+            .map((item) => String(item).trim())
+            .filter((item) => Boolean(item))
+        : undefined;
+    return { command, args };
+}
 function parseProviderOverrideObject(value) {
     if (typeof value === "string") {
         const commandLine = value.trim();
@@ -107,6 +133,11 @@ function parseProviderOverrideObject(value) {
             .map((item) => String(item).trim())
             .filter((item) => Boolean(item))
         : undefined;
+    const fallbackCommands = Array.isArray(record.fallbackCommands)
+        ? record.fallbackCommands
+            .map(parseCommandObject)
+            .filter((item) => Boolean(item))
+        : undefined;
     const sessionDelayMs = typeof record.sessionDelayMs === "number" &&
         Number.isFinite(record.sessionDelayMs) &&
         record.sessionDelayMs >= 0
@@ -117,6 +148,8 @@ function parseProviderOverrideObject(value) {
         override.command = command;
     if (args)
         override.args = args;
+    if (fallbackCommands)
+        override.fallbackCommands = fallbackCommands;
     if (typeof record.authMethodId === "string") {
         override.authMethodId = record.authMethodId.trim() || null;
     }

package/dist/lib/acp2aisdk/session-runtime.mjs

@@ -1,18 +1,19 @@
-import process from "node:process";
 import { getConversation } from "../conversations/store.mjs";
 import { getBuiltinToolRuntimeKey, mergeToolMcpServers, } from "../../tools/registry.mjs";
 import { buildAcpCapabilitySnapshot } from "./capabilities.mjs";
 import { applyAcpConfigOption, applyAcpThoughtLevel } from "./config-options.mjs";
 import { normalizeAdditionalDirectories, normalizeMcpServers, } from "./mcp-servers.mjs";
+import { buildProviderCommandEnv, createProviderCommandNotFoundError, formatProviderCommand, isProviderCommandAvailable, isProviderCommandStartupError, resolveProviderCommand, } from "./provider-command.mjs";
 import { installAcpProviderCompatibility } from "./provider-compat.mjs";
 import { getAcpProviderDefaultModeId, normalizeAcpProvider, resolveAcpProviderConfig, } from "./provider-registry.mjs";
 import { normalizePermissionMode } from "./runtime-options.mjs";
 import { createAcpSessionKey, createInitialMetadata, getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, } from "./session-store.mjs";
 import { createACPProvider, } from "./vendor/acp-ai-provider/index.mjs";
-function buildProviderSettings({ command, args, authMethodId, sessionDelayMs, persistSession, workspacePath, mcpServers, additionalDirectories, existingSessionId, }) {
+function buildProviderSettings({ command, args, env, authMethodId, sessionDelayMs, persistSession, workspacePath, mcpServers, additionalDirectories, existingSessionId, }) {
     const session = Object.assign({ cwd: workspacePath, mcpServers }, (additionalDirectories.length > 0 ? { additionalDirectories } : {}));
     return Object.assign(Object.assign(Object.assign(Object.assign({ command,
-        args, env: Object.assign({}, process.env), initialize: {
+        args,
+        env, initialize: {
             clientCapabilities: {
                 fs: {
                     readTextFile: false,
@@ -45,7 +46,7 @@ async function prepareSessionCapabilities(entry, tools) {
     }
 }
 export async function getOrCreateSession(request, tools) {
-    var _a, _b;
+    var _a, _b, _c;
     const store = getGlobalAcpSessionStore();
     store.cleanupIdle();
     const providerKey = normalizeAcpProvider(request.provider);
@@ -79,7 +80,11 @@ export async function getOrCreateSession(request, tools) {
     const resumableSessionId = (conversation === null || conversation === void 0 ? void 0 : conversation.provider) === providerKey
         ? ((_b = conversation.providerSessionId) !== null && _b !== void 0 ? _b : null)
         : null;
-    const createEntry = (existingSessionId, warnings = []) => {
+    const providerCommandEnv = buildProviderCommandEnv();
+    const createEntry = (commandConfig, existingSessionId, warnings = []) => {
+        const resolvedCommand = resolveProviderCommand(commandConfig, {
+            env: providerCommandEnv,
+        });
         const normalizedMcp = normalizeMcpServers(request.mcpServers);
         const mergedMcpServers = mergeToolMcpServers(normalizedMcp.servers, {
             workspacePath,
@@ -93,8 +98,9 @@ export async function getOrCreateSession(request, tools) {
             context: request.context,
         });
         const provider = createACPProvider(buildProviderSettings({
-            command: providerConfig.command,
-            args: providerConfig.args,
+            command: resolvedCommand.command,
+            args: resolvedCommand.args,
+            env: providerCommandEnv,
             authMethodId: providerConfig.authMethodId,
             sessionDelayMs: providerConfig.sessionDelayMs,
             persistSession: providerConfig.persistSession,
@@ -122,23 +128,55 @@ export async function getOrCreateSession(request, tools) {
             promptHistoryStrategy: existingSessionId ? "session" : "full",
         };
     };
-    const entry = createEntry(resumableSessionId);
-    store.set(sessionKey, entry);
+    const commandCandidates = [
+        { command: providerConfig.command, args: providerConfig.args },
+        ...((_c = providerConfig.fallbackCommands) !== null && _c !== void 0 ? _c : []),
+    ];
+    const prepareEntryWithCommandCandidates = async (existingSessionId, warnings = []) => {
+        const commandWarnings = [];
+        let lastStartupError = null;
+        for (const [index, commandConfig] of commandCandidates.entries()) {
+            const hasFallback = index < commandCandidates.length - 1;
+            const commandLabel = formatProviderCommand(commandConfig);
+            if (!isProviderCommandAvailable(commandConfig, {
+                env: providerCommandEnv,
+            })) {
+                const error = createProviderCommandNotFoundError(commandConfig);
+                lastStartupError = error;
+                if (!hasFallback)
+                    throw error;
+                commandWarnings.push(`ACP provider command unavailable (${commandLabel}); trying fallback.`);
+                continue;
+            }
+            const entry = createEntry(commandConfig, existingSessionId, [
+                ...warnings,
+                ...commandWarnings,
+            ]);
+            store.set(sessionKey, entry);
+            try {
+                await prepareSessionCapabilities(entry, tools);
+                return entry;
+            }
+            catch (error) {
+                store.cleanup(sessionKey);
+                lastStartupError = error;
+                if (!hasFallback || !isProviderCommandStartupError(error))
+                    throw error;
+                commandWarnings.push(`ACP provider command failed (${commandLabel}); trying fallback.`);
+            }
+        }
+        throw (lastStartupError !== null && lastStartupError !== void 0 ? lastStartupError : createProviderCommandNotFoundError(commandCandidates[0]));
+    };
     try {
-        await prepareSessionCapabilities(entry, tools);
-        return entry;
+        return await prepareEntryWithCommandCandidates(resumableSessionId);
     }
     catch (error) {
-        store.cleanup(sessionKey);
         if (!resumableSessionId)
             throw error;
     }
-    const fallbackEntry = createEntry(null, [
+    return prepareEntryWithCommandCandidates(null, [
         `Failed to resume ACP session "${resumableSessionId}"; started a new session with UI message history instead.`,
     ]);
-    store.set(sessionKey, fallbackEntry);
-    await prepareSessionCapabilities(fallbackEntry, tools);
-    return fallbackEntry;
 }
 export async function applyRequestedModelAndMode(entry) {
     const { model, modeId } = entry.metadata;

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

@@ -8,11 +8,14 @@ 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;
+export type AcpProviderCommand = {
     command: string;
     args?: string[];
+};
+export type AcpProviderRegistryEntry = AcpProviderCommand & {
+    provider: AcpProviderKey;
+    label: string;
+    fallbackCommands?: AcpProviderCommand[];
     authMethodId?: string | null;
     sessionDelayMs?: number | null;
     persistSession?: boolean;
@@ -20,7 +23,7 @@ export type AcpProviderRegistryEntry = {
     defaultModeId?: string | null;
     supportsImages: boolean;
 };
-export type AcpProviderOverride = Partial<Pick<AcpProviderRegistryEntry, "command" | "args" | "authMethodId" | "sessionDelayMs" | "persistSession" | "defaultModel" | "defaultModeId">>;
+export type AcpProviderOverride = Partial<Pick<AcpProviderRegistryEntry, "command" | "args" | "fallbackCommands" | "authMethodId" | "sessionDelayMs" | "persistSession" | "defaultModel" | "defaultModeId">>;
 export type AcpChatRequest = {
     id?: string;
     threadId?: string;

package/dist/public-api/server.d.ts

@@ -2,4 +2,4 @@ export { cancelAcpSession, cleanupAcpSession, getAcpSessionMetadata, listAcpSess
 export { buildAcpCapabilitySnapshot } from "../lib/acp2aisdk/capabilities";
 export { ACP_PROVIDER_ALIASES, ACP_PROVIDER_DEFAULT_MODE_IDS, ACP_PROVIDER_KEYS, ACP_PROVIDER_REGISTRY, getAcpProviderDefaultModeId, isAcpProviderKey, normalizeAcpProvider, readProviderOverridesFromEnv, resolveAcpProviderConfig, } from "../lib/acp2aisdk/provider-registry";
 export { createAcpSessionKey, createInitialMetadata, DEFAULT_PERMISSION_MODE, DEFAULT_THREAD_ID, getDefaultWorkspacePath, getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, SESSION_IDLE_TTL_MS, } from "../lib/acp2aisdk/session-store";
-export type { AcpCapability, AcpCapabilityOption, AcpCapabilitySnapshot, AcpChatRequest, AcpCleanupResult, AcpMcpServer, AcpPermissionMode, AcpProviderKey, AcpProviderRegistryEntry, AcpRunState, AcpRuntimeMetadata, AcpSessionLookupRequest, AcpStreamChatResult, } from "../lib/acp2aisdk/types";
+export type { AcpCapability, AcpCapabilityOption, AcpCapabilitySnapshot, AcpChatRequest, AcpCleanupResult, AcpMcpServer, AcpPermissionMode, AcpProviderCommand, AcpProviderKey, AcpProviderRegistryEntry, AcpRunState, AcpRuntimeMetadata, AcpSessionLookupRequest, AcpStreamChatResult, } from "../lib/acp2aisdk/types";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axhub/acp",
-	"version": "0.1.2-beta.0",
+	"version": "0.1.2-beta.2",
 	"private": false,
 	"engines": {
 		"node": ">=20.9.0"
@@ -44,7 +44,7 @@
 	],
 	"scripts": {
 		"dev": "node scripts/dev-server.mjs",
-		"dev:host": "node scripts/dev-server.mjs --hostname 0.0.0.0 --cors-origin http://localhost:53817,http://127.0.0.1:53817",
+		"dev:host": "node scripts/dev-server.mjs --hostname 0.0.0.0",
 		"build": "next build",
 		"build:public-api": "node scripts/build-public-api.mjs",
 		"build:sanitize": "node scripts/sanitize-next-build.mjs",