@skaile/workspaces 4.17.0 → 4.19.0

package/dist/bridge/drivers/omp.js

@@ -1,7 +1,11 @@
-import { entrySurface } from '../../chunk-C3YE4REG.js';
+import { checkToolInputSchema } from '../../chunk-X5O56UO4.js';
+import { entrySurface } from '../../chunk-25BOOOSM.js';
+import { dispatchCapability } from '../../chunk-TOXPRXAK.js';
 import { stripRunnerPrivateEnv, classifyGenericErrorMessage } from '../../chunk-BGY4KTU6.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, registryDriverConfig, entryCredentialValue, providerCredentialEnvName } from '../../chunk-3VGQLF3N.js';
+import { wrapAgentCommand, resolveAgentExec } from '../../chunk-YROR332M.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, registryDriverConfig, entryCredentialValue, providerCredentialEnvName } from '../../chunk-RGB45PIL.js';
 import '../../chunk-6E6PKKAD.js';
+import { withActivityLabelJsonSchema } from '../../chunk-QQ3G5N7X.js';
 import '../../chunk-JMKB7IB4.js';
 import '../../chunk-DPLIN2RA.js';
 import { AI_PROVIDER_SURFACES, registryEntries, isEntryEnabled, parseModelRef, normalizeEntryBaseUrl, resolveEntryBaseUrl } from '../../chunk-GZZPKAV5.js';
@@ -365,6 +369,63 @@ function buildOmpToolArgs(tools) {
   if (effective.length === 0) return ["--no-tools"];
   return ["--tools", effective.join(",")];
 }
