@skaile/workspaces 5.7.0 → 5.9.0

package/dist/bridge/drivers/omp.js

@@ -1,14 +1,13 @@
 import { checkToolInputSchema } from '../../chunk-X5O56UO4.js';
-import { entrySurface } from '../../chunk-JLSCA5T5.js';
-import { scopeReconfigureModel } from '../../chunk-EINLFFP6.js';
-import { dispatchCapability } from '../../chunk-NARITJS2.js';
-import { stripRunnerPrivateEnv, classifyGenericErrorMessage } from '../../chunk-XBSQ4KMC.js';
+import { entrySurface } from '../../chunk-UO7WPLDY.js';
+import { dispatchCapability } from '../../chunk-2H73V6XR.js';
+import { ReconfigureLedger, stripRunnerPrivateEnv, classifyGenericErrorMessage } from '../../chunk-B4X2N7JQ.js';
 import { wrapAgentCommand, resolveAgentExec } from '../../chunk-YROR332M.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, registryDriverConfig, entryCredentialValue, providerCredentialEnvName } from '../../chunk-BTK7ECLH.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, TOOL_ALLOWLIST_UNSUPPORTED, registryDriverConfig, entryCredentialValue, providerCredentialEnvName } from '../../chunk-5NNNV76P.js';
 import '../../chunk-6E6PKKAD.js';
-import { withActivityLabelJsonSchema } from '../../chunk-DMLDYFDS.js';
+import { withActivityLabelJsonSchema } from '../../chunk-F4NJDSR7.js';
 import '../../chunk-ICSCSM5D.js';
-import '../../chunk-JMKB7IB4.js';
+import '../../chunk-UMVKJM4Q.js';
 import { AI_PROVIDER_SURFACES, registryEntries, isEntryEnabled, parseModelRef, normalizeEntryBaseUrl, resolveEntryBaseUrl } from '../../chunk-MJHSLODD.js';
 import '../../chunk-C3CAXQMA.js';
 import '../../chunk-BOFL7GIF.js';
@@ -520,119 +519,75 @@ var OmpDriver = class extends AgentDriver {
     return this.config.model;
   }
   /**
-   * What the running omp process was last told, by config snapshot: `model`,
-   * `thinking` and `effort` are the config values those settings came from (also
-   * the rollback targets when omp rejects a change), `level` the omp thinking
-   * level sent. Set at spawn, updated on each successful `set_*`.
+   * Owns the desired config, drift and ordering of live reconfigures. Its
+   * snapshot is what the running omp process was last told: the config values
+   * `model`, `modelRef`, `thinking` and `effort` came from (the rollback targets
+   * when omp refuses a change) and the omp thinking `level` sent. Set at spawn,
+   * updated on each successful `set_*`.
    */
