@pwrdrvr/agent-acp 0.16.0 → 0.17.0

package/dist/mcp-server-config.d.ts

@@ -0,0 +1,40 @@
+import { McpServer } from '@agentclientprotocol/sdk';
+
+/** ACP key/value entry used by stdio environments and HTTP headers. */
+type AcpMcpKeyValue = {
+    name: string;
+    value: string;
+};
+/** Host-friendly collection accepted wherever ACP requires key/value entries. */
+type AcpMcpKeyValueCollection = Readonly<Record<string, string>> | readonly AcpMcpKeyValue[];
+/** Backward-compatible stdio MCP configuration. ACP stdio has no `type` field. */
+type AcpStdioMcpServerConfig = {
+    name: string;
+    command: string;
+    args?: readonly string[];
+    env?: AcpMcpKeyValueCollection;
+};
+/** Streamable HTTP MCP configuration from the ACP v1 schema. */
+type AcpHttpMcpServerConfig = {
+    name: string;
+    type: "http";
+    url: string;
+    headers: AcpMcpKeyValueCollection;
+};
+/** Legacy HTTP+SSE MCP configuration from the ACP v1 schema. */
+type AcpSseMcpServerConfig = {
+    name: string;
+    type: "sse";
+    url: string;
+    headers: AcpMcpKeyValueCollection;
+};
+/** Public MCP input accepted by agent-acp session lifecycle methods. */
+type AcpMcpServerConfig = AcpStdioMcpServerConfig | AcpHttpMcpServerConfig | AcpSseMcpServerConfig;
+/** Exact MCP server wire union from the pinned ACP protocol library. */
+type AcpMcpServerWireConfig = McpServer;
+/** Serialize a host-friendly config into the exact ACP v1 wire representation. */
+declare function normalizeAcpMcpServerConfig(server: AcpMcpServerConfig): AcpMcpServerWireConfig;
+/** Serialize a per-session list without retaining mutable caller collections. */
+declare function normalizeAcpMcpServerConfigs(servers: readonly AcpMcpServerConfig[]): AcpMcpServerWireConfig[];
+
+export { type AcpHttpMcpServerConfig, type AcpMcpKeyValue, type AcpMcpKeyValueCollection, type AcpMcpServerConfig, type AcpMcpServerWireConfig, type AcpSseMcpServerConfig, type AcpStdioMcpServerConfig, normalizeAcpMcpServerConfig, normalizeAcpMcpServerConfigs };

package/dist/mcp-server-config.js

@@ -0,0 +1,9 @@
+import {
+  normalizeAcpMcpServerConfig,
+  normalizeAcpMcpServerConfigs
+} from "./chunk-64RRSPSB.js";
+export {
+  normalizeAcpMcpServerConfig,
+  normalizeAcpMcpServerConfigs
+};
+//# sourceMappingURL=mcp-server-config.js.map

package/dist/mcp-server-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/strategies.d.ts

@@ -0,0 +1,20 @@
+import { a as AcpAgentStrategy } from './strategy-types-C7yw6yQL.js';
+export { A as AcpAgentQuirks, b as AcpDiscoveryProbe, c as AcpSpawnSpec, L as LocalAcpAgentProbe, d as LocalAcpProbeOptions, e as LocalAcpProbeResult, f as buildAcpBackendId, g as defaultQuirks } from './strategy-types-C7yw6yQL.js';
+
+declare const geminiStrategy: AcpAgentStrategy;
+
+declare const grokStrategy: AcpAgentStrategy;
+
+declare const kimiStrategy: AcpAgentStrategy;
+
+declare const qwenStrategy: AcpAgentStrategy;
+
+declare const BUILT_IN_ACP_STRATEGIES: readonly AcpAgentStrategy[];
+/** Index a list of strategies by id (built-ins by default). */
+declare function buildStrategyTable(strategies?: readonly AcpAgentStrategy[]): Map<string, AcpAgentStrategy>;
+/** Look up a strategy by its registry id, falling back to the built-in table. */
+declare function strategyById(id: string, table?: Map<string, AcpAgentStrategy>): AcpAgentStrategy | undefined;
+/** Look up a strategy by its neutral backend id (`acp:<id>`). */
+declare function strategyByBackendId(backendId: string, strategies?: readonly AcpAgentStrategy[]): AcpAgentStrategy | undefined;
+
+export { AcpAgentStrategy, BUILT_IN_ACP_STRATEGIES, buildStrategyTable, geminiStrategy, grokStrategy, kimiStrategy, qwenStrategy, strategyByBackendId, strategyById };

package/dist/strategies.js

@@ -0,0 +1,25 @@
+import {
+  BUILT_IN_ACP_STRATEGIES,
+  buildAcpBackendId,
+  buildStrategyTable,
+  defaultQuirks,
+  geminiStrategy,
+  grokStrategy,
+  kimiStrategy,
+  qwenStrategy,
+  strategyByBackendId,
+  strategyById
+} from "./chunk-OFMIS7W6.js";
+export {
+  BUILT_IN_ACP_STRATEGIES,
+  buildAcpBackendId,
+  buildStrategyTable,
+  defaultQuirks,
+  geminiStrategy,
+  grokStrategy,
+  kimiStrategy,
+  qwenStrategy,
+  strategyByBackendId,
+  strategyById
+};
+//# sourceMappingURL=strategies.js.map

package/dist/strategies.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/strategy-types-C7yw6yQL.d.ts

@@ -0,0 +1,82 @@
+type LocalAcpProbeResult = {
+    stdout?: string | Buffer;
+    stderr?: string | Buffer;
+};
+type LocalAcpProbeOptions = {
+    /** Budget for this probe spawn. An injected probe should honor it so a slow
+     *  CLI is reported as "did not answer in time", not as "not installed". */
+    timeoutMs?: number | undefined;
+    /** Fires when discovery is abandoned mid-probe. */
+    signal?: AbortSignal | undefined;
+};
+type LocalAcpAgentProbe = (command: string, args: string[], options?: LocalAcpProbeOptions) => Promise<LocalAcpProbeResult>;
+/** How a strategy decides it is installed + ACP-capable on this machine. */
+type AcpDiscoveryProbe = {
+    /** Args that print a version (probed first; failure = not installed). */
+    versionArgs: string[];
+    /** Args probed to confirm ACP support. When `helpMatches` is set the OUTPUT
+     *  must match it; when omitted, a SUCCESSFUL probe (exit 0) is itself the
+     *  signal — for args that are an ACP subcommand whose mere existence proves
+     *  capability (e.g. `kimi acp --help`). */
+    helpArgs: string[];
+    /** Regex the help/usage output must match for the agent to count as
+     *  ACP-capable. OMIT to rely on the help probe's EXIT CODE instead — more
+     *  robust than parsing help prose, which drifts across CLI versions. */
+    helpMatches?: RegExp;
+    /** Bare command name tried first. */
+    command: string;
+    /** Additional candidate command paths (Homebrew prefixes, `~/.<agent>/bin`, …). */
+    fallbackCommands?: string[];
+};
+/** Launch invocation: how to spawn the CLI in ACP stdio server mode. */
+type AcpSpawnSpec = {
+    /** Command to run (resolved against the discovered candidate at spawn time). */
+    command: string;
+    /** Args that put the CLI into ACP stdio server mode (e.g. `["--acp"]`). */
+    args: string[];
+    /** Extra env to set when launching (e.g. Gemini workspace-trust). */
+    env?: Record<string, string>;
+    /** Extra args appended only when missing (e.g. Gemini `--skip-trust`). */
+    ensureArgs?: string[];
+};
+/**
+ * Normalization quirks the normalizer reads. NO agent-id literal ever appears
+ * in the normalizer — it reads these fields off the strategy it was constructed
+ * with. A synthetic strategy with different quirk values flows through the
+ * normalizer with zero normalizer changes (asserted in tests).
+ */
+type AcpAgentQuirks = {
+    /**
+     * Whether agent "thought"/reasoning chunks surface as assistant messages.
+     * Qwen sets this false (its thoughts are noisy scaffolding); others true.
+     */
+    surfaceThoughts: boolean;
+    /**
+     * Where the auto-generated thread title comes from:
+     *   • "topic-update"  — a `tool_call` titled `Update topic to: "…"` (Gemini/Kimi/Qwen);
+     *   • "session-summary" — a vendor `session_summary_generated` update (Grok);
+     *   • "both" — recognize either.
+     */
+    titleFrom: "topic-update" | "session-summary" | "both";
+    /** Vendor notification methods routed through the same session/update path. */
+    vendorNotificationMethods?: string[];
+};
+type AcpAgentStrategy = {
+    /** Strategy id, also the registry id (`gemini`, `grok`, `kimi`, `qwen`, …). */
+    id: string;
+    /** Neutral backend id (`acp:<id>`) used as the thread/session correlation key. */
+    backendId: string;
+    displayName: string;
+    authors: string[];
+    license?: string;
+    repositoryUrl?: string;
+    discoveryProbe: AcpDiscoveryProbe;
+    spawn: AcpSpawnSpec;
+    quirks: AcpAgentQuirks;
+};
+/** Build the neutral backend id for a registry id. */
+declare function buildAcpBackendId(registryId: string): string;
+/** Quirks for an unknown/synthetic strategy default to the common case. */
+declare function defaultQuirks(overrides?: Partial<AcpAgentQuirks>): AcpAgentQuirks;
+
+export { type AcpAgentQuirks as A, type LocalAcpAgentProbe as L, type AcpAgentStrategy as a, type AcpDiscoveryProbe as b, type AcpSpawnSpec as c, type LocalAcpProbeOptions as d, type LocalAcpProbeResult as e, buildAcpBackendId as f, defaultQuirks as g };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pwrdrvr/agent-acp",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "ACP (Agent Client Protocol) backend adapter for agent-kit: speaks ACP over stdio to local Kimi/Qwen/Gemini/Grok CLIs and normalizes their session/update stream into the agent-core neutral schema.",
   "license": "MIT",
   "author": "PwrDrvr LLC",
@@ -9,6 +9,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./strategies": {
+      "types": "./dist/strategies.d.ts",
+      "import": "./dist/strategies.js"
+    },
+    "./discovery": {
+      "types": "./dist/discovery.d.ts",
+      "import": "./dist/discovery.js"
+    },
+    "./mcp-server-config": {
+      "types": "./dist/mcp-server-config.d.ts",
+      "import": "./dist/mcp-server-config.js"
     }
   },
   "main": "./dist/index.js",
@@ -44,7 +56,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean --sourcemap",
+    "build": "tsup --entry.index src/index.ts --entry.strategies src/entries/strategies.ts --entry.discovery src/entries/discovery.ts --entry.mcp-server-config src/entries/mcp-server-config.ts --format esm --dts --clean --sourcemap",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "vitest run"
   }