@providerkit/core 0.15.1 → 0.16.1

package/src/presets.ts

@@ -451,15 +451,50 @@ export const PROVIDER_PRESETS = {
     // by tabrunner's Claude plan sign-in).
     headers: { "anthropic-beta": "claude-code-20250219,oauth-2025-04-20" },
   },
-  /** The Codex backend behind a ChatGPT sign-in — Responses wire, no public
-   *  model list, so these ids are the list. */
+  /**
+   * The Codex backend behind a ChatGPT sign-in — Responses wire, no public
+   * model list, so these ids are the list.
+   *
+   * The endpoint is `/backend-api/codex/responses`, with no version segment.
+   * Without the `path` the adapter appends `/v1/responses`, the POST 404s, and
+   * a 404 classifies as "model": every call failed telling the user their
+   * model id was wrong. `session-id` is the header the official Codex client
+   * sends; the backend keys its prompt cache on it (cc-proxy, in daily use
+   * against this backend, 2026-09).
+   */
   chatgpt: {
     shape: "responses",
     baseUrl: "https://chatgpt.com/backend-api/codex",
+    path: "/responses",
+    sessionHeader: "session-id",
     auth: "oauth",
     defaultModel: "gpt-5.3-codex",
     models: ["gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.5", "gpt-5.4-mini"],
   },
+  /**
+   * A Grok subscription (SuperGrok, X Premium) — the backend the Grok CLI
+   * talks to, Responses wire. Distinct from `xai`, which is the keyed API and
+   * bills per token.
+   *
+   * The two `x-…` headers are what switch the backend into CLI-token mode;
+   * without them the subscription token is refused. The version header is the
+   * Grok CLI release cc-proxy sends by default (2026-09); pass your own in
+   * `headers` when the backend starts asking for a newer one. Tool calls on
+   * this backend are keyed by `call_id` alone, which the adapter follows.
+   */
+  grok: {
+    shape: "responses",
+    baseUrl: "https://cli-chat-proxy.grok.com/v1",
+    path: "/responses",
+    auth: "oauth",
+    defaultModel: "grok-4.7",
+    models: ["grok-4.7", "grok-4.6", "grok-4.5", "grok-composer-2.5-fast"],
+    headers: {
+      "x-xai-token-auth": "xai-grok-cli",
+      "x-grok-client-identifier": "grok-shell",
+      "x-grok-client-version": "0.2.93",
+    },
+  },
   /** Kimi's coding endpoint reached with a subscription token instead of a
    *  key — Kimi bills the two separately. */
   "kimi-plan": {

package/src/providers/anthropic.ts

@@ -1,5 +1,5 @@
 // Anthropic-shape adapter — SSE from POST /v1/messages.
-import { fileRefused, streamError } from "../errors.ts";
+import { fileRefused, streamCut, streamError } from "../errors.ts";
 import { schemaPrompt, toAnthropicToolSchema } from "../schema.ts";
 import { parseToolArgs } from "../tool-args.ts";
 import { streamSse, apiUrl } from "../transport.ts";
@@ -14,6 +14,7 @@ import type {
   Provider,
   ProviderChunk,
   StreamOptions,
+  ToolChoice,
   ToolDefinition,
 } from "../types.ts";
 
@@ -203,6 +204,18 @@ function mapStopReason(reason: string | undefined): FinishReason | undefined {
   }
 }
 
+interface AnthropicToolChoice {
+  type: "auto" | "any" | "none" | "tool";
+  name?: string;
+  disable_parallel_tool_use?: boolean;
+}
+
+function toAnthropicToolChoice(choice: Exclude<ToolChoice, "auto">): AnthropicToolChoice {
+  if (choice === "none") return { type: "none" };
+  if (choice === "required") return { type: "any" };
+  return { type: "tool", name: choice.name };
+}
+
 function partsToAnthropic(content: string | ContentPart[], provider: string): unknown[] {
   if (typeof content === "string") return [{ type: "text", text: content }];
   return content.map((part) => {
@@ -387,13 +400,17 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
           input_schema: toAnthropicToolSchema(tool.inputSchema),
         }));
       }
-      if (opts.toolChoice && opts.toolChoice !== "auto" && !unforced) {
-        request.tool_choice =
-          opts.toolChoice === "none"
-            ? { type: "none" }
-            : opts.toolChoice === "required"
-              ? { type: "any" }
-              : { type: "tool", name: opts.toolChoice.name };
+      const choice =
+        opts.toolChoice && opts.toolChoice !== "auto" && !unforced
+          ? toAnthropicToolChoice(opts.toolChoice)
+          : undefined;
+      // This wire says "one call at a time" inside the tool choice, so asking
+      // for it needs a choice to ride on — `auto` when the caller named none.
+      // `none` calls nothing, so there is nothing to serialize.
+      if (opts.parallelToolCalls === false && offered.length > 0 && choice?.type !== "none") {
+        request.tool_choice = { ...(choice ?? { type: "auto" }), disable_parallel_tool_use: true };
+      } else if (choice) {
+        request.tool_choice = choice;
       }
       // Extended mode, which is all Claude 4.5 and older have, can't think on
       // two kinds of request this adapter sends, so those run without thinking.
@@ -448,6 +465,19 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
       let outputTokens = 0;
       let toolCall: { index: number; id: string; name: string } | null = null;
       let blockIndex = -1;
+      // What proves the turn ended rather than the socket: a stated stop
+      // reason, or `message_stop`. See the check after the loop.
+      let stopped = false;
+      let closed = false;
+      const usageChunk = (): ProviderChunk => ({
+        type: "usage",
+        usage: {
+          inputTokens: freshInputTokens + cachedInputTokens + cacheWriteTokens,
+          cachedInputTokens,
+          cacheWriteTokens,
+          outputTokens,
+        },
+      });
 
       for await (const data of streamSse({
         url: apiUrl(baseUrl, "/v1/messages"),
@@ -463,6 +493,7 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
         provider: id,
         ...(opts.signal ? { signal: opts.signal } : {}),
         ...(config.fetchImpl ? { fetchImpl: config.fetchImpl } : {}),
+        ...(opts.onActivity ? { onActivity: opts.onActivity } : {}),
       })) {
         let event: AnthropicEvent;
         try {
@@ -530,24 +561,26 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
             cachedInputTokens = event.usage?.cache_read_input_tokens ?? cachedInputTokens;
             cacheWriteTokens = event.usage?.cache_creation_input_tokens ?? cacheWriteTokens;
             outputTokens = event.usage?.output_tokens ?? outputTokens;
+            if (event.delta?.stop_reason) stopped = true;
             const finishReason = mapStopReason(event.delta?.stop_reason);
             if (finishReason) yield { type: "finish", finishReason };
             break;
           }
 
           case "message_stop":
-            yield {
-              type: "usage",
-              usage: {
-                inputTokens: freshInputTokens + cachedInputTokens + cacheWriteTokens,
-                cachedInputTokens,
-                cacheWriteTokens,
-                outputTokens,
-              },
-            };
+            closed = true;
+            yield usageChunk();
             break;
         }
       }
+      if (closed) return;
+      // A gateway that states its stop reason and then skips `message_stop`
+      // still finished the turn — and still billed it.
+      if (stopped) {
+        yield usageChunk();
+        return;
+      }
+      throw streamCut(id);
     },
   };
   return withConfiguredFallbacks(provider, config);

package/src/providers/gemini.ts

@@ -5,7 +5,7 @@
 // its own chain of thought on the next turn. Written straight against the REST
 // wire rather than @google/genai, because this package ships zero dependencies
 // and the SDK is a Node-shaped one.
-import { streamError } from "../errors.ts";
+import { ProviderError, streamCut, streamError } from "../errors.ts";
 import { schemaPrompt, toGeminiToolSchema } from "../schema.ts";
 import { parseToolArgs } from "../tool-args.ts";
 import { streamSse, apiUrl } from "../transport.ts";
@@ -257,6 +257,8 @@ interface GeminiResponse {
   };
   /** Present only on the in-band failure below — never on a real candidate. */
   error?: GeminiStatus;
+  /** A prompt Gemini refused outright: no candidate at all, just the reason. */
+  promptFeedback?: { blockReason?: string };
 }
 
 export function createGeminiProvider(config: GeminiConfig): Provider {
@@ -329,6 +331,16 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
       ];
       if (systemParts.length > 0) request.systemInstruction = { parts: systemParts };
       if (tools.length > 0) {
+        // Gemini has no switch for one call per turn. Sending the request
+        // anyway would hand back the parallel calls the caller ruled out.
+        if (opts.parallelToolCalls === false) {
+          throw new ProviderError(
+            id,
+            "invalid",
+            `${id}: Gemini can't limit a turn to one tool call. Leave parallelToolCalls unset ` +
+              "for Gemini models, or run the calls it returns one at a time.",
+          );
+        }
         request.tools = [
           {
             functionDeclarations: tools.map((tool) => ({
@@ -351,6 +363,7 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
       // remembered rather than read off the final chunk.
       let sawFunctionCalls = false;
       let callIndex = 0;
+      let finished = false;
 
       for await (const data of streamSse({
         // Without `?alt=sse` the response is one long JSON array that only
@@ -361,6 +374,7 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
         provider: id,
         ...(opts.signal ? { signal: opts.signal } : {}),
         ...(config.fetchImpl ? { fetchImpl: config.fetchImpl } : {}),
+        ...(opts.onActivity ? { onActivity: opts.onActivity } : {}),
       })) {
         let chunk: GeminiResponse;
         try {
@@ -373,6 +387,14 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
         // throttle or an overload landing after that arrives here as a
         // google.rpc.Status in the body rather than as a status line.
         if (chunk.error) throw streamError(id, chunk.error);
+        // A blocked PROMPT has no candidate to finish, so it reads as a cut
+        // stream — retried, into the same block. It is a content failure.
+        const blocked = chunk.promptFeedback?.blockReason;
+        if (blocked) {
+          throw new ProviderError(id, "content", `${id}: the prompt was blocked (${blocked})`, {
+            code: blocked,
+          });
+        }
 
         if (chunk.usageMetadata) {
           const usage = chunk.usageMetadata;
@@ -385,6 +407,9 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
               // turn by most of what it cost.
               outputTokens: (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0),
               cachedInputTokens: usage.cachedContentTokenCount ?? 0,
+              ...(usage.thoughtsTokenCount !== undefined
+                ? { reasoningTokens: usage.thoughtsTokenCount }
+                : {}),
             },
           };
         }
@@ -428,6 +453,7 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
         }
 
         if (candidate.finishReason) {
+          finished = true;
           yield {
             type: "finish",
             // A turn that called tools finishes as tool_calls whatever the
@@ -437,6 +463,9 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
           };
         }
       }
+      // Gemini states a finish reason on the last candidate of every turn it
+      // completes; a stream that closes without one was cut.
+      if (!finished) throw streamCut(id);
     },
   };
 

package/src/providers/openai.ts

@@ -3,7 +3,7 @@
 // This is the dialect most gateways speak, so one adapter serves OpenAI,
 // OpenRouter, DeepSeek, GLM, Kimi, Groq, Together, vLLM, Ollama and LM Studio.
 // Their divergences are small and named where they appear.
-import { fileRefused, streamError } from "../errors.ts";
+import { fileRefused, streamCut, streamError } from "../errors.ts";
 import { streamSse, apiUrl } from "../transport.ts";
 import { attributionHeaders } from "../attribution.ts";
 import type {
@@ -315,7 +315,14 @@ function partsToOpenAI(content: string | ContentPart[], provider: string): unkno
  */
 export function toOpenAIMessages(messages: readonly ChatMessage[], provider = "openai"): unknown[] {
   const out: unknown[] = [];
+  // Images from a run of tool results, held until the run ends. See "tool".
+  let toolImages: unknown[] = [];
+  const flushToolImages = () => {
+    if (toolImages.length > 0) out.push({ role: "user", content: toolImages });
+    toolImages = [];
+  };
   for (const message of messages) {
+    if (message.role !== "tool") flushToolImages();
     switch (message.role) {
       case "system":
         out.push({ role: "system", content: message.content });
@@ -329,17 +336,16 @@ export function toOpenAIMessages(messages: readonly ChatMessage[], provider = "o
         out.push({ role: "tool", tool_call_id: message.toolCallId, content: message.content });
         // This dialect has no image slot on a tool message — a `tool` role takes
         // text and nothing else. A screenshot a tool hands back therefore
-        // follows as its own user message, which is the only way the model ever
-        // sees it. Dropped instead, the turn reads as a tool that returned
-        // words about a picture nobody was shown.
-        if (message.images?.length) {
-          out.push({
-            role: "user",
-            content: message.images.map((image) => ({
-              type: "image_url",
-              image_url: { url: toDataUri(image) },
-            })),
-          });
+        // follows as a user message, which is the only way the model ever sees
+        // it. Dropped instead, the turn reads as a tool that returned words
+        // about a picture nobody was shown.
+        //
+        // It follows the whole RUN of tool results, not this one: an assistant
+        // turn that made parallel calls needs every answer before any user
+        // message, and an image wedged between two of them is a 400 that
+        // classifies as "invalid" — never retried, never walked to a backup.
+        for (const image of message.images ?? []) {
+          toolImages.push({ type: "image_url", image_url: { url: toDataUri(image) } });
         }
         break;
 
@@ -369,6 +375,7 @@ export function toOpenAIMessages(messages: readonly ChatMessage[], provider = "o
       }
     }
   }
+  flushToolImages();
   return out;
 }
 
@@ -392,9 +399,12 @@ interface OpenAIChunk {
     prompt_tokens?: number;
     completion_tokens?: number;
     prompt_tokens_details?: { cached_tokens?: number };
+    completion_tokens_details?: { reasoning_tokens?: number };
     /** DeepSeek's native API reports the cache-hit count here instead of in
      *  `prompt_tokens_details`, and it is absent from every OpenAI SDK type. */
     prompt_cache_hit_tokens?: number;
+    /** Kimi (Moonshot) puts it at the top level of `usage`. */
+    cached_tokens?: number;
     /** OpenRouter only, from here down: what the call cost, in its credits,
      *  which are US dollars. */
     cost?: unknown;
@@ -487,6 +497,8 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
             parameters: tool.inputSchema,
           },
         }));
+        // Only beside tools: OpenAI refuses the field on a request without any.
+        if (opts.parallelToolCalls === false) request.parallel_tool_calls = false;
       }
       if (opts.toolChoice && opts.toolChoice !== "auto") {
         request.tool_choice =
@@ -561,6 +573,7 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
         ? "/chat/completions"
         : "/v1/chat/completions";
 
+      let ended = false;
       for await (const data of streamSse({
         url: apiUrl(baseUrl, config.path ?? defaultPath),
         headers: {
@@ -575,6 +588,10 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
         provider: id,
         ...(opts.signal ? { signal: opts.signal } : {}),
         ...(config.fetchImpl ? { fetchImpl: config.fetchImpl } : {}),
+        ...(opts.onActivity ? { onActivity: opts.onActivity } : {}),
+        onDone: () => {
+          ended = true;
+        },
       })) {
         let chunk: OpenAIChunk;
         try {
@@ -594,13 +611,15 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
         // A usage-only frame carries no choices — this shape sends it last.
         if (chunk.usage) {
           const input = chunk.usage.prompt_tokens ?? 0;
-          // Two spellings for the same subset. DeepSeek's native endpoint uses
-          // its own field, and reading only the standard one bills every cached
-          // token at the full input rate — on an agent loop, where the re-sent
-          // prefix is overwhelmingly hits, that overstates a run by up to 10×.
+          // Three spellings for the same subset. DeepSeek's native endpoint and
+          // Kimi each use their own field, and reading only the standard one
+          // bills every cached token at the full input rate — on an agent loop,
+          // where the re-sent prefix is overwhelmingly hits, that overstates a
+          // run by up to 10×.
           const cached =
             chunk.usage.prompt_tokens_details?.cached_tokens ??
             chunk.usage.prompt_cache_hit_tokens ??
+            chunk.usage.cached_tokens ??
             0;
           const reportedCostUsd = reportsCost ? openRouterCostUsd(chunk.usage) : undefined;
           yield {
@@ -611,6 +630,9 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
               // Anthropic's, which excludes them. No reconciling to do.
               cachedInputTokens: cached,
               outputTokens: chunk.usage.completion_tokens ?? 0,
+              ...(chunk.usage.completion_tokens_details?.reasoning_tokens !== undefined
+                ? { reasoningTokens: chunk.usage.completion_tokens_details.reasoning_tokens }
+                : {}),
               ...(reportedCostUsd !== undefined ? { reportedCostUsd } : {}),
             },
           };
@@ -653,9 +675,13 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
           if (has) yield out;
         }
 
+        if (choice.finish_reason) ended = true;
         const finishReason = mapFinishReason(choice.finish_reason);
         if (finishReason) yield { type: "finish", finishReason };
       }
+      // Either proof will do: some gateways send `[DONE]` with no finish, and
+      // some a finish with no `[DONE]`. Neither means the socket closed early.
+      if (!ended) throw streamCut(id);
     },
   };