190proof 1.0.113 → 1.0.115

package/README.md

@@ -279,6 +279,8 @@ Optional per-request knobs live on `payload` (`GenericPayload`):
 - `payload.streaming`: `boolean` - OpenRouter-only (default: true). Streams the completion over SSE. A streaming attempt is bounded by two independent timers instead of `requestTimeoutMs`: `streamTimeoutMs` (total wall clock, default 600000) and the per-useful-chunk stall timeout (`chunkTimeoutMs` argument, default 15000). A chunk is "useful" only if it advances content, reasoning, tool-call fragments, finish_reason, or usage — SSE comment keep-alives (`: OPENROUTER PROCESSING`) and role-only deltas don't reset the stall timer, so a hung provider dies within one stall window while a healthy long generation can run to the total budget. Set `streaming: false` for the old single-JSON-body transport.
 - `payload.streamTimeoutMs`: `number` - OpenRouter-only: total wall-clock budget per streaming attempt (default: 600000).
 - `payload.streamDeadlineAt`: `number` - OpenRouter-only: absolute deadline (epoch ms) for the whole call **including retries** — the caller's turn budget. Each attempt gets `min(streamTimeoutMs, deadline - now)`, and once under 10s remain the call fails fast instead of starting a generation that cannot be delivered. Use it whenever the caller has its own timeout: a per-attempt budget alone is re-granted on every retry and can outlive that timeout.
+- `payload.thinkingConfig`: `Record<string, unknown>` - Google-only: forwarded verbatim as `generationConfig.thinkingConfig` on the Gemini request — e.g. `{ thinkingBudget: 0 }` to disable thinking, `{ thinkingLevel: "HIGH" }` on models that take a level. Ignored by all other adapters; shapes are model-specific and validated by Google, not the SDK.
+- `payload.reasoningEffort`: `string` - OpenAI-only: forwarded as `reasoning_effort` on the request. Valid values are model-dependent (`none`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max`). Reasoning-by-default models (the gpt-5.6 family) reject function tools on `/chat/completions` with a 400 unless this is explicitly `"none"` — their implicit default is `medium`. Ignored by all other adapters.
 
 When a streaming attempt is cut at its **total deadline** and prose has already arrived, the partial answer is returned with `truncated: true` on the response rather than discarded — those tokens were generated and billed, so throwing them away costs money and gives the user nothing. Surface such a reply as incomplete. Salvage never applies to tool-call turns (half-streamed arguments are unparseable JSON), to stalls (the provider died mid-thought), or to caller aborts. When nothing is salvageable, the discard is logged with an approximate token count — aborted attempts never receive OpenRouter's `usage` chunk, so that log line is the only record of the wasted spend.
 
@@ -304,6 +306,9 @@ interface ParsedResponseMessage {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    // Reasoning/thinking tokens spent before the visible answer; currently
+    // populated from Google's usageMetadata.thoughtsTokenCount.
+    thoughts_tokens?: number;
   } | null; // null when streaming
 }
 ```

package/dist/index.d.mts

@@ -199,6 +199,13 @@ interface ParsedResponseMessage {
         total_tokens: number;
         /** Prompt tokens served from the provider's cache (subset of prompt_tokens). */
         cached_tokens?: number;
+        /**
+         * Reasoning/thinking tokens spent before the visible answer (subset of
+         * completion_tokens on some providers, separate on others). Currently
+         * populated from Google's `usageMetadata.thoughtsTokenCount`; undefined
+         * when the provider reports none.
+         */
+        thoughts_tokens?: number;
     } | null;
 }
 interface FunctionCall {
@@ -275,11 +282,27 @@ interface GenericPayload {
     };
     temperature?: number;
     fallbackModel?: AnyModel;
+    /**
+     * Google-only: forwarded verbatim as `generationConfig.thinkingConfig` on
+     * the Gemini request — e.g. `{ thinkingBudget: 0 }` to disable thinking or
+     * `{ thinkingLevel: "HIGH" }` on models that take a level. Ignored by all
+     * other adapters. Shapes are model-specific and validated by Google, not
+     * the SDK.
+     */
+    thinkingConfig?: Record<string, unknown>;
     /**
      * OpenRouter-only: provider-routing preferences. Ignored by non-OpenRouter
      * adapters. Forwarded as the request body's `provider` field.
      */
     provider?: OpenRouterProviderPreferences;
+    /**
+     * OpenAI-only: forwarded as `reasoning_effort` on the request. Valid values
+     * are model-dependent (`none`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max`).
+     * Reasoning-by-default models (gpt-5.6 family) 400 on /chat/completions when
+     * function tools are present unless this is explicitly `"none"` — their
+     * implicit default is `medium`. Ignored by all other adapters.
+     */
+    reasoningEffort?: string;
     /**
      * Per-request HTTP timeout in ms for the underlying provider call (applied
      * per attempt, not across retries). Honored by all adapters (Anthropic,

package/dist/index.d.ts

@@ -199,6 +199,13 @@ interface ParsedResponseMessage {
         total_tokens: number;
         /** Prompt tokens served from the provider's cache (subset of prompt_tokens). */
         cached_tokens?: number;
+        /**
+         * Reasoning/thinking tokens spent before the visible answer (subset of
+         * completion_tokens on some providers, separate on others). Currently
+         * populated from Google's `usageMetadata.thoughtsTokenCount`; undefined
+         * when the provider reports none.
+         */
+        thoughts_tokens?: number;
     } | null;
 }
 interface FunctionCall {
@@ -275,11 +282,27 @@ interface GenericPayload {
     };
     temperature?: number;
     fallbackModel?: AnyModel;
+    /**
+     * Google-only: forwarded verbatim as `generationConfig.thinkingConfig` on
+     * the Gemini request — e.g. `{ thinkingBudget: 0 }` to disable thinking or
+     * `{ thinkingLevel: "HIGH" }` on models that take a level. Ignored by all
+     * other adapters. Shapes are model-specific and validated by Google, not
+     * the SDK.
+     */
+    thinkingConfig?: Record<string, unknown>;
     /**
      * OpenRouter-only: provider-routing preferences. Ignored by non-OpenRouter
      * adapters. Forwarded as the request body's `provider` field.
      */
     provider?: OpenRouterProviderPreferences;
+    /**
+     * OpenAI-only: forwarded as `reasoning_effort` on the request. Valid values
+     * are model-dependent (`none`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max`).
+     * Reasoning-by-default models (gpt-5.6 family) 400 on /chat/completions when
+     * function tools are present unless this is explicitly `"none"` — their
+     * implicit default is `medium`. Ignored by all other adapters.
+     */
+    reasoningEffort?: string;
     /**
      * Per-request HTTP timeout in ms for the underlying provider call (applied
      * per attempt, not across retries). Honored by all adapters (Anthropic,

package/dist/index.js

@@ -349,6 +349,7 @@ async function prepareOpenAIPayload(identifier, payload) {
   const preparedPayload = {
     model: payload.model,
     messages: [],
+    reasoning_effort: payload.reasoningEffort,
     tools: (_a = payload.functions) == null ? void 0 : _a.map((fn) => ({
       type: "function",
       function: fn
@@ -948,6 +949,7 @@ async function prepareGoogleAIPayload(_identifier, payload) {
   const preparedPayload = {
     model: payload.model,
     messages: [],
+    thinkingConfig: payload.thinkingConfig,
     tools: payload.functions ? {
       functionDeclarations: payload.functions.map((fn) => ({
         name: fn.name,
@@ -1044,7 +1046,10 @@ async function callGoogleAI(id, payload, requestTimeoutMs = 12e4, signal) {
   const contents = jigGoogleMessages(payload.messages);
   const requestBody = {
     contents,
-    generationConfig: { responseModalities: ["TEXT"] }
+    generationConfig: {
+      responseModalities: ["TEXT"],
+      ...payload.thinkingConfig ? { thinkingConfig: payload.thinkingConfig } : {}
+    }
   };
   if (payload.tools)
     requestBody.tools = [payload.tools];
@@ -1150,7 +1155,8 @@ async function callGoogleAI(id, payload, requestTimeoutMs = 12e4, signal) {
       prompt_tokens: (_o = response.usageMetadata.promptTokenCount) != null ? _o : 0,
       completion_tokens: (_p = response.usageMetadata.candidatesTokenCount) != null ? _p : 0,
       total_tokens: (_q = response.usageMetadata.totalTokenCount) != null ? _q : 0,
-      cached_tokens: (_r = response.usageMetadata.cachedContentTokenCount) != null ? _r : 0
+      cached_tokens: (_r = response.usageMetadata.cachedContentTokenCount) != null ? _r : 0,
+      thoughts_tokens: response.usageMetadata.thoughtsTokenCount
     } : null
   };
 }