rovecode 0.3.2 → 0.4.0-beta.2

package/src/providers/thinking.ts

@@ -1,189 +0,0 @@
-/** ONE effort dial (core/types.ts ThinkingEffort: auto | off | low | medium | high), every wire it can reach.
- *  This module answers, for a model on a protocol, two questions the adapters and the humans both ask:
- *  which request fields carry the level, and — in one sentence — what the model will actually receive.
- *  stream.ts spreads `thinkingPlan(...).fields` into the body; /effort and `rovecode model show` print `says`.
- *
- *  Rules (Berkay, 2026-09-04): `auto` sends NOTHING and leaves the endpoint's own default standing (the
- *  Claude 5 family reasons adaptively on its own; the old default "off" switched that off). `off` is an
- *  explicit disable where the API has one, otherwise nothing. A level maps onto the endpoint's own
- *  vocabulary; where the vocabulary has fewer steps, medium rounds UP (a rovecode "medium" asks for more
- *  than "low"). A model that always reasons, or has no reasoning mode, gets nothing — sending a dial such a
- *  model rejects is a 400, not a downgrade (grok-4, gpt-4-class on OpenAI proper).
- *
- *  Dialects are matched by MODEL ID, provider-agnostic (the same GLM under kaesra, zai or openrouter is one
- *  family) — except OpenRouter, whose unified `reasoning` object wins for every model it fronts, and Groq's
- *  Qwen vocabulary. The catalog's word is stronger than any regex: a model models.dev lists WITHOUT a
- *  reasoning mode (ModelRef.reasoning === false, stamped by cli/runtime.ts buildDef) gets nothing.
- *
- *  Only Anthropic and GLM-5.3 are measured live (stream.ts header, profiles.ts header). The other
- *  vocabularies are the vendors' published API docs as of 2026-09 — docs/thinking.md carries the matrix
- *  and marks each row measured or documented. */
-
-import type { ModelRef, ThinkingEffort } from "../core/types.ts";
-import { GLM_53_MODEL_RE, wireProfileFor } from "./profiles.ts";
-
-export type WireProtocol = "openai" | "anthropic";
-type Level = "low" | "medium" | "high";
-type Setting = "auto" | "off" | Level;
-
-export interface ThinkingPlan {
-  /** the dialect that answered (docs/thinking.md row) */
-  dialect: string;
-  /** spread into the request body */
-  fields: Record<string, unknown>;
-  /** one sentence for the human: the exact field, or why nothing goes */
-  says: string;
-}
-
-/** undefined (a bare ModelRef) is auto — the runtime stamps every ref, but adapters must not care */
-const setting = (e: ThinkingEffort | undefined): Setting => e ?? "auto";
-const NOTHING_AUTO = "nothing — auto: the endpoint's own default stands";
-
-// ------------------------------------------------------------------ Anthropic (Messages API), two shapes
-
-/** Anthropic has TWO request shapes and no model exposes both — see the measured table in stream.ts.
- *  The shape is learned per provider+model from a wrong-shape 400 (stream.ts anthropicPost). */
-export type AnthropicThinkingShape = "effort" | "budget";
-
-/** The budget in tokens per level for the older `thinking.enabled` shape. Steps ~x4 apart so the
- *  levels are felt. The endpoint requires ≥1024 and max_tokens strictly greater (anthropicMaxTokens). */
-export function thinkingBudget(effort: ThinkingEffort | undefined): number | null {
-  switch (effort) {
-    case "low": return 2_048;
-    case "medium": return 8_192;
-    case "high": return 24_576;
-    default: return null; // "off", "auto" and unset: no budget
-  }
-}
-
-/** the request fields that carry the effort, for one shape */
-export function anthropicThinking(effort: ThinkingEffort | undefined, shape: AnthropicThinkingShape): Record<string, unknown> {
-  if (effort === undefined || effort === "auto") return {};              // unset / auto: leave the model's default alone (Claude 5: adaptive, high)
-  if (effort === "off") return { thinking: { type: "disabled" } };       // explicit, deliberate: opus-5 thinks unless told not to
-  if (shape === "effort") return { output_config: { effort } };          // low | medium | high (the API also has xhigh/max)
-  const budget = thinkingBudget(effort);
-  return budget === null ? {} : { thinking: { type: "enabled", budget_tokens: budget } };
-}
-
-function anthropicPlan(level: Setting, shape: AnthropicThinkingShape): ThinkingPlan {
-  const fields = anthropicThinking(level, shape);
-  const says = level === "auto" ? NOTHING_AUTO
-    : level === "off" ? 'thinking: { type: "disabled" } — an explicit off; Claude 5 reasons by default'
-    : `${JSON.stringify(fields).slice(1, -1).replace(/"(\w+)":/g, "$1: ").replace(/,/g, ", ")} (the ${shape} shape — learned from the endpoint, kept per model)`;
-  return { dialect: `anthropic/${shape}`, fields, says };
-}
-
-// ------------------------------------------------------------------ OpenAI-compatible dialects
-
-interface Dialect {
-  id: string;
-  matches(m: ModelRef): boolean;
-  /** never called with "auto" — that is answered centrally with nothing */
-  plan(level: "off" | Level, m: ModelRef): { fields: Record<string, unknown>; says: string };
-}
-
-const q = (s: string): string => JSON.stringify(s);
-const nothing = (why: string): { fields: Record<string, unknown>; says: string } => ({ fields: {}, says: `nothing — ${why}` });
-const word = (w: string, note = ""): { fields: Record<string, unknown>; says: string } => ({ fields: { reasoning_effort: w }, says: `reasoning_effort: ${q(w)}${note ? ` (${note})` : ""}` });
-const onOff = (on: boolean, vendor: string): { fields: Record<string, unknown>; says: string } => ({
-  fields: { thinking: { type: on ? "enabled" : "disabled" } },
-  says: `thinking: { type: ${q(on ? "enabled" : "disabled")} } (${vendor} has an on/off switch, no levels)`,
-});
-const id = (re: RegExp) => (m: ModelRef): boolean => re.test(m.model);
-
-const DIALECTS: readonly Dialect[] = [
-  // the catalog's word first: models.dev says this model has no reasoning mode — a dial would be rejected or ignored
-  { id: "catalog: no reasoning mode", matches: (m) => m.reasoning === false,
-    plan: (_l, m) => nothing(`the catalog lists ${m.model} without a reasoning mode, so no dial is sent`) },
-  // OpenRouter normalizes every upstream behind one object; its own words (low|medium|high, enabled)
-  { id: "openrouter", matches: (m) => m.provider === "openrouter",
-    plan: (l) => l === "off"
-      ? { fields: { reasoning: { enabled: false } }, says: "reasoning: { enabled: false } (OpenRouter's unified field; a model that always reasons ignores it)" }
-      : { fields: { reasoning: { effort: l } }, says: `reasoning: { effort: ${q(l)} } (OpenRouter's unified field, translated per upstream)` } },
-  // GLM-5.3: measured (profiles.ts) — low|high|max, medium rounds up to high, cannot be switched off. The
-  // words come from the wire profile; ROVECODE_PROFILE=off means "no GLM tuning at all", so the plain
-  // OpenAI word goes instead (the A/B the off-switch exists for), and off sends nothing either way.
-  { id: "glm-5.3", matches: id(GLM_53_MODEL_RE),
-    plan: (l, m) => {
-      if (l === "off") return nothing("GLM-5.3 cannot switch thinking off (Z.ai: thinking.type accepts enabled only); the endpoint default is max");
-      const profile = wireProfileFor(m);
-      if (profile === null) return word(l, "ROVECODE_PROFILE=off: the plain word, not GLM's low | high | max");
-      return word(profile.reasoningEffort(l)!, "GLM's words are low | high | max; medium rounds up");
-    } },
-  { id: "glm", matches: id(/(^|[/:])glm-(4\.[5-9]|4\.\d{2,}|5(\.\d+)?)(?=[-:]|$)/i), plan: (l) => onOff(l !== "off", "GLM") },
-  { id: "deepseek", matches: id(/deepseek/i),
-    plan: (l, m) => /reasoner|r1/i.test(m.model) ? nothing(`${m.model} always thinks — no dial`) : onOff(l !== "off", "DeepSeek") },
-  { id: "qwen", matches: id(/(^|[/:])(qwen|qwq)/i),
-    plan: (l, m) => {
-      if (m.provider === "groq") return l === "off" ? word("none", "Groq's Qwen words are none | default") : word("default", "Groq's Qwen words are none | default");
-      if (l === "off") return { fields: { enable_thinking: false }, says: "enable_thinking: false (DashScope / most Qwen hosts; a vLLM host wants chat_template_kwargs instead and ignores this)" };
-      const budget = thinkingBudget(l)!;
-      return { fields: { enable_thinking: true, thinking_budget: budget }, says: `enable_thinking: true, thinking_budget: ${budget} (DashScope's fields; a host without them ignores both)` };
-    } },
-  { id: "kimi", matches: id(/kimi|moonshot/i),
-    plan: (l, m) => /thinking/i.test(m.model) ? nothing(`${m.model} always thinks — no dial`)
-      : /k2[.-]5|k2\.5/i.test(m.model) ? onOff(l !== "off", "Moonshot K2.5") : nothing(`${m.model} has no thinking mode (the -thinking variant does)`) },
-  { id: "gemini", matches: id(/gemini/i),
-    plan: (l, m) => l !== "off" ? word(l, "Google's OpenAI-compatible layer maps low | medium | high to a thinking budget")
-      : /flash/i.test(m.model) ? { fields: { extra_body: { google: { thinking_config: { thinking_budget: 0 } } } }, says: "extra_body.google.thinking_config.thinking_budget: 0 (Flash can switch thinking off; Pro cannot)" }
-      : nothing(`${m.model} cannot switch thinking off (Gemini Pro keeps a minimum budget)`) },
-  // xAI (docs.x.ai, fetched 2026-09-04): grok-4.3 / 4.5 / 4.6 / 4.20 take reasoning_effort none | low | medium | high;
-  // the retired grok-4-0709 / grok-4-fast slugs are served by grok-4.3 since 2026-05-15, so they take the same words
-  { id: "grok", matches: id(/grok/i),
-    plan: (l, m) => /non-reasoning/i.test(m.model) ? nothing(`${m.model} has no reasoning mode`)
-      : /grok-3-mini/i.test(m.model) ? (l === "off" ? nothing("grok-3-mini cannot switch reasoning off") : word(l === "low" ? "low" : "high", "xAI's words for grok-3-mini are low | high; medium rounds up"))
-      : l === "off" ? word("none", "xAI's explicit off (grok-4.3 and later; retired grok-4 slugs are served by grok-4.3)") : word(l, "xAI's words are none | low | medium | high") },
-  { id: "gpt-oss", matches: id(/gpt-oss/i), plan: (l) => l === "off" ? nothing("gpt-oss cannot switch reasoning off (low is the floor)") : word(l) },
-  { id: "openai o-series", matches: id(/(^|[/:])o[134](-|$)/i), plan: (l, m) => l === "off" ? nothing(`${m.model} cannot switch reasoning off`) : word(l) },
-  { id: "openai gpt-5", matches: id(/(^|[/:])gpt-5/i),
-    plan: (l, m) => l !== "off" ? word(l)
-      : /gpt-5\.[1-9]/i.test(m.model) ? word("none", "gpt-5.1 and later: the explicit off") : word("minimal", "gpt-5 has no off; minimal is its floor") },
-  { id: "openai gpt-4 class", matches: id(/(^|[/:])(gpt-4|gpt-3\.5|chatgpt)/i), plan: (_l, m) => nothing(`${m.model} has no reasoning mode and OpenAI rejects reasoning_effort for it`) },
-  { id: "mistral", matches: id(/magistral|mistral|codestral|ministral|pixtral/i),
-    plan: (_l, m) => /magistral/i.test(m.model) ? nothing("Magistral always reasons — no dial") : nothing(`${m.model} has no reasoning mode`) },
-  { id: "minimax", matches: id(/minimax/i), plan: (_l, m) => nothing(`${m.model} always reasons — no dial`) },
-  // the floor for anything else: the OpenAI word; off sends nothing (no common explicit disable)
-  { id: "openai-compatible default", matches: () => true,
-    plan: (l) => l === "off" ? nothing("off sends nothing here: no common explicit disable on OpenAI-compatible endpoints; a model without a reasoning mode ignores the word anyway")
-      : word(l, "the OpenAI word; a model without a reasoning mode ignores it") },
-];
-
-/** the dialect a model on the OpenAI-compatible wire speaks (for docs and the matrix) */
-export function dialectFor(model: ModelRef): Dialect["id"] {
-  return DIALECTS.find((d) => d.matches(model))!.id;
-}
-
-/** what goes on the wire for this model, on this protocol, at its effort — and the sentence that says so */
-export function thinkingPlan(model: ModelRef, protocol: WireProtocol, opts: { shape?: AnthropicThinkingShape } = {}): ThinkingPlan {
-  const level = setting(model.effort);
-  if (protocol === "anthropic") return anthropicPlan(level, opts.shape ?? "effort");
-  const d = DIALECTS.find((x) => x.matches(model))!;
-  if (level === "auto") return { dialect: d.id, fields: {}, says: NOTHING_AUTO };
-  return { dialect: d.id, ...d.plan(level, model) };
-}
-
-/** the five rows `rovecode model show` prints: level → what this model receives */
-export function thinkingTable(model: ModelRef, protocol: WireProtocol, opts: { shape?: AnthropicThinkingShape } = {}): { level: ThinkingEffort; says: string }[] {
-  return (["auto", "off", "low", "medium", "high"] as const).map((level) => ({ level, says: thinkingPlan({ ...model, effort: level }, protocol, opts).says }));
-}
-
-/** the one line the /effort note appends: `<provider/model> receives: <says>` */
-export function thinkingLine(model: ModelRef, protocol: WireProtocol, opts: { shape?: AnthropicThinkingShape } = {}): string {
-  return `${model.provider}/${model.model} receives: ${thinkingPlan(model, protocol, opts).says}`;
-}
-
-/** `rovecode model show`: the model, its protocol and dialect, then every level with what it puts on the
- *  wire — the current level marked. `model.effort` is the current level. */
-export function thinkingReport(model: ModelRef, protocol: WireProtocol, opts: { shape?: AnthropicThinkingShape; source?: string; catalog?: string } = {}): string[] {
-  const current = setting(model.effort);
-  const dialect = protocol === "anthropic" ? `anthropic (${opts.shape ?? "effort"} shape)` : dialectFor(model);
-  const lines = [
-    `${model.provider}/${model.model}${opts.source ? `  (${opts.source})` : ""}`,
-    `  protocol  ${protocol}`,
-    `  dialect   ${dialect}${model.reasoning === false ? "  — the catalog lists no reasoning mode" : model.reasoning === true ? "  — the catalog lists a reasoning mode" : ""}`,
-    ...(opts.catalog ? [`  prices    ${opts.catalog}`] : []), // where the numbers /cost uses come from — models.dev, or rovecode's own table
-    `  effort    ${current}  (ROVECODE_EFFORT / --effort / /effort)`,
-  ];
-  for (const row of thinkingTable(model, protocol, opts)) lines.push(`  ${row.level === current ? "*" : " "} ${row.level.padEnd(7)} ${row.says}`);
-  return lines;
-}