+var OMP_HOST_TOOL_NAME_MAX = 64;
+function buildOmpHostTools(tools) {
+  const taken = new Set(OMP_BUILTIN_TOOLS);
+  const out = { definitions: [], capabilityNames: /* @__PURE__ */ new Map(), dropped: [] };
+  for (const tool of tools) {
+    const parameters = { ...withActivityLabelJsonSchema(tool.parameters), type: "object" };
+    const reason = checkToolInputSchema(parameters);
+    if (reason) {
+      out.dropped.push({ tool: tool.name, reason });
+      continue;
+    }
+    const base = tool.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, OMP_HOST_TOOL_NAME_MAX) || "capability";
+    let name = base;
+    for (let n = 2; taken.has(name); n++) {
+      const suffix = `_${n}`;
+      name = `${base.slice(0, OMP_HOST_TOOL_NAME_MAX - suffix.length)}${suffix}`;
+    }
+    taken.add(name);
+    out.capabilityNames.set(name, tool.name);
+    out.definitions.push({
+      name,
+      label: tool.name,
+      description: tool.description,
+      parameters,
+      loadMode: "essential"
+    });
+  }
+  return out;
+}
+var OMP_THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "auto"
+];
+var OMP_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+function ompThinkingLevel(cfg) {
+  const level = (() => {
+    if (cfg.thinking === "disabled") return "off";
+    if (cfg.effort) return cfg.effort;
+    if (cfg.thinking === "enabled") return "medium";
+    if (cfg.thinking === "adaptive") return "auto";
+    return void 0;
+  })();
+  return level !== void 0 && OMP_THINKING_LEVELS.includes(level) ? level : void 0;
+}
+function splitOmpModel(model) {
+  const slash = model.indexOf("/");
+  if (slash > 0 && slash < model.length - 1) {
+    return { provider: model.slice(0, slash), modelId: model.slice(slash + 1) };
+  }
+  return void 0;
+}
 var OmpDriver = class extends AgentDriver {
   driverInfo = {
     id: "omp",
@@ -383,19 +444,169 @@ var OmpDriver = class extends AgentDriver {
   prevText = "";
   /** OMP session ID captured via `get_state` after each turn. */
   _ompSessionId;
+  /**
+   * Usage of the most recent turn, summed over every model call in it (a tool
+   * loop is one prompt but many assistant messages). Cleared when a turn
+   * starts, like claude-sdk, so it never mixes two turns.
+   */
+  _lastTokens = null;
+  /**
+   * Prompt size of the most recent model call: the real context fill, which
+   * `_lastTokens` (turn-cumulative) overstates on a tool loop. omp's own
+   * `get_state.contextUsage.tokens` replaces it once that reply lands.
+   */
+  _lastContextTokens = null;
+  /** Context window of the active model, from `get_state.contextUsage`. */
+  _contextWindow = null;
+  getTokenUsage() {
+    return this._lastTokens;
+  }
+  getContextTokens() {
+    return this._lastContextTokens;
+  }
+  getContextWindow() {
+    return this._contextWindow;
+  }
   /** Per-turn settlement handlers; non-null only while a prompt is in flight. */
   turnResolve = null;
   turnReject = null;
+  /** omp host tool name → capability name for the last `set_host_tools` sent. */
+  hostToolCapabilities = /* @__PURE__ */ new Map();
+  /** In-flight `host_tool_call`s by omp request id; aborted by `host_tool_cancel`. */
+  hostToolCalls = /* @__PURE__ */ new Map();
+  /** Requests awaiting a `response`, by request id; failed when the process goes away. */
+  pendingRequests = /* @__PURE__ */ new Map();
+  /** Unsubscribes the capability registry listener; set while a process runs. */
+  unsubscribeToolsChanged = null;
+  /** Request ids whose failed `response` is logged by the caller, not surfaced as an error event. */
+  quietRequestIds = /* @__PURE__ */ new Set();
+  /** Capability tools already warned about, so a re-send logs each once. */
+  warnedDroppedHostTools = /* @__PURE__ */ new Set();
+  /** The `ask` (or `select` fallback) omp is parked on, until answered, cancelled or the process ends. */
+  pendingQuestion = null;
+  /**
+   * Tail of the FIFO of prompts: each `prompt()`/`promptInput()` runs only after
+   * the previous one settled, so one turn at a time is ever in flight (omp runs
+   * a single agent loop). Never rejects.
+   */
+  promptTail = Promise.resolve();
   get runtimeSessionId() {
     return this._ompSessionId;
   }
+  /** Slash commands from omp's last `available_commands_update`. */
+  cachedCommands = [];
+  getSlashCommands() {
+    return this.cachedCommands;
+  }
   getModel() {
     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_*`.
+   */
+  ompApplied = {};
+  /** Serialises live reconfigure RPCs so concurrent patches never interleave. */
+  reconfigureChain = Promise.resolve();
+  /**
+   * 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.
+   */
+  reconfigure(patch) {
+    if (patch.model !== void 0) {
+      this.config.model = patch.model;
+      if (this.config.modelRef !== void 0) this.config.modelRef = patch.model;
+    }
+    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);
+      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`
+        });
+        this.rollbackModel(model);
+      } else if (await this.sendReconfigure({ type: "set_model", ...target })) {
+        applied.model = model;
+        applied.modelRef = this.config.modelRef;
+      } else {
+        this.rollbackModel(model);
+      }
+    }
+    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 })) {
+        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;
+      }
+    }
+  }
+  /**
+   * 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.
+   */
+  async sendReconfigure(msg) {
+    try {
+      const resp = await this.request(msg);
+      if (resp.success) return true;
+      this.log.warn("omp rejected reconfigure", { type: msg.type, error: resp.error });
+    } 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}` });
+    }
+    return false;
+  }
   /**
    * @param config - Driver configuration. omp-relevant fields:
    *   - `cwd` — working directory; omp session files are stored under `<cwd>/.omp/sessions/`.
-   *   - `model` / `provider` — forwarded as `--model [provider/]model`.
+   *   - `model` — forwarded as `--model <selector>`. In registry mode `modelRef` takes precedence at spawn; `reconfigure({ model })` keeps both in step.
    *   - `systemPrompt` — written to `<cwd>/.omp/system.md` and appended via `--append-system-prompt`.
    *   - `agentDir` — sets `PI_CODING_AGENT_DIR`; omp reads agent identity from this directory.
    *   - `sshKeyPath` — injected as `GIT_SSH_COMMAND` for authenticated git operations.
@@ -406,13 +617,13 @@ var OmpDriver = class extends AgentDriver {
     this.config = config;
   }
   async start() {
-    if (this.proc) return;
     if (this.startPromise) return this.startPromise;
+    if (this.proc) return;
     this.startPromise = this._start();
     return this.startPromise;
   }
   async _start() {
-    const args = ["--mode", "rpc"];
+    const args = ["--mode", "rpc-ui", "--no-ui"];
     const sessionDir = path.join(this.config.cwd, ".omp", "sessions");
     await fs.mkdir(sessionDir, { recursive: true });
     args.push("--session-dir", sessionDir);
@@ -438,6 +649,15 @@ var OmpDriver = class extends AgentDriver {
     }
     const modelArg = providers?.modelArg ?? this.config.model;
     if (modelArg) args.push("--model", modelArg);
+    const thinkingLevel = ompThinkingLevel(this.config);
+    if (thinkingLevel) args.push("--thinking", thinkingLevel);
+    this.ompApplied = {
+      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 });
@@ -465,7 +685,7 @@ var OmpDriver = class extends AgentDriver {
     const overridePreArgs = process.env.OMP_BRIDGE_PREARGS ? process.env.OMP_BRIDGE_PREARGS.split(/\s+/).filter(Boolean) : [];
     const spawnBin = overrideBin || "omp";
     const spawnArgs = overrideBin ? [...overridePreArgs, ...args] : args;
-    return new Promise((resolve, reject) => {
+    const spawned = await new Promise((resolve, reject) => {
       this.log.info("spawning omp", {
         bin: spawnBin,
         args: spawnArgs,
@@ -474,7 +694,8 @@ var OmpDriver = class extends AgentDriver {
       if (env.PI_CODING_AGENT_DIR)
         this.log.debug("env: PI_CODING_AGENT_DIR set", { value: env.PI_CODING_AGENT_DIR });
       if (env.GIT_SSH_COMMAND) this.log.debug("env: GIT_SSH_COMMAND set");
-      const proc = spawn(spawnBin, spawnArgs, {
+      const target = wrapAgentCommand(spawnBin, spawnArgs, resolveAgentExec());
+      const proc = spawn(target.command, target.args, {
         cwd: this.config.cwd,
         env,
         stdio: ["pipe", "pipe", "pipe"]
@@ -482,6 +703,11 @@ var OmpDriver = class extends AgentDriver {
       this.proc = proc;
       const procEmitter = proc;
       procEmitter.on("error", (err) => {
+        if (this.proc !== proc) {
+          clearTimeout(readyTimeout);
+          reject(err);
+          return;
+        }
         const detail = this.classifyProcessError(err);
         this.log.error("process error", err, { detail });
         this.emit("agent-event", { type: "error", error: detail.message, detail });
@@ -490,6 +716,12 @@ var OmpDriver = class extends AgentDriver {
       });
       procEmitter.on("exit", (code, signal) => {
         this.log.info("process exited", { code, signal });
+        if (this.proc !== proc) {
+          clearTimeout(readyTimeout);
+          reject(new Error("omp process killed before it was ready"));
+          if (this.proc === null) this.emit("exit", { code, signal });
+          return;
+        }
         const lastStderr = this.stderrBuffer.slice(-10).join("\n");
         const crashed = code !== null && code !== 0;
         if (crashed) {
@@ -532,21 +764,341 @@ var OmpDriver = class extends AgentDriver {
       }
       const startTime = Date.now();
       const readyTimeout = setTimeout(() => {
-        if (!this.ready) {
+        if (!this.ready && this.proc === proc) {
           this.log.warn("ready timeout, proceeding", { timeoutMs: 5e3 });
           this.ready = true;
-          resolve();
+          resolve(proc);
         }
       }, 5e3);
       this.once("ready", () => {
         clearTimeout(readyTimeout);
-        if (!this.ready) {
+        if (!this.ready && this.proc === proc) {
           this.log.info("process ready", { elapsedMs: Date.now() - startTime });
           this.ready = true;
-          resolve();
+          resolve(proc);
         }
       });
     });
+    const assertCurrent = () => {
+      if (this.proc !== spawned) throw new Error("omp process was killed during start");
+    };
+    assertCurrent();
+    const hooks = this.config.capabilities;
+    if (hooks) {
+      this.unsubscribeToolsChanged = hooks.onToolsChanged?.(() => {
+        void this.syncHostTools();
+      }) ?? null;
+    }
+    await Promise.all([this.enableAskDialog(), hooks ? this.syncHostTools() : void 0]);
+    assertCurrent();
+    void this.captureState({ announceSession: false });
+  }
+  /**
+   * Register the runner's capabilities with omp as host tools.
+   *
+   * Sends the full set every time: `set_host_tools` replaces omp's previous
+   * host-owned set, so a registry change that removes a capability takes
+   * effect too. Best-effort — a failure is logged and the session runs
+   * without host tools rather than failing to start.
+   */
+  async syncHostTools() {
+    const hooks = this.config.capabilities;
+    if (!hooks || !this.proc) return;
+    const set = buildOmpHostTools(hooks.composeTools());
+    for (const { tool, reason } of set.dropped) {
+      const key = `${tool}\0${reason}`;
+      if (this.warnedDroppedHostTools.has(key)) continue;
+      this.warnedDroppedHostTools.add(key);
+      this.log.warn("host tool dropped: invalid input schema", { tool, reason });
+    }
+    this.hostToolCapabilities = set.capabilityNames;
+    try {
+      const response = await this.request(
+        { type: "set_host_tools", tools: set.definitions },
+        { quiet: true }
+      );
+      if (response.success) {
+        const data = response.data;
+        this.log.info("registered omp host tools", { toolNames: data?.toolNames });
+      } else {
+        this.log.error("omp rejected host tools", new Error(response.error ?? "unknown error"), {
+          tools: set.definitions.map((t) => t.name)
+        });
+      }
+    } catch (err) {
+      this.log.error("registering omp host tools failed", err);
+    }
+  }
+  /**
+   * Execute a capability omp asked the host to run (`host_tool_call`) and
+   * answer with `host_tool_result`. Goes through {@link dispatchCapability}
+   * so validation, fire-and-forget and render semantics match claude-sdk.
+   *
+   * Emits `tool_call` / `tool_execution_end` around the dispatch: the
+   * normalizer does not read omp's own tool frames, so without these the
+   * call — and its `activity_label` — would never reach the chat.
+   */
+  handleHostToolCall(event) {
+    const id = event.id;
+    if (typeof id !== "string") return;
+    const hostName = typeof event.toolName === "string" ? event.toolName : "";
+    const name = this.hostToolCapabilities.get(hostName) ?? hostName;
+    const callId = typeof event.toolCallId === "string" ? event.toolCallId : id;
+    const input = event.arguments ?? {};
+    const hooks = this.config.capabilities;
+    const controller = new AbortController();
+    const call = { controller, name };
+    this.hostToolCalls.set(id, call);
+    this.emit("agent-event", {
+      type: "tool_call",
+      name,
+      tool: { name },
+      toolCallId: callId,
+      input
+    });
+    void (async () => {
+      let text;
+      let isError = false;
+      try {
+        if (!hooks) throw new Error(`no capability host for ${name}`);
+        const dispatch = await dispatchCapability(
+          hooks,
+          callId,
+          name,
+          input,
+          () => this.log.warn("background capability handler failed", {
+            name,
+            callId
+            // Nothing from the error: its message can quote the call's content.
+          }),
+          controller.signal
+        );
+        text = typeof dispatch.result === "string" ? dispatch.result : JSON.stringify(dispatch.result ?? {});
+      } catch (err) {
+        isError = true;
+        text = `Error: ${err?.message ?? String(err)}`;
+      }
+      if (this.hostToolCalls.get(id) !== call) return;
+      this.hostToolCalls.delete(id);
+      this.emit("agent-event", { type: "tool_execution_end", toolName: name });
+      try {
+        this.send({
+          type: "host_tool_result",
+          id,
+          result: { content: [{ type: "text", text }] },
+          ...isError ? { isError: true } : {}
+        });
+      } catch (err) {
+        this.log.warn("host tool result undeliverable", { name, callId, error: String(err) });
+      }
+    })();
+  }
+  /**
+   * `host_tool_cancel`: omp aborted the call, so abort the capability handler
+   * and close the call's chat activity (the handler's later settlement is
+   * ignored, so this is the only `tool_execution_end` the call gets).
+   */
+  handleHostToolCancel(event) {
+    const targetId = event.targetId;
+    if (typeof targetId !== "string") return;
+    this.abortHostToolCall(targetId);
+  }
+  /** Abort one in-flight host tool call and end its activity; no-op if already settled. */
+  abortHostToolCall(id) {
+    const call = this.hostToolCalls.get(id);
+    if (!call) return;
+    this.hostToolCalls.delete(id);
+    call.controller.abort();
+    this.emit("agent-event", { type: "tool_execution_end", toolName: call.name });
+  }
+  // ── Interactive questions (`ask`) ──────────────────────────────────────────
+  /**
+   * `extension_ui_request`: omp asks the host something. Only `ask` (and the
+   * `select` omp falls back to when `set_ask_dialog` is unavailable) can carry
+   * a user question; both park until {@link answerQuestion}. Presentation
+   * frames expect no reply. Every other kind is a dialog nobody here can
+   * answer, so it is cancelled at once — an unanswered dialog would leave the
+   * tool call, and the turn, waiting forever.
+   */
+  handleExtensionUiRequest(event) {
+    const method = event.method;
+    if (method === "cancel") {
+      if (typeof event.targetId === "string" && this.pendingQuestion?.id === event.targetId) {
+        this.pendingQuestion = null;
+      }
+      return;
+    }
+    if (method === "notify" || method === "setStatus" || method === "setWidget" || method === "setTitle" || method === "set_editor_text" || method === "open_url") {
+      return;
+    }
+    const id = event.id;
+    if (typeof id !== "string") return;
+    let parsed = null;
+    if (method === "ask") parsed = this.parseAskRequest(id, event);
+    else if (method === "select") parsed = this.parseSelectRequest(id, event);
+    if (!parsed) {
+      this.log.debug("cancelling unsupported omp dialog", { method: String(method) });
+      this.sendUiResponse({ id, cancelled: true });
+      return;
+    }
+    this.cancelPendingQuestion();
+    this.pendingQuestion = parsed;
+    this.announceQuestion(parsed, event);
+  }
+  parseAskRequest(id, event) {
+    if (!Array.isArray(event.questions) || event.questions.length === 0) return null;
+    const questions = [];
+    for (const raw of event.questions) {
+      const q = raw;
+      if (!q || typeof q.id !== "string" || typeof q.question !== "string" || !q.question) {
+        return null;
+      }
+      const options = (Array.isArray(q.options) ? q.options : []).flatMap((o) => {
+        let label = o;
+        if (o && typeof o === "object" && "label" in o) label = o.label;
+        return typeof label === "string" ? [label] : [];
+      });
+      questions.push({ id: q.id, question: q.question, options, multi: q.multi === true });
+    }
+    return { id, method: "ask", questions, answers: questions.map(() => void 0) };
+  }
+  parseSelectRequest(id, event) {
+    if (typeof event.title !== "string" || !event.title || !Array.isArray(event.options)) {
+      return null;
+    }
+    const options = event.options.filter((o) => typeof o === "string");
+    if (options.length === 0) return null;
+    return {
+      id,
+      method: "select",
+      questions: [{ id, question: event.title, options, multi: false }],
+      answers: [void 0]
+    };
+  }
+  /**
+   * Publish the parked question the way claude-sdk does for `AskUserQuestion`:
+   * an assistant `tool_use` block the normalizer turns into one `question`
+   * event per question, plus the matching `tool_call`. Option descriptions and
+   * `header`s survive in the tool input for consumers that render them.
+   */
+  announceQuestion(pending, event) {
+    const rawQuestions = Array.isArray(event.questions) ? event.questions : [];
+    const input = {
+      requestId: pending.id,
+      questions: pending.questions.map((q, i) => {
+        const raw = rawQuestions[i];
+        return {
+          question: q.question,
+          ...typeof raw?.header === "string" ? { header: raw.header } : {},
+          multiSelect: q.multi,
+          options: q.options.map((label, j) => {
+            const description = raw?.options?.[j]?.description;
+            return { label, ...typeof description === "string" ? { description } : {} };
+          })
+        };
+      })
+    };
+    const toolCallId = `omp-ask:${pending.id}`;
+    this.emit("agent-event", {
+      type: "message_start",
+      message: {
+        role: "assistant",
+        content: [{ type: "tool_use", name: "AskUserQuestion", id: toolCallId, input }]
+      }
+    });
+    this.emit("agent-event", {
+      type: "tool_call",
+      name: "AskUserQuestion",
+      tool: { name: "AskUserQuestion" },
+      toolCallId,
+      input
+    });
+    this.log.debug("paused on omp ask", { questions: pending.questions.length });
+  }
+  hasPendingQuestion() {
+    return this.pendingQuestion !== null;
+  }
+  /**
+   * While omp is parked on a question a reply that is not an answer must not
+   * become a prompt: the turn is still running, and a second prompt would
+   * collide with it.
+   */
+  get acceptsReplyAsPrompt() {
+    return this.pendingQuestion === null;
+  }
+  answerQuestion(answer, question, requestId) {
+    const pending = this.pendingQuestion;
+    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) return false;
+    pending.answers[index] = answer;
+    if (pending.answers.some((a) => a === void 0)) return true;
+    this.pendingQuestion = null;
+    this.sendUiResponse(this.buildQuestionResponse(pending));
+    this.log.debug("answered omp ask", { questions: pending.questions.length });
+    return true;
+  }
+  /** Shape the collected answers as the `extension_ui_response` payload for the request's method. */
+  buildQuestionResponse(pending) {
+    const find = (options, text) => options.find((o) => o === text) ?? options.find((o) => o.toLowerCase() === text.toLowerCase());
+    if (pending.method === "select") {
+      const match = find(pending.questions[0].options, (pending.answers[0] ?? "").trim());
+      if (match !== void 0) return { id: pending.id, value: match };
+      this.log.warn("select answer matches no option; cancelling it");
+      return { id: pending.id, cancelled: true };
+    }
+    const answers = pending.questions.map((q, i) => {
+      const text = (pending.answers[i] ?? "").trim();
+      const whole = find(q.options, text);
+      if (whole !== void 0) return { id: q.id, selectedOptions: [whole] };
+      if (q.multi) {
+        const parts = text.split(",").map((p) => p.trim()).filter(Boolean);
+        const matched = parts.map((p) => find(q.options, p));
+        if (parts.length > 0 && matched.every((m) => m !== void 0)) {
+          return { id: q.id, selectedOptions: [...new Set(matched)] };
+        }
+      }
+      return { id: q.id, selectedOptions: [], ...text ? { customInput: text } : {} };
+    });
+    return { id: pending.id, answers };
+  }
+  /** Write an `extension_ui_response`; undeliverable (process gone) is logged, not thrown. */
+  sendUiResponse(payload) {
+    try {
+      this.send({ type: "extension_ui_response", ...payload });
+    } catch (err) {
+      this.log.warn("extension ui response undeliverable", { error: String(err) });
+    }
+  }
+  /** Drop the pending question and tell omp it was cancelled, so its tool call unwinds. */
+  cancelPendingQuestion() {
+    const pending = this.pendingQuestion;
+    if (!pending) return;
+    this.pendingQuestion = null;
+    this.sendUiResponse({ id: pending.id, cancelled: true });
+  }
+  /**
+   * Opt in to omp's single `ask` dialog request (off by default per process).
+   * Best-effort: a build without the command answers with a failed response and
+   * its `ask` keeps degrading to one `select` per question, which
+   * {@link handleExtensionUiRequest} still surfaces as a question.
+   */
+  async enableAskDialog() {
+    try {
+      const response = await this.request(
+        { type: "set_ask_dialog", enabled: true },
+        { quiet: true }
+      );
+      if (!response.success) {
+        this.log.warn("omp rejected set_ask_dialog; ask falls back to select", {
+          error: response.error
+        });
+      }
+    } catch (err) {
+      this.log.warn("set_ask_dialog failed", { error: String(err) });
+    }
   }
   extractMessageText(msg) {
     if (!msg) return "";
@@ -556,19 +1108,59 @@ var OmpDriver = class extends AgentDriver {
       return c.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("");
     return "";
   }
+  /**
+   * `available_commands_update`: replace the cached slash-command list and
+   * publish it. Names carry no leading slash (omp's already don't), matching
+   * claude-sdk's `commands_available`. Entries without a name are skipped.
+   */
+  handleCommandsUpdate(event) {
+    const raw = Array.isArray(event.commands) ? event.commands : [];
+    const commands = [];
+    for (const entry of raw) {
+      if (!entry || typeof entry !== "object") continue;
+      const c = entry;
+      if (typeof c.name !== "string" || !c.name) continue;
+      const hint = c.input && typeof c.input === "object" ? c.input.hint : void 0;
+      commands.push({
+        name: c.name,
+        description: typeof c.description === "string" ? c.description : "",
+        argumentHint: typeof hint === "string" && hint ? hint : void 0
+      });
+    }
+    this.cachedCommands = commands;
+    this.emit("agent-event", { type: "commands_available", commands });
+    this.log.debug("discovered slash commands", { count: commands.length });
+  }
   handleEvent(event) {
     if (event.type === "ready") {
       this.emit("ready");
       return;
     }
     if (event.type === "response") {
-      if (!event.success && event.error) {
+      const quiet = typeof event.id === "string" && this.quietRequestIds.delete(event.id);
+      if (!event.success && event.error && !quiet) {
         const detail = this.classifyErrorMessage(event.error);
         this.emit("agent-event", { type: "error", error: event.error, detail });
       }
       this.emit(`response:${event.id}`, event);
       return;
     }
+    if (event.type === "host_tool_call") {
+      this.handleHostToolCall(event);
+      return;
+    }
+    if (event.type === "host_tool_cancel") {
+      this.handleHostToolCancel(event);
+      return;
+    }
+    if (event.type === "extension_ui_request") {
+      this.handleExtensionUiRequest(event);
+      return;
+    }
+    if (event.type === "available_commands_update") {
+      this.handleCommandsUpdate(event);
+      return;
+    }
     if (event.type === "error" && event.error) {
       const detail = this.classifyErrorMessage(event.error);
       this.emit("agent-event", { ...event, detail });
@@ -583,7 +1175,13 @@ var OmpDriver = class extends AgentDriver {
         delta = text;
       }
       this.prevText = text;
-      this.emit("agent-event", { ...event, _textDelta: delta });
+      const sub = event.assistantMessageEvent;
+      const thinking = sub && typeof sub === "object" && "type" in sub && sub.type === "thinking_delta" ? "delta" in sub && typeof sub.delta === "string" ? sub.delta : "" : "";
+      this.emit("agent-event", {
+        ...event,
+        _textDelta: delta,
+        ...thinking ? { _thinkingDelta: thinking } : {}
+      });
       return;
     }
     if (event.type === "message_start") {
@@ -592,6 +1190,7 @@ var OmpDriver = class extends AgentDriver {
     if (event.type === "message_end" || event.type === "agent_end") {
       this.prevText = "";
     }
+    if (event.type === "message_end") this.recordMessageUsage(event.message);
     if (event.type === "message_end" && event.message?.role === "assistant" && event.message.stopReason === "error") {
       const error = event.message.errorMessage || "omp request failed";
       const detail = this.classifyErrorMessage(error);
@@ -599,7 +1198,7 @@ var OmpDriver = class extends AgentDriver {
       this.emit("agent-event", { type: "error", error, detail });
     }
     if (event.type === "agent_end") {
-      void this.captureSessionId();
+      void this.captureState();
     }
     this.emit("agent-event", event);
     if (event.type === "agent_end") {
@@ -627,31 +1226,23 @@ var OmpDriver = class extends AgentDriver {
     reject?.(err);
   }
   /**
-   * Query OMP for the current session ID via `get_state` RPC.
-   * Emits a `session_info` event on success so the forge layer can persist the ID.
-   * Failures are silently swallowed — session tracking is best-effort.
+   * Query OMP's current state via the `get_state` RPC.
+   *
+   * Always refreshes the context fill from `contextUsage`. With
+   * `announceSession` (the default, used after each turn) it also records the
+   * native session ID and emits a `session_info` event so the forge layer can
+   * persist it. Failures are silently swallowed — both are best-effort.
    */
-  async captureSessionId() {
+  async captureState(options = {}) {
+    const announceSession = options.announceSession ?? true;
     try {
-      const id = this.nextId();
-      const response = await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error("get_state timeout")), 5e3);
-        this.once(`response:${id}`, (resp) => {
-          clearTimeout(timer);
-          resolve(resp);
-        });
-        try {
-          this.send({ id, type: "get_state" });
-        } catch (err) {
-          clearTimeout(timer);
-          reject(err);
-        }
-      });
+      const response = await this.request({ type: "get_state" }, { quiet: !announceSession });
       if (response.success && response.data) {
         const data = response.data;
+        this.captureContextUsage(data.contextUsage);
         const sessionId = data.sessionId;
         const sessionFile = data.sessionFile;
-        if (sessionId) {
+        if (announceSession && sessionId) {
           this._ompSessionId = sessionId;
           this.log.debug("omp session id assigned", { sessionId });
           this.emit("agent-event", {
@@ -664,9 +1255,99 @@ var OmpDriver = class extends AgentDriver {
     } catch {
     }
   }
+  /** `get_state.contextUsage` → context fill + window; absent or malformed values are ignored. */
+  captureContextUsage(raw) {
+    if (!raw || typeof raw !== "object") return;
+    const tokens = "tokens" in raw ? raw.tokens : void 0;
+    const contextWindow = "contextWindow" in raw ? raw.contextWindow : void 0;
+    if (typeof tokens === "number" && Number.isFinite(tokens) && tokens >= 0) {
+      this._lastContextTokens = tokens;
+    }
+    if (typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0) {
+      this._contextWindow = contextWindow;
+    }
+  }
+  /** Forget the previous turn's usage; called as a new turn begins. */
+  beginUsageTurn() {
+    this._lastTokens = null;
+    this._lastContextTokens = null;
+  }
+  /**
+   * Fold one finished assistant message into the turn's usage. Only the
+   * `message_end` value is final (`message_start` and partials carry running
+   * zeros). A message without usage, or an errored one reporting all zeros,
+   * bills nothing and must neither create a reading nor wipe a good one.
+   */
+  recordMessageUsage(message) {
+    if (message?.role !== "assistant" || !message.usage) return;
+    const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+    const input = count(message.usage.input);
+    const output = count(message.usage.output);
+    const cacheRead = count(message.usage.cacheRead);
+    const cacheWrite = count(message.usage.cacheWrite);
+    const reasoning = count(message.usage.reasoningTokens);
+    const total = count(message.usage.totalTokens);
+    const callContext = (input ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+    if (callContext + (output ?? 0) + (total ?? 0) === 0) return;
+    const turn = { ...this._lastTokens };
+    const add = (key, value) => {
+      if (value !== void 0) turn[key] = (turn[key] ?? 0) + value;
+    };
+    add("inputTokens", input);
+    add("outputTokens", output);
+    add("cacheReadTokens", cacheRead);
+    add("cacheCreationTokens", cacheWrite);
+    add("reasoningTokens", reasoning);
+    add("totalTokens", total);
+    this._lastTokens = turn;
+    if (callContext > 0) this._lastContextTokens = callContext;
+  }
   nextId() {
     return `req-${++this.reqId}`;
   }
+  /**
+   * Send a command and await its `response` frame.
+   *
+   * @param options.quiet - Leave a failed response to the caller instead of
+   *   surfacing it as an `error` agent event.
+   * @throws When the process is not running or no response arrives within
+   *   `options.timeoutMs` (default 5 s).
+   */
+  request(msg, options = {}) {
+    const id = this.nextId();
+    const event = `response:${id}`;
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const onResponse = (resp) => {
+      clearTimeout(timer);
+      this.pendingRequests.delete(id);
+      resolve(resp);
+    };
+    const fail = (err, keepQuiet = false) => {
+      clearTimeout(timer);
+      this.pendingRequests.delete(id);
+      this.removeListener(event, onResponse);
+      if (!keepQuiet) this.quietRequestIds.delete(id);
+      reject(err);
+    };
+    const timer = setTimeout(
+      () => fail(new Error(`${msg.type} timeout`), true),
+      options.timeoutMs ?? 5e3
+    );
+    this.once(event, onResponse);
+    this.pendingRequests.set(id, fail);
+    if (options.quiet) this.quietRequestIds.add(id);
+    try {
+      this.send({ id, ...msg });
+    } catch (err) {
+      fail(err);
+    }
+    return promise;
+  }
   send(msg) {
     if (!this.proc?.stdin?.writable) {
       const detail = {
@@ -694,15 +1375,94 @@ var OmpDriver = class extends AgentDriver {
    * @throws {Error} When the omp process is not running, its stdin is closed, or
    *   the child crashes/exits before the turn completes.
    */
-  async prompt(message) {
+  prompt(message) {
+    return this.enqueuePrompt(() => this.runPrompt({ message }));
+  }
+  /**
+   * Run one prompt after every earlier one settled. A question omp is parked on
+   * is cancelled first, synchronously and ahead of the queue: the parked turn
+   * can only finish once its `ask` is released, so the new prompt (the user
+   * typing instead of answering) must not wait behind it. The runner does not
+   * serialise `prompt` commands, so the driver does, as claude-sdk does.
+   */
+  enqueuePrompt(run) {
+    this.cancelPendingQuestion();
+    const queued = this.promptTail.then(run);
+    this.promptTail = queued.then(
+      () => void 0,
+      () => void 0
+    );
+    return queued;
+  }
+  /**
+   * Structured prompt: text plus image/file/skill attachments. Images travel as
+   * omp `ImageContent` (`prompt.images`, base64 + mimeType); file and skill
+   * attachments are named in a text preamble, because omp reads files itself.
+   * Turn settlement is shared with {@link prompt}.
+   */
+  promptInput(input) {
+    return this.enqueuePrompt(async () => this.runPrompt(await this.buildPromptPayload(input)));
+  }
+  /** Resolve attachments into the `message` + `images` fields of an omp `prompt` frame. */
+  async buildPromptPayload(input) {
+    const attachments = input.attachments ?? [];
+    if (attachments.length === 0) return { message: input.text };
+    const mimeByExt = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp"
+    };
+    const images = [];
+    const preamble = [];
+    let root;
+    for (const attachment of attachments) {
+      if (attachment.type !== "image") {
+        preamble.push(`[Attached ${attachment.type}: ${attachment.name} (${attachment.path})]`);
+        continue;
+      }
+      root ??= await fs.realpath(this.config.cwd);
+      const resolved = await fs.realpath(path.resolve(root, attachment.path));
+      const rel = path.relative(root, resolved);
+      const escapes = rel === ".." || rel.startsWith(`..${path.sep}`);
+      if (rel === "" || escapes || path.isAbsolute(rel)) {
+        throw new Error(`Image attachment is outside the workspace: ${attachment.path}`);
+      }
+      const mimeType = mimeByExt[path.extname(resolved).toLowerCase()];
+      if (!mimeType) {
+        throw new Error(`Unsupported image type for attachment: ${attachment.path}`);
+      }
+      const { size } = await fs.stat(resolved);
+      if (size > OMP_MAX_IMAGE_BYTES) {
+        throw new Error(`Image attachment too large (${size} bytes > 5 MB): ${attachment.path}`);
+      }
+      images.push({
+        type: "image",
+        data: (await fs.readFile(resolved)).toString("base64"),
+        mimeType
+      });
+    }
+    const message = preamble.length ? `${preamble.join("\n")}
+
+${input.text}` : input.text;
+    return { message, ...images.length ? { images } : {} };
+  }
+  /**
+   * Send one `prompt` frame and resolve when the turn completes (`agent_end`).
+   * Rejects if the child dies first.
+   */
+  async runPrompt(payload) {
     await this.start();
+    await this.syncReconfigure();
     const id = this.nextId();
     const turnPromise = new Promise((resolve, reject) => {
       this.turnResolve = resolve;
       this.turnReject = reject;
     });
+    this.beginUsageTurn();
     try {
-      this.send({ id, type: "prompt", message });
+      this.send({ id, type: "prompt", ...payload });
     } catch (err) {
       this.turnResolve = null;
       this.turnReject = null;
@@ -721,6 +1481,7 @@ var OmpDriver = class extends AgentDriver {
     if (!this.proc) return;
     const id = this.nextId();
     this.send({ id, type: "abort" });
+    this.cancelPendingQuestion();
   }
   /** `true` when the omp child process is alive and has not been killed. */
   get isRunning() {
@@ -733,14 +1494,18 @@ var OmpDriver = class extends AgentDriver {
    * `OmpDriver` to start a fresh session.
    */
   kill() {
-    if (this.proc) {
-      this.proc.kill("SIGTERM");
-      this.cleanup();
-    }
+    const proc = this.proc;
+    if (!proc) return;
+    this.rejectTurn(new Error("omp process killed"));
+    proc.kill("SIGTERM");
+    this.cleanup();
   }
   async resetSession() {
     this.kill();
     this.config = { ...this.config, resumeSessionId: void 0 };
+    this._lastTokens = null;
+    this._lastContextTokens = null;
+    this._contextWindow = null;
     await this.start();
   }
   classifyProcessError(err) {
@@ -803,6 +1568,14 @@ var OmpDriver = class extends AgentDriver {
     this.ready = false;
     this.startPromise = null;
     this.stderrBuffer = [];
+    this.unsubscribeToolsChanged?.();
+    this.unsubscribeToolsChanged = null;
+    this.hostToolCapabilities = /* @__PURE__ */ new Map();
+    for (const id of [...this.hostToolCalls.keys()]) this.abortHostToolCall(id);
+    for (const fail of [...this.pendingRequests.values()]) fail(new Error("omp process ended"));
+    this.pendingRequests.clear();
+    this.quietRequestIds.clear();
+    this.pendingQuestion = null;
   }
 };
 var ompDriverTarget = {
@@ -819,6 +1592,6 @@ var ompDriverTarget = {
   }).listModels()
 };
 
-export { OMP_BUILTIN_TOOLS, OMP_DEFAULT_TOOLS, OmpDriver, buildOmpChildEnv, buildOmpToolArgs, ompDriverTarget };
+export { OMP_BUILTIN_TOOLS, OMP_DEFAULT_TOOLS, OMP_THINKING_LEVELS, OmpDriver, buildOmpChildEnv, buildOmpHostTools, buildOmpToolArgs, ompDriverTarget, ompThinkingLevel, splitOmpModel };
 //# sourceMappingURL=omp.js.map
 //# sourceMappingURL=omp.js.map