@jxburros/ai-nugget 0.6.0 → 0.7.3

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

@@ -26,7 +26,8 @@ class AnthropicAdapter {
     }
     async *stream(conn, req) {
         const started = Date.now();
-        const jsonMode = req.responseFormat?.type === 'json' && !req.tools?.length;
+        const nativeJson = modernModel(req.model);
+        const jsonMode = req.responseFormat?.type === 'json' && !nativeJson && !req.tools?.length;
         let firstTokenMs = null;
         let text = '';
         let inputTokens;
@@ -34,6 +35,7 @@ class AnthropicAdapter {
         let stopReason;
         let sawTerminal = false;
         const emittedTools = [];
+        const responseBlocks = new Map();
         // Partial tool_use blocks keyed by content-block index (input_json_delta accumulation).
         const blocks = new Map();
         const timeout = (0, base_js_1.streamTimeout)(conn, req.signal);
@@ -41,19 +43,29 @@ class AnthropicAdapter {
         // Anthropic JSON mode is implemented as a forced `json_output` tool, which
         // cannot coexist with the caller's own tools — same silent-downgrade shape
         // as Gemini, so it gets the same signal rather than quietly dropping.
-        if (req.responseFormat?.type === 'json' && req.tools?.length) {
+        if (req.responseFormat?.type === 'json' && !nativeJson && req.tools?.length) {
             yield {
                 type: 'context',
                 kind: 'json_mode_downgraded',
                 data: { reason: 'Anthropic JSON mode uses a forced tool and cannot be combined with caller tools; the request was sent without JSON mode', provider: conn.provider },
             };
         }
+        if (req.responseFormat?.type === 'json' && nativeJson && !req.responseFormat.schema) {
+            yield { type: 'context', kind: 'json_mode_downgraded', data: { provider: conn.provider, reason: 'Claude native JSON outputs require a schema; using a JSON instruction without constrained decoding.' } };
+        }
         try {
             const res = await (0, transport_js_1.postResponse)(`${conn.baseUrl}/v1/messages`, body(req, jsonMode), conn.headers, timeout.signal, conn.provider);
             const contentType = res.headers.get('content-type') ?? '';
             if (!contentType.includes('text/event-stream')) {
                 const data = await res.json();
                 const parsed = parseResponse(data);
+                const content = (0, util_js_1.asRecord)(data)?.content;
+                if (Array.isArray(content))
+                    content.forEach((block, i) => {
+                        const record = (0, util_js_1.asRecord)(block);
+                        if (record)
+                            responseBlocks.set(i, record);
+                    });
                 inputTokens = parsed.inputTokens;
                 outputTokens = parsed.outputTokens;
                 stopReason = parsed.stopReason;
@@ -80,7 +92,12 @@ class AnthropicAdapter {
                     if (!record)
                         continue;
                     const type = (0, util_js_1.asString)(record.type);
-                    if (type === 'message_start') {
+                    if (type === 'error') {
+                        const error = (0, util_js_1.asRecord)(record.error);
+                        const statuses = { overloaded_error: 529, rate_limit_error: 429, authentication_error: 401, permission_error: 403, invalid_request_error: 400, not_found_error: 404, api_error: 500, billing_error: 402, timeout_error: 504, request_too_large: 413 };
+                        throw (0, errors_js_1.classify)(statuses[(0, util_js_1.asString)(error?.type) ?? ''] ?? 500, JSON.stringify(record), conn.provider);
+                    }
+                    else if (type === 'message_start') {
                         const usage = (0, util_js_1.asRecord)((0, util_js_1.asRecord)(record.message)?.usage);
                         inputTokens = (0, util_js_1.asNumber)(usage?.input_tokens) ?? inputTokens;
                         outputTokens = (0, util_js_1.asNumber)(usage?.output_tokens) ?? outputTokens;
@@ -88,6 +105,8 @@ class AnthropicAdapter {
                     else if (type === 'content_block_start') {
                         const index = (0, util_js_1.asNumber)(record.index) ?? 0;
                         const block = (0, util_js_1.asRecord)(record.content_block);
+                        if (block)
+                            responseBlocks.set(index, { ...block });
                         if (block?.type === 'tool_use') {
                             blocks.set(index, { id: (0, util_js_1.asString)(block.id) ?? (0, base_js_1.randomId)(), name: (0, util_js_1.asString)(block.name) ?? 'unknown', raw: '' });
                         }
@@ -95,6 +114,14 @@ class AnthropicAdapter {
                     else if (type === 'content_block_delta') {
                         const index = (0, util_js_1.asNumber)(record.index) ?? 0;
                         const delta = (0, util_js_1.asRecord)(record.delta);
+                        const block = responseBlocks.get(index);
+                        if (block && delta) {
+                            const field = delta.type === 'text_delta' ? 'text' : delta.type === 'thinking_delta' ? 'thinking' : delta.type === 'signature_delta' ? 'signature' : undefined;
+                            if (field)
+                                block[field] = String(block[field] ?? '') + String(delta[field] ?? '');
+                            if (delta.type === 'citations_delta')
+                                block.citations = [...(Array.isArray(block.citations) ? block.citations : []), delta.citation];
+                        }
                         if (delta?.type === 'text_delta') {
                             const piece = (0, util_js_1.asString)(delta.text) ?? '';
                             if (piece) {
@@ -121,6 +148,9 @@ class AnthropicAdapter {
                         const partial = blocks.get(index);
                         if (partial) {
                             const call = { id: partial.id, name: partial.name, raw: partial.raw, arguments: (0, base_js_1.parseArgs)(partial.raw) };
+                            const block = responseBlocks.get(index);
+                            if (block)
+                                block.input = call.arguments;
                             blocks.delete(index);
                             if (jsonMode && call.name === JSON_MODE_TOOL) {
                                 text = jsonTextFrom([call], text);
@@ -152,6 +182,7 @@ class AnthropicAdapter {
             const hasTools = emittedTools.length > 0;
             yield { type: 'done', result: {
                     text,
+                    providerState: { provider: conn.provider, model: req.model, content: [...responseBlocks.entries()].sort(([a], [b]) => a - b).map(([, block]) => block) },
                     toolCalls: hasTools ? emittedTools : undefined,
                     finishReason: mapStop(stopReason, hasTools),
                     usage: inputTokens !== undefined || outputTokens !== undefined ? { inputTokens, outputTokens, estimated: false } : (0, tokens_js_1.estimatedUsage)((0, util_js_1.textFromMessages)(req.messages), text),
@@ -196,9 +227,15 @@ function body(req, jsonMode) {
         top_p: req.topP,
         stop_sequences: req.stopSequences,
         system,
-        messages: toAnthropicMessages(req.messages.filter((m) => m.role !== 'system')),
+        messages: toAnthropicMessages(req.messages.filter((m) => m.role !== 'system'), req.model),
         stream: true,
     };
+    if (req.responseFormat?.type === 'json' && modernModel(req.model) && req.responseFormat.schema) {
+        base.output_config = { format: { type: 'json_schema', schema: schemaFor(req) } };
+    }
+    if (req.responseFormat?.type === 'json' && modernModel(req.model) && !req.responseFormat.schema) {
+        base.system = [system, 'Return only valid JSON, without markdown fences or a preamble.'].filter(Boolean).join('\n\n');
+    }
     if (jsonMode) {
         // Forced-tool JSON mode: Anthropic has no response_format, so we make the
         // model answer through a single required tool whose input is the JSON we want.
@@ -214,16 +251,51 @@ 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 (modernModel(req.model)) {
+            const none = req.reasoningEffort === 'none';
+            if (none && alwaysThinking(req.model))
+                throw new errors_js_1.AIError('This Claude model cannot disable thinking; choose a reasoning effort instead.', { kind: 'invalid_request', provider: 'anthropic' });
+            base.thinking = { type: none ? (/^claude-sonnet-5-5(?:-|$)/.test(req.model) ? 'between_tools' : 'disabled') : 'adaptive' };
+            base.output_config = { ...(0, util_js_1.asRecord)(base.output_config), effort: none ? 'low' : req.reasoningEffort === 'minimal' ? 'low' : req.reasoningEffort };
+        }
+        else 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);
+    const result = (0, util_js_1.applyProviderOptions)(base, req.providerOptions, ['output_config']);
+    if (modernModel(req.model)) {
+        delete result.temperature;
+        delete result.top_p;
+        delete result.top_k;
+    }
+    const choice = (0, util_js_1.asRecord)(result.tool_choice);
+    if (noForcedTools(req.model) && (choice?.type === 'tool' || choice?.type === 'any')) {
+        throw new errors_js_1.AIError('This Claude model does not support forced tool choice; use auto or structured outputs.', { kind: 'invalid_request', provider: 'anthropic' });
+    }
+    return result;
 }
-function toAnthropicMessages(messages) {
+function toAnthropicMessages(messages, model) {
     const out = [];
     for (let index = 0; index < messages.length; index += 1) {
         const message = messages[index];
         if (message.role !== 'tool') {
-            out.push(toAnthropicMessage(message));
+            out.push(toAnthropicMessage(message, model));
             continue;
         }
         const content = [];
@@ -237,7 +309,10 @@ function toAnthropicMessages(messages) {
     }
     return out;
 }
-function toAnthropicMessage(m) {
+function toAnthropicMessage(m, model) {
+    if (m.role === 'assistant' && m.providerState?.provider === 'anthropic' && m.providerState.model === model) {
+        return { role: 'assistant', content: m.providerState.content };
+    }
     // Tool-role messages are handled by toAnthropicMessages' batching loop and
     // never reach here, so no tool branch is needed.
     // assistant turns that carried tool calls replay them as tool_use blocks,
@@ -302,7 +377,20 @@ function jsonTextFrom(toolCalls, fallback) {
 function mapStop(stop, hasTools) {
     if (stop === 'tool_use' && hasTools)
         return 'tool';
+    if (stop === 'refusal')
+        return 'content_filter';
     if (stop === 'max_tokens')
         return 'length';
     return 'stop';
 }
+/** Models released after Opus 4.6 use adaptive effort and reject sampling knobs.
+ * Unknown/custom IDs retain legacy behavior rather than guessing capabilities. */
+function modernModel(model) {
+    return /^claude-(?:opus-(?:4-[78]|5(?:-5)?)|sonnet-5(?:-5)?|haiku-5-5|(?:fable|mythos)-5(?:-1)?|mythos-preview)(?:-\d{8}|-latest)?$/.test(model);
+}
+function alwaysThinking(model) {
+    return /^claude-(?:fable-|mythos-|opus-5-5(?:-|$))/.test(model);
+}
+function noForcedTools(model) {
+    return /^claude-(?:(?:opus|sonnet)-5-5(?:-|$)|(?:fable|mythos)-5-1(?:-|$))/.test(model);
+}

package/nugget/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/nugget/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/nugget/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/nugget/dist/cjs/agent/loop.js

@@ -35,6 +35,7 @@ async function* run(opts, resolveResult) {
             yield emit(opts, { type: 'step_start', step });
             const calls = [];
             let stepText = '';
+            let providerState;
             let streamFailure;
             // In promptJson mode a tool directive must not leak into the visible
             // stream, so directive-looking text is withheld from `delta` events (still
@@ -49,6 +50,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 },
@@ -67,6 +69,7 @@ async function* run(opts, resolveResult) {
                 if (event.type === 'error')
                     streamFailure = event.error;
                 if (event.type === 'done') {
+                    providerState = event.result.providerState;
                     usage = usage ? (0, tokens_js_1.mergeUsage)(usage, event.result.usage) : event.result.usage;
                     if (toolMode === 'promptJson' && calls.length === 0)
                         calls.push(...callsFromPromptJson(stepText));
@@ -87,7 +90,7 @@ async function* run(opts, resolveResult) {
             finalText = stepText;
             messages.push(toolMode === 'promptJson'
                 ? { role: 'assistant', content: stepText }
-                : { role: 'assistant', content: stepText, toolCalls: calls.length ? calls : undefined });
+                : { role: 'assistant', content: stepText, providerState, toolCalls: calls.length ? calls : undefined });
             if (calls.length === 0)
                 return yield* yieldDone('finished');
             for (const call of calls) {

package/nugget/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') {
@@ -82,12 +86,33 @@ class AIHandler {
                             }
                             continue;
                         }
-                        if (event.type === 'delta' || event.type === 'tool_call')
+                        if (event.type === 'delta' || event.type === 'tool_call' || event.type === 'reasoning')
                             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/nugget/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/nugget/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));
+}

package/nugget/dist/cjs/util.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REASONING_BUDGET_TOKENS = void 0;
 exports.asRecord = asRecord;
 exports.asString = asString;
 exports.asNumber = asNumber;
@@ -110,3 +111,16 @@ function sleep(ms, signal) {
         }
     });
 }
+/**
+ * Token budgets behind the {@link ReasoningEffort} tiers for providers that
+ * express effort as a thinking-token budget (Anthropic `budget_tokens`, Google
+ * `thinkingBudget`). `'none'` is 0. Deliberately conservative: they are floors
+ * a model may stop under, not ceilings it fills.
+ */
+exports.REASONING_BUDGET_TOKENS = {
+    none: 0,
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384,
+};

package/nugget/dist/handler.d.ts

@@ -30,6 +30,12 @@ export interface HandlerOptions {
      * explicit `policy: allowAllPolicy()` says the same thing and is clearer.
      */
     silencePolicyWarning?: boolean;
+    /**
+     * Strip inline `<think>…</think>`-style reasoning out of `delta` events and `ChatResult.text`,
+     * emitting it as `{ type: 'reasoning' }` events instead (default `true`; see `src/reasoning.ts`).
+     * Set `false` to receive the raw answer text exactly as the provider sent it.
+     */
+    stripInlineReasoning?: boolean;
     /**
      * Optional cost estimator. Called once per successful call/embedding with the
      * final usage; its return value (USD) is stored on the telemetry record's

package/nugget/dist/handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"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"}