@jxburros/ai-nugget 0.6.0 → 0.7.3

package/dist/handler.js

@@ -2,6 +2,7 @@ import { adapterFor } from './adapters/index.js';
 import { applyAuth, profileFor } from './adapters/profiles.js';
 import { AIError, fromUnknown } from './errors.js';
 import { extractJson } from './json.js';
+import { containsReasoningBlock, createReasoningStripper, stripReasoningBlocks } from './reasoning.js';
 import { allowAllPolicy } from './policy.js';
 import { SessionRedactor } from './redact.js';
 import { promptChars, sleep } from './util.js';
@@ -67,8 +68,11 @@ export 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 ? createReasoningStripper() : null;
                 try {
                     for await (const event of adapter.stream(resolved, req)) {
                         if (event.type === 'start') {
@@ -78,12 +82,33 @@ export 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 (containsReasoningBlock(result.text)) {
+                                    result = { ...result, text: stripReasoningBlocks(result.text) };
+                                }
+                            }
+                            await this.recordSuccess(callId, conn, req, startedAt, attempt, result);
                             recorded = true;
-                            yield event;
+                            yield { ...event, result };
                             return;
                         }
                         yield event;

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './types.js';
 export * from './errors.js';
 export * from './transport.js';
 export * from './json.js';
+export * from './reasoning.js';
 export * from './tokens.js';
 export * from './keys.js';
 export * from './connect.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export * from './types.js';
 export * from './errors.js';
 export * from './transport.js';
 export * from './json.js';
+export * from './reasoning.js';
 export * from './tokens.js';
 export * from './keys.js';
 export * from './connect.js';

package/dist/reasoning.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+export interface ReasoningStripResult {
+    /** Text safe to show from this chunk (may be empty). */
+    visible: string;
+    /** Reasoning text removed from this chunk (may be empty). */
+    reasoning: string;
+}
+export interface ReasoningStripper {
+    /** Feed the next raw delta; returns what may be shown and what was reasoning. */
+    push(chunk: string): ReasoningStripResult;
+    /** End of stream: flushes any held-back prefix that never became a tag. */
+    end(): ReasoningStripResult;
+    /** True while inside an unterminated reasoning block. */
+    readonly inReasoning: boolean;
+}
+export declare function createReasoningStripper(): ReasoningStripper;
+/** Whole-string form: `{ visible, reasoning }` for already-buffered text. */
+export declare function stripReasoningBlocksDetailed(text: string): ReasoningStripResult;
+/** Whole-string form returning only the visible text. */
+export declare function stripReasoningBlocks(text: string): string;
+/** Cheap pre-check: does `text` carry any inline reasoning tag (open or close)? */
+export declare function containsReasoningBlock(text: string): boolean;
+//# sourceMappingURL=reasoning.d.ts.map

package/dist/reasoning.js

@@ -0,0 +1,154 @@
+/**
+ * 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.
+ */
+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';
+}
+export 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. */
+export 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. */
+export function stripReasoningBlocks(text) {
+    return stripReasoningBlocksDetailed(text).visible;
+}
+/** Cheap pre-check: does `text` carry any inline reasoning tag (open or close)? */
+export function containsReasoningBlock(text) {
+    const lower = text.toLowerCase();
+    return TAG_PAIRS.some((p) => lower.includes(p.open) || lower.includes(p.close));
+}
+//# sourceMappingURL=reasoning.js.map

package/dist/types.d.ts

@@ -7,9 +7,17 @@ export interface ContentPart {
     imageBase64?: string;
     mimeType?: string;
 }
+/** Opaque provider response content, for replay within the same model/tool workflow.
+ * Keep it unmodified; never include it in telemetry or display it as answer text. */
+export interface ProviderState {
+    provider: string;
+    model: string;
+    content: Record<string, unknown>[];
+}
 export interface ChatMessage {
     role: Role;
     content: string | ContentPart[];
+    providerState?: ProviderState;
     toolCalls?: ToolCall[];
     toolCallId?: string;
     name?: string;
@@ -25,12 +33,28 @@ export interface ToolSchema {
     description: string;
     parameters: object;
 }
+/**
+ * How hard a reasoning-capable model should think before answering. The nugget
+ * maps one vocabulary onto each provider's own knob (see `docs/providers.md`,
+ * "Reasoning effort"): OpenAI `reasoning_effort`, Anthropic `thinking`
+ * (`budget_tokens` tiers), Google `generationConfig.thinkingConfig.thinkingBudget`,
+ * Ollama `think`. `'none'` disables reasoning where the provider allows it.
+ * Unset means the provider's own default — the nugget never sends the knob
+ * unasked, because non-reasoning models reject it.
+ */
+export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high';
 export interface ChatRequest {
     model: string;
     messages: ChatMessage[];
     temperature?: number;
     maxTokens?: number;
     topP?: number;
+    /**
+     * Reasoning effort for thinking-capable models — see {@link ReasoningEffort}.
+     * A provider-native value in `providerOptions` (e.g. `reasoning_effort`,
+     * `thinking`, `thinkingConfig`, `think`) wins over this on collision.
+     */
+    reasoningEffort?: ReasoningEffort;
     responseFormat?: {
         type: 'text';
     } | {
@@ -114,6 +138,7 @@ export interface Usage {
 }
 export interface ChatResult {
     text: string;
+    providerState?: ProviderState;
     toolCalls?: ToolCall[];
     finishReason: 'stop' | 'length' | 'tool' | 'content_filter' | 'error' | 'canceled';
     usage: Usage;

package/dist/util.d.ts

@@ -21,4 +21,11 @@ export declare function joinUrl(base: string, path: string): string;
  */
 export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * 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.
+ */
+export declare const REASONING_BUDGET_TOKENS: Record<'none' | 'minimal' | 'low' | 'medium' | 'high', number>;
 //# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -98,4 +98,17 @@ export 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.
+ */
+export const REASONING_BUDGET_TOKENS = {
+    none: 0,
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384,
+};
 //# sourceMappingURL=util.js.map

package/nugget/VERSION.txt

@@ -1,2 +1,2 @@
-0.6.0
-762595605eef73dde3751687e21190d8281be3ade9d699d02620920f6c021de2
+0.7.3
+f6bc628594f887826274e9019dff75be686d5043e9823ccdbb0a4d9765552752

package/nugget/dist/adapters/engines/anthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/adapters/engines/anthropic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,kBAAkB,EAAE,WAAW,EAAY,MAAM,gBAAgB,CAAC;AAMlJ,qBAAa,gBAAiB,YAAW,eAAe;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBACd,QAAQ,EAAE,MAAM;IAItB,IAAI,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAUpE,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC;IA2HrF;;;;OAIG;IACG,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CAajE"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/adapters/engines/anthropic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,kBAAkB,EAAE,WAAW,EAAY,MAAM,gBAAgB,CAAC;AAMlJ,qBAAa,gBAAiB,YAAW,eAAe;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBACd,QAAQ,EAAE,MAAM;IAItB,IAAI,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAUpE,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC;IAmJrF;;;;OAIG;IACG,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CAajE"}

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

@@ -1,7 +1,7 @@
-import { AIError } from '../../errors.js';
+import { AIError, classify } 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 {
@@ -23,7 +23,8 @@ export 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;
@@ -31,6 +32,7 @@ export 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 = streamTimeout(conn, req.signal);
@@ -38,19 +40,29 @@ export 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 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 = asRecord(data)?.content;
+                if (Array.isArray(content))
+                    content.forEach((block, i) => {
+                        const record = asRecord(block);
+                        if (record)
+                            responseBlocks.set(i, record);
+                    });
                 inputTokens = parsed.inputTokens;
                 outputTokens = parsed.outputTokens;
                 stopReason = parsed.stopReason;
@@ -77,7 +89,12 @@ export class AnthropicAdapter {
                     if (!record)
                         continue;
                     const type = asString(record.type);
-                    if (type === 'message_start') {
+                    if (type === 'error') {
+                        const error = 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 classify(statuses[asString(error?.type) ?? ''] ?? 500, JSON.stringify(record), conn.provider);
+                    }
+                    else if (type === 'message_start') {
                         const usage = asRecord(asRecord(record.message)?.usage);
                         inputTokens = asNumber(usage?.input_tokens) ?? inputTokens;
                         outputTokens = asNumber(usage?.output_tokens) ?? outputTokens;
@@ -85,6 +102,8 @@ export class AnthropicAdapter {
                     else if (type === 'content_block_start') {
                         const index = asNumber(record.index) ?? 0;
                         const block = asRecord(record.content_block);
+                        if (block)
+                            responseBlocks.set(index, { ...block });
                         if (block?.type === 'tool_use') {
                             blocks.set(index, { id: asString(block.id) ?? randomId(), name: asString(block.name) ?? 'unknown', raw: '' });
                         }
@@ -92,6 +111,14 @@ export class AnthropicAdapter {
                     else if (type === 'content_block_delta') {
                         const index = asNumber(record.index) ?? 0;
                         const delta = 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 = asString(delta.text) ?? '';
                             if (piece) {
@@ -118,6 +145,9 @@ export class AnthropicAdapter {
                         const partial = blocks.get(index);
                         if (partial) {
                             const call = { id: partial.id, name: partial.name, raw: partial.raw, arguments: 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);
@@ -149,6 +179,7 @@ export 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 } : estimatedUsage(textFromMessages(req.messages), text),
@@ -192,9 +223,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.
@@ -210,16 +247,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 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 = { ...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 = 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);
+    const result = applyProviderOptions(base, req.providerOptions, ['output_config']);
+    if (modernModel(req.model)) {
+        delete result.temperature;
+        delete result.top_p;
+        delete result.top_k;
+    }
+    const choice = asRecord(result.tool_choice);
+    if (noForcedTools(req.model) && (choice?.type === 'tool' || choice?.type === 'any')) {
+        throw new 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 = [];
@@ -233,7 +305,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,
@@ -298,8 +373,21 @@ 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);
+}
 //# sourceMappingURL=anthropic.js.map