zelari-code 2.35.0 → 2.36.0

package/dist/cli/main.bundled.js

@@ -1473,7 +1473,7 @@ var init_anthropicOAuth = __esm({
     init_grokOAuth();
     DEFAULT_ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
     ANTHROPIC_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
-    ANTHROPIC_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+    ANTHROPIC_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
     ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
     ANTHROPIC_SCOPE = "org:create_api_key user:profile user:inference";
     AnthropicOAuthError = class extends Error {
@@ -1495,7 +1495,35 @@ function registerDefaultRefreshImpls() {
   if (!registry.has("chatgpt")) registry.set("chatgpt", chatgptRefreshAdapter);
   if (!registry.has("anthropic")) registry.set("anthropic", anthropicRefreshAdapter);
 }
-var registry, grokRefreshAdapter, chatgptRefreshAdapter, anthropicRefreshAdapter;
+function normalizeRefreshError(providerId, err) {
+  const code = err?.code;
+  const message = err instanceof Error ? err.message : String(err);
+  if (code === "invalid_grant" || message.includes("invalid_grant")) {
+    return new RefreshRejectedError(
+      `${providerId}: refresh token rejected (invalid_grant) \u2014 run /login ${providerId} to re-authenticate`,
+      providerId,
+      err
+    );
+  }
+  return err;
+}
+async function runRefreshImpl(id3, refreshToken) {
+  const existing = inflightRefresh.get(id3);
+  if (existing) return existing;
+  const impl = getRefreshImpl(id3);
+  if (!impl) {
+    throw new Error(`No refresh impl registered for provider "${id3}"`);
+  }
+  const run = Promise.resolve().then(() => impl(id3, refreshToken)).catch((err) => {
+    throw normalizeRefreshError(id3, err);
+  });
+  inflightRefresh.set(id3, run);
+  void run.finally(() => {
+    if (inflightRefresh.get(id3) === run) inflightRefresh.delete(id3);
+  }).catch(() => void 0);
+  return run;
+}
+var registry, grokRefreshAdapter, chatgptRefreshAdapter, anthropicRefreshAdapter, RefreshRejectedError, inflightRefresh;
 var init_refreshRegistry = __esm({
   "src/cli/refreshRegistry.ts"() {
     "use strict";
@@ -1514,6 +1542,17 @@ var init_refreshRegistry = __esm({
     anthropicRefreshAdapter = async (_providerId, refreshToken) => {
       return refreshAnthropicToken({ refreshToken });
     };
+    RefreshRejectedError = class extends Error {
+      constructor(message, providerId, cause) {
+        super(message);
+        this.providerId = providerId;
+        this.cause = cause;
+        this.name = "RefreshRejectedError";
+      }
+      /** Marker callers can check without importing the class. */
+      reloginRequired = true;
+    };
+    inflightRefresh = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1742,11 +1781,7 @@ var init_keyStore = __esm({
       "anthropic"
     ];
     defaultRefreshImpl = async (providerId, refreshToken) => {
-      const impl = getRefreshImpl(providerId);
-      if (!impl) {
-        throw new Error(`No refresh impl registered for provider "${providerId}"`);
-      }
-      return impl(providerId, refreshToken);
+      return runRefreshImpl(providerId, refreshToken);
     };
   }
 });
@@ -1767,10 +1802,11 @@ function effortLevelsFor(id3, model) {
   const m = (model ?? "").trim();
   switch (id3) {
     case "grok":
-    case "openai-compatible":
-    case "custom":
       if (grokHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
       return [...BASE_EFFORTS];
+    case "openai-compatible":
+    case "custom":
+      return [...BASE_EFFORTS, "xhigh", "max"];
     case "chatgpt":
       if (gptHasMax(m)) return [...BASE_EFFORTS, "xhigh", "max"];
       if (gptHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
@@ -1983,13 +2019,14 @@ function translateOpenAiCompatibleThinking(providerId, spec, model) {
       };
   }
 }
-function translateResponsesThinking(spec, model) {
+function translateResponsesThinking(spec, model, providerId) {
   if (spec === "auto") return { patch: {}, degraded: false };
+  const id3 = providerId ?? "chatgpt";
   switch (spec.kind) {
     case "off":
       return { patch: { reasoning: { effort: "minimal" } }, degraded: false };
     case "effort": {
-      const resolved = clampEffort("chatgpt", model, spec.effort);
+      const resolved = clampEffort(id3, model, spec.effort);
       return withClampNote(
         { reasoning: { effort: resolved.effort } },
         resolved.clamped,
@@ -1997,7 +2034,7 @@ function translateResponsesThinking(spec, model) {
       );
     }
     case "budget":
-      return degrade('thinking "budget" is not supported for chatgpt \u2014 use low/medium/high/xhigh/max');
+      return degrade(`thinking "budget" is not supported on the Responses API for "${id3}" \u2014 use low/medium/high/xhigh/max`);
   }
 }
 function translateAnthropicThinking(spec, model) {
@@ -2046,6 +2083,7 @@ __export(providerConfig_exports, {
   clearKrakenVerifier: () => clearKrakenVerifier,
   getActiveModel: () => getActiveModel,
   getActiveProvider: () => getActiveProvider,
+  getApiStyleFor: () => getApiStyleFor,
   getCustomEndpoint: () => getCustomEndpoint,
   getKrakenVerifierOverride: () => getKrakenVerifierOverride,
   getModelForProvider: () => getModelForProvider,
@@ -2054,6 +2092,7 @@ __export(providerConfig_exports, {
   getThinkingForProvider: () => getThinkingForProvider,
   loadProviderConfig: () => loadProviderConfig,
   setActiveProviderId: () => setActiveProviderId,
+  setApiStyleFor: () => setApiStyleFor,
   setCustomEndpoint: () => setCustomEndpoint,
   setKrakenVerifier: () => setKrakenVerifier,
   setModelForProvider: () => setModelForProvider,
@@ -2071,6 +2110,7 @@ function mergeStoredProviderConfig(parsed) {
       modelByProvider: { ...DEFAULTS.modelByProvider, ...parsed.modelByProvider },
       thinkingByProvider: { ...DEFAULTS.thinkingByProvider, ...parsed.thinkingByProvider },
       customEndpoints: mergeCustomEndpoints(parsed.customEndpoints),
+      apiStyleByProvider: mergeApiStyles(parsed.apiStyleByProvider),
       krakenVerifier: mergeKrakenVerifier(parsed.krakenVerifier)
     };
   }
@@ -2084,6 +2124,17 @@ function cloneDefaults() {
     customEndpoints: { ...DEFAULTS.customEndpoints }
   };
 }
+function mergeApiStyles(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const result = {};
+  const validIds = new Set(PROVIDERS.map((p3) => p3.id));
+  for (const [key, value] of Object.entries(raw)) {
+    if (!validIds.has(key)) continue;
+    if (value !== "responses") continue;
+    result[key] = "responses";
+  }
+  return result;
+}
 function applyEnvOverrides(config2) {
   const envActive = process.env.ANATHEMA_ACTIVE_PROVIDER;
   const envModel = process.env.OPENAI_MODEL;
@@ -2155,6 +2206,23 @@ function clearCustomEndpoint(id3) {
   delete config2.customEndpoints[id3];
   writeProviderConfig(config2);
 }
+function getApiStyleFor(id3) {
+  return getProviderConfig().apiStyleByProvider?.[id3] === "responses" ? "responses" : "chat";
+}
+function setApiStyleFor(id3, style) {
+  const spec = PROVIDERS.find((p3) => p3.id === id3);
+  if (!spec) {
+    throw new Error(`Unknown provider id: "${id3}". Available: ${PROVIDERS.map((p3) => p3.id).join(", ")}`);
+  }
+  if (style !== "chat" && style !== "responses") {
+    throw new Error(`Invalid api style: "${style}". Use 'chat' or 'responses'.`);
+  }
+  const config2 = getProviderConfig();
+  if (!config2.apiStyleByProvider) config2.apiStyleByProvider = {};
+  if (style === "chat") delete config2.apiStyleByProvider[id3];
+  else config2.apiStyleByProvider[id3] = "responses";
+  writeProviderConfig(config2);
+}
 function mergeKrakenVerifier(raw) {
   if (!raw || typeof raw !== "object") return void 0;
   const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
@@ -2362,23 +2430,23 @@ async function resolveAuthToken(provider, options) {
   return resolved?.apiKey;
 }
 async function resolveDiscoveryHeaders(provider, authToken) {
-  const headers2 = { Accept: "application/json" };
-  if (!authToken) return headers2;
+  const headers3 = { Accept: "application/json" };
+  if (!authToken) return headers3;
   if (provider === "anthropic") {
-    headers2.Authorization = `Bearer ${authToken}`;
-    headers2["x-api-key"] = authToken;
-    headers2["anthropic-version"] = "2023-06-01";
-    headers2["anthropic-beta"] = "oauth-2025-04-20";
-    return headers2;
+    headers3.Authorization = `Bearer ${authToken}`;
+    headers3["x-api-key"] = authToken;
+    headers3["anthropic-version"] = "2023-06-01";
+    headers3["anthropic-beta"] = "oauth-2025-04-20";
+    return headers3;
   }
-  headers2.Authorization = `Bearer ${authToken}`;
+  headers3.Authorization = `Bearer ${authToken}`;
   if (provider === "chatgpt") {
     const { getOAuthToken: getOAuthToken2 } = await Promise.resolve().then(() => (init_keyStore(), keyStore_exports));
     const accountId = getOAuthToken2("chatgpt")?.accountId;
-    if (accountId) headers2["ChatGPT-Account-Id"] = accountId;
-    headers2["OpenAI-Beta"] = "responses=experimental";
+    if (accountId) headers3["ChatGPT-Account-Id"] = accountId;
+    headers3["OpenAI-Beta"] = "responses=experimental";
   }
-  return headers2;
+  return headers3;
 }
 function parseAnthropicModelsResponse(json3) {
   if (!json3 || typeof json3 !== "object") return [];
@@ -2430,8 +2498,8 @@ async function discoverModelsForProvider(provider, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
   let response;
   try {
-    const headers2 = await resolveDiscoveryHeaders(provider, authToken);
-    response = await fetchImpl(url2, { method: "GET", headers: headers2 });
+    const headers3 = await resolveDiscoveryHeaders(provider, authToken);
+    response = await fetchImpl(url2, { method: "GET", headers: headers3 });
   } catch (err) {
     throw new ModelDiscoveryError(
       `Network error contacting ${url2}: ${err instanceof Error ? err.message : String(err)}`,
@@ -38221,7 +38289,7 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.35.0";
+    CORE_VERSION = "2.36.0";
   }
 });
 
@@ -51016,7 +51084,7 @@ function openaiCompatibleProvider(config2) {
       const forceRecoveryTool = generation?.toolChoice === "required" && capabilities.buildRecovery.forceToolChoice && recoveryAttempt <= capabilities.buildRecovery.maxForcedTurns;
       body.tool_choice = forceRecoveryTool ? "required" : "auto";
     }
-    const headers2 = {
+    const headers3 = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${config2.apiKey}`,
       ...config2.extraHeaders ?? {}
@@ -51024,7 +51092,7 @@ function openaiCompatibleProvider(config2) {
     const affinityHeader = capabilities.promptCache.conversationAffinityHeader;
     const conversationId = params.conversationId?.trim();
     if (affinityHeader && conversationId && conversationId.length <= 256 && !/[\u0000-\u001f\u007f]/.test(conversationId)) {
-      headers2[affinityHeader] = conversationId;
+      headers3[affinityHeader] = conversationId;
     }
     let response;
     let lastErrText = "";
@@ -51049,7 +51117,7 @@ function openaiCompatibleProvider(config2) {
         try {
           response = await fetch(`${config2.baseUrl}/chat/completions`, {
             method: "POST",
-            headers: headers2,
+            headers: headers3,
             body: JSON.stringify(body),
             // Cancel aborts the HTTP request; stream idle is enforced below
             // per-chunk so active multi-minute streams are not killed.
@@ -52958,6 +53026,244 @@ var init_chatgpt = __esm({
   }
 });
 
+// src/cli/provider/responsesApi.ts
+function backoffDelay2(attempt, retryAfterHeader) {
+  if (retryAfterHeader) {
+    const seconds = Number.parseFloat(retryAfterHeader);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, BACKOFF_CAP_MS2);
+    }
+  }
+  return Math.min(BACKOFF_BASE_MS2 * 2 ** attempt, BACKOFF_CAP_MS2);
+}
+function abortableSleep2(ms, signal) {
+  return new Promise((resolve9) => {
+    if (signal?.aborted) return resolve9();
+    const t = setTimeout(resolve9, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve9();
+      },
+      { once: true }
+    );
+  });
+}
+function headers2(config2) {
+  const h = {
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${config2.apiKey}`
+  };
+  if (config2.extraHeaders) Object.assign(h, config2.extraHeaders);
+  return h;
+}
+function responsesApiProvider(config2) {
+  return async function* (params) {
+    const capabilities = capabilitiesFor(params.model, config2.providerId);
+    const { instructions, input } = toInput(params.messages);
+    const body = {
+      model: params.model,
+      stream: true,
+      input
+    };
+    if (instructions) body.instructions = instructions;
+    if (params.tools && params.tools.length > 0) {
+      body.tools = params.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }));
+    }
+    const generation = params.generation;
+    body.temperature = generation?.temperature ?? capabilities.sampling.temperature;
+    const maxTokens = generation?.maxTokens ?? capabilities.maxOutputTokens;
+    if (typeof maxTokens === "number" && maxTokens > 0) {
+      body.max_output_tokens = maxTokens;
+    }
+    const thinkingSpec = config2.thinking ?? "auto";
+    if (thinkingSpec !== "auto") {
+      const t = translateResponsesThinking(thinkingSpec, config2.model, config2.providerId);
+      if (t.degraded) {
+        console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
+      } else {
+        Object.assign(body, t.patch);
+      }
+    }
+    const base2 = config2.baseUrl.replace(/\/$/, "");
+    const url2 = `${base2}/responses`;
+    let response;
+    let lastStatus = 0;
+    let lastErrText = "";
+    for (let attempt = 0; ; attempt++) {
+      const connectController = new AbortController();
+      const connectTimer = setTimeout(
+        () => connectController.abort(
+          new Error(
+            `Provider connect timeout after ${Math.round(PROVIDER_CONNECT_TIMEOUT_MS / 1e3)}s (no response headers). Override ZELARI_PROVIDER_CONNECT_TIMEOUT_MS.`
+          )
+        ),
+        PROVIDER_CONNECT_TIMEOUT_MS
+      );
+      const signals = [connectController.signal];
+      if (params.signal) signals.push(params.signal);
+      try {
+        response = await fetch(url2, {
+          method: "POST",
+          headers: headers2(config2),
+          body: JSON.stringify(body),
+          signal: signals.length === 1 ? signals[0] : AbortSignal.any(signals)
+        });
+      } catch (err) {
+        lastStatus = 0;
+        lastErrText = err instanceof Error ? err.message : String(err);
+        if (params.signal?.aborted) {
+          yield { kind: "error", message: "aborted" };
+          return;
+        }
+        if (attempt < MAX_RETRIES2) {
+          await abortableSleep2(backoffDelay2(attempt, null), params.signal);
+          continue;
+        }
+        yield { kind: "error", message: `Network error: ${lastErrText}` };
+        return;
+      } finally {
+        clearTimeout(connectTimer);
+      }
+      if (response.ok && response.body) break;
+      lastStatus = response.status;
+      lastErrText = await response.text().catch(() => "");
+      if (!RETRYABLE_STATUSES2.has(response.status) || attempt >= MAX_RETRIES2) break;
+      await abortableSleep2(backoffDelay2(attempt, response.headers.get("retry-after")), params.signal);
+      if (params.signal?.aborted) {
+        yield { kind: "error", message: "aborted" };
+        return;
+      }
+    }
+    if (!response || !response.ok || !response.body) {
+      const msg = lastStatus === 0 ? `Network error: ${lastErrText}` : `HTTP ${lastStatus}: ${lastErrText.slice(0, 240)}`;
+      yield { kind: "error", message: msg };
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const tools = /* @__PURE__ */ new Map();
+    let emittedTool = false;
+    const flush = function* (id3) {
+      const t = tools.get(id3);
+      if (!t?.name) return;
+      let args = {};
+      try {
+        args = JSON.parse(t.argsJson || "{}");
+      } catch {
+        args = {};
+      }
+      tools.delete(id3);
+      emittedTool = true;
+      yield { kind: "tool_call", toolCallId: t.id, toolName: t.name, args };
+    };
+    const streamStartedAt = Date.now();
+    let lastUsefulAt = streamStartedAt;
+    const streamDeadline = streamStartedAt + PROVIDER_STREAM_MAX_MS;
+    try {
+      while (true) {
+        const { value, done } = await readChunkWithTimeout(reader, {
+          idleMs: PROVIDER_STREAM_IDLE_MS,
+          deadlineMs: streamDeadline,
+          signal: params.signal,
+          lastUsefulAt: () => lastUsefulAt
+        });
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data:")) continue;
+          const data = trimmed.slice(5).trim();
+          if (!data || data === "[DONE]") continue;
+          let ev;
+          try {
+            ev = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          const type = typeof ev.type === "string" ? ev.type : "";
+          if (type) lastUsefulAt = Date.now();
+          if (type === "response.output_text.delta" && typeof ev.delta === "string") {
+            yield { kind: "text", delta: ev.delta };
+          } else if (type === "response.reasoning_text.delta" && typeof ev.delta === "string") {
+            yield { kind: "thinking", delta: ev.delta };
+          } else if (type === "response.output_item.added") {
+            const item = ev.item;
+            if (item?.type === "function_call") {
+              const id3 = String(item.call_id ?? item.id ?? `fc-${tools.size}`);
+              tools.set(id3, {
+                id: id3,
+                name: typeof item.name === "string" ? item.name : "",
+                argsJson: typeof item.arguments === "string" ? item.arguments : ""
+              });
+            }
+          } else if (type === "response.function_call_arguments.delta") {
+            const itemId = String(ev.item_id ?? ev.call_id ?? "");
+            const existing = itemId ? tools.get(itemId) : [...tools.values()].at(-1);
+            if (existing && typeof ev.delta === "string") existing.argsJson += ev.delta;
+          } else if (type === "response.output_item.done") {
+            const item = ev.item;
+            if (item?.type === "function_call") {
+              const id3 = String(item.call_id ?? item.id ?? "");
+              if (id3) yield* flush(id3);
+            }
+          } else if (type === "response.completed") {
+            const usage = ev.response?.usage;
+            if (usage) {
+              yield {
+                kind: "usage",
+                usage: {
+                  promptTokens: usage.input_tokens ?? usage.prompt_tokens ?? 0,
+                  completionTokens: usage.output_tokens ?? usage.completion_tokens ?? 0,
+                  totalTokens: usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+                }
+              };
+            }
+            yield { kind: "finish", reason: emittedTool ? "tool_calls" : "stop" };
+            return;
+          } else if (type === "response.failed" || type === "error") {
+            const msg = typeof ev.message === "string" ? ev.message : JSON.stringify(ev.error ?? ev).slice(0, 200);
+            yield { kind: "error", message: msg };
+            return;
+          }
+        }
+      }
+      for (const id3 of [...tools.keys()]) yield* flush(id3);
+      yield { kind: "finish", reason: emittedTool ? "tool_calls" : "stop" };
+    } finally {
+      reader.releaseLock();
+    }
+  };
+}
+var RETRYABLE_STATUSES2, MAX_RETRIES2, BACKOFF_BASE_MS2, BACKOFF_CAP_MS2;
+var init_responsesApi = __esm({
+  "src/cli/provider/responsesApi.ts"() {
+    "use strict";
+    init_openai_compatible();
+    init_chatgpt();
+    init_thinking();
+    init_capabilities();
+    RETRYABLE_STATUSES2 = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+    MAX_RETRIES2 = (() => {
+      const raw = process.env.ZELARI_PROVIDER_MAX_RETRIES;
+      const n = raw ? Number.parseInt(raw, 10) : 3;
+      return Number.isFinite(n) && n >= 0 ? n : 3;
+    })();
+    BACKOFF_BASE_MS2 = 500;
+    BACKOFF_CAP_MS2 = 8e3;
+  }
+});
+
 // src/cli/provider/resolveStream.ts
 var resolveStream_exports = {};
 __export(resolveStream_exports, {
@@ -52966,6 +53272,9 @@ __export(resolveStream_exports, {
 function buildProviderStream(config2) {
   if (config2.providerId === "anthropic") return anthropicMessagesProvider(config2);
   if (config2.providerId === "chatgpt") return chatgptResponsesProvider(config2);
+  if (getApiStyleFor(config2.providerId) === "responses") {
+    return responsesApiProvider(config2);
+  }
   return openaiCompatibleProvider(config2);
 }
 var init_resolveStream = __esm({
@@ -52974,6 +53283,8 @@ var init_resolveStream = __esm({
     init_openai_compatible();
     init_anthropic();
     init_chatgpt();
+    init_responsesApi();
+    init_providerConfig();
   }
 });
 
@@ -60440,11 +60751,11 @@ var init_httpTransport = __esm({
         const sid = this.sessionId;
         this.sessionId = null;
         if (!sid) return;
-        const headers2 = {
+        const headers3 = {
           ...this.opts.headers ?? {},
           "mcp-session-id": sid
         };
-        void fetch(this.opts.url, { method: "DELETE", headers: headers2 }).catch(() => {
+        void fetch(this.opts.url, { method: "DELETE", headers: headers3 }).catch(() => {
         });
       }
       // ── internals ────────────────────────────────────────────────────────
@@ -60454,15 +60765,15 @@ var init_httpTransport = __esm({
         const timer = setTimeout(() => ac.abort(), timeoutMs2 + ABORT_GRACE_MS);
         const hadSession = this.sessionId !== null;
         try {
-          const headers2 = {
+          const headers3 = {
             "content-type": "application/json",
             accept: "application/json, text/event-stream",
             ...this.opts.headers ?? {}
           };
-          if (this.sessionId) headers2["mcp-session-id"] = this.sessionId;
+          if (this.sessionId) headers3["mcp-session-id"] = this.sessionId;
           const res = await fetch(this.opts.url, {
             method: "POST",
-            headers: headers2,
+            headers: headers3,
             signal: ac.signal,
             body: JSON.stringify({ jsonrpc: "2.0", ...msg })
           });
@@ -65494,6 +65805,16 @@ function handleProviderPicker(ctx, openPicker) {
 function handleProviderCustom(ctx, opts) {
   const id3 = ctx.activeProviderSpec.id;
   try {
+    if (opts.apiStyle) {
+      if (id3 === "chatgpt" || id3 === "anthropic") {
+        appendSystem(ctx.setMessages, `[provider] ${id3} has a fixed transport \u2014 nothing to select.`);
+        return;
+      }
+      setApiStyleFor(id3, opts.apiStyle);
+      const target = opts.apiStyle === "responses" ? "POST /responses" : "POST /chat/completions";
+      appendSystem(ctx.setMessages, `[provider] ${id3} endpoint style set to ${opts.apiStyle} (${target})`);
+      return;
+    }
     if (opts.clear) {
       clearCustomEndpoint(id3);
       appendSystem(ctx.setMessages, `[provider] cleared custom endpoint for ${id3} \u2014 falling back to default`);
@@ -70095,6 +70416,7 @@ function parseSetConfigFlags(argv) {
   let model;
   let endpoint;
   let thinking;
+  let apiStyle;
   let endpointClear = false;
   let verifierProvider;
   let verifierModel;
@@ -70113,6 +70435,9 @@ function parseSetConfigFlags(argv) {
     } else if (arg === "--thinking") {
       thinking = argv[i + 1];
       i++;
+    } else if (arg === "--api-style") {
+      apiStyle = argv[i + 1];
+      i++;
     } else if (arg === "--endpoint-clear") {
       endpointClear = true;
     } else if (arg === "--verifier-provider") {
@@ -70125,7 +70450,7 @@ function parseSetConfigFlags(argv) {
       verifierClear = true;
     }
   }
-  if (!provider && !model && !endpoint && !endpointClear && !thinking && !verifierProvider && !verifierModel && !verifierClear) {
+  if (!provider && !model && !endpoint && !endpointClear && !thinking && !apiStyle && !verifierProvider && !verifierModel && !verifierClear) {
     return {
       request: null,
       error: "--set-config: nothing to update \u2014 provide at least one of --provider, --model, --endpoint, --thinking, --verifier-provider + --verifier-model, --verifier-clear, or --endpoint-clear"
@@ -70140,6 +70465,9 @@ function parseSetConfigFlags(argv) {
   if (endpoint !== void 0 && endpoint.trim().length === 0) {
     return { request: null, error: "--endpoint cannot be empty" };
   }
+  if (apiStyle !== void 0 && apiStyle !== "chat" && apiStyle !== "responses") {
+    return { request: null, error: "invalid --api-style " + apiStyle + " (use chat or responses)" };
+  }
   if (verifierClear && (verifierProvider || verifierModel)) {
     return { request: null, error: "--verifier-clear conflicts with --verifier-provider/--verifier-model" };
   }
@@ -70164,6 +70492,7 @@ function parseSetConfigFlags(argv) {
       model: model?.trim(),
       endpoint: endpoint?.trim(),
       endpointClear: endpointClear || void 0,
+      apiStyle,
       thinking: thinking?.trim().toLowerCase(),
       verifierProvider: verifierProvider?.trim(),
       verifierModel: verifierModel?.trim(),
@@ -70243,6 +70572,7 @@ function buildDesktopConfigSnapshot() {
       models,
       defaultModel,
       endpoint: custom2 ?? null,
+      apiStyle: p3.id === "anthropic" || p3.id === "chatgpt" ? void 0 : getApiStyleFor(p3.id),
       baseUrl: custom2 ?? builtin,
       authKind: !hasKey ? "none" : oauth ? "oauth" : "api_key",
       expiresAt: stored?.expiresAt ?? null,
@@ -70289,6 +70619,9 @@ function applySetConfig(req) {
     if (req.endpoint) {
       setCustomEndpoint(targetProvider, req.endpoint);
     }
+    if (req.apiStyle) {
+      setApiStyleFor(targetProvider, req.apiStyle);
+    }
     if (req.model) {
       setModelForProvider(targetProvider, req.model);
     }
@@ -79657,6 +79990,24 @@ ${formatSkillList(availableSkills)}`
           customEndpoint: url2
         };
       }
+      if (subcommand === "api") {
+        const target = args[1];
+        if (!target || target === "show") {
+          return {
+            handled: true,
+            kind: "provider_custom",
+            message: "Usage: /provider api chat \u2014 POST /chat/completions (default)\n         /provider api responses \u2014 POST /responses (OpenAI Responses API)\nApplies to the active provider; chatgpt/anthropic have a fixed transport."
+          };
+        }
+        if (target !== "chat" && target !== "responses") {
+          return {
+            handled: true,
+            kind: "provider_custom",
+            message: `[provider] unknown api style: ${target}. Use: chat | responses`
+          };
+        }
+        return { handled: true, kind: "provider_custom", apiStyle: target };
+      }
       const providerId = subcommand;
       const sub = args[1];
       if (sub === "refresh") {
@@ -81013,27 +81364,27 @@ function parseCsv(text) {
     records.pop();
   }
   if (records.length === 0) return { headers: [], rows: [] };
-  const headers2 = records[0];
+  const headers3 = records[0];
   const rows = records.slice(1).map((r) => {
     const obj = {};
-    for (let i = 0; i < headers2.length; i++) obj[headers2[i]] = r[i] ?? "";
+    for (let i = 0; i < headers3.length; i++) obj[headers3[i]] = r[i] ?? "";
     return obj;
   });
-  return { headers: headers2, rows };
+  return { headers: headers3, rows };
 }
 function applyTemplate(template, row) {
   return template.replace(/\{([a-zA-Z_][\w-]*)\}/g, (_, k) => row[k] ?? "");
 }
-function serializeCsv(headers2, rows) {
+function serializeCsv(headers3, rows) {
   const escape = (v) => {
     if (v.includes(",") || v.includes("\n") || v.includes('"')) {
       return `"${v.replace(/"/g, '""')}"`;
     }
     return v;
   };
-  const out = [headers2.map(escape).join(",")];
+  const out = [headers3.map(escape).join(",")];
   for (const row of rows) {
-    out.push(headers2.map((h) => escape(row[h] ?? "")).join(","));
+    out.push(headers3.map((h) => escape(row[h] ?? "")).join(","));
   }
   return out.join("\n") + "\n";
 }
@@ -81047,21 +81398,21 @@ async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
   const absCsv = path80.isAbsolute(args.csv_path) ? args.csv_path : path80.join(opts.parentCwd, args.csv_path);
   const absOut = path80.isAbsolute(args.output_csv_path) ? args.output_csv_path : path80.join(opts.parentCwd, args.output_csv_path);
-  const { headers: headers2, rows } = await readCsv(absCsv);
-  if (headers2.length === 0) {
+  const { headers: headers3, rows } = await readCsv(absCsv);
+  if (headers3.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
   }
   if (!args.id_column) {
     throw new Error("kraken_csv_fanout: id_column is required");
   }
-  if (!headers2.includes(args.id_column)) {
-    throw new Error(`kraken_csv_fanout: id_column "${args.id_column}" not in CSV header [${headers2.join(", ")}]`);
+  if (!headers3.includes(args.id_column)) {
+    throw new Error(`kraken_csv_fanout: id_column "${args.id_column}" not in CSV header [${headers3.join(", ")}]`);
   }
   const concurrency = args.max_concurrency ?? resolveMaxConcurrency();
   opts.onLog?.(`csv fanout: ${rows.length} rows \xD7 ${args.agent_kind} @ concurrency=${concurrency}`);
   const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? TASK_TOOL_TIMEOUT_MS : 3e5;
   const outputRecords = rows.map((r) => ({ ...r, status: "pending", result: "", error: "" }));
-  const outHeaders = [...headers2, "status", "result", "error"];
+  const outHeaders = [...headers3, "status", "result", "error"];
   let writeChain2 = Promise.resolve();
   function queueWrite(contents) {
     const next = writeChain2.then(() => atomicWrite(absOut, contents));
@@ -82422,6 +82773,7 @@ function useSlashDispatch(params) {
       handleProviderCustom(providerCtx, {
         endpoint: result.customEndpoint,
         clear: result.customClear,
+        apiStyle: result.apiStyle,
         message: result.message
       });
       setInput("");