@justin06lee/yagami 0.4.1 → 0.6.0

package/dist/{chunk-ASS6MJ7C.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";
@@ -180,7 +183,7 @@ function resolveClaudeExecutable(explicit) {
 }
 
 // src/version.ts
-var VERSION = "0.4.1";
+var VERSION = "0.5.0";
 
 // src/core/providers/acp.ts
 import { spawn, spawnSync } from "child_process";
@@ -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 {
@@ -1115,13 +1721,13 @@ function detectProviders(config = {}) {
     const preset = presetFor(id);
     const entry = config[id] ?? {};
     const command = entry.command ?? preset?.command ?? id;
-    const path7 = findExecutable(command, entry.path ? { explicit: entry.path } : {});
+    const path8 = findExecutable(command, entry.path ? { explicit: entry.path } : {});
     return {
       id,
       label: entry.label ?? preset?.label ?? id,
       kind: preset?.kind ?? "acp",
-      installed: path7 !== void 0 && entry.enabled !== false,
-      ...path7 ? { path: path7 } : {},
+      installed: path8 !== void 0 && entry.enabled !== false,
+      ...path8 ? { path: path8 } : {},
       loginCommand: entry.loginCommand ?? preset?.loginCommand ?? `${command} (sign in per its docs)`,
       installHint: preset?.installHint ?? `Install \`${command}\`.`
     };
@@ -1792,6 +2398,266 @@ ${promptText}`;
   }
 };
 
+// src/core/hostConfig.ts
+import * as fs7 from "fs";
+import * as os6 from "os";
+import * as path7 from "path";
+function yagamiConfigDir() {
+  return process.env["YAGAMI_CONFIG_DIR"] ?? path7.join(os6.homedir(), ".config", "yagami");
+}
+function loadHostEngineConfig() {
+  let file = {};
+  try {
+    file = JSON.parse(fs7.readFileSync(path7.join(yagamiConfigDir(), "config.json"), "utf8"));
+  } catch {
+  }
+  const env = process.env;
+  const defaultProvider = env["YAGAMI_PROVIDER"] ?? (typeof file["defaultProvider"] === "string" ? file["defaultProvider"] : void 0);
+  const defaultModel = env["YAGAMI_DEFAULT_MODEL"] ?? (typeof file["defaultModel"] === "string" ? file["defaultModel"] : void 0);
+  const claudePath = env["YAGAMI_CLAUDE_PATH"] ?? (typeof file["claudePath"] === "string" ? file["claudePath"] : void 0);
+  const claudeConfigDir = typeof file["claudeConfigDir"] === "string" ? file["claudeConfigDir"] : void 0;
+  const providers = file["providers"];
+  return {
+    ...defaultProvider ? { defaultProvider } : {},
+    ...defaultModel ? { defaultModel } : {},
+    ...providers != null && typeof providers === "object" && !Array.isArray(providers) ? { providerConfig: providers } : {},
+    ...claudePath ? { claudePath } : {},
+    ...claudeConfigDir ? { claudeConfigDir } : {}
+  };
+}
+
+// src/core/openai.ts
+var IGNORED_OPENAI_PARAMS = [
+  "presence_penalty",
+  "frequency_penalty",
+  "logit_bias",
+  "logprobs",
+  "top_logprobs",
+  "seed",
+  "user",
+  "response_format",
+  "prediction",
+  "modalities",
+  "audio",
+  "store",
+  "parallel_tool_calls",
+  "web_search_options"
+];
+var EFFORT_MAP = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: "max"
+};
+function imagePartToBlock(part) {
+  const url = part["image_url"]?.["url"];
+  if (typeof url !== "string" || url.length === 0) {
+    throw new ApiError(400, "invalid_request_error", "`image_url` parts must carry an `image_url.url` string");
+  }
+  const dataUrl = /^data:([^;,]+);base64,(.+)$/s.exec(url);
+  if (dataUrl) {
+    return { type: "image", source: { type: "base64", media_type: dataUrl[1], data: dataUrl[2] } };
+  }
+  if (/^https?:\/\//.test(url)) {
+    return { type: "image", source: { type: "url", url } };
+  }
+  throw new ApiError(400, "invalid_request_error", "`image_url.url` must be a data: URL or an http(s) URL");
+}
+function partsToContent(parts, role) {
+  const blocks = [];
+  for (const part of parts) {
+    if (part?.type === "text" && typeof part["text"] === "string") {
+      blocks.push({ type: "text", text: part["text"] });
+    } else if (part?.type === "image_url" && role === "user") {
+      blocks.push(imagePartToBlock(part));
+    } else {
+      throw new ApiError(
+        400,
+        "invalid_request_error",
+        `unsupported content part type "${String(part?.type)}" for role "${role}" (yagami supports "text", plus "image_url" in user messages)`
+      );
+    }
+  }
+  return blocks.every((b) => b.type === "text") ? blocks.map((b) => b["text"]).join("\n") : blocks;
+}
+function messageText(content, role) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  const flattened = partsToContent(content, role);
+  if (typeof flattened !== "string") {
+    throw new ApiError(400, "invalid_request_error", `"${role}" messages may only contain text parts`);
+  }
+  return flattened;
+}
+function chatToMessagesRequest(body) {
+  if (body == null || typeof body !== "object") {
+    throw new ApiError(400, "invalid_request_error", "request body must be a JSON object");
+  }
+  if (body.tools != null || body.tool_choice != null || body.functions != null || body.function_call != null) {
+    throw new ApiError(
+      400,
+      "invalid_request_error",
+      "yagami does not support `tools`/function calling: the backing engine runs as a pure completions endpoint and never executes or emits tool calls."
+    );
+  }
+  if (body.n != null && body.n !== 1) {
+    throw new ApiError(400, "invalid_request_error", "`n` must be 1 (yagami produces a single completion)");
+  }
+  if (!Array.isArray(body.messages) || body.messages.length === 0) {
+    throw new ApiError(400, "invalid_request_error", "`messages` must be a non-empty array");
+  }
+  const systemParts = [];
+  const messages = [];
+  for (const [i, m] of body.messages.entries()) {
+    const role = m?.role;
+    if (role === "system" || role === "developer") {
+      systemParts.push(messageText(m.content, role));
+    } else if (role === "user") {
+      messages.push({ role: "user", content: Array.isArray(m.content) ? partsToContent(m.content, "user") : m.content ?? "" });
+    } else if (role === "assistant") {
+      messages.push({ role: "assistant", content: messageText(m.content, "assistant") });
+    } else if (role === "tool" || role === "function") {
+      throw new ApiError(400, "invalid_request_error", "yagami does not support tool/function messages (tool calling is disabled by design)");
+    } else {
+      throw new ApiError(400, "invalid_request_error", `messages[${i}].role must be "system", "developer", "user", or "assistant"`);
+    }
+  }
+  const extraIgnored = IGNORED_OPENAI_PARAMS.filter((p) => body[p] != null).map(String);
+  let effort;
+  if (body.reasoning_effort != null) {
+    effort = EFFORT_MAP[String(body.reasoning_effort)];
+    if (!effort) extraIgnored.push("reasoning_effort");
+  }
+  const maxTokens = body.max_completion_tokens ?? body.max_tokens;
+  const system = systemParts.filter((s) => s.length > 0).join("\n\n");
+  const req = {
+    ...body.model !== void 0 ? { model: body.model } : {},
+    messages,
+    ...system.length > 0 ? { system } : {},
+    ...maxTokens !== void 0 ? { max_tokens: maxTokens } : {},
+    ...body.temperature !== void 0 ? { temperature: body.temperature } : {},
+    ...body.top_p !== void 0 ? { top_p: body.top_p } : {},
+    ...body.stop != null ? { stop_sequences: Array.isArray(body.stop) ? body.stop : [body.stop] } : {},
+    ...body.metadata != null ? { metadata: body.metadata } : {},
+    ...body.service_tier != null ? { service_tier: String(body.service_tier) } : {},
+    ...effort ? { effort } : {},
+    ...body.stream === true ? { stream: true } : {}
+  };
+  return { req, extraIgnored, includeUsage: body.stream_options?.include_usage === true };
+}
+function finishReason(stopReason) {
+  return stopReason === "max_tokens" ? "length" : "stop";
+}
+function toOpenAiUsage(usage) {
+  return {
+    prompt_tokens: usage.input_tokens,
+    completion_tokens: usage.output_tokens,
+    total_tokens: usage.input_tokens + usage.output_tokens
+  };
+}
+function toChatCompletion(resp) {
+  const text = resp.content.filter((b) => b.type === "text").map((b) => String(b["text"] ?? "")).join("");
+  const thinking = resp.content.filter((b) => b.type === "thinking").map((b) => String(b["thinking"] ?? "")).join("");
+  return {
+    id: resp.id.replace(/^msg_/, "chatcmpl_"),
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: resp.model,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content: text, ...thinking ? { reasoning_content: thinking } : {}, refusal: null },
+        finish_reason: finishReason(resp.stop_reason),
+        logprobs: null
+      }
+    ],
+    usage: toOpenAiUsage(resp.usage)
+  };
+}
+function openAiErrorBody(err) {
+  return { error: { message: err.message, type: err.type, param: null, code: null } };
+}
+var ChatChunkTranslator = class {
+  constructor(includeUsage) {
+    this.includeUsage = includeUsage;
+  }
+  includeUsage;
+  id = "chatcmpl_stream";
+  model = "";
+  created = Math.floor(Date.now() / 1e3);
+  stopReason = null;
+  usage = { input_tokens: 0, output_tokens: 0 };
+  /** Set when the engine reported an error mid-stream (no [DONE] after). */
+  errored = false;
+  chunk(delta, finish = null) {
+    return {
+      id: this.id,
+      object: "chat.completion.chunk",
+      created: this.created,
+      model: this.model,
+      choices: [{ index: 0, delta, finish_reason: finish }]
+    };
+  }
+  /** Translate one engine SSE event into zero or more OpenAI chunk payloads. */
+  push(ev) {
+    const data = ev.data;
+    switch (ev.event) {
+      case "message_start": {
+        const message = data["message"];
+        if (message?.id) this.id = message.id.replace(/^msg_/, "chatcmpl_");
+        if (message?.model) this.model = message.model;
+        return [this.chunk({ role: "assistant", content: "" })];
+      }
+      case "content_block_delta": {
+        const delta = data["delta"];
+        if (delta?.type === "text_delta" && delta.text) return [this.chunk({ content: delta.text })];
+        if (delta?.type === "thinking_delta" && delta.thinking) return [this.chunk({ reasoning_content: delta.thinking })];
+        return [];
+      }
+      case "message_delta": {
+        const delta = data["delta"];
+        if (delta?.stop_reason) this.stopReason = delta.stop_reason;
+        const usage = data["usage"];
+        if (usage) this.usage = usage;
+        return [];
+      }
+      case "message_stop": {
+        const out = [this.chunk({}, finishReason(this.stopReason))];
+        if (this.includeUsage) {
+          out.push({
+            id: this.id,
+            object: "chat.completion.chunk",
+            created: this.created,
+            model: this.model,
+            choices: [],
+            usage: toOpenAiUsage(this.usage)
+          });
+        }
+        return out;
+      }
+      case "error": {
+        this.errored = true;
+        const error = data["error"];
+        return [{ error: { message: error?.message ?? "stream error", type: error?.type ?? "api_error", param: null, code: null } }];
+      }
+      default:
+        return [];
+    }
+  }
+};
+function modelListBody(models) {
+  const created = Math.floor(Date.now() / 1e3);
+  return {
+    object: "list",
+    data: models.map((m) => ({ type: "model", object: "model", created, owned_by: "yagami", ...m })),
+    has_more: false,
+    ...models[0] ? { first_id: models[0].id } : {},
+    ...models.length > 0 ? { last_id: models[models.length - 1].id } : {}
+  };
+}
+
 export {
   ApiError,
   YagamiError,
@@ -1802,6 +2668,7 @@ export {
   toApiError,
   parseModelRef,
   qualifiedModel,
+  isSessionProvider,
   findExecutable,
   resolveExecutable,
   resolveClaudeExecutable,
@@ -1816,6 +2683,13 @@ export {
   loadProviders,
   detectProviders,
   SessionCache,
-  YagamiEngine
+  YagamiEngine,
+  yagamiConfigDir,
+  loadHostEngineConfig,
+  chatToMessagesRequest,
+  toChatCompletion,
+  openAiErrorBody,
+  ChatChunkTranslator,
+  modelListBody
 };
-//# sourceMappingURL=chunk-ASS6MJ7C.js.map
+//# sourceMappingURL=chunk-ZYHC7PXX.js.map