package/src/providers/wire-messages.ts

@@ -1,129 +0,0 @@
-/** Wire message lowering (ADR-003 seam; extracted from stream.ts for the 400-line cap): harness
- *  Message[] → OpenAI chat-completions / Anthropic Messages request shapes. Text and tool shapes
- *  are byte-identical to the pre-#34 stream.ts lowering. Port #34 adds image parts:
- *  - vision model: a USER message carrying images becomes a content-block array in part order —
- *    OpenAI `{type:"image_url", image_url:{url:"data:<mime>;base64,<data>", detail:"auto"}}`,
- *    Anthropic `{type:"image", source:{type:"base64", media_type, data}}`; image-free messages
- *    keep their plain-string content, so nothing changes for existing histories;
- *  - no vision (`vision: false` — stream.ts asks the models.dev catalog): each image lowers to
- *    imagePlaceholder() text and the message stays a plain string. The session keeps the real
- *    image; only the request is substituted (cline media.ts:6-12 pattern, opencode
- *    provider/transform.ts:409-441 unsupportedParts);
- *  - a sidecar that cannot be read lowers to a placeholder too — a request body never throws.
- *  Images on assistant/tool messages are nothing this harness produces (tool results with images
- *  are out of scope for #34): an assistant message WITHOUT tool calls lowers them to placeholder
- *  text (lowerContent's non-user branch); a tool-role message emits its tool_result parts only and
- *  an assistant message WITH tool calls emits partsText + tool_calls, so image parts on those two
- *  shapes are dropped from the request — never turned into blocks. */
-
-import type { Message, ImagePart } from "../core/types.ts";
-import { partsText } from "../core/loop.ts";
-import { anthropicImageBlock, openaiImageBlock, imagePlaceholder } from "../core/images.ts";
-
-export interface WireOptions {
-  /** the target model accepts image input; default true (unknown models are given the image —
-   *  a wrong guess fails loudly at the provider instead of silently dropping the user's image) */
-  vision?: boolean;
-}
-
-type Block = Record<string, unknown>;
-
-/** Content for a non-tool message: the pre-#34 plain string when no image is present; blocks in
- *  part order for a user message the model can see; placeholder text otherwise (text parts glue
- *  with "" exactly as partsText does, each image is its own line). */
-export function lowerContent(m: Message, vision: boolean, toBlock: (p: ImagePart) => Block | undefined): string | Block[] {
-  if (!m.parts.some((p) => p.kind === "image")) return partsText(m.parts);
-  if (vision && m.role === "user") {
-    const blocks: Block[] = [];
-    for (const p of m.parts) {
-      if (p.kind === "text") { if (p.text) blocks.push({ type: "text", text: p.text }); }
-      else if (p.kind === "image") blocks.push(toBlock(p) ?? { type: "text", text: imagePlaceholder(p, "file unavailable") });
-    }
-    return blocks;
-  }
-  const pieces: string[] = [];
-  let text = "";
-  for (const p of m.parts) {
-    if (p.kind === "text") text += p.text;
-    else if (p.kind === "image") {
-      if (text) { pieces.push(text); text = ""; }
-      pieces.push(imagePlaceholder(p, vision ? "file unavailable" : undefined));
-    }
-  }
-  if (text) pieces.push(text);
-  return pieces.join("\n");
-}
-
-export function toOpenAiMessages(messages: Message[], opts: WireOptions = {}): Record<string, unknown>[] {
-  const vision = opts.vision ?? true;
-  const out: Record<string, unknown>[] = [];
-  for (const m of messages) {
-    const calls = m.parts.filter((p) => p.kind === "tool_call");
-    const results = m.parts.filter((p) => p.kind === "tool_result");
-    if (m.role === "tool") {
-      for (const r of results) {
-        if (r.kind === "tool_result") out.push({ role: "tool", tool_call_id: r.callId, content: r.output });
-      }
-      continue;
-    }
-    if (m.role === "assistant" && calls.length > 0) {
-      out.push({
-        role: "assistant",
-        content: partsText(m.parts) || null,
-        tool_calls: calls.map((c) => c.kind === "tool_call" ? {
-          id: c.id, type: "function", function: { name: c.tool, arguments: JSON.stringify(c.args) },
-        } : {}),
-      });
-    } else {
-      const content = lowerContent(m, vision, (p) => openaiImageBlock(p));
-      if (content.length > 0 || m.role === "system") out.push({ role: m.role, content });
-    }
-  }
-  return out;
-}
-
-/** StreamOptions.tools carries bare ToolSchema entries (name/description/args) — that is what
- *  every call site (loop → adapters) passes. Tolerate a {schema} wrapper (a full Tool object)
- *  too, so a mis-passed registry entry degrades gracefully instead of throwing mid-request. */
-export function asToolSchema(t: unknown): { name: string; description: string; args: Record<string, unknown> } {
-  const o = t as { name?: string; description?: string; args?: Record<string, unknown>; schema?: { name: string; description: string; args: Record<string, unknown> } };
-  return o.schema ?? { name: o.name ?? "unknown", description: o.description ?? "", args: o.args ?? {} };
-}
-
-export function toOpenAiToolSchemas(tools: unknown[]): Record<string, unknown>[] {
-  return tools.map((t) => {
-    const s = asToolSchema(t);
-    return { type: "function", function: { name: s.name, description: s.description, parameters: s.args } };
-  });
-}
-
-export function toAnthropicMessages(messages: Message[], opts: WireOptions = {}): Record<string, unknown>[] {
-  const vision = opts.vision ?? true;
-  const out: Record<string, unknown>[] = [];
-  for (const m of messages) {
-    if (m.role === "system") continue;
-    const calls = m.parts.filter((p) => p.kind === "tool_call");
-    const results = m.parts.filter((p) => p.kind === "tool_result");
-    if (m.role === "tool") {
-      for (const r of results) {
-        if (r.kind === "tool_result") {
-          out.push({ role: "user", content: [{ type: "tool_result", tool_use_id: r.callId, content: r.output, is_error: !r.ok }] });
-        }
-      }
-      continue;
-    }
-    if (m.role === "assistant" && calls.length > 0) {
-      const text = partsText(m.parts);
-      const content: Block[] = [];
-      if (text) content.push({ type: "text", text });
-      for (const c of calls) {
-        if (c.kind === "tool_call") content.push({ type: "tool_use", id: c.id, name: c.tool, input: c.args });
-      }
-      out.push({ role: "assistant", content });
-    } else {
-      const content = lowerContent(m, vision, anthropicImageBlock);
-      if (content.length > 0) out.push({ role: m.role === "user" ? "user" : "assistant", content });
-    }
-  }
-  return out;
-}

package/src/providers/wire-responses.ts

@@ -1,79 +0,0 @@
-/** Responses-API message lowering (aion port #75, brought over 2026-09-07) — the `/responses` twin of
- *  wire-messages.ts: harness Message[] → `{ instructions?, input[] }`, ToolSchema[] → flat function tools.
- *  Pattern source (MIT): earendil-works/pi packages/ai/src/api/openai-responses-shared.ts convertResponsesMessages
- *  :184-246 and convertResponsesTools :382-394, with these deviations:
- *  - system text → the request's `instructions` (joined "\n"; omitted when empty — pi :174-181 pushes a
- *    developer/system item instead; codex openai-codex-responses.ts:553 uses `instructions` like this);
- *  - user → `{ role: "user", content: [input_text | input_image] }` (pi :186-206): the image blocks are
- *    `{ type: "input_image", detail: "auto", image_url: "data:<mime>;base64,…" }` under the port #34 vision gate
- *    of wire-messages.ts lowerContent — placeholder text on a model without image input or for a sidecar that
- *    cannot be read (never a throw); an image-free message is ONE input_text;
- *  - assistant → `message , function_call*`: the text becomes `{ type: "message", role: "assistant",
- *    status: "completed", id: "msg_rovecode_<i>", content: [{ type: "output_text", text, annotations: [] }] }`
- *    (pi :229-230 fallback ids; ≤ 64 chars); every tool call is `{ type: "function_call", call_id, name,
- *    arguments }` with NO `id` (pi :253-263 drops the item id when it cannot be paired — rovecode never stores
- *    one, so it is always omitted);
- *  - tool results → `{ type: "function_call_output", call_id, output }`, empty output → "(no tool output)" (pi :89);
- *  - tools are FLAT `{ type: "function", name, description, parameters }` (pi :382-394) — never nested under
- *    `function` like the chat-completions shape (wire-messages.ts toOpenAiToolSchemas).
- *  NOT brought over from aion: reasoning REPLAY. aion stores each Responses reasoning item as a `reasoning`
- *  MessagePart (signature = the item JSON) and replays it verbatim ahead of the assistant message next turn, so
- *  the model gets its own prior chain back. rovecode's MessagePart has no reasoning kind; adding one touches every
- *  exhaustive switch on part.kind (store, export, TUIs, both other wires) and is its own change. Until then each
- *  turn on this wire reasons afresh; the gap is named in `rovecode help env` under ROVECODE_OPENAI_WIRE.
- *  Not ported either: pi's `phase`, text signatures, custom_tool_call / deferred tools, strict mode, surrogate sanitising. */
-
-import type { ImagePart, Message, ModelRef } from "../core/types.ts";
-import { partsText } from "../core/loop.ts";
-import { imageData } from "../core/images.ts";
-import { asToolSchema, lowerContent, type WireOptions } from "./wire-messages.ts";
-
-type Item = Record<string, unknown>;
-
-export interface ResponsesInput { instructions?: string; input: Item[] }
-
-/** what a tool result with empty output is sent as (pi :89 — the API rejects an empty output string) */
-export const NO_TOOL_OUTPUT = "(no tool output)";
-
-/** the Responses input_image block; undefined when the bytes are unavailable (lowerContent then substitutes text) */
-function inputImage(p: ImagePart): Item | undefined {
-  const data = imageData(p);
-  return data === undefined ? undefined : { type: "input_image", detail: "auto", image_url: `data:${p.mime};base64,${data}` };
-}
-
-/** a user message's content list: wire-messages.ts lowerContent's blocks with `text` → `input_text` */
-function userContent(m: Message, vision: boolean): Item[] {
-  const content = lowerContent(m, vision, inputImage);
-  if (typeof content === "string") return content ? [{ type: "input_text", text: content }] : [];
-  return content.map((b) => (b.type === "text" ? { type: "input_text", text: b.text } : b));
-}
-
-export function toResponsesInput(messages: Message[], opts: WireOptions & { model: ModelRef }): ResponsesInput {
-  const vision = opts.vision ?? true;
-  const input: Item[] = [];
-  const instructions = messages.filter((m) => m.role === "system").map((m) => partsText(m.parts)).join("\n");
-  messages.forEach((m, i) => {
-    if (m.role === "system") return;
-    if (m.role === "tool") {
-      for (const p of m.parts) if (p.kind === "tool_result") input.push({ type: "function_call_output", call_id: p.callId, output: p.output || NO_TOOL_OUTPUT });
-      return;
-    }
-    if (m.role === "user") {
-      const content = userContent(m, vision);
-      if (content.length > 0) input.push({ role: "user", content });
-      return;
-    }
-    const text = partsText(m.parts);
-    if (text) input.push({ type: "message", role: "assistant", status: "completed", id: `msg_rovecode_${i}`, content: [{ type: "output_text", text, annotations: [] }] });
-    for (const p of m.parts) if (p.kind === "tool_call") input.push({ type: "function_call", call_id: p.id, name: p.tool, arguments: JSON.stringify(p.args ?? {}) });
-  });
-  return { ...(instructions ? { instructions } : {}), input };
-}
-
-/** flat function tools (pi :382-394); tolerates the {schema} wrapper like toOpenAiToolSchemas */
-export function toResponsesTools(tools: unknown[]): Item[] {
-  return tools.map((t) => {
-    const s = asToolSchema(t);
-    return { type: "function", name: s.name, description: s.description, parameters: s.args };
-  });
-}

package/src/providers/wire-select.ts

@@ -1,53 +0,0 @@
-/** OpenAI wire selection (aion port #75, brought over 2026-09-07): ONE rule that decides, PER CALL, whether an
- *  OpenAI-protocol request goes to `/responses` (providers/responses.ts) or `/chat/completions` (providers/stream.ts
- *  openaiCompatStream / openaiCompatStreaming). The two production factories — providerStream / providerStreaming —
- *  return ONE StreamFn built with `openAiWire`, so a router chain that streams different ModelRefs through the same
- *  StreamFn (providers/router.ts wrap) gets the right wire for each candidate, and the OAuth refresh wrap
- *  (oauth/seam.ts oauthStream) needs no change. The selection is static — no runtime 404 → chat re-issue
- *  (ADR-003: still ONE loop; errors cross as turns).
- *
- *  Precedence (`selectOpenAiWire`):
- *  1. `cfg.wire` — set by the OpenAI OAuth `toAuth` (a ChatGPT token is accepted by the Codex Responses
- *     backend only, oauth/openai.ts) → always that wire, whatever the model;
- *  2. `ROVECODE_OPENAI_WIRE=responses|chat` (read directly, like every ROVECODE_* knob here; no settings key yet)
- *     → that wire, for any provider id; an unrecognised value falls through;
- *  3. `cfg.id === "openai"` and the model is not marked non-reasoning — the runtime's stamp on the ModelRef
- *     (cli/runtime.ts buildDef sets `reasoning` from models.dev) first, else the offline catalog (catalog.ts
- *     supportsReasoning): `true` OR unknown (gpt-5, o3, gpt-5.3-codex, an unlisted gpt-5-codex — the #60/#34
- *     "unknown = fail loudly at the provider" rule, so a Responses-only id absent from the snapshot is not
- *     sent to a 404) → responses;
- *  4. else chat — `openai/gpt-4o`, `openai/gpt-4.1`, EVERY other provider id (`custom`, groq, deepseek,
- *     openrouter, ollama, mock …) keep today's byte-identical `/chat/completions` body. The Anthropic
- *     protocol never consults this module (the factories branch on protocol first).
- *  Pattern source (MIT): earendil-works/pi packages/ai/src/api/openai-responses.ts — pi routes by the model's
- *  declared `api` ("openai-responses" vs "openai-completions") from its model table; rovecode has no per-model
- *  api column, so the catalog's `reasoning` flag stands in for it, with the two explicit overrides above. */
-
-import type { Message, ModelRef, StreamEvent, StreamOptions } from "../core/types.ts";
-import { supportsReasoning } from "./catalog.ts";
-import type { MakeStream } from "./oauth/seam.ts";
-import type { ProviderConfig } from "./stream.ts";
-
-export type OpenAiWire = "responses" | "chat";
-/** the `ROVECODE_OPENAI_WIRE` values */
-export const OPENAI_WIRES: readonly OpenAiWire[] = ["responses", "chat"];
-export const OPENAI_WIRE_ENV = "ROVECODE_OPENAI_WIRE";
-
-/** "responses" | "chat" (trimmed, any case), else undefined — an unrecognised env value falls through to the default rule */
-export function parseWire(v: string | undefined): OpenAiWire | undefined {
-  const t = (v ?? "").trim().toLowerCase();
-  return t === "responses" || t === "chat" ? t : undefined;
-}
-
-/** the wire for THIS request (header precedence). `env` is injectable for tests; production reads process.env. */
-export function selectOpenAiWire(cfg: Pick<ProviderConfig, "id" | "wire">, model: ModelRef, env: Record<string, string | undefined> = process.env): OpenAiWire {
-  return cfg.wire ?? parseWire(env[OPENAI_WIRE_ENV]) ?? (cfg.id === "openai" && (model.reasoning ?? supportsReasoning(model)) !== false ? "responses" : "chat");
-}
-
-/** A MakeStream (oauth/seam.ts shape) whose StreamFn picks `responses` or `chat` per call from the ModelRef
- *  it is given — the same opts (base URL, key, headers) reach whichever adapter serves the call. */
-export function openAiWire(cfg: Pick<ProviderConfig, "id" | "wire">, chat: MakeStream, responses: MakeStream): MakeStream {
-  return (opts) => async function* (model: ModelRef, messages: Message[], options?: StreamOptions): AsyncGenerator<StreamEvent> {
-    yield* (selectOpenAiWire(cfg, model) === "responses" ? responses : chat)(opts)(model, messages, options);
-  };
-}