@jxburros/ai-nugget 0.6.0 → 0.7.0

package/README.md

@@ -1,6 +1,6 @@
 # AI Nugget
 
-**Version 0.6.0** · [What's changed since 0.5.0](#whats-changed-since-050) · [Changelog](./CHANGELOG.md) · [Upgrading](./UPGRADING.md)
+**Version 0.7.0** · [What's changed since 0.6.0](#whats-changed-since-060) · [Changelog](./CHANGELOG.md) · [Upgrading](./UPGRADING.md)
 
 A small, zero-dependency, isomorphic TypeScript nugget for talking to AI model
 providers through one pipeline:
@@ -108,12 +108,35 @@ new AIHandler({
 - **Seams** — `KeySource` (env/literal/memory/chain + ref parsing), `Redactor`,
   neutral `GovernancePolicy` (`blocklistPolicy`/`allowlistPolicy`/`composePolicies`),
   `TelemetrySink`, and an optional `pricing` hook. `providerOptions` passes
-  provider-native fields through without waiting for a library release.
+  provider-native fields through without waiting for a library release;
+  `reasoningEffort` is one word for "how hard should the model think", mapped
+  per provider ([docs](./docs/providers.md#reasoning-effort)).
 - **Agent layer** (`@jxburros/ai-nugget/agent`) — `defineTool`, `runAgent()`
   model↔tool loop over the full pipeline, streamed `AgentEvent`s, budgets with
   honest `stopReason`s, an `ApprovalGate` for side-effecting tools, and
   `native`/`promptJson`/`auto` tool modes.
 
+## What's changed since 0.6.0
+
+**0.7.0 is backward-compatible for ordinary consumers** — the first two changes are additive; the third changes what `delta` carries for reasoning models (see UPGRADING). Full detail in the
+[changelog](./CHANGELOG.md) and [UPGRADING.md](./UPGRADING.md#06x--070).
+
+- **`ChatRequest.reasoningEffort`** (`none` / `minimal` / `low` / `medium` /
+  `high`) — one vocabulary for reasoning effort, mapped onto OpenAI
+  `reasoning_effort`, Anthropic `thinking`, Google `thinkingConfig`, and Ollama
+  `think`; forwarded by the agent loop via `AgentOptions.reasoningEffort`.
+  Never sent unless you set it. See [Reasoning effort](./docs/providers.md#reasoning-effort).
+- **OpenAI reasoning models can call tools again.** `/chat/completions` refuses
+  function tools unless `reasoning_effort` is `'none'`; the `openaiChat` engine
+  now retries that one request with it set and emits a
+  `reasoning_effort_disabled_for_tools` context event so the change is visible.
+  Learned from AI Server Studio's Build 3 shakedown, where every tool-using
+  turn on `gpt-5.x`/`gpt-6` 400'd.
+- **Inline `<think>` reasoning never reaches `delta` or `result.text`.** The
+  handler strips it on every engine and emits it as `reasoning` events
+  (`stripInlineReasoning: false` opts out). Ported from the stripper AI Server
+  Studio had to run at every call site. See [Inline reasoning](./docs/providers.md#inline-reasoning-is-stripped-at-the-seam).
+
 ## What's changed since 0.5.0
 
 **0.6.0 is backward-compatible** — every change below is additive. The one thing
@@ -177,3 +200,9 @@ seam), and not a UI. The governance seam ships neutral: it is where an app *can*
 enforce rules, not a place the library imposes its own.
 
 <!-- GitHub Pages deployment is configured in .github/workflows/pages.yml. -->
+
+---
+
+## Project Stewardship
+
+This project is developed by **Jeffrey** through **JX Holdings, LLC**. GitHub: [`jxburros`](https://github.com/jxburros).

package/UPGRADING.md

@@ -1,5 +1,29 @@
 # Upgrading
 
+## 0.6.x → 0.7.0
+
+**Backward-compatible for ordinary consumers.** Two additive changes and one
+default-behaviour change worth knowing about:
+
+- **Inline reasoning is stripped by default.** A model that writes
+  `<think>…</think>` (or `<thinking>`, `<reasoning>`, `<|begin_of_thought|>`)
+  into its answer no longer has that text in `delta` events or
+  `ChatResult.text`; it arrives as `{ type: 'reasoning', text }` events, the
+  same channel a provider-native thinking field already used. If your app
+  parsed or displayed those tags itself, either delete that code or pass
+  `new AIHandler({ stripInlineReasoning: false })` to keep the raw text.
+
+- **`ChatRequest.reasoningEffort`** (and `AgentOptions.reasoningEffort`) — a
+  new optional field. Nothing is sent to any provider unless you set it. If you
+  already pass `reasoning_effort` / `thinking` / `thinkingConfig` / `think`
+  through `providerOptions`, that keeps winning on collision.
+- **A new `context` stream event, `reasoning_effort_disabled_for_tools`** — the
+  `openaiChat` engine emits it when it retried a tool-using request with
+  `reasoning_effort: 'none'` after OpenAI refused the first attempt. Ignoring
+  it keeps the old behaviour minus the 400. If you *want* the hard failure
+  instead (to route to `/v1/responses` yourself), set `reasoningEffort: 'none'`
+  explicitly on tool-using turns — then no retry happens and any 400 is yours.
+
 ## 0.5.x → 0.6.0
 
 Behavior-compatible for ordinary consumers, with **two things worth checking**.

package/dist/adapters/engines/anthropic.js

@@ -1,7 +1,7 @@
 import { AIError } from '../../errors.js';
 import { estimatedUsage } from '../../tokens.js';
 import { fetchJson, postResponse, sseLines } from '../../transport.js';
-import { applyProviderOptions, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
+import { applyProviderOptions, REASONING_BUDGET_TOKENS, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
 import { DEFAULT_TIMEOUT_MS, parseArgs, randomId, safeParse, streamAnomaly, streamError, streamTimeout } from './base.js';
 const JSON_MODE_TOOL = 'json_output';
 export class AnthropicAdapter {
@@ -210,6 +210,24 @@ function body(req, jsonMode) {
         else if (req.toolChoice === 'none')
             base.tool_choice = { type: 'none' };
     }
+    if (req.reasoningEffort !== undefined) {
+        // First-class reasoning effort → extended thinking. Anthropic requires
+        // `budget_tokens < max_tokens` and rejects temperature/top_p alongside
+        // thinking, so the budget is fitted under max_tokens (raising max_tokens
+        // when the caller's value leaves no room) and the samplers are dropped.
+        if (req.reasoningEffort === 'none') {
+            base.thinking = { type: 'disabled' };
+        }
+        else {
+            const budget = REASONING_BUDGET_TOKENS[req.reasoningEffort];
+            const maxTokens = typeof base.max_tokens === 'number' ? base.max_tokens : 4096;
+            if (maxTokens <= budget)
+                base.max_tokens = budget + 1024;
+            base.thinking = { type: 'enabled', budget_tokens: budget };
+            delete base.temperature;
+            delete base.top_p;
+        }
+    }
     // providerOptions carries Anthropic-native fields (`thinking`, `metadata`,
     // top-level `cache_control` extras, `service_tier`, …) without a release.
     return applyProviderOptions(base, req.providerOptions);

package/dist/adapters/engines/google.js

@@ -1,7 +1,7 @@
 import { AIError } from '../../errors.js';
 import { estimatedUsage } from '../../tokens.js';
 import { fetchJson, postResponse, sseLines } from '../../transport.js';
-import { applyProviderOptions, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
+import { applyProviderOptions, REASONING_BUDGET_TOKENS, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
 import { DEFAULT_TIMEOUT_MS, randomId, safeParse, streamAnomaly, streamError, streamTimeout } from './base.js';
 export class GoogleAdapter {
     provider;
@@ -184,6 +184,13 @@ function body(req) {
             config.allowedFunctionNames = [req.toolChoice.name];
         payload.toolConfig = { functionCallingConfig: config };
     }
+    if (req.reasoningEffort !== undefined) {
+        // First-class reasoning effort → Gemini's thinking budget. 0 disables
+        // thinking on models that allow it; others treat it as a minimum.
+        payload.generationConfig.thinkingConfig = {
+            thinkingBudget: REASONING_BUDGET_TOKENS[req.reasoningEffort],
+        };
+    }
     // providerOptions reaches Google-native fields: top-level `safetySettings`,
     // `cachedContent`, and `generationConfig` extras (`thinkingConfig`,
     // `responseModalities`, …) merged one level deep into generationConfig.

package/dist/adapters/engines/ollama.js

@@ -172,6 +172,12 @@ function body(req) {
         format: req.responseFormat?.type === 'json' ? (req.responseFormat.schema ?? 'json') : undefined,
         tools: req.tools?.map((tool) => ({ type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } })),
     };
+    // First-class reasoning effort → Ollama's `think` flag (reasoning arrives in
+    // `message.thinking`, which this engine already routes to `reasoning` events).
+    // Ollama has no graded effort for most models, so anything but `'none'` is
+    // `true`. Only sent when asked for: a model without thinking support rejects it.
+    if (req.reasoningEffort !== undefined)
+        base.think = req.reasoningEffort !== 'none';
     // providerOptions reaches Ollama's real request fields — `options.num_ctx`,
     // `options.num_keep`, top-level `keep_alive`, `think`, etc. `options` is
     // merged one level deep so num_ctx joins the samplers above rather than

package/dist/adapters/engines/openaiChat.d.ts

@@ -13,4 +13,10 @@ export declare class OpenAIChatAdapter implements ProviderAdapter {
     }>;
     embed(conn: ResolvedConnection, req: EmbedRequest): Promise<EmbedResult>;
 }
+/**
+ * True when a `/chat/completions` 400 is the "function tools with reasoning_effort
+ * are not supported" refusal AND the request actually carried tools AND the caller
+ * did not already pin `reasoning_effort` (in which case the choice is theirs).
+ */
+export declare function shouldRetryWithoutReasoningEffort(error: unknown, req: ChatRequest): boolean;
 //# sourceMappingURL=openaiChat.d.ts.map

package/dist/adapters/engines/openaiChat.js

@@ -34,7 +34,34 @@ export class OpenAIChatAdapter {
         const timeout = streamTimeout(conn, req.signal);
         yield { type: 'start', callId: '', provider: conn.provider, model: req.model };
         try {
-            const res = await postResponse(urlFor(conn, this.profile, req), openAiBody(req, this.profile), conn.headers, timeout.signal, conn.provider);
+            let res;
+            try {
+                res = await postResponse(urlFor(conn, this.profile, req), openAiBody(req, this.profile), conn.headers, timeout.signal, conn.provider);
+            }
+            catch (error) {
+                // OpenAI's `/chat/completions` refuses function tools on a reasoning model
+                // unless `reasoning_effort` is `'none'` ("Function tools with reasoning_effort
+                // are not supported … use /v1/responses or set reasoning_effort to 'none'").
+                // The nugget never sets `reasoning_effort` itself, so the provider default
+                // applies and every tool-using turn 400s. Rather than make each app learn
+                // this the hard way, retry the one request once with the effort disabled
+                // and say so on the stream. Reactive on purpose: sending
+                // `reasoning_effort` up front would 400 on non-reasoning models instead.
+                // A caller-requested effort is overridden too — the alternative is a hard
+                // 400 with no tool call at all — and the context event says so.
+                if (!shouldRetryWithoutReasoningEffort(error, req))
+                    throw error;
+                yield {
+                    type: 'context',
+                    kind: 'reasoning_effort_disabled_for_tools',
+                    data: {
+                        reason: 'provider rejected function tools with reasoning_effort; retried with reasoning_effort: none',
+                        requested: req.providerOptions?.reasoning_effort ?? req.reasoningEffort ?? null,
+                    },
+                };
+                const retryReq = { ...req, providerOptions: { ...req.providerOptions, reasoning_effort: 'none' } };
+                res = await postResponse(urlFor(conn, this.profile, retryReq), openAiBody(retryReq, this.profile), conn.headers, timeout.signal, conn.provider);
+            }
             const contentType = res.headers.get('content-type') ?? '';
             if (!contentType.includes('text/event-stream')) {
                 // Server ignored stream:true (or is a buffered gateway) — recover the whole body.
@@ -169,6 +196,10 @@ function openAiBody(req, profile) {
     };
     if (req.maxTokens !== undefined)
         body[profile.quirks?.maxTokensParam ?? 'max_tokens'] = req.maxTokens;
+    // First-class reasoning effort → OpenAI's `reasoning_effort`. Only sent when
+    // asked for: non-reasoning models reject the parameter outright.
+    if (req.reasoningEffort !== undefined)
+        body.reasoning_effort = req.reasoningEffort;
     // providerOptions carries OpenAI-native fields the nugget doesn't model
     // (`reasoning_effort`, `parallel_tool_calls`, `seed`, `logprobs`, …). `apiVersion`
     // is consumed by urlFor for Azure and stripped here so it never hits the body.
@@ -255,4 +286,23 @@ function mapFinish(finish, hasToolCalls) {
         return 'content_filter';
     return 'stop';
 }
+/**
+ * True when a `/chat/completions` 400 is the "function tools with reasoning_effort
+ * are not supported" refusal AND the request actually carried tools AND the caller
+ * did not already pin `reasoning_effort` (in which case the choice is theirs).
+ */
+export function shouldRetryWithoutReasoningEffort(error, req) {
+    if (!(error instanceof AIError) || error.status !== 400)
+        return false;
+    if (!req.tools || req.tools.length === 0)
+        return false;
+    // Already `'none'` (from either knob) — the refusal is about something else.
+    const effective = req.providerOptions && 'reasoning_effort' in req.providerOptions
+        ? req.providerOptions.reasoning_effort
+        : req.reasoningEffort;
+    if (effective === 'none')
+        return false;
+    const text = `${error.raw ?? ''} ${error.message}`.toLowerCase();
+    return text.includes('reasoning_effort') && text.includes('tool');
+}
 //# sourceMappingURL=openaiChat.js.map

package/dist/agent/loop.d.ts

@@ -1,5 +1,5 @@
 import type { AIHandler } from '../handler.js';
-import type { AIErrorKind, ChatMessage, Connection, StreamEvent, ToolCall, Usage } from '../types.js';
+import type { AIErrorKind, ChatMessage, Connection, ReasoningEffort, StreamEvent, ToolCall, Usage } from '../types.js';
 import type { ToolSpec } from './tools.js';
 export interface AgentOptions {
     handler: AIHandler;
@@ -30,6 +30,8 @@ export interface AgentOptions {
     maxTokens?: number;
     topP?: number;
     stopSequences?: string[];
+    /** Reasoning effort forwarded to every turn — see {@link ChatRequest.reasoningEffort}. */
+    reasoningEffort?: ReasoningEffort;
     /** Provider-native passthrough forwarded to every turn — see {@link ChatRequest.providerOptions}. */
     providerOptions?: Record<string, unknown>;
     budget?: {

package/dist/agent/loop.js

@@ -46,6 +46,7 @@ async function* run(opts, resolveResult) {
                 maxTokens: opts.maxTokens,
                 topP: opts.topP,
                 stopSequences: opts.stopSequences,
+                reasoningEffort: opts.reasoningEffort,
                 providerOptions: opts.providerOptions,
                 signal: agentSignal.signal,
                 metadata: { ...opts.metadata, agentStep: step },

package/dist/cjs/adapters/engines/anthropic.js

@@ -214,6 +214,24 @@ function body(req, jsonMode) {
         else if (req.toolChoice === 'none')
             base.tool_choice = { type: 'none' };
     }
+    if (req.reasoningEffort !== undefined) {
+        // First-class reasoning effort → extended thinking. Anthropic requires
+        // `budget_tokens < max_tokens` and rejects temperature/top_p alongside
+        // thinking, so the budget is fitted under max_tokens (raising max_tokens
+        // when the caller's value leaves no room) and the samplers are dropped.
+        if (req.reasoningEffort === 'none') {
+            base.thinking = { type: 'disabled' };
+        }
+        else {
+            const budget = util_js_1.REASONING_BUDGET_TOKENS[req.reasoningEffort];
+            const maxTokens = typeof base.max_tokens === 'number' ? base.max_tokens : 4096;
+            if (maxTokens <= budget)
+                base.max_tokens = budget + 1024;
+            base.thinking = { type: 'enabled', budget_tokens: budget };
+            delete base.temperature;
+            delete base.top_p;
+        }
+    }
     // providerOptions carries Anthropic-native fields (`thinking`, `metadata`,
     // top-level `cache_control` extras, `service_tier`, …) without a release.
     return (0, util_js_1.applyProviderOptions)(base, req.providerOptions);

package/dist/cjs/adapters/engines/google.js

@@ -188,6 +188,13 @@ function body(req) {
             config.allowedFunctionNames = [req.toolChoice.name];
         payload.toolConfig = { functionCallingConfig: config };
     }
+    if (req.reasoningEffort !== undefined) {
+        // First-class reasoning effort → Gemini's thinking budget. 0 disables
+        // thinking on models that allow it; others treat it as a minimum.
+        payload.generationConfig.thinkingConfig = {
+            thinkingBudget: util_js_1.REASONING_BUDGET_TOKENS[req.reasoningEffort],
+        };
+    }
     // providerOptions reaches Google-native fields: top-level `safetySettings`,
     // `cachedContent`, and `generationConfig` extras (`thinkingConfig`,
     // `responseModalities`, …) merged one level deep into generationConfig.

package/dist/cjs/adapters/engines/ollama.js

@@ -176,6 +176,12 @@ function body(req) {
         format: req.responseFormat?.type === 'json' ? (req.responseFormat.schema ?? 'json') : undefined,
         tools: req.tools?.map((tool) => ({ type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } })),
     };
+    // First-class reasoning effort → Ollama's `think` flag (reasoning arrives in
+    // `message.thinking`, which this engine already routes to `reasoning` events).
+    // Ollama has no graded effort for most models, so anything but `'none'` is
+    // `true`. Only sent when asked for: a model without thinking support rejects it.
+    if (req.reasoningEffort !== undefined)
+        base.think = req.reasoningEffort !== 'none';
     // providerOptions reaches Ollama's real request fields — `options.num_ctx`,
     // `options.num_keep`, top-level `keep_alive`, `think`, etc. `options` is
     // merged one level deep so num_ctx joins the samplers above rather than

package/dist/cjs/adapters/engines/openaiChat.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatAdapter = void 0;
+exports.shouldRetryWithoutReasoningEffort = shouldRetryWithoutReasoningEffort;
 const errors_js_1 = require("../../errors.js");
 const tokens_js_1 = require("../../tokens.js");
 const transport_js_1 = require("../../transport.js");
@@ -37,7 +38,34 @@ class OpenAIChatAdapter {
         const timeout = (0, base_js_1.streamTimeout)(conn, req.signal);
         yield { type: 'start', callId: '', provider: conn.provider, model: req.model };
         try {
-            const res = await (0, transport_js_1.postResponse)(urlFor(conn, this.profile, req), openAiBody(req, this.profile), conn.headers, timeout.signal, conn.provider);
+            let res;
+            try {
+                res = await (0, transport_js_1.postResponse)(urlFor(conn, this.profile, req), openAiBody(req, this.profile), conn.headers, timeout.signal, conn.provider);
+            }
+            catch (error) {
+                // OpenAI's `/chat/completions` refuses function tools on a reasoning model
+                // unless `reasoning_effort` is `'none'` ("Function tools with reasoning_effort
+                // are not supported … use /v1/responses or set reasoning_effort to 'none'").
+                // The nugget never sets `reasoning_effort` itself, so the provider default
+                // applies and every tool-using turn 400s. Rather than make each app learn
+                // this the hard way, retry the one request once with the effort disabled
+                // and say so on the stream. Reactive on purpose: sending
+                // `reasoning_effort` up front would 400 on non-reasoning models instead.
+                // A caller-requested effort is overridden too — the alternative is a hard
+                // 400 with no tool call at all — and the context event says so.
+                if (!shouldRetryWithoutReasoningEffort(error, req))
+                    throw error;
+                yield {
+                    type: 'context',
+                    kind: 'reasoning_effort_disabled_for_tools',
+                    data: {
+                        reason: 'provider rejected function tools with reasoning_effort; retried with reasoning_effort: none',
+                        requested: req.providerOptions?.reasoning_effort ?? req.reasoningEffort ?? null,
+                    },
+                };
+                const retryReq = { ...req, providerOptions: { ...req.providerOptions, reasoning_effort: 'none' } };
+                res = await (0, transport_js_1.postResponse)(urlFor(conn, this.profile, retryReq), openAiBody(retryReq, this.profile), conn.headers, timeout.signal, conn.provider);
+            }
             const contentType = res.headers.get('content-type') ?? '';
             if (!contentType.includes('text/event-stream')) {
                 // Server ignored stream:true (or is a buffered gateway) — recover the whole body.
@@ -173,6 +201,10 @@ function openAiBody(req, profile) {
     };
     if (req.maxTokens !== undefined)
         body[profile.quirks?.maxTokensParam ?? 'max_tokens'] = req.maxTokens;
+    // First-class reasoning effort → OpenAI's `reasoning_effort`. Only sent when
+    // asked for: non-reasoning models reject the parameter outright.
+    if (req.reasoningEffort !== undefined)
+        body.reasoning_effort = req.reasoningEffort;
     // providerOptions carries OpenAI-native fields the nugget doesn't model
     // (`reasoning_effort`, `parallel_tool_calls`, `seed`, `logprobs`, …). `apiVersion`
     // is consumed by urlFor for Azure and stripped here so it never hits the body.
@@ -259,3 +291,22 @@ function mapFinish(finish, hasToolCalls) {
         return 'content_filter';
     return 'stop';
 }
+/**
+ * True when a `/chat/completions` 400 is the "function tools with reasoning_effort
+ * are not supported" refusal AND the request actually carried tools AND the caller
+ * did not already pin `reasoning_effort` (in which case the choice is theirs).
+ */
+function shouldRetryWithoutReasoningEffort(error, req) {
+    if (!(error instanceof errors_js_1.AIError) || error.status !== 400)
+        return false;
+    if (!req.tools || req.tools.length === 0)
+        return false;
+    // Already `'none'` (from either knob) — the refusal is about something else.
+    const effective = req.providerOptions && 'reasoning_effort' in req.providerOptions
+        ? req.providerOptions.reasoning_effort
+        : req.reasoningEffort;
+    if (effective === 'none')
+        return false;
+    const text = `${error.raw ?? ''} ${error.message}`.toLowerCase();
+    return text.includes('reasoning_effort') && text.includes('tool');
+}

package/dist/cjs/agent/loop.js

@@ -49,6 +49,7 @@ async function* run(opts, resolveResult) {
                 maxTokens: opts.maxTokens,
                 topP: opts.topP,
                 stopSequences: opts.stopSequences,
+                reasoningEffort: opts.reasoningEffort,
                 providerOptions: opts.providerOptions,
                 signal: agentSignal.signal,
                 metadata: { ...opts.metadata, agentStep: step },

package/dist/cjs/handler.js

@@ -6,6 +6,7 @@ const index_js_1 = require("./adapters/index.js");
 const profiles_js_1 = require("./adapters/profiles.js");
 const errors_js_1 = require("./errors.js");
 const json_js_1 = require("./json.js");
+const reasoning_js_1 = require("./reasoning.js");
 const policy_js_1 = require("./policy.js");
 const redact_js_1 = require("./redact.js");
 const util_js_1 = require("./util.js");
@@ -71,8 +72,11 @@ class AIHandler {
             const maxAttempts = this.opts.retry?.maxAttempts ?? 3;
             let emittedStart = false;
             let emittedOutput = false;
+            const stripInline = this.opts.stripInlineReasoning !== false;
             for (;;) {
                 attempt += 1;
+                // One stripper per attempt: a retried stream starts its tag state over.
+                const stripper = stripInline ? (0, reasoning_js_1.createReasoningStripper)() : null;
                 try {
                     for await (const event of adapter.stream(resolved, req)) {
                         if (event.type === 'start') {
@@ -84,10 +88,31 @@ class AIHandler {
                         }
                         if (event.type === 'delta' || event.type === 'tool_call')
                             emittedOutput = true;
+                        if (event.type === 'delta' && stripper) {
+                            // Inline reasoning never reaches `delta`; it rides the reasoning channel like a
+                            // provider-native thinking field would.
+                            const piece = stripper.push(event.text);
+                            if (piece.reasoning)
+                                yield { type: 'reasoning', text: piece.reasoning };
+                            if (piece.visible)
+                                yield { type: 'delta', text: piece.visible };
+                            continue;
+                        }
                         if (event.type === 'done') {
-                            await this.recordSuccess(callId, conn, req, startedAt, attempt, event.result);
+                            let result = event.result;
+                            if (stripper) {
+                                const tail = stripper.end();
+                                if (tail.reasoning)
+                                    yield { type: 'reasoning', text: tail.reasoning };
+                                if (tail.visible)
+                                    yield { type: 'delta', text: tail.visible };
+                                if ((0, reasoning_js_1.containsReasoningBlock)(result.text)) {
+                                    result = { ...result, text: (0, reasoning_js_1.stripReasoningBlocks)(result.text) };
+                                }
+                            }
+                            await this.recordSuccess(callId, conn, req, startedAt, attempt, result);
                             recorded = true;
-                            yield event;
+                            yield { ...event, result };
                             return;
                         }
                         yield event;

package/dist/cjs/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./types.js"), exports);
 __exportStar(require("./errors.js"), exports);
 __exportStar(require("./transport.js"), exports);
 __exportStar(require("./json.js"), exports);
+__exportStar(require("./reasoning.js"), exports);
 __exportStar(require("./tokens.js"), exports);
 __exportStar(require("./keys.js"), exports);
 __exportStar(require("./connect.js"), exports);

package/dist/cjs/reasoning.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Inline reasoning stripper — keeps a reasoning model's chain of thought out of `delta` events
+ * and `ChatResult.text`, routing it to the `reasoning` stream event instead.
+ *
+ * Reasoning models (deepseek-r1, phi4-reasoning, qwq, …) emit their thinking either in the
+ * provider's dedicated field — which every engine already maps to `{ type: 'reasoning' }` — or
+ * INLINE in the answer as `<think>…</think>`-style blocks. Inline reasoning routinely quotes the
+ * system prompt and tool instructions back verbatim, so an app that streams `delta` straight to
+ * a screen, a database or a JSON parser leaks it. Every consumer would otherwise write this
+ * state machine, and most would get the split-tag and template-opened cases wrong; the handler
+ * runs it once, on every engine, unless `HandlerOptions.stripInlineReasoning` is `false`.
+ *
+ * Ported from AI Server Studio's `services/reasoningFilter.ts` (2026-09-05), which had to exist
+ * because the nugget did not do this.
+ *
+ * Two subtleties the tests pin:
+ *   - Tags may be split across chunks, so a trailing partial `<thi` is held back until the next
+ *     chunk decides whether it opens a tag. An unterminated block is reasoning to the end.
+ *   - The **orphan close**: a closing tag with no opening one at the head of the stream, because
+ *     the runtime's chat template emitted `<think>` itself. Handled once per stream, only before
+ *     any visible text has gone out, and only when the closing tag starts its own line — a
+ *     `</think>` quoted mid-sentence in a real answer is left alone.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReasoningStripper = createReasoningStripper;
+exports.stripReasoningBlocksDetailed = stripReasoningBlocksDetailed;
+exports.stripReasoningBlocks = stripReasoningBlocks;
+exports.containsReasoningBlock = containsReasoningBlock;
+const TAG_PAIRS = [
+    { open: '<think>', close: '</think>' },
+    { open: '<thinking>', close: '</thinking>' },
+    { open: '<reasoning>', close: '</reasoning>' },
+    { open: '<|begin_of_thought|>', close: '<|end_of_thought|>' },
+];
+const LONGEST_TAG = Math.max(...TAG_PAIRS.flatMap((p) => [p.open.length, p.close.length]));
+function partialTagSuffixLength(text) {
+    const lower = text.toLowerCase();
+    const maxLen = Math.min(LONGEST_TAG - 1, lower.length);
+    for (let len = maxLen; len >= 1; len -= 1) {
+        const tail = lower.slice(lower.length - len);
+        if (tail[0] !== '<')
+            continue;
+        for (const pair of TAG_PAIRS) {
+            if (pair.open.startsWith(tail) || pair.close.startsWith(tail))
+                return len;
+        }
+    }
+    return 0;
+}
+function closesOwnLine(text, idx) {
+    let i = idx - 1;
+    while (i >= 0 && (text[i] === ' ' || text[i] === '\t' || text[i] === '\r'))
+        i -= 1;
+    return i < 0 || text[i] === '\n';
+}
+function createReasoningStripper() {
+    let pending = '';
+    let inReasoning = false;
+    let closeTag = '';
+    let emittedVisible = false;
+    let orphanConsumed = false;
+    function process(input, flushAll) {
+        let text = pending + input;
+        pending = '';
+        let visible = '';
+        let reasoning = '';
+        while (text.length > 0) {
+            const lower = text.toLowerCase();
+            if (inReasoning) {
+                const idx = lower.indexOf(closeTag);
+                if (idx === -1) {
+                    const hold = flushAll ? 0 : partialTagSuffixLength(text);
+                    const consumed = text.length - hold;
+                    reasoning += text.slice(0, consumed);
+                    pending = text.slice(consumed);
+                    text = '';
+                    if (flushAll) {
+                        reasoning += pending;
+                        pending = '';
+                    }
+                    break;
+                }
+                reasoning += text.slice(0, idx);
+                text = text.slice(idx + closeTag.length);
+                inReasoning = false;
+                closeTag = '';
+                if (text.startsWith('\n'))
+                    text = text.slice(1);
+                continue;
+            }
+            let openIdx = -1;
+            let pair = null;
+            for (const p of TAG_PAIRS) {
+                const i = lower.indexOf(p.open);
+                if (i !== -1 && (openIdx === -1 || i < openIdx)) {
+                    openIdx = i;
+                    pair = p;
+                }
+            }
+            let orphanCloseIdx = -1;
+            let orphanCloseLen = 0;
+            if (!emittedVisible && !orphanConsumed) {
+                for (const p of TAG_PAIRS) {
+                    const i = lower.indexOf(p.close);
+                    if (i !== -1 && (orphanCloseIdx === -1 || i < orphanCloseIdx) && closesOwnLine(text, i)) {
+                        orphanCloseIdx = i;
+                        orphanCloseLen = p.close.length;
+                    }
+                }
+            }
+            if (orphanCloseIdx !== -1 && (openIdx === -1 || orphanCloseIdx < openIdx)) {
+                orphanConsumed = true;
+                reasoning += text.slice(0, orphanCloseIdx);
+                text = text.slice(orphanCloseIdx + orphanCloseLen).replace(/^\n+/, '');
+                continue;
+            }
+            if (openIdx === -1 || !pair) {
+                const hold = flushAll ? 0 : partialTagSuffixLength(text);
+                visible += text.slice(0, text.length - hold);
+                pending = text.slice(text.length - hold);
+                text = '';
+                break;
+            }
+            visible += text.slice(0, openIdx);
+            text = text.slice(openIdx + pair.open.length);
+            inReasoning = true;
+            closeTag = pair.close;
+        }
+        if (visible.trim().length > 0)
+            emittedVisible = true;
+        return { visible, reasoning };
+    }
+    return {
+        push: (chunk) => process(chunk, false),
+        end: () => process('', true),
+        get inReasoning() {
+            return inReasoning;
+        },
+    };
+}
+/** Whole-string form: `{ visible, reasoning }` for already-buffered text. */
+function stripReasoningBlocksDetailed(text) {
+    if (!text)
+        return { visible: '', reasoning: '' };
+    const stripper = createReasoningStripper();
+    const a = stripper.push(text);
+    const b = stripper.end();
+    return { visible: (a.visible + b.visible).trim(), reasoning: a.reasoning + b.reasoning };
+}
+/** Whole-string form returning only the visible text. */
+function stripReasoningBlocks(text) {
+    return stripReasoningBlocksDetailed(text).visible;
+}
+/** Cheap pre-check: does `text` carry any inline reasoning tag (open or close)? */
+function containsReasoningBlock(text) {
+    const lower = text.toLowerCase();
+    return TAG_PAIRS.some((p) => lower.includes(p.open) || lower.includes(p.close));
+}