@justin06lee/yagami 0.5.0 → 0.6.0

package/dist/{chunk-2UG5CR5X.js → chunk-ZYHC7PXX.js}

@@ -108,6 +108,9 @@ function parseModelRef(model, providerIds) {
 function qualifiedModel(providerId, model) {
   return `${providerId}:${model}`;
 }
+function isSessionProvider(p) {
+  return typeof p.openSession === "function";
+}
 
 // src/core/executable.ts
 import * as fs from "fs";
@@ -439,6 +442,22 @@ var AcpProvider = class {
       conn.close();
     }
   }
+  /**
+   * A live, interactive ACP session: the agent runs warm in the project
+   * directory with ITS OWN defaults — no plan-mode hardening, no forced
+   * config. Tool calls stream as normalized events and permission requests
+   * go to the host's handler, exactly as the agent's own client would ask.
+   */
+  openSession(options) {
+    return new AcpAgentSession({
+      id: this.id,
+      modelConfigId: this.modelConfigId,
+      connect: (cwd) => this.connectImpl(cwd),
+      classify: (err, ctx) => this.classify(err, ctx),
+      selectModel: (conn, sessionId, configOptions, model) => this.selectModel(conn, sessionId, configOptions, model),
+      options
+    });
+  }
   async selectModel(conn, sessionId, configOptions, model) {
     const option = configOptions?.find((o) => o.id === this.modelConfigId) ?? configOptions?.find((o) => o.category === "model");
     if (!option || option.type !== "select") {
@@ -495,6 +514,175 @@ var AcpProvider = class {
     return `${plain ?? "unknown version"} \u26A0 no ACP handshake (${handshakeError ?? "unknown error"}) \u2014 too old, or a different program with the same name?`;
   }
 };
+var AcpAgentSession = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.provider = cfg.id;
+  }
+  cfg;
+  provider;
+  conn;
+  sessionId;
+  queue = null;
+  opening;
+  closed = false;
+  costUsd;
+  /** Updates often omit title/kind — remember them from the start event. */
+  toolMeta = /* @__PURE__ */ new Map();
+  get id() {
+    return this.sessionId;
+  }
+  ensureOpen() {
+    this.opening ??= this.open();
+    return this.opening;
+  }
+  async open() {
+    const { options } = this.cfg;
+    const conn = await this.cfg.connect(options.cwd);
+    this.conn = conn;
+    let configOptions;
+    if (options.resume && supportsResume(conn.init)) {
+      const resumed = await conn.agent.resumeSession({ sessionId: options.resume, cwd: options.cwd }).catch((err) => {
+        throw this.cfg.classify(err);
+      });
+      this.sessionId = options.resume;
+      configOptions = resumed.configOptions;
+    } else {
+      const created = await conn.agent.newSession({ cwd: options.cwd, mcpServers: [] }).catch((err) => {
+        throw this.cfg.classify(err);
+      });
+      this.sessionId = created.sessionId;
+      configOptions = created.configOptions;
+    }
+    const sessionId = this.sessionId;
+    const mode = options.native?.mode;
+    if (mode) await conn.agent.setSessionMode({ sessionId, modeId: mode }).catch(() => {
+    });
+    if (options.model) await this.cfg.selectModel(conn, sessionId, configOptions, options.model);
+    conn.setHandlers({
+      onPermission: (p) => this.onPermission(p),
+      onUpdate: (n) => this.onUpdate(n)
+    });
+  }
+  async onPermission(p) {
+    const toolCall = p.toolCall;
+    const request = {
+      provider: this.provider,
+      ...this.sessionId ? { sessionId: this.sessionId } : {},
+      tool: toolCall?.title ?? "tool",
+      ...toolCall?.kind ? { kind: toolCall.kind } : {},
+      ...toolCall?.title ? { title: toolCall.title } : {},
+      input: toolCall?.rawInput,
+      raw: p
+    };
+    let decision = "deny";
+    try {
+      decision = await this.cfg.options.permissions.decide(request);
+    } catch {
+    }
+    this.queue?.push({ type: "permission", request, decision });
+    const preferred = {
+      allow: ["allow_once", "allow_always"],
+      allow_always: ["allow_always", "allow_once"],
+      deny: ["reject_once", "reject_always"],
+      deny_always: ["reject_always", "reject_once"]
+    };
+    for (const kind of preferred[decision]) {
+      const option = p.options.find((o) => o.kind === kind);
+      if (option) return { outcome: { outcome: "selected", optionId: option.optionId } };
+    }
+    return rejectOption(p);
+  }
+  onUpdate(n) {
+    if (n.sessionId !== this.sessionId) return;
+    const u = n.update;
+    switch (u.sessionUpdate) {
+      case "agent_message_chunk":
+        if (u.content.type === "text") this.queue?.push({ type: "text", text: u.content.text });
+        break;
+      case "agent_thought_chunk":
+        if (u.content.type === "text") this.queue?.push({ type: "thinking", text: u.content.text });
+        break;
+      case "tool_call": {
+        const t = u;
+        const meta = { name: t.kind ?? "tool", ...t.title ? { title: t.title } : {}, ...t.kind ? { kind: t.kind } : {} };
+        this.toolMeta.set(t.toolCallId, meta);
+        this.queue?.push({
+          type: "tool_call",
+          id: t.toolCallId,
+          status: "started",
+          ...meta,
+          ...t.rawInput !== void 0 ? { input: t.rawInput } : {}
+        });
+        break;
+      }
+      case "tool_call_update": {
+        const t = u;
+        const known = this.toolMeta.get(t.toolCallId);
+        const meta = {
+          name: t.kind ?? known?.name ?? "tool",
+          ...t.title ?? known?.title ? { title: t.title ?? known?.title } : {},
+          ...t.kind ?? known?.kind ? { kind: t.kind ?? known?.kind } : {}
+        };
+        this.queue?.push({
+          type: "tool_call",
+          id: t.toolCallId,
+          status: t.status === "completed" ? "completed" : t.status === "failed" ? "failed" : "updated",
+          ...meta,
+          ...t.rawOutput !== void 0 ? { output: t.rawOutput } : {}
+        });
+        break;
+      }
+      case "usage_update": {
+        const cost = u.cost;
+        if (cost && typeof cost.amount === "number" && (cost.currency ?? "USD") === "USD") this.costUsd = cost.amount;
+        break;
+      }
+      default:
+        this.queue?.push({ type: "raw", provider: this.provider, payload: u });
+        break;
+    }
+  }
+  async *send(input) {
+    if (this.closed) throw new ProviderError(this.provider, "session is closed");
+    if (this.queue) throw new ProviderError(this.provider, "a turn is already running");
+    await this.ensureOpen();
+    const sessionId = this.sessionId;
+    const text = typeof input === "string" ? input : input.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+    const media = typeof input === "string" ? [] : input.filter((b) => b.type === "image");
+    const queue = new AsyncQueue();
+    this.queue = queue;
+    this.costUsd = void 0;
+    this.conn.agent.prompt({ sessionId, prompt: toAcpBlocks(text, media, this.provider) }).then((res) => {
+      queue.push({
+        type: "done",
+        usage: mapAcpUsage(res.usage ?? void 0),
+        ...this.costUsd !== void 0 ? { costUsd: this.costUsd } : {},
+        stopReason: mapStopReason(res.stopReason)
+      });
+      queue.end();
+    }).catch((err) => queue.fail(this.cfg.classify(err)));
+    try {
+      yield { type: "session", sessionId };
+      for await (const event of queue) yield event;
+    } finally {
+      if (this.queue === queue) this.queue = null;
+    }
+  }
+  async interrupt() {
+    if (!this.sessionId || !this.conn) return;
+    await this.conn.agent.cancel({ sessionId: this.sessionId }).catch(() => {
+    });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.queue?.fail(new ProviderError(this.provider, "session closed"));
+    this.queue = null;
+    this.conn?.close();
+    this.conn = void 0;
+  }
+};
 function supportsResume(init) {
   const caps = init.agentCapabilities;
   return caps?.sessionCapabilities?.resume !== void 0;
@@ -787,15 +975,419 @@ function mediaPrompt(text, media) {
 }
 
 // src/core/providers/codex.ts
-import { spawn as spawn3, spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
 import * as fs4 from "fs";
 import * as os4 from "os";
 import * as path4 from "path";
-import * as readline3 from "readline";
+import * as readline4 from "readline";
 
-// src/core/providers/jsonl.ts
+// src/core/providers/codexSession.ts
 import { spawn as spawn2 } from "child_process";
 import * as readline2 from "readline";
+var CodexAgentSession = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  provider = "codex";
+  child;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  threadId;
+  currentTurnId;
+  queue = null;
+  lastUsage;
+  opening;
+  closed = false;
+  /** Item text already emitted as deltas, so item/completed only fills gaps. */
+  emitted = /* @__PURE__ */ new Map();
+  get id() {
+    return this.threadId;
+  }
+  fail(err) {
+    for (const [, p] of this.pending) p.reject(err);
+    this.pending.clear();
+    this.queue?.fail(err);
+    this.queue = null;
+  }
+  classify(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (looksLikeAuthFailure(message)) {
+      return new AuthRequiredError("codex", this.config.loginCommand, message.slice(0, 200));
+    }
+    return classifyProviderFailure("codex", this.config.loginCommand, err);
+  }
+  request(method, params) {
+    const child = this.child;
+    if (!child?.stdin?.writable) return Promise.reject(new ProviderError("codex", "app-server is not running"));
+    const id = this.nextId++;
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+    return promise;
+  }
+  respond(id, result) {
+    this.child?.stdin?.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}
+`);
+  }
+  notify(method, params) {
+    this.child?.stdin?.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
+`);
+  }
+  ensureOpen() {
+    this.opening ??= this.open();
+    return this.opening;
+  }
+  async open() {
+    const { executable, env, options } = this.config;
+    const child = spawn2(executable, ["app-server"], {
+      cwd: options.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    let stderr = "";
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+      if (stderr.length > 16e3) stderr = stderr.slice(-8e3);
+    });
+    child.on("error", (err) => this.fail(this.classify(err)));
+    child.on("exit", (code) => {
+      if (this.closed) return;
+      this.fail(this.classify(new Error(`codex app-server exited with code ${code}${stderr ? `: ${stderr.trim().slice(-400)}` : ""}`)));
+    });
+    const rl = readline2.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        return;
+      }
+      this.dispatch(msg);
+    });
+    await this.request("initialize", {
+      clientInfo: { name: this.config.options.appName ?? "yagami", title: this.config.options.appName ?? "yagami", version: VERSION },
+      capabilities: { experimentalApi: true, requestAttestation: false }
+    });
+    this.notify("initialized", {});
+    const native = options.native ?? {};
+    const overrides = {
+      cwd: options.cwd,
+      ...options.model ? { model: options.model } : {},
+      ...native.approvalPolicy ? { approvalPolicy: native.approvalPolicy } : {},
+      ...native.sandbox ? { sandbox: native.sandbox } : {},
+      ...native.config ? { config: native.config } : {},
+      ...options.systemPrompt ? { developerInstructions: options.systemPrompt } : {}
+    };
+    if (options.resume) {
+      try {
+        const resumed = await this.request("thread/resume", { threadId: options.resume, ...overrides });
+        this.threadId = resumed["thread"]?.id ?? options.resume;
+        return;
+      } catch {
+      }
+    }
+    const started = await this.request("thread/start", overrides);
+    this.threadId = started["thread"]?.id;
+    if (!this.threadId) throw new ProviderError("codex", "thread/start returned no thread id");
+  }
+  // ── inbound traffic ────────────────────────────────────────────────
+  dispatch(msg) {
+    if (msg.method === void 0 && msg.id !== void 0) {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      if (msg.error) pending.reject(this.classify(new Error(msg.error.message ?? "codex error")));
+      else pending.resolve(msg.result ?? {});
+      return;
+    }
+    if (!msg.method) return;
+    if (msg.id !== void 0) {
+      void this.handleServerRequest(msg.method, msg.id, msg.params ?? {});
+      return;
+    }
+    this.handleNotification(msg.method, msg.params ?? {});
+  }
+  push(event) {
+    this.queue?.push(event);
+  }
+  handleNotification(method, params) {
+    if (params["threadId"] !== void 0 && params["threadId"] !== this.threadId) return;
+    switch (method) {
+      case "item/agentMessage/delta": {
+        const itemId = params["itemId"];
+        const delta = params["delta"];
+        this.emitted.set(itemId, (this.emitted.get(itemId) ?? 0) + delta.length);
+        this.push({ type: "text", text: delta });
+        break;
+      }
+      case "item/started":
+      case "item/completed": {
+        this.handleItem(params["item"], method === "item/completed");
+        break;
+      }
+      case "thread/tokenUsage/updated": {
+        const usage = params["tokenUsage"];
+        const last = usage?.last;
+        if (last) {
+          this.lastUsage = {
+            input_tokens: last["inputTokens"] ?? 0,
+            output_tokens: last["outputTokens"] ?? 0,
+            cache_read_input_tokens: last["cachedInputTokens"] ?? 0,
+            cache_creation_input_tokens: last["cacheWriteInputTokens"] ?? 0
+          };
+        }
+        break;
+      }
+      case "turn/completed": {
+        const turn = params["turn"];
+        const queue = this.queue;
+        this.queue = null;
+        this.currentTurnId = void 0;
+        if (!queue) break;
+        if (turn.status === "failed") {
+          queue.fail(this.classify(new Error(turn.error?.message ?? "turn failed")));
+        } else {
+          queue.push({
+            type: "done",
+            ...this.lastUsage ? { usage: this.lastUsage } : {},
+            stopReason: turn.status === "interrupted" ? "interrupted" : "end_turn"
+          });
+          queue.end();
+        }
+        break;
+      }
+      case "error": {
+        this.push({ type: "raw", provider: "codex", payload: { method, params } });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  /** Normalize thread items into tool_call / thinking events. */
+  handleItem(item, completed) {
+    if (!item) return;
+    const id = String(item["id"] ?? "");
+    switch (item["type"]) {
+      case "agentMessage": {
+        if (!completed) break;
+        const text = String(item["text"] ?? "");
+        const seen = this.emitted.get(id) ?? 0;
+        if (text.length > seen) this.push({ type: "text", text: text.slice(seen) });
+        this.emitted.delete(id);
+        break;
+      }
+      case "reasoning": {
+        if (!completed) break;
+        const summary = item["summary"]?.join("\n") ?? "";
+        if (summary) this.push({ type: "thinking", text: summary });
+        break;
+      }
+      case "commandExecution": {
+        const failed = item["status"] === "failed" || item["status"] === "declined";
+        this.push({
+          type: "tool_call",
+          id,
+          name: "shell",
+          status: completed ? failed ? "failed" : "completed" : "started",
+          title: String(item["command"] ?? "command"),
+          kind: "execute",
+          input: { command: item["command"], cwd: item["cwd"] },
+          ...completed ? { output: { output: item["aggregatedOutput"], exitCode: item["exitCode"] } } : {}
+        });
+        break;
+      }
+      case "fileChange": {
+        const changes = item["changes"] ?? [];
+        const failed = item["status"] === "failed" || item["status"] === "declined";
+        this.push({
+          type: "tool_call",
+          id,
+          name: "apply_patch",
+          status: completed ? failed ? "failed" : "completed" : "started",
+          title: changes.map((c) => c.path).filter(Boolean).join(", ") || "file changes",
+          kind: "edit",
+          input: { changes }
+        });
+        break;
+      }
+      case "mcpToolCall": {
+        this.push({
+          type: "tool_call",
+          id,
+          name: `${String(item["server"] ?? "mcp")}.${String(item["tool"] ?? "tool")}`,
+          status: completed ? item["status"] === "failed" ? "failed" : "completed" : "started",
+          kind: "other",
+          input: item["arguments"]
+        });
+        break;
+      }
+      case "webSearch": {
+        this.push({
+          type: "tool_call",
+          id,
+          name: "web_search",
+          status: completed ? "completed" : "started",
+          kind: "fetch",
+          input: { query: item["query"] }
+        });
+        break;
+      }
+      case "userMessage":
+      case "plan":
+        break;
+      default:
+        this.push({ type: "raw", provider: "codex", payload: item });
+        break;
+    }
+  }
+  // ── approvals: forwarded to the host, answered like the TUI would ──
+  async decide(request) {
+    try {
+      const decision = await this.config.options.permissions.decide(request);
+      this.push({ type: "permission", request, decision });
+      return decision;
+    } catch {
+      return "deny";
+    }
+  }
+  async handleServerRequest(method, id, params) {
+    switch (method) {
+      case "item/commandExecution/requestApproval": {
+        const decision = await this.decide({
+          provider: "codex",
+          ...this.threadId ? { sessionId: this.threadId } : {},
+          tool: "shell",
+          kind: "execute",
+          title: String(params["command"] ?? "command"),
+          input: { command: params["command"], cwd: params["cwd"], reason: params["reason"] },
+          raw: params
+        });
+        this.respond(id, {
+          decision: decision === "allow" ? "accept" : decision === "allow_always" ? "acceptForSession" : "decline"
+        });
+        break;
+      }
+      case "item/fileChange/requestApproval": {
+        const decision = await this.decide({
+          provider: "codex",
+          ...this.threadId ? { sessionId: this.threadId } : {},
+          tool: "apply_patch",
+          kind: "edit",
+          title: String(params["reason"] ?? "apply file changes"),
+          input: { reason: params["reason"], grantRoot: params["grantRoot"] },
+          raw: params
+        });
+        this.respond(id, {
+          decision: decision === "allow" ? "accept" : decision === "allow_always" ? "acceptForSession" : "decline"
+        });
+        break;
+      }
+      case "item/permissions/requestApproval": {
+        const requested = params["permissions"];
+        const decision = await this.decide({
+          provider: "codex",
+          ...this.threadId ? { sessionId: this.threadId } : {},
+          tool: "permissions",
+          kind: "other",
+          title: String(params["reason"] ?? "extra permissions"),
+          input: requested,
+          raw: params
+        });
+        const granted = decision === "allow" || decision === "allow_always";
+        this.respond(id, {
+          permissions: granted ? { network: requested?.["network"] ?? void 0, fileSystem: requested?.["fileSystem"] ?? void 0 } : {},
+          scope: decision === "allow_always" ? "session" : "turn"
+        });
+        break;
+      }
+      // legacy approval shapes, still sent by some codepaths
+      case "execCommandApproval":
+      case "applyPatchApproval": {
+        const decision = await this.decide({
+          provider: "codex",
+          ...this.threadId ? { sessionId: this.threadId } : {},
+          tool: method === "execCommandApproval" ? "shell" : "apply_patch",
+          kind: method === "execCommandApproval" ? "execute" : "edit",
+          title: String(params["command"] ?? params["reason"] ?? "approval"),
+          input: params,
+          raw: params
+        });
+        this.respond(id, {
+          decision: decision === "allow" ? "approved" : decision === "allow_always" ? "approved_for_session" : { denied: { rejection: "denied by the user" } }
+        });
+        break;
+      }
+      case "item/tool/requestUserInput": {
+        this.respond(id, { answers: {} });
+        break;
+      }
+      case "mcpServer/elicitation/request": {
+        this.respond(id, { action: "decline", content: null, _meta: null });
+        break;
+      }
+      default: {
+        this.child?.stdin?.write(
+          `${JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32601, message: `unsupported request: ${method}` } })}
+`
+        );
+        break;
+      }
+    }
+  }
+  // ── the ProviderSession surface ────────────────────────────────────
+  async *send(input) {
+    if (this.closed) throw new ProviderError("codex", "session is closed");
+    if (this.queue) throw new ProviderError("codex", "a turn is already running");
+    await this.ensureOpen();
+    const blocks = typeof input === "string" ? [{ type: "text", text: input }] : input;
+    const { paths, cleanup } = writeTempImages(blocks);
+    const items = [];
+    for (const block of blocks) {
+      if (block.type === "text" && typeof block.text === "string") {
+        items.push({ type: "text", text: block.text, text_elements: [] });
+      }
+    }
+    for (const p of paths) items.push({ type: "localImage", path: p });
+    if (items.length === 0) items.push({ type: "text", text: "", text_elements: [] });
+    const queue = new AsyncQueue();
+    this.queue = queue;
+    this.lastUsage = void 0;
+    try {
+      const result = await this.request("turn/start", {
+        threadId: this.threadId,
+        input: items,
+        ...this.config.options.effort ? { effort: this.config.options.effort } : {}
+      });
+      this.currentTurnId = result["turn"]?.id;
+      yield { type: "session", sessionId: this.threadId };
+      for await (const event of queue) yield event;
+    } finally {
+      cleanup();
+      if (this.queue === queue) this.queue = null;
+    }
+  }
+  async interrupt() {
+    if (!this.threadId || !this.currentTurnId) return;
+    await this.request("turn/interrupt", { threadId: this.threadId, turnId: this.currentTurnId }).catch(() => {
+    });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.fail(new ProviderError("codex", "session closed"));
+    this.child?.kill("SIGTERM");
+    this.child = void 0;
+  }
+};
+
+// src/core/providers/jsonl.ts
+import { spawn as spawn3 } from "child_process";
+import * as readline3 from "readline";
 var ProcessExitError = class extends Error {
   constructor(exitCode, stderr) {
     super(`process exited with code ${exitCode}${stderr ? `: ${stderr.trim().split("\n").slice(-3).join(" | ")}` : ""}`);
@@ -808,7 +1400,7 @@ var ProcessExitError = class extends Error {
 };
 function spawnJsonl(options) {
   const queue = new AsyncQueue();
-  const child = spawn2(options.command, options.args, {
+  const child = spawn3(options.command, options.args, {
     cwd: options.cwd,
     env: options.env,
     stdio: [options.stdin !== void 0 ? "pipe" : "ignore", "pipe", "pipe"]
@@ -818,7 +1410,7 @@ function spawnJsonl(options) {
     stderr += chunk.toString();
     if (stderr.length > 16e3) stderr = stderr.slice(-8e3);
   });
-  const rl = readline2.createInterface({ input: child.stdout, crlfDelay: Infinity });
+  const rl = readline3.createInterface({ input: child.stdout, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const trimmed = line.trim();
     if (!trimmed.startsWith("{")) return;
@@ -933,10 +1525,24 @@ var CodexProvider = class {
     if (req.signal?.aborted) return;
     if (!done) throw new ProviderError(this.id, "codex exited without completing the turn");
   }
+  /**
+   * A live, interactive Codex session (`codex app-server` — the TUI's own
+   * engine): streamed tool events, the user's config.toml verbatim, and
+   * approval requests forwarded to the host's permission handler. The
+   * completion-turn `run()` path above stays for API-style callers.
+   */
+  openSession(options) {
+    return new CodexAgentSession({
+      executable: this.executable,
+      env: this.env,
+      loginCommand: this.loginCommand,
+      options
+    });
+  }
   /** Ask the app-server protocol for the model catalog (no tokens spent). */
   listModels() {
     return new Promise((resolve, reject) => {
-      const child = spawn3(this.executable, ["app-server"], { env: this.env, stdio: ["pipe", "pipe", "pipe"] });
+      const child = spawn4(this.executable, ["app-server"], { env: this.env, stdio: ["pipe", "pipe", "pipe"] });
       let stderr = "";
       let settled = false;
       const finish = (fn) => {
@@ -954,7 +1560,7 @@ var CodexProvider = class {
         "close",
         () => finish(() => reject(classifyProviderFailure(this.id, this.loginCommand, new Error(stderr.trim() || "app-server exited"))))
       );
-      const rl = readline3.createInterface({ input: child.stdout });
+      const rl = readline4.createInterface({ input: child.stdout });
       rl.on("line", (line) => {
         let msg;
         try {
@@ -2062,6 +2668,7 @@ export {
   toApiError,
   parseModelRef,
   qualifiedModel,
+  isSessionProvider,
   findExecutable,
   resolveExecutable,
   resolveClaudeExecutable,
@@ -2085,4 +2692,4 @@ export {
   ChatChunkTranslator,
   modelListBody
 };
-//# sourceMappingURL=chunk-2UG5CR5X.js.map
+//# sourceMappingURL=chunk-ZYHC7PXX.js.map