-  ompApplied = {};
-  /** Serialises live reconfigure RPCs so concurrent patches never interleave. */
-  reconfigureChain = Promise.resolve();
+  reconfig;
   /**
-   * Apply `model` / `thinking` / `effort` to this driver and, when the process
-   * is up and idle, to the running omp session (`set_model` /
-   * `set_thinking_level`). The base contract is synchronous and void, so the
-   * RPCs are fire-and-forget: a rejected change is surfaced as an `error`
-   * agent event and the config rolls back, keeping {@link getModel} honest.
-   *
-   * A patch that arrives mid-turn or before `ready` is not lost: config is the
-   * source of truth, flushed before the next `prompt()` and read by the next
-   * spawn. A model `set_model` cannot express live (no `provider/` prefix) is
-   * rejected the same way as one omp refuses: an `error` event and a rollback,
-   * since the running process cannot switch to it. In registry mode the patch
-   * also replaces `modelRef`, so a respawn (crash, `resetSession()`) starts the
-   * reconfigured model; models.yml already lists every enabled provider.
+   * Apply `model` / `thinking` / `effort`: the {@link ReconfigureLedger} writes
+   * the desired config and, when the process is up and idle, pushes it through
+   * {@link applyLive} (`set_model` / `set_thinking_level`), answering from omp's
+   * reply. A patch that arrives mid-turn or before `ready` is not lost: config is
+   * the source of truth, flushed before the next `prompt()` and read by the next
+   * spawn. A refusal (omp's, or a model `set_model` cannot express live: no
+   * `provider/` prefix) rolls the config back and answers `rejected`. In registry
+   * mode the patch also replaces `modelRef`, so a respawn (crash, `resetSession()`)
+   * starts the reconfigured model; models.yml already lists every enabled provider.
    */
   reconfigure(patch) {
-    if (patch.model !== void 0) {
-      const scope = scopeReconfigureModel({
-        model: patch.model,
-        modelRef: this.config.modelRef,
-        registry: this.config.registry,
-        roles: this.config.roles
-      });
-      if (scope.ok) {
-        this.config.model = patch.model;
-        if (scope.modelRef !== void 0) this.config.modelRef = scope.modelRef;
-      } else {
-        this.log.warn("model change refused; keeping the current model", {
-          model: patch.model,
-          providerId: scope.providerId
-        });
-      }
-    }
-    if (patch.thinking !== void 0) this.config.thinking = patch.thinking;
-    if (patch.effort !== void 0) this.config.effort = patch.effort;
-    void this.syncReconfigure();
-  }
-  syncReconfigure() {
-    this.reconfigureChain = this.reconfigureChain.then(() => this.applyReconfigure());
-    return this.reconfigureChain;
-  }
-  /** Push config drift to the running process. Never rejects. */
-  async applyReconfigure() {
-    if (!this.proc || !this.ready || this.turnResolve) return;
-    const applied = this.ompApplied;
-    const model = this.config.model;
-    if (model !== void 0 && model !== applied.model) {
-      const target = splitOmpModel(model);
+    return this.reconfig.reconfigure(patch);
+  }
+  /** Push drifted model / thinking settings to the running process. Never rejects. */
+  async applyLive(delta, applied, { late }) {
+    if (delta.model !== void 0) {
+      const target = splitOmpModel(delta.model);
       if (!target) {
-        this.log.warn("model has no provider prefix; set_model cannot apply it live", { model });
-        this.emit("agent-event", {
-          type: "error",
-          error: `set_model cannot apply "${model}" live (no provider/ prefix); model unchanged`
+        const message = `set_model cannot apply "${delta.model}" live (no provider/ prefix); model unchanged`;
+        this.log.warn("model has no provider prefix; set_model cannot apply it live", {
+          model: delta.model
         });
-        this.rollbackModel(model);
-      } else if (await this.sendReconfigure({ type: "set_model", ...target })) {
-        applied.model = model;
-        applied.modelRef = this.config.modelRef;
-      } else {
-        this.rollbackModel(model);
+        if (!late) this.emit("agent-event", { type: "error", error: message });
+        return { rejected: message };
       }
+      const refusal = await this.sendReconfigure({ type: "set_model", ...target }, late);
+      if (refusal !== null) return { rejected: refusal };
+      applied.model = delta.model;
+      applied.modelRef = delta.modelRef ?? applied.modelRef;
     }
-    await this.applyThinking();
-  }
-  /**
-   * Restore the model the running process holds after a failed live switch —
-   * unless a newer patch already replaced `model` (it will be applied next).
-   */
-  rollbackModel(attempted) {
-    if (this.config.model !== attempted) return;
-    this.config.model = this.ompApplied.model;
-    this.config.modelRef = this.ompApplied.modelRef;
-  }
-  /** Push thinking/effort drift to the running process. Never rejects. */
-  async applyThinking() {
-    const applied = this.ompApplied;
-    const { thinking, effort } = this.config;
-    const level = ompThinkingLevel({ thinking, effort });
-    if (level !== void 0 && level !== applied.level) {
-      if (await this.sendReconfigure({ type: "set_thinking_level", level })) {
+    if (delta.thinking !== void 0 || delta.effort !== void 0) {
+      const level = ompThinkingLevel(this.config);
+      if (level !== void 0 && level !== applied.level) {
+        const refusal = await this.sendReconfigure({ type: "set_thinking_level", level }, late);
+        if (refusal !== null) return { rejected: refusal };
         applied.level = level;
-        applied.thinking = thinking;
-        applied.effort = effort;
-      } else if (this.config.thinking === thinking && this.config.effort === effort) {
-        this.config.thinking = applied.thinking;
-        this.config.effort = applied.effort;
       }
     }
+    return "applied";
   }
   /**
-   * Send one live-reconfigure request. A failed `response` is already emitted
-   * as an `error` event by {@link handleEvent}; a transport failure (timeout,
-   * process gone) is emitted here. Returns whether omp accepted it.
+   * Send one live-reconfigure request. A failed `response` is emitted as an
+   * `error` event by {@link handleEvent}, and a transport failure (timeout,
+   * process gone) here, unless `late`: a refusal of a patch already answered
+   * `ok` reaches the host as `reconfigure_rejected`, so it gets no `error`
+   * event as well. Returns `null` when omp accepted it, else why not.
    */
-  async sendReconfigure(msg) {
+  async sendReconfigure(msg, late) {
     try {
-      const resp = await this.request(msg);
-      if (resp.success) return true;
+      const resp = await this.request(msg, { quiet: late });
+      if (resp.success) return null;
       this.log.warn("omp rejected reconfigure", { type: msg.type, error: resp.error });
+      return typeof resp.error === "string" ? resp.error : `omp refused ${msg.type}`;
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
       this.log.warn("reconfigure request failed", { type: msg.type, error });
-      this.emit("agent-event", { type: "error", error: `${msg.type} failed: ${error}` });
+      if (!late) {
+        this.emit("agent-event", { type: "error", error: `${msg.type} failed: ${error}` });
+      }
+      return `${msg.type} failed: ${error}`;
     }
-    return false;
   }
   /**
    * @param config - Driver configuration. omp-relevant fields:
@@ -646,6 +601,14 @@ var OmpDriver = class extends AgentDriver {
   constructor(config) {
     super();
     this.config = config;
+    this.reconfig = new ReconfigureLedger({
+      config: () => this.config,
+      isLive: () => this.proc !== null && this.ready,
+      isIdle: () => !this.turnResolve,
+      applyLive: (delta, applied, context) => this.applyLive(delta, applied, context),
+      onLateRejection: (rollback) => this.emit("reconfigure-rollback", rollback),
+      log: this.log
+    });
   }
   async start() {
     if (this.startPromise) return this.startPromise;
@@ -682,13 +645,13 @@ var OmpDriver = class extends AgentDriver {
     if (modelArg) args.push("--model", modelArg);
     const thinkingLevel = ompThinkingLevel(this.config);
     if (thinkingLevel) args.push("--thinking", thinkingLevel);
-    this.ompApplied = {
+    this.reconfig.setSnapshot({
       model: this.config.model,
       modelRef: this.config.modelRef,
       thinking: this.config.thinking,
       effort: this.config.effort,
       level: thinkingLevel
-    };
+    });
     const toolArgs = buildOmpToolArgs(this.config.tools);
     if (toolArgs.length > 0) {
       this.log.info("applying tool restrictions", { args: toolArgs });
@@ -1065,7 +1028,7 @@ var OmpDriver = class extends AgentDriver {
     if (!pending || typeof answer !== "string") return false;
     if (requestId !== void 0 && requestId !== pending.id) return false;
     let index = question !== void 0 ? pending.questions.findIndex((q) => q.question === question) : -1;
-    if (index === -1) index = pending.answers.findIndex((a) => a === void 0);
+    if (index === -1) index = pending.answers.indexOf(void 0);
     if (index === -1) return false;
     pending.answers[index] = answer;
     if (pending.answers.some((a) => a === void 0)) return true;
@@ -1435,6 +1398,8 @@ var OmpDriver = class extends AgentDriver {
    * Turn settlement is shared with {@link prompt}.
    */
   promptInput(input) {
+    if (input.toolAllowlist !== void 0)
+      return Promise.reject(new Error(TOOL_ALLOWLIST_UNSUPPORTED));
     return this.enqueuePrompt(async () => this.runPrompt(await this.buildPromptPayload(input)));
   }
   /** Resolve attachments into the `message` + `images` fields of an omp `prompt` frame. */
@@ -1488,7 +1453,7 @@ ${input.text}` : input.text;
    */
   async runPrompt(payload) {
     await this.start();
-    await this.syncReconfigure();
+    await this.reconfig.flushBeforeTurn();
     const id = this.nextId();
     const turnPromise = new Promise((resolve, reject) => {
       this.turnResolve = resolve;
@@ -1600,6 +1565,7 @@ ${input.text}` : input.text;
     this.rl = null;
     this.proc = null;
     this.ready = false;
+    this.reconfig.setSnapshot(null);
     this.startPromise = null;
     this.stderrBuffer = [];
     this.unsubscribeToolsChanged?.();