@band-ai/sdk 0.4.1 → 0.4.2

package/dist/{chunk-UFO6XMCV.js → chunk-KXLV645N.js}

@@ -5778,6 +5778,149 @@ function extractAssistantText3(event) {
   return blocks.map((block) => block.type === "text" ? block.text ?? "" : "").filter((text) => text.length > 0).join("\n");
 }
 
+// src/adapters/acp/sessionConfigReconciliation.ts
+var FAILURE_CODE_SESSION_CONFIG = "session_config";
+var MISSING_CONFIG_OPTIONS_REASON = "missing_config_options";
+var AcpSessionConfigTimeoutError = class extends Error {
+};
+var AcpSessionConfigError = class extends Error {
+  provider;
+  sessionId;
+  optionId;
+  selectedValue;
+  acpCode;
+  detail;
+  timedOut;
+  constructor(input) {
+    super(input.message, input.cause !== void 0 ? { cause: input.cause } : void 0);
+    this.name = "AcpSessionConfigError";
+    this.provider = input.provider;
+    this.sessionId = input.sessionId;
+    this.optionId = input.optionId;
+    this.selectedValue = input.selectedValue;
+    this.acpCode = input.acpCode;
+    this.detail = input.detail;
+    this.timedOut = input.timedOut ?? false;
+  }
+  toAgentFailure() {
+    return agentFailure(
+      this.provider,
+      this.message,
+      this.acpCode !== void 0 ? String(this.acpCode) : FAILURE_CODE_SESSION_CONFIG,
+      {
+        sessionId: this.sessionId,
+        optionId: this.optionId,
+        selectedValue: this.selectedValue,
+        detail: this.detail
+      }
+    );
+  }
+};
+async function applySessionConfigSelections(input) {
+  let catalog = input.catalog;
+  for (const { configId, value: selectedValue } of sessionConfigSelectionEntries(input.selections)) {
+    if (selectedValue === void 0) {
+      continue;
+    }
+    const option = catalog.find((entry) => entry?.id === configId);
+    if (!option || !isSessionConfigSelect(option)) {
+      throw new AcpSessionConfigError({
+        provider: input.provider,
+        sessionId: input.sessionId,
+        optionId: configId,
+        selectedValue,
+        message: `Session config option "${configId}" is not available after prior selections.`
+      });
+    }
+    if (selectedValue === option.currentValue) {
+      continue;
+    }
+    const availableValues = flattenConfigSelectOptions(option.options).map((entry) => entry.value);
+    if (!availableValues.includes(selectedValue)) {
+      throw new AcpSessionConfigError({
+        provider: input.provider,
+        sessionId: input.sessionId,
+        optionId: configId,
+        selectedValue,
+        message: `Session config value "${selectedValue}" is not advertised for option "${configId}".`,
+        detail: { availableValues }
+      });
+    }
+    const timeoutMessage = `setSessionConfigOption did not respond within ${input.timeoutMs}ms`;
+    try {
+      const response = await withTimeout(
+        input.setOption({ sessionId: input.sessionId, configId, value: selectedValue }),
+        input.timeoutMs,
+        () => new AcpSessionConfigTimeoutError(timeoutMessage)
+      );
+      if (!Array.isArray(response?.configOptions)) {
+        throw new AcpSessionConfigError({
+          provider: input.provider,
+          sessionId: input.sessionId,
+          optionId: configId,
+          selectedValue,
+          message: `Session config option "${configId}" response did not include a refreshed catalog.`,
+          detail: { reason: MISSING_CONFIG_OPTIONS_REASON }
+        });
+      }
+      catalog = response.configOptions;
+    } catch (error) {
+      if (error instanceof AcpSessionConfigError) {
+        throw error;
+      }
+      const acpError = asAcpJsonRpcError(error);
+      throw new AcpSessionConfigError({
+        provider: input.provider,
+        sessionId: input.sessionId,
+        optionId: configId,
+        selectedValue,
+        acpCode: acpError?.code,
+        detail: acpError?.data,
+        message: acpError?.message ?? asErrorMessage(error),
+        cause: error,
+        timedOut: error instanceof AcpSessionConfigTimeoutError
+      });
+    }
+  }
+  return { catalog };
+}
+function sessionConfigSelectionEntries(selections) {
+  if (isOrderedSessionConfigSelections(selections)) {
+    return selections;
+  }
+  return Object.keys(selections).map((configId) => ({ configId, value: selections[configId] }));
+}
+function isOrderedSessionConfigSelections(selections) {
+  return Array.isArray(selections);
+}
+function isSessionConfigSelect(option) {
+  return option?.type === "select";
+}
+function flattenConfigSelectOptions(options) {
+  if (!Array.isArray(options)) {
+    return [];
+  }
+  return options.flatMap((entry) => {
+    if (!asOptionalRecord(entry)) {
+      return [];
+    }
+    if ("group" in entry) {
+      return Array.isArray(entry.options) ? entry.options : [];
+    }
+    return [entry];
+  });
+}
+function isAcpErrorResponse(error) {
+  return typeof error === "object" && error !== null && typeof error.code === "number" && typeof error.message === "string";
+}
+function asAcpJsonRpcError(error) {
+  if (isAcpErrorResponse(error)) {
+    return error;
+  }
+  const nested = asOptionalRecord(error)?.error;
+  return isAcpErrorResponse(nested) ? nested : void 0;
+}
+
 // src/adapters/acp/ACPClientAdapter.ts
 import { spawn as spawn2 } from "child_process";
 import { createConnection } from "net";
@@ -6088,6 +6231,13 @@ var acpModule = new LazyAsyncValue({
 });
 
 // src/adapters/acp/ACPClientAdapter.ts
+function createConnectionRetirement() {
+  let reject = () => void 0;
+  const promise = new Promise((_resolve, rejectPromise) => {
+    reject = rejectPromise;
+  });
+  return { promise, reject };
+}
 var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 6e4;
 var DEFAULT_TURN_TIMEOUT_MS = 60 * 6e4;
 var SET_SESSION_CONFIG_TIMEOUT_MS = 1e4;
@@ -6145,6 +6295,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
   permissionTimeoutMs;
   turnTimeoutMs;
   logger;
+  customSection;
   backend = null;
   backendPromise = null;
   client = null;
@@ -6155,6 +6306,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
   started = false;
   systemPrompt = "";
   spawnPromise = null;
+  connectionRetirements = /* @__PURE__ */ new WeakMap();
   // Bumped by `stop()` and on every successful spawn install. Cleanup/timeout
   // and permission maps key by this plus session id so a stale generation
   // cannot alias a same-id session on a newer connection.
@@ -6181,6 +6333,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
     this.resolveSessionModel = options.resolveSessionModel;
     this.resolveSessionConfig = options.resolveSessionConfig;
     this.logger = resolveLogger(options.logger);
+    this.customSection = options.customSection;
     this.permissionTimeoutMs = options.permissionTimeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
     if ((this.resolvePermission || this.resolveSessionMode || this.resolveSessionModel || this.resolveSessionConfig) && (!Number.isFinite(this.permissionTimeoutMs) || this.permissionTimeoutMs <= 0)) {
       throw new ValidationError(`permissionTimeoutMs must be a positive finite number, got ${options.permissionTimeoutMs}`);
@@ -6212,7 +6365,8 @@ var ACPClientAdapter = class extends SimpleAdapter {
     this.systemPrompt = renderSystemPrompt({
       agentName,
       agentDescription,
-      includeBaseInstructions: false
+      includeBaseInstructions: false,
+      customSection: this.customSection
     });
     await this.ensureConnection();
   }
@@ -6245,13 +6399,17 @@ var ACPClientAdapter = class extends SimpleAdapter {
 
 ${messageWithContext}`;
       this.bootstrappedSessions.add(sessionKey);
-      const response = await withTimeout(connection.prompt({
-        sessionId,
-        prompt: [{
-          type: "text",
-          text: promptText
-        }]
-      }), this.turnTimeoutMs, () => new AcpTurnTimeoutError());
+      const response = await withTimeout(
+        this.raceAgainstConnectionRetirement(connection, connection.prompt({
+          sessionId,
+          prompt: [{
+            type: "text",
+            text: promptText
+          }]
+        })),
+        this.turnTimeoutMs,
+        () => new AcpTurnTimeoutError()
+      );
       await this.flushChunks({
         client,
         tools,
@@ -6292,12 +6450,17 @@ ${messageWithContext}`;
           }
         }
       }
-      const acpError = asAcpJsonRpcError(error);
+      const configError = error instanceof AcpSessionConfigError ? error : void 0;
+      const acpError = configError ? void 0 : asAcpJsonRpcError(error);
       await reportTurnFailure(
         tools,
-        isTimeout ? agentFailure(this.provider, "ACP turn timed out.", FAILURE_CODE_TIMEOUT) : acpError ? agentFailure(this.provider, acpError.message, String(acpError.code), acpError.data) : agentFailure(this.provider, asErrorMessage(error)),
+        isTimeout ? agentFailure(this.provider, "ACP turn timed out.", FAILURE_CODE_TIMEOUT) : configError ? configError.toAgentFailure() : acpError ? agentFailure(this.provider, acpError.message, String(acpError.code), acpError.data) : agentFailure(this.provider, asErrorMessage(error)),
         this.logger,
-        { roomId: context.roomId, sessionId }
+        {
+          roomId: context.roomId,
+          sessionId: configError?.sessionId ?? sessionId,
+          ...configError ? { optionId: configError.optionId, selectedValue: configError.selectedValue } : {}
+        }
       );
     }
   }
@@ -6316,17 +6479,12 @@ ${messageWithContext}`;
   // would risk blocking this room's turn lock forever on the very process
   // that just proved it can hang.
   async abandonTimedOutTurn(connection, sessionId, generation) {
-    const key = this.sessionKey(generation, sessionId);
-    this.activeSessions.delete(key);
-    this.abandonedSessions.add(key);
-    const owner = [...this.roomToSession.entries()].find(([, value]) => value.sessionId === sessionId && value.generation === generation);
-    if (owner) {
-      this.unlinkOwner(owner[0], owner[1]);
-    }
-    abandon(
-      () => connection.cancel({ sessionId }),
-      (error) => this.safeWarn("acp_client.cancel_failed", { sessionId, error: asErrorMessage(error) })
-    );
+    this.evictAbandonedSession(sessionId, generation, connection, () => {
+      const owner = [...this.roomToSession.entries()].find(([, value]) => value.sessionId === sessionId && value.generation === generation);
+      if (owner) {
+        this.unlinkOwner(owner[0], owner[1]);
+      }
+    });
   }
   // A per-room async mutex: `fn` for a given `roomId` never overlaps another
   // call for that same room, while different rooms stay fully concurrent.
@@ -6452,6 +6610,11 @@ ${messageWithContext}`;
     void connection.closed.then(() => reject(new Error("ACP connection closed while a session operation was still in flight")));
     return Promise.race([operation, closedRejection]);
   }
+  raceAgainstConnectionRetirement(connection, operation) {
+    const retirement = this.connectionRetirements.get(connection) ?? createConnectionRetirement();
+    this.connectionRetirements.set(connection, retirement);
+    return Promise.race([operation, retirement.promise]);
+  }
   unlinkRoom(roomId) {
     const owner = this.roomToSession.get(roomId);
     if (owner) {
@@ -6596,7 +6759,7 @@ ${messageWithContext}`;
         this.activeSessions.add(restoredKey);
         this.bootstrappedSessions.add(restoredKey);
         await this.configureSessionMode(roomId, existingSessionId, restored.modes, connection);
-        await this.configureSessionConfig(roomId, existingSessionId, restored.configOptions, connection);
+        await this.configureSessionConfig(roomId, existingSessionId, restored.configOptions, connection, connectionGeneration, client);
         if (!this.resolveSessionConfig) {
           await this.configureSessionModel(roomId, existingSessionId, restored.configOptions, connection);
         }
@@ -6610,13 +6773,13 @@ ${messageWithContext}`;
     this.linkOrAbandon(roomId, created.sessionId, generation, connectionGeneration, client);
     this.activeSessions.add(this.sessionKey(connectionGeneration, created.sessionId));
     await this.configureSessionMode(roomId, created.sessionId, created.modes, connection);
-    await this.configureSessionConfig(roomId, created.sessionId, created.configOptions, connection);
+    await this.configureSessionConfig(roomId, created.sessionId, created.configOptions, connection, connectionGeneration, client);
     if (!this.resolveSessionConfig) {
       await this.configureSessionModel(roomId, created.sessionId, created.configOptions, connection);
     }
     return created.sessionId;
   }
-  async configureSessionConfig(roomId, sessionId, configOptions, connection) {
+  async configureSessionConfig(roomId, sessionId, configOptions, connection, connectionGeneration, client) {
     if (!this.resolveSessionConfig || !Array.isArray(configOptions) || configOptions.length === 0) {
       return;
     }
@@ -6629,35 +6792,76 @@ ${messageWithContext}`;
     if (!selections) {
       return;
     }
-    for (const option of advertisedOptions) {
-      const selectedValue = selections[option.id];
-      if (selectedValue === void 0 || selectedValue === option.currentValue || !isSessionConfigSelect(option)) {
-        continue;
-      }
-      const availableValues = flattenConfigSelectOptions(option.options).map((entry) => entry.value);
-      if (!availableValues.includes(selectedValue)) {
-        this.safeWarn("resolveSessionConfig selected a value this session does not advertise", {
-          sessionId,
-          configId: option.id,
-          selectedValue,
-          availableValues
-        });
-        continue;
-      }
-      try {
-        await withTimeout(
-          connection.setSessionConfigOption({ sessionId, configId: option.id, value: selectedValue }),
-          SET_SESSION_CONFIG_TIMEOUT_MS,
-          `setSessionConfigOption did not respond within ${SET_SESSION_CONFIG_TIMEOUT_MS}ms`
-        );
-      } catch (error) {
-        this.safeWarn("failed to switch session config option", {
-          sessionId,
-          configId: option.id,
-          selectedValue,
-          error: String(error)
-        });
+    try {
+      await applySessionConfigSelections({
+        provider: this.provider,
+        sessionId,
+        catalog: advertisedOptions,
+        selections,
+        setOption: (params) => connection.setSessionConfigOption(params),
+        timeoutMs: SET_SESSION_CONFIG_TIMEOUT_MS
+      });
+    } catch (error) {
+      this.abandonFailedConfigSession(
+        roomId,
+        sessionId,
+        connectionGeneration,
+        client,
+        connection,
+        error instanceof AcpSessionConfigError && error.timedOut
+      );
+      throw error;
+    }
+  }
+  // A config failure mid-establish must not leave a half-applied session
+  // active for the room: the next turn needs a fresh `newSession` catalog.
+  abandonFailedConfigSession(roomId, sessionId, connectionGeneration, client, connection, retireConnection) {
+    const key = this.sessionKey(connectionGeneration, sessionId);
+    this.bootstrappedSessions.delete(key);
+    client.resetChunks(sessionId);
+    this.evictAbandonedSession(sessionId, connectionGeneration, connection, () => {
+      const owner = this.roomToSession.get(roomId);
+      if (owner && owner.sessionId === sessionId && owner.generation === connectionGeneration) {
+        this.unlinkOwner(roomId, owner);
       }
+    });
+    if (retireConnection) {
+      this.retireConnection(connection, connectionGeneration);
+    }
+  }
+  // Common half of timeout and config-failure abandon: mark the session
+  // unusable for restore, unlink ownership, and best-effort cancel.
+  evictAbandonedSession(sessionId, connectionGeneration, connection, unlink) {
+    const key = this.sessionKey(connectionGeneration, sessionId);
+    const wasActive = this.activeSessions.delete(key);
+    if (wasActive) {
+      this.abandonedSessions.add(key);
+    }
+    unlink();
+    abandon(
+      () => connection.cancel({ sessionId }),
+      (error) => this.safeWarn("acp_client.cancel_failed", { sessionId, error: asErrorMessage(error) })
+    );
+  }
+  // A timed-out config RPC means this transport has already failed to answer
+  // one request. Retire it so the next turn cannot wait forever on another.
+  retireConnection(connection, generation) {
+    if (this.connection !== connection || this.connectionGeneration !== generation) {
+      return;
+    }
+    const handle = this.connectionHandle;
+    this.connectionGeneration++;
+    this.connection = null;
+    this.connectionHandle = null;
+    this.connectionState = null;
+    this.client = null;
+    this.pruneConnectionGeneration(generation);
+    this.connectionRetirements.get(connection)?.reject(new Error("ACP connection retired after a config timeout"));
+    if (handle) {
+      abandon(
+        () => handle.stop(),
+        (error) => this.safeWarn("acp_client.handle_stop_after_config_timeout", { error: asErrorMessage(error) })
+      );
     }
   }
   // The single gate an establishment must pass before it's allowed to claim
@@ -7271,39 +7475,12 @@ async function createTcpConnection(client, endpoint, signal) {
   };
 }
 var MODEL_CONFIG_OPTION_KEY = "model";
-function isSessionConfigSelect(option) {
-  return option?.type === "select";
-}
 function isModelConfigOption(option) {
   return isSessionConfigSelect(option) && option.category === MODEL_CONFIG_OPTION_KEY;
 }
 function isModelConfigOptionById(option) {
   return isSessionConfigSelect(option) && option.id === MODEL_CONFIG_OPTION_KEY;
 }
-function flattenConfigSelectOptions(options) {
-  if (!Array.isArray(options)) {
-    return [];
-  }
-  return options.flatMap((entry) => {
-    if (!asOptionalRecord(entry)) {
-      return [];
-    }
-    if ("group" in entry) {
-      return Array.isArray(entry.options) ? entry.options : [];
-    }
-    return [entry];
-  });
-}
-function isAcpErrorResponse(error) {
-  return typeof error === "object" && error !== null && typeof error.code === "number" && typeof error.message === "string";
-}
-function asAcpJsonRpcError(error) {
-  if (isAcpErrorResponse(error)) {
-    return error;
-  }
-  const nested = asOptionalRecord(error)?.error;
-  return isAcpErrorResponse(nested) ? nested : void 0;
-}
 
 // src/adapters/acp/BandACPServerAdapter.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -8153,6 +8330,10 @@ export {
   HttpOpencodeClient,
   OpencodeAdapter,
   ClaudeSDKAdapter,
+  FAILURE_CODE_SESSION_CONFIG,
+  MISSING_CONFIG_OPTIONS_REASON,
+  AcpSessionConfigError,
+  applySessionConfigSelections,
   ACPClientAdapter,
   BandACPServerAdapter,
   ACPServer,