@pwrdrvr/agent-acp 0.15.0 → 0.16.0

package/dist/index.d.ts

@@ -14,7 +14,16 @@ interface AcpJsonRpcTransport {
  *  drives. Injectable (via `createConnection`) so the adapter can be unit-tested
  *  without spawning a real agent. The library's `ClientSideConnection` satisfies
  *  this structurally (its methods take typed schema params; we pass records that
- *  match at runtime). */
+ *  match at runtime).
+ *
+ *  Every entry here MUST exist on the real `ClientSideConnection`. It is
+ *  attached with an `as unknown as` cast (see `createConnection`), so a name
+ *  that is merely plausible type-checks and then throws
+ *  "conn.<name> is not a function" at runtime, on the wire, against a user's
+ *  agent. `setSessionModel` was such an entry: ACP 1.3 has no `session/set_model`
+ *  at all, so every model selection died before it was sent. Anything the SDK
+ *  does not expose as a typed method belongs in `dispatch`'s default arm, which
+ *  sends it verbatim through `request()`. */
 interface AcpAgentConnection {
     initialize(params: Record<string, unknown>): Promise<unknown>;
     newSession(params: Record<string, unknown>): Promise<unknown>;
@@ -22,7 +31,6 @@ interface AcpAgentConnection {
     prompt(params: Record<string, unknown>): Promise<unknown>;
     cancel(params: Record<string, unknown>): Promise<void>;
     setSessionMode(params: Record<string, unknown>): Promise<unknown>;
-    setSessionModel(params: Record<string, unknown>): Promise<unknown>;
     authenticate(params: Record<string, unknown>): Promise<unknown>;
     request(method: string, params: Record<string, unknown>): Promise<unknown>;
     notify(method: string, params: Record<string, unknown>): Promise<void>;
@@ -301,7 +309,11 @@ type AcpPromptContentBlock = {
     mimeType: string;
     data: string;
 };
-type AcpRuntimeOptionSource = "mode" | "model" | "configOption";
+type AcpRuntimeOptionSource = "mode" | "model" | "configOption"
+/** A model write that travels as `session/set_config_option` because the
+ *  agent exposes model choice as a config option rather than via the legacy
+ *  top-level `models` capability. See `setModel`. */
+ | "modelConfigOption";
 type AcpAgentClientOptions = {
     /** The transport (real stdio or a fake). */
     transport: AcpJsonRpcTransport;
@@ -389,8 +401,9 @@ declare class AcpAgentClient implements AgentBackend {
      * Public `AgentBackend.startThread`: accepts NEUTRAL `AgentStartThreadOptions`
      * and maps them onto an ACP `session/new`. ACP supports:
      *   • `cwd` → `session/new.cwd`.
-     *   • `model` → applied via `session/set_model` after the session opens, when
-     *     the agent advertises model selection (best-effort; debug-logged if not).
+     *   • `model` → applied after the session opens, by whichever route the agent
+     *     advertises: the `model` config option, or legacy `session/set_model`
+     *     (best-effort; debug-logged if not). See `setModel`.
      *   • `instructions` is NOT injected here — ACP `session/new` has no base-
      *     instructions slot, matching the adapter's existing behavior. A host that
      *     wants system framing sends it as leading turn text.
@@ -480,6 +493,25 @@ declare class AcpAgentClient implements AgentBackend {
      *  releasing here never blocks resume. */
     archiveThread(threadId: string): Promise<void>;
     setMode(threadId: string, modeId: string): Promise<void>;
+    /** Apply a model selection by whichever route the agent actually advertises.
+     *
+     *  ACP 1.3 has NO `session/set_model` — it is absent from `AGENT_METHODS`.
+     *  An agent that offers model choice does it through a config option with
+     *  `category: "model"` (Kimi's `session/new` returns exactly that, and nothing
+     *  under `models`). Some agents still accept `session/set_model` as a vendor
+     *  extension, and the `models.availableModels` shape is still honoured for
+     *  them, but it is not what the protocol defines any more.
+     *
+     *  Two reasons to prefer the config option when the agent offers it. The READ
+     *  path already draws this distinction — `modelIdFromCapabilities` and
+     *  `modelsFromCapabilities` both fall back to the config option — and the two
+     *  disagreeing lets a host list models it cannot then select. And the config
+     *  option's REPLY carries the agent's full refreshed config set, where
+     *  `session/set_model` answers `{}` and refreshes only via an async
+     *  notification. On Kimi the model DETERMINES which thought levels exist —
+     *  `K2.7 Coding` offers only `on`, `K3` offers `low`/`high`/`max` — and
+     *  `applyReasoning` picks from `runtimeCapabilities` on the following
+     *  `startTurn`, so the refresh this write leaves behind is what it reads. */
     setModel(threadId: string, modelId: string): Promise<void>;
     setConfigOption(threadId: string, optionId: string, value: string): Promise<void>;
     close(): Promise<void>;

package/dist/index.js

@@ -144,8 +144,9 @@ var AcpConnection = class {
         return await conn.prompt(params);
       case "session/set_mode":
         return await conn.setSessionMode(params);
-      case "session/set_model":
-        return await conn.setSessionModel(params);
+      // `session/set_model` is deliberately NOT cased here: SDK 1.3 has no
+      // typed `setSessionModel`, so it goes out through the default arm's
+      // generic `request()` for agents still speaking the older method.
       case "session/cancel":
         await conn.cancel(params);
         return {};
@@ -1061,8 +1062,9 @@ var AcpAgentClient = class {
    * Public `AgentBackend.startThread`: accepts NEUTRAL `AgentStartThreadOptions`
    * and maps them onto an ACP `session/new`. ACP supports:
    *   • `cwd` → `session/new.cwd`.
-   *   • `model` → applied via `session/set_model` after the session opens, when
-   *     the agent advertises model selection (best-effort; debug-logged if not).
+   *   • `model` → applied after the session opens, by whichever route the agent
+   *     advertises: the `model` config option, or legacy `session/set_model`
+   *     (best-effort; debug-logged if not). See `setModel`.
    *   • `instructions` is NOT injected here — ACP `session/new` has no base-
    *     instructions slot, matching the adapter's existing behavior. A host that
    *     wants system framing sends it as leading turn text.
@@ -1440,7 +1442,32 @@ var AcpAgentClient = class {
   async setMode(threadId, modeId) {
     await this.setRuntimeOption(threadId, "mode", modeId, modeId);
   }
+  /** Apply a model selection by whichever route the agent actually advertises.
+   *
+   *  ACP 1.3 has NO `session/set_model` — it is absent from `AGENT_METHODS`.
+   *  An agent that offers model choice does it through a config option with
+   *  `category: "model"` (Kimi's `session/new` returns exactly that, and nothing
+   *  under `models`). Some agents still accept `session/set_model` as a vendor
+   *  extension, and the `models.availableModels` shape is still honoured for
+   *  them, but it is not what the protocol defines any more.
+   *
+   *  Two reasons to prefer the config option when the agent offers it. The READ
+   *  path already draws this distinction — `modelIdFromCapabilities` and
+   *  `modelsFromCapabilities` both fall back to the config option — and the two
+   *  disagreeing lets a host list models it cannot then select. And the config
+   *  option's REPLY carries the agent's full refreshed config set, where
+   *  `session/set_model` answers `{}` and refreshes only via an async
+   *  notification. On Kimi the model DETERMINES which thought levels exist —
+   *  `K2.7 Coding` offers only `on`, `K3` offers `low`/`high`/`max` — and
+   *  `applyReasoning` picks from `runtimeCapabilities` on the following
+   *  `startTurn`, so the refresh this write leaves behind is what it reads. */
   async setModel(threadId, modelId) {
+    const advertisesModelsCapability = (this.runtimeCapabilities?.models?.availableModels?.length ?? 0) > 0;
+    const option = modelConfigOption(this.runtimeCapabilities);
+    if (!advertisesModelsCapability && option !== void 0) {
+      await this.setRuntimeOption(threadId, "modelConfigOption", option.id, modelId);
+      return;
+    }
     await this.setRuntimeOption(threadId, "model", modelId, modelId);
   }
   async setConfigOption(threadId, optionId, value) {
@@ -1597,7 +1624,16 @@ var AcpAgentClient = class {
       value
     );
     const runtimeCapabilities = this.captureRuntimeCapabilities("session-load", result);
-    const requested = source === "configOption" ? { configValues: { [optionId]: value }, updatedAt: this.now() } : source === "mode" ? { currentModeId: value, updatedAt: this.now() } : { currentModelId: value, updatedAt: this.now() };
+    const requested = source === "configOption" ? { configValues: { [optionId]: value }, updatedAt: this.now() } : source === "mode" ? { currentModeId: value, updatedAt: this.now() } : source === "modelConfigOption" ? (
+      // Record BOTH: it IS the config option's value, and it IS the
+      // session's model. A consumer reading `currentModelId` must not
+      // have to know which route the agent happened to expose.
+      {
+        currentModelId: value,
+        configValues: { [optionId]: value },
+        updatedAt: this.now()
+      }
+    ) : { currentModelId: value, updatedAt: this.now() };
     session.runtimeState = mergeAcpRuntimeState(session.runtimeState, requested);
     const effectiveCapabilities = runtimeCapabilities ?? this.runtimeCapabilities;
     if (effectiveCapabilities) {
@@ -1610,7 +1646,7 @@ var AcpAgentClient = class {
     this.emitThreadSettings(session, effectiveCapabilities, session.runtimeState);
   }
   async setRuntimeOptionOnTransport(protocolSessionId, source, optionId, value) {
-    if (source === "configOption") {
+    if (source === "configOption" || source === "modelConfigOption") {
       return await this.transport.request("session/set_config_option", {
         sessionId: protocolSessionId,
         configId: optionId,