@jxburros/ai-nugget 0.4.1 → 0.7.0

package/dist/handler.js

@@ -1,9 +1,21 @@
 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';
+/**
+ * A *startup* notice, so it fires once per process rather than once per handler
+ * — an app that builds a handler per request would otherwise flood its logs
+ * with a message that says the same thing every time.
+ */
+let warnedNoPolicy = false;
+/** Test seam: reset the once-per-process startup notice. */
+export function resetPolicyWarningForTests() {
+    warnedNoPolicy = false;
+}
 export class AIHandler {
     opts;
     active = 0;
@@ -14,6 +26,15 @@ export class AIHandler {
     constructor(opts) {
         this.opts = opts;
         this.policy = opts.policy ?? allowAllPolicy();
+        // `allowAllPolicy()` stays the default — a library must not decide an app's
+        // governance — but "no policy configured" should be visible at runtime, not
+        // only in a README paragraph. Passing an explicit policy (including
+        // `allowAllPolicy()`) is the opt-out.
+        if (!opts.policy && !opts.silencePolicyWarning && !warnedNoPolicy) {
+            warnedNoPolicy = true;
+            globalThis.console?.warn?.('[ai-nugget] No GovernancePolicy configured — every provider/model is allowed. ' +
+                'Pass `policy` (e.g. allowlistPolicy(...)), or `policy: allowAllPolicy()` / `silencePolicyWarning: true` to accept this deliberately.');
+        }
     }
     async chat(conn, req) {
         let result;
@@ -31,42 +52,13 @@ export class AIHandler {
         const callId = createCallId();
         const startedAt = Date.now();
         const adapter = adapterFor(conn.provider, conn.baseUrl);
-        const policyResult = this.policy.checkModel(conn.provider, req.model);
-        if (!policyResult.allowed) {
-            const error = new AIError(policyResult.reason, { kind: 'policy_blocked', retryable: false, provider: conn.provider });
-            await this.recordFailure(callId, conn, req, startedAt, 1, error);
-            yield { type: 'error', error: this.redactedError(error) };
-            return;
-        }
-        let resolved;
-        try {
-            resolved = await this.resolveConnection(conn);
-        }
-        catch (errorValue) {
-            // Key resolution failures (missing/locked/denied) are a recorded outcome,
-            // not an uncaught throw — the traceability contract covers them too.
-            const error = fromUnknown(errorValue, conn.provider);
-            await this.recordFailure(callId, conn, req, startedAt, 1, error);
-            yield { type: 'error', error: this.redactedError(error) };
-            return;
-        }
-        const info = { callId, connection: conn, provider: conn.provider, model: req.model, metadata: req.metadata };
-        try {
-            if (await this.opts.hooks?.beforeCall?.(info) === 'deny') {
-                const error = new AIError('Call denied by beforeCall hook', { kind: 'policy_blocked', retryable: false, provider: conn.provider });
-                await this.recordFailure(callId, conn, req, startedAt, 1, error);
-                yield { type: 'error', error: this.redactedError(error) };
-                return;
-            }
-        }
-        catch (errorValue) {
-            // A throwing beforeCall hook is a recorded, redacted outcome too — not
-            // an uncaught throw that skips telemetry and the redaction guarantee.
-            const error = fromUnknown(errorValue, conn.provider);
-            await this.recordFailure(callId, conn, req, startedAt, 1, error);
-            yield { type: 'error', error: this.redactedError(error) };
-            return;
-        }
+        const preflight = await this.preflight(callId, conn, req.model, req.metadata);
+        if (!preflight.ok)
+            return yield* this.failStream(callId, conn, req, startedAt, 1, preflight.error);
+        // One idempotency key per logical call, reused across every retry attempt,
+        // so a provider that supports it collapses a re-sent generation instead of
+        // billing it twice (see `supportsIdempotencyKey` in the profile table).
+        const resolved = withIdempotencyKey(preflight.resolved, callId);
         let acquired = false;
         let recorded = false;
         let attempt = 0;
@@ -76,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') {
@@ -89,10 +84,31 @@ export 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 (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;
@@ -101,11 +117,11 @@ export class AIHandler {
                 }
                 catch (errorValue) {
                     const error = fromUnknown(errorValue, conn.provider);
+                    // `emittedOutput` stops retries once any byte has reached the caller:
+                    // never silently re-run a partially delivered answer.
                     if (!error.retryable || attempt >= maxAttempts || req.signal?.aborted || emittedOutput) {
-                        await this.recordFailure(callId, conn, req, startedAt, attempt, error);
                         recorded = true;
-                        yield { type: 'error', error: this.redactedError(error) };
-                        return;
+                        return yield* this.failStream(callId, conn, req, startedAt, attempt, error);
                     }
                     const delayMs = this.retryDelay(error, attempt);
                     yield { type: 'retry', attempt, reason: error.kind, delayMs };
@@ -113,21 +129,15 @@ export class AIHandler {
                         await sleep(delayMs, req.signal);
                     }
                     catch (sleepError) {
-                        const canceled = fromUnknown(sleepError, conn.provider);
-                        await this.recordFailure(callId, conn, req, startedAt, attempt, canceled);
                         recorded = true;
-                        yield { type: 'error', error: this.redactedError(canceled) };
-                        return;
+                        return yield* this.failStream(callId, conn, req, startedAt, attempt, fromUnknown(sleepError, conn.provider));
                     }
                 }
             }
         }
         catch (errorValue) {
-            const error = fromUnknown(errorValue, conn.provider);
-            await this.recordFailure(callId, conn, req, startedAt, Math.max(1, attempt), error);
             recorded = true;
-            yield { type: 'error', error: this.redactedError(error) };
-            return;
+            return yield* this.failStream(callId, conn, req, startedAt, Math.max(1, attempt), fromUnknown(errorValue, conn.provider));
         }
         finally {
             if (acquired)
@@ -137,6 +147,52 @@ export class AIHandler {
             }
         }
     }
+    /**
+     * The shared pre-call preamble: policy check → key resolution → `beforeCall`
+     * hook. Every entry point (`stream`, `embed`, `listModels`/`testConnection`)
+     * runs exactly this sequence, so it lives once. Failures are *returned*, not
+     * recorded — each caller owns its own telemetry shape (`recordFailure` for
+     * chat/probe, `recordEmbed` for embeddings) and records the returned error.
+     */
+    async preflight(callId, conn, model, metadata) {
+        const policyResult = this.policy.checkModel(conn.provider, model);
+        if (!policyResult.allowed) {
+            return { ok: false, error: new AIError(policyResult.reason, { kind: 'policy_blocked', retryable: false, provider: conn.provider }) };
+        }
+        let resolved;
+        try {
+            resolved = await this.resolveConnection(conn);
+        }
+        catch (errorValue) {
+            // Key resolution failures (missing/locked/denied) are a recorded outcome,
+            // not an uncaught throw — the traceability contract covers them too.
+            return { ok: false, error: fromUnknown(errorValue, conn.provider) };
+        }
+        try {
+            const info = {
+                callId,
+                connection: safeConnection(conn),
+                provider: conn.provider,
+                model,
+                metadata,
+                resolved: safeResolved(resolved),
+            };
+            if (await this.opts.hooks?.beforeCall?.(info) === 'deny') {
+                return { ok: false, error: new AIError('Call denied by beforeCall hook', { kind: 'policy_blocked', retryable: false, provider: conn.provider }) };
+            }
+        }
+        catch (errorValue) {
+            // A throwing beforeCall hook is a recorded, redacted outcome too — not
+            // an uncaught throw that skips telemetry and the redaction guarantee.
+            return { ok: false, error: fromUnknown(errorValue, conn.provider) };
+        }
+        return { ok: true, resolved };
+    }
+    /** Record a failed call and emit the single redacted `error` event for it. */
+    async *failStream(callId, conn, req, startedAt, attempts, error) {
+        await this.recordFailure(callId, conn, req, startedAt, attempts, error);
+        yield { type: 'error', error: this.redactedError(error) };
+    }
     async listModels(conn) {
         return this.runProbe(conn, '__listModels__', async (resolved) => {
             const adapter = adapterFor(conn.provider, conn.baseUrl);
@@ -161,23 +217,111 @@ export class AIHandler {
             return { ok: false, message: error instanceof Error ? this.redact(error.message) : 'Connection failed' };
         }
     }
-    async runProbe(conn, operation, action) {
+    /**
+     * Warm a connection so the first real call doesn't pay cold DNS/TLS and
+     * (for a local daemon) process spin-up on the hot path. Runs a lightweight
+     * health probe and never throws — call it once at boot. Combined with a CJS
+     * `require` path it removes the cold-start "offline" false negative.
+     */
+    async prewarm(conn) {
+        try {
+            await this.testConnection(conn);
+        }
+        catch {
+            // Warm-up only: a failure here just means the first real call pays the cost.
+        }
+    }
+    /**
+     * Chat that returns typed, validated output. Requests JSON mode, extracts the
+     * JSON from the reply, and validates it against any Standard Schema validator
+     * (Zod / Valibot / ArkType). On a validation miss it performs exactly one
+     * corrective retry that shows the model its error, then throws
+     * `invalid_response` if still invalid. No schema library is bundled — the
+     * caller supplies the schema.
+     */
+    async chatParsed(conn, req, schema) {
+        const base = { ...req, responseFormat: req.responseFormat ?? { type: 'json' } };
+        let result = await this.chat(conn, base);
+        let validated = await validateWithSchema(schema, result.text);
+        if (validated.ok)
+            return { data: validated.value, result };
+        const retry = {
+            ...base,
+            messages: [
+                ...base.messages,
+                { role: 'assistant', content: result.text },
+                { role: 'user', content: `That response did not match the required schema (${validated.message}). Reply again with ONLY a valid JSON value that matches it.` },
+            ],
+        };
+        result = await this.chat(conn, retry);
+        validated = await validateWithSchema(schema, result.text);
+        if (validated.ok)
+            return { data: validated.value, result };
+        throw new AIError(`Model output failed schema validation: ${validated.message}`, { kind: 'invalid_response', provider: conn.provider });
+    }
+    /**
+     * Produce embeddings through the same governed pipeline as chat: policy check,
+     * key resolution, `beforeCall` hook, concurrency, and exactly one redacted
+     * telemetry record. Throws a typed `invalid_request` error for providers whose
+     * adapter has no `embed` (Anthropic, Google) rather than failing silently.
+     */
+    async embed(conn, req) {
         const callId = createCallId();
         const startedAt = Date.now();
-        const req = { model: operation, messages: [], metadata: { operation } };
-        const policyResult = this.policy.checkModel(conn.provider, operation);
-        if (!policyResult.allowed) {
-            const error = new AIError(policyResult.reason, { kind: 'policy_blocked', retryable: false, provider: conn.provider });
-            await this.recordFailure(callId, conn, req, startedAt, 1, error);
+        const inputChars = (Array.isArray(req.input) ? req.input : [req.input]).reduce((sum, text) => sum + text.length, 0);
+        const fail = async (error) => {
+            await this.recordEmbed(callId, conn, req, startedAt, { estimated: true }, inputChars, error);
             throw this.redactedError(error);
+        };
+        const preflight = await this.preflight(callId, conn, req.model, req.metadata);
+        if (!preflight.ok)
+            return fail(preflight.error);
+        const resolved = preflight.resolved;
+        const adapter = adapterFor(conn.provider, conn.baseUrl);
+        if (!adapter.embed) {
+            return fail(new AIError(`Provider ${conn.provider} does not support embeddings`, { kind: 'invalid_request', retryable: false, provider: conn.provider }));
         }
-        let resolved;
+        await this.acquire(req.signal);
         try {
-            resolved = await this.resolveConnection(conn);
-            const info = { callId, connection: conn, provider: conn.provider, model: operation, metadata: req.metadata };
-            if (await this.opts.hooks?.beforeCall?.(info) === 'deny') {
-                throw new AIError('Call denied by beforeCall hook', { kind: 'policy_blocked', retryable: false, provider: conn.provider });
-            }
+            const result = await adapter.embed(resolved, req);
+            await this.recordEmbed(callId, conn, req, startedAt, result.usage, inputChars);
+            return result;
+        }
+        catch (errorValue) {
+            return fail(fromUnknown(errorValue, conn.provider));
+        }
+        finally {
+            this.release();
+        }
+    }
+    async recordEmbed(callId, conn, req, startedAt, usage, inputChars, error) {
+        const costUsd = error ? undefined : this.opts.pricing?.({ provider: conn.provider, model: req.model, usage });
+        await this.record({
+            callId,
+            connectionId: conn.id,
+            provider: conn.provider,
+            model: req.model,
+            startedAt,
+            timing: { firstTokenMs: null, totalMs: Date.now() - startedAt },
+            usage,
+            finishReason: error ? (error.kind === 'canceled' ? 'canceled' : 'error') : 'stop',
+            ...(error ? { error: { kind: error.kind, status: error.status, message: error.message } } : {}),
+            attempts: 1,
+            metadata: { ...req.metadata, operation: '__embed__' },
+            promptChars: inputChars,
+            responseChars: 0,
+            ...(costUsd !== undefined ? { costUsd } : {}),
+        });
+    }
+    async runProbe(conn, operation, action) {
+        const callId = createCallId();
+        const startedAt = Date.now();
+        const req = { model: operation, messages: [], metadata: { operation } };
+        try {
+            const preflight = await this.preflight(callId, conn, operation, req.metadata);
+            if (!preflight.ok)
+                throw preflight.error;
+            const resolved = preflight.resolved;
             await this.acquire(undefined);
             try {
                 const value = await action(resolved);
@@ -278,6 +422,7 @@ export class AIHandler {
         return Math.round(exponential * (0.75 + Math.random() * 0.5));
     }
     async recordSuccess(callId, conn, req, startedAt, attempts, result) {
+        const costUsd = this.opts.pricing?.({ provider: conn.provider, model: req.model, usage: result.usage });
         await this.record({
             callId,
             connectionId: conn.id,
@@ -291,6 +436,7 @@ export class AIHandler {
             metadata: req.metadata,
             promptChars: promptChars(req.messages),
             responseChars: result.text.length,
+            ...(costUsd !== undefined ? { costUsd } : {}),
         });
     }
     async recordFailure(callId, conn, req, startedAt, attempts, error) {
@@ -371,6 +517,65 @@ function redactMetadata(metadata, redact) {
 function trimSlash(value) {
     return value.replace(/\/+$/, '');
 }
+/**
+ * Drops the resolved API key *and* neutralizes the auth headers built from it,
+ * so a `beforeCall` hook can inspect the endpoint but never the secret.
+ * `keyRef` is scrubbed too — a `{ kind: 'literal' }` ref carries the plaintext
+ * key, and hooks routinely log the whole object.
+ */
+function safeResolved(resolved) {
+    const { apiKey: _apiKey, headers, ...rest } = resolved;
+    return { ...rest, ...safeKeyRef(resolved), headers: maskAuthHeaders(headers) };
+}
+/**
+ * The caller's own `Connection`, with any plaintext `keyRef` masked. Hooks get
+ * the connection so they can key off `id`/`provider`/`baseUrl`; they must never
+ * be handed the secret, since logging `info.connection` for audit is the
+ * obvious thing to do and would otherwise ship the key in clear text.
+ */
+function safeConnection(conn) {
+    return { ...conn, ...safeKeyRef(conn) };
+}
+function safeKeyRef(conn) {
+    if (conn.keyRef?.kind !== 'literal')
+        return conn.keyRef === undefined ? {} : { keyRef: conn.keyRef };
+    return { keyRef: { kind: 'literal', value: REDACTED } };
+}
+const REDACTED = '[REDACTED]';
+/** Header names whose value is derived from the API key by {@link applyAuth}. */
+const AUTH_HEADERS = new Set(['authorization', 'x-api-key', 'x-goog-api-key', 'api-key']);
+function maskAuthHeaders(headers) {
+    const masked = {};
+    for (const [name, value] of Object.entries(headers)) {
+        masked[name] = AUTH_HEADERS.has(name.toLowerCase()) ? REDACTED : value;
+    }
+    return masked;
+}
+/**
+ * Attach a per-call `Idempotency-Key` for providers that honor one, so a retry
+ * after a dropped connection can't be billed as a second generation. Only set
+ * where the profile declares support, and never overrides a caller-supplied
+ * header.
+ */
+function withIdempotencyKey(resolved, callId) {
+    const profile = profileFor(resolved.provider, resolved.baseUrl);
+    if (!profile.quirks?.supportsIdempotencyKey)
+        return resolved;
+    if (Object.keys(resolved.headers).some((name) => name.toLowerCase() === 'idempotency-key'))
+        return resolved;
+    return { ...resolved, headers: { ...resolved.headers, 'idempotency-key': callId } };
+}
+async function validateWithSchema(schema, text) {
+    const value = extractJson(text);
+    if (value === null)
+        return { ok: false, message: 'no JSON found in model output' };
+    const result = await schema['~standard'].validate(value);
+    if (result.issues) {
+        const message = result.issues.map((issue) => issue.message).join('; ');
+        return { ok: false, message: message || 'validation failed' };
+    }
+    return { ok: true, value: result.value };
+}
 function createCallId() {
     return globalThis.crypto?.randomUUID?.() ?? `call_${Date.now()}_${Math.random().toString(36).slice(2)}`;
 }

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/redact.d.ts

@@ -1,4 +1,22 @@
 import type { Redactor } from './types.js';
+/**
+ * Prefixed secret formats. Each pattern is anchored on a vendor prefix that is
+ * distinctive enough that a match is a secret, not a coincidence.
+ */
+export declare const SECRET_PATTERNS: RegExp[];
+/**
+ * Unprefixed/opaque secrets — Azure OpenAI `api-key` values, AWS *secret*
+ * access keys, generic bearer/session tokens — carry no distinctive prefix, so
+ * matching them on shape alone would redact commit SHAs, content hashes, and
+ * base64 payloads. These patterns instead anchor on the *label* that precedes
+ * the value (`api-key: …`, `"aws_secret_access_key": "…"`, `password=…`) and
+ * redact only the value, keeping the label readable in logs.
+ *
+ * Exact-match registration (`SessionRedactor.addSecret`, which the handler does
+ * for every resolved key) remains the only guaranteed catch for a bare,
+ * unlabeled, unprefixed secret.
+ */
+export declare const LABELED_SECRET_PATTERNS: RegExp[];
 export declare function createDefaultRedactor(extraSecrets?: Iterable<string>): Redactor;
 export declare class SessionRedactor implements Redactor {
     private secrets;