agentfootprint 2.13.0 → 2.14.0

package/dist/types/events/registry.d.ts.map

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

package/dist/types/security/index.d.ts

@@ -40,5 +40,6 @@ export { PolicyHaltError } from './PolicyHaltError.js';
 export type { PolicyHaltContext } from './PolicyHaltError.js';
 export { extractSequence, SYNTHETIC_DENY_PREFIX } from './extractSequence.js';
 export type { ExtractSequenceOptions } from './extractSequence.js';
+export { redactThinkingBlocks, REDACTED_PLACEHOLDER } from './thinkingRedaction.js';
 export type { PermissionChecker, PermissionRequest, PermissionDecision, ToolCallEntry, ToolResultContent, } from '../adapters/types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/security/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/security/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEpF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAMnE,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,iBAAiB,GAClB,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/security/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEpF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAMpF,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,iBAAiB,GAClB,MAAM,sBAAsB,CAAC"}

package/dist/types/security/thinkingRedaction.d.ts

@@ -0,0 +1,51 @@
+/**
+ * thinkingRedaction — content scrubbing for ThinkingBlock[] before
+ * persistence + audit-log adapters fire.
+ *
+ * Pattern: Pure function. Same shape as the v2.4 RedactionPolicy.scope-
+ * patterns / emit-patterns helpers — regex match + replace.
+ *
+ * Mental model — TWO-LAYER persistence:
+ *   - LLMMessage.thinkingBlocks IS persisted to scope.history (required
+ *     for Anthropic signature round-trip).
+ *   - Audit-log adapters (CloudWatch, Datadog OTel, etc.) read from
+ *     scope.history. Sensitive reasoning (PII in chain-of-thought,
+ *     internal IDs the model worked through) lands there too.
+ *   - This helper scrubs content patterns BEFORE the assistant message
+ *     pushes to scope.history, so the audit-log surface only sees
+ *     redacted content while the LLM still sees the unredacted reasoning
+ *     for round-trip integrity.
+ *
+ * The signature field is NEVER touched by redaction — Anthropic's
+ * server-side signature is bound to the original content; modifying
+ * content here would invalidate the signature. Resolution: signature
+ * survives byte-exact, content gets scrubbed. This means the Anthropic
+ * API will reject the next turn IF the consumer wired thinkingPatterns
+ * AND uses Anthropic with extended-thinking-plus-tools. Document.
+ *
+ * Recommended use:
+ *   - DON'T wire thinkingPatterns when using Anthropic extended thinking
+ *     + tool calls (signature breaks).
+ *   - DO wire thinkingPatterns when using OpenAI o1/o3 (no signature,
+ *     no round-trip requirement) or for offline log scrubbing.
+ *   - For Anthropic + sensitive reasoning, prefer audit-log-side
+ *     redaction (filter in your CloudWatch / Datadog adapter rather
+ *     than the framework's persistence point).
+ */
+import type { ThinkingBlock } from '../thinking/types.js';
+/** Sentinel string used in place of redacted content. */
+export declare const REDACTED_PLACEHOLDER = "[REDACTED]";
+/**
+ * Return a copy of `blocks` with each block's `content` field scrubbed
+ * by every pattern in `patterns`. Returns the input array unchanged
+ * when `patterns` is undefined, empty, or no block content matches.
+ *
+ * Signature + summary + providerMeta fields are preserved BYTE-EXACT
+ * — only `content` is touched.
+ *
+ * Anthropic signature warning: scrubbing content invalidates the
+ * Anthropic server-side signature. Round-trip will fail with HTTP 400
+ * on the next turn. Document this in the consumer recipe.
+ */
+export declare function redactThinkingBlocks(blocks: readonly ThinkingBlock[], patterns: readonly RegExp[] | undefined): readonly ThinkingBlock[];
+//# sourceMappingURL=thinkingRedaction.d.ts.map

package/dist/types/security/thinkingRedaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinkingRedaction.d.ts","sourceRoot":"","sources":["../../../src/security/thinkingRedaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,yDAAyD;AACzD,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACtC,SAAS,aAAa,EAAE,CAe1B"}

package/dist/types/thinking/AnthropicThinkingHandler.d.ts

@@ -0,0 +1,43 @@
+/**
+ * AnthropicThinkingHandler — normalizes Anthropic's extended-thinking
+ * response shape into the framework's `ThinkingBlock[]` contract.
+ *
+ * Anthropic emits thinking via blocks in `response.content`:
+ *
+ *   ```ts
+ *   { type: 'thinking',          thinking: 'reasoning text', signature: 'opaque-base64' }
+ *   { type: 'redacted_thinking',                              signature: 'opaque-base64' }
+ *   { type: 'text',              text: 'visible content' }
+ *   { type: 'tool_use',          id, name, input }
+ *   ```
+ *
+ * The handler filters for `'thinking'` + `'redacted_thinking'` blocks,
+ * preserves the `signature` field BYTE-EXACT (Anthropic validates
+ * signatures server-side on the next turn — any modification = HTTP 400),
+ * and ignores other block types (visible text + tool calls flow through
+ * the existing `LLMResponse.content` / `LLMResponse.toolCalls` paths).
+ *
+ * **Critical invariant:** signature pass-through is byte-exact. The
+ * handler MUST NOT trim, normalize encoding, JSON-roundtrip, or
+ * otherwise touch the signature string. Tests verify this explicitly.
+ *
+ * **Three input shapes** Anthropic produces (per Phase 4a panel review):
+ *   1. Non-streaming response: full `response.content` array
+ *   2. Streaming aggregated:   AnthropicProvider accumulates chunks +
+ *                              calls handler with the same array shape
+ *   3. Bedrock-via-Anthropic:  deferred to Phase 5+ (separate handler
+ *                              or extension of this one)
+ *
+ * Streaming + non-streaming converge on shape #1 because the provider
+ * handles the distinction — handler only sees the assembled content
+ * array.
+ *
+ * **`parseChunk` is OPTIONAL** — Phase 3's framework path populates
+ * `LLMChunk.thinkingDelta` from inside AnthropicProvider's `stream()`
+ * directly, bypassing handler.parseChunk. We still implement it for
+ * consumer integrations that want to use the handler on raw Anthropic
+ * chunks directly (e.g., custom transports).
+ */
+import type { ThinkingHandler } from './types.js';
+export declare const anthropicThinkingHandler: ThinkingHandler;
+//# sourceMappingURL=AnthropicThinkingHandler.d.ts.map

package/dist/types/thinking/AnthropicThinkingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnthropicThinkingHandler.d.ts","sourceRoot":"","sources":["../../../src/thinking/AnthropicThinkingHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAiB,eAAe,EAAE,MAAM,YAAY,CAAC;AAqDjE,eAAO,MAAM,wBAAwB,EAAE,eAwDtC,CAAC"}

package/dist/types/thinking/MockThinkingHandler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MockThinkingHandler — canonical example for the v2.14 ThinkingHandler
+ * contract. Used by:
+ *
+ *   1. Tests — drives the shared contract test (every shipped handler
+ *      MUST satisfy the same invariants this mock demonstrates).
+ *   2. Future provider authors — reference implementation showing how
+ *      to handle BOTH Anthropic-shape inputs (signed blocks, possibly
+ *      redacted) and OpenAI-shape inputs (multi-block summary). The
+ *      pattern of "discriminate by shape, normalize each branch" is
+ *      reusable across providers.
+ *   3. The MockProvider for end-to-end tests of the framework wiring
+ *      without depending on a real LLM SDK.
+ *
+ * Defaults are deliberately sensitive-data-free — no fake PII, no
+ * fake-signature material that could be confused for real cryptography,
+ * no internal-looking IDs. Sets the example for consumer-authored
+ * handlers.
+ */
+import type { ThinkingHandler } from './types.js';
+/** Shape the mock recognizes for Anthropic-style raw inputs. */
+interface MockAnthropicRaw {
+    readonly kind: 'anthropic';
+    readonly blocks: ReadonlyArray<{
+        readonly type: 'thinking' | 'redacted_thinking';
+        readonly thinking?: string;
+        readonly signature?: string;
+    }>;
+}
+/** Shape the mock recognizes for OpenAI-style raw inputs. */
+interface MockOpenAIRaw {
+    readonly kind: 'openai';
+    readonly summarySteps: readonly string[];
+}
+/**
+ * Build an Anthropic-style raw input for tests. Signature is a marker
+ * string — real Anthropic signatures are opaque base64.
+ */
+export declare function mockAnthropicRaw(blocks: readonly {
+    content: string;
+    signature?: string;
+    redacted?: boolean;
+}[]): MockAnthropicRaw;
+/**
+ * Build an OpenAI-style raw input for tests — one summary step per
+ * string. Each step becomes a separate ThinkingBlock with `summary: true`.
+ */
+export declare function mockOpenAIRaw(summarySteps: readonly string[]): MockOpenAIRaw;
+export declare const mockThinkingHandler: ThinkingHandler;
+export {};
+//# sourceMappingURL=MockThinkingHandler.d.ts.map

package/dist/types/thinking/MockThinkingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockThinkingHandler.d.ts","sourceRoot":"","sources":["../../../src/thinking/MockThinkingHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAiB,eAAe,EAAE,MAAM,YAAY,CAAC;AAEjE,gEAAgE;AAChE,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,CAAC;QAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;KAC7B,CAAC,CAAC;CACJ;AAED,6DAA6D;AAC7D,UAAU,aAAa;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAiBD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,GAC7E,gBAAgB,CASlB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CAE5E;AAED,eAAO,MAAM,mBAAmB,EAAE,eA0CjC,CAAC"}

package/dist/types/thinking/OpenAIThinkingHandler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * OpenAIThinkingHandler — normalizes OpenAI's o1/o3 reasoning_summary
+ * structured output into the framework's `ThinkingBlock[]` contract.
+ *
+ * OpenAI's reasoning_summary shape varies by model + API version:
+ *
+ *   1. Older o1 format — simple string:
+ *        "I worked through the problem by first..."
+ *
+ *   2. Newer o3+ structured — array of summary items:
+ *        [
+ *          { type: 'summary_text', text: 'Identify the user request' },
+ *          { type: 'summary_text', text: 'Choose appropriate tool' },
+ *        ]
+ *
+ *   3. Missing entirely — most calls (gpt-4o, or o1/o3 without
+ *      reasoning_summary param requested) → undefined raw input
+ *
+ * Handler dispatches on shape; output is `ThinkingBlock[]` with
+ * `summary: true` per Phase 1 contract — distinguishes structured-
+ * summary blocks from raw thinking content (Anthropic's shape).
+ *
+ * **No signature** — OpenAI doesn't sign reasoning. The output's
+ * `signature` field stays undefined. No round-trip integrity invariant
+ * (unlike Anthropic).
+ *
+ * **No `parseChunk`** — OpenAI doesn't stream reasoning content as of
+ * early 2026. Reasoning arrives only on the terminal response. Per
+ * Phase 1 design, `parseChunk` is optional; we omit entirely.
+ *
+ * **No `usage.thinking` computation** — reasoning_tokens lives on
+ * `response.usage.completion_tokens_details.reasoning_tokens` and is
+ * the OpenAIProvider's job to surface (deferred). Handler doesn't
+ * compute token counts.
+ */
+import type { ThinkingHandler } from './types.js';
+export declare const openAIThinkingHandler: ThinkingHandler;
+//# sourceMappingURL=OpenAIThinkingHandler.d.ts.map

package/dist/types/thinking/OpenAIThinkingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAIThinkingHandler.d.ts","sourceRoot":"","sources":["../../../src/thinking/OpenAIThinkingHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAiB,eAAe,EAAE,MAAM,YAAY,CAAC;AAcjE,eAAO,MAAM,qBAAqB,EAAE,eAoCnC,CAAC"}

package/dist/types/thinking/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * agentfootprint/thinking — extended-thinking subsystem (v2.14+).
+ *
+ * **Two-layer architecture:**
+ *
+ *   • CONSUMER-FACING:    `ThinkingHandler` — simple function-pair
+ *                          implemented by provider authors.
+ *   • FRAMEWORK-INTERNAL: each handler is auto-wrapped in a real
+ *                         footprintjs subflow at chart build time;
+ *                         shows in trace as own runtimeStageId.
+ *
+ * **Auto-wire by provider name:**
+ *
+ *   ```ts
+ *   import { Agent } from 'agentfootprint';
+ *
+ *   // Library scans SHIPPED_THINKING_HANDLERS, finds the handler
+ *   // whose providerNames includes provider.name. Mounted as a
+ *   // sub-subflow of sf-call-llm.
+ *   const agent = Agent.create({ provider: anthropic({...}), model: '...' })
+ *     .build();
+ *
+ *   // Opt out:
+ *   //   .thinkingHandler(undefined)
+ *   // Override with a custom handler:
+ *   //   .thinkingHandler(myCustomHandler)
+ *   ```
+ *
+ * **Custom handlers:**
+ *
+ *   ```ts
+ *   import { type ThinkingHandler } from 'agentfootprint/thinking';
+ *
+ *   export const geminiThinkingHandler: ThinkingHandler = {
+ *     id: 'gemini',
+ *     providerNames: ['gemini'],
+ *     normalize(raw) { ... },
+ *     parseChunk(chunk) { ... },  // optional
+ *   };
+ *   ```
+ *
+ * Failure isolation: handler `normalize()` throws are caught by the
+ * framework — emit `agentfootprint.agent.thinking_parse_failed`, drop
+ * the blocks, continue. Same graceful pattern as v2.11.6
+ * `tools.discovery_failed`.
+ */
+export type { ThinkingBlock, ThinkingHandler } from './types.js';
+export { mockThinkingHandler, mockAnthropicRaw, mockOpenAIRaw } from './MockThinkingHandler.js';
+export { anthropicThinkingHandler } from './AnthropicThinkingHandler.js';
+export { openAIThinkingHandler } from './OpenAIThinkingHandler.js';
+export { SHIPPED_THINKING_HANDLERS, findThinkingHandler } from './registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/thinking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/thinking/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEjE,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEhG,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/dist/types/thinking/registry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Registry — single source of truth for the framework's auto-wire
+ * logic AND the shared contract test.
+ *
+ * Phase 3 wiring scans this array at chart build time and selects the
+ * first handler whose `providerNames` includes the active
+ * `provider.name`. Phase 4a adds AnthropicThinkingHandler; Phase 5
+ * adds OpenAIThinkingHandler — append-only as new providers ship.
+ *
+ * Future provider authors:
+ *   • Implement `ThinkingHandler` for your provider
+ *   • Append to this array
+ *   • The shared contract test in `test/thinking/contract.test.ts`
+ *     verifies your handler honors the framework's invariants
+ */
+import type { ThinkingHandler } from './types.js';
+/**
+ * All thinking handlers shipped with the library. Append in alphabetical
+ * order (by `id`) so diffs stay readable as new handlers land.
+ */
+export declare const SHIPPED_THINKING_HANDLERS: readonly ThinkingHandler[];
+/**
+ * Look up a handler by `provider.name`. Returns the first match in
+ * `SHIPPED_THINKING_HANDLERS`. Returns `undefined` when no handler
+ * matches — framework treats this as "no thinking support for this
+ * provider", which is the correct default for providers that don't
+ * emit thinking content (gpt-3.5, mistral, etc.).
+ *
+ * Used by:
+ *   • Phase 3 framework auto-wire (chart build time)
+ *   • Tests verifying registry lookup
+ */
+export declare function findThinkingHandler(providerName: string): ThinkingHandler | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/types/thinking/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/thinking/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,eAAe,EAI/D,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAKrF"}

package/dist/types/thinking/types.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Thinking — public types for the v2.14 extended-thinking subsystem.
+ *
+ * Mental model — TWO-LAYER architecture:
+ *
+ *   • CONSUMER-FACING:   `ThinkingHandler` — a simple function-pair
+ *                        (id, providerNames, normalize, parseChunk?).
+ *                        Provider authors and custom-LLM consumers
+ *                        implement THIS shape.
+ *
+ *   • FRAMEWORK-INTERNAL: each `ThinkingHandler` is auto-wrapped in a
+ *                         real footprintjs subflow at chart build time.
+ *                         The subflow gets its own `runtimeStageId`,
+ *                         narrative entry, and InOutRecorder boundary
+ *                         — full trace observability for free without
+ *                         the consumer writing flowchart code.
+ *
+ * Same pattern as how consumers write a `Tool` and the framework wraps
+ * dispatch in a tool-call subflow, or how consumers write a
+ * `ToolProvider` and the framework wraps `list()` in the Tools slot
+ * subflow.
+ *
+ * @see SHIPPED_THINKING_HANDLERS for the registry the framework uses
+ *      to auto-wire by `provider.name` (Phase 3 wiring).
+ * @see MockThinkingHandler for the canonical example demonstrating
+ *      both Anthropic-shape (signed blocks) and OpenAI-shape (multi-
+ *      block summary) inputs.
+ */
+/**
+ * One thinking block from an LLM response, normalized into a provider-
+ * agnostic shape. A response may contain multiple blocks (e.g. OpenAI's
+ * structured reasoning_summary emits one block per summary step).
+ *
+ * Discriminator `type`:
+ *   - `'thinking'`            — content is the model's reasoning
+ *   - `'redacted_thinking'`   — Anthropic emits this when reasoning
+ *                               trips a safety filter; content is
+ *                               EMPTY but `signature` is still required
+ *                               for round-trip on the next turn
+ */
+export interface ThinkingBlock {
+    /**
+     * Block type discriminator. Required so consumers can distinguish
+     * normal thinking blocks from server-redacted ones (Anthropic-only
+     * today; other providers may produce only `'thinking'`).
+     */
+    readonly type: 'thinking' | 'redacted_thinking';
+    /**
+     * Reasoning content as plain text. EMPTY string when `type ===
+     * 'redacted_thinking'` (the model's reasoning was redacted by the
+     * provider's safety layer; only the signature remains).
+     */
+    readonly content: string;
+    /**
+     * Provider cryptographic signature for round-trip integrity.
+     *
+     * **Anthropic:** REQUIRED for any block emitted in a response that
+     * also contained tool_use. The signed block MUST be echoed
+     * byte-exact in the assistant message of subsequent tool_result
+     * turns — Anthropic validates the signature server-side and rejects
+     * (HTTP 400) requests where signed blocks are missing or modified.
+     *
+     * **OpenAI:** not used (their reasoning_summary doesn't sign blocks).
+     *
+     * **Future providers:** opaque to the framework; preserved as-is.
+     *
+     * The framework persists this field in `scope.history` so the
+     * provider's serialization layer (Phase 4b) can echo it back on the
+     * next request.
+     */
+    readonly signature?: string;
+    /**
+     * `true` when this block is a structured-summary step rather than
+     * raw thinking content. Set by `OpenAIThinkingHandler` for each step
+     * of `reasoning_summary`; never set by Anthropic. Consumers
+     * displaying thinking can render summary blocks differently
+     * (e.g. as numbered steps) from raw blocks (continuous prose).
+     */
+    readonly summary?: boolean;
+    /**
+     * Provider-specific metadata escape hatch for fields the normalized
+     * shape doesn't model.
+     *
+     * **ANTI-PATTERN:** providers MUST NOT include sensitive raw data
+     * here (PII, internal IDs, request tokens, customer data). Use the
+     * dedicated `signature` field for cryptographic material; nothing
+     * else identity-bearing. The framework excludes `providerMeta` from
+     * `getNarrative()` by default to avoid accidental audit-log leakage.
+     */
+    readonly providerMeta?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The consumer-facing contract for thinking normalization. Provider
+ * authors and custom-LLM consumers implement this shape; the framework
+ * auto-wraps each handler in a real footprintjs subflow at chart build
+ * time so the trace shows it as a discrete `runtimeStageId` (e.g.
+ * `sf-call-llm/thinking-{id}#5`).
+ *
+ * The framework matches handlers to providers by `providerNames` —
+ * the first handler whose `providerNames` includes the active
+ * `provider.name` is auto-wired. Override per-agent via
+ * `.thinkingHandler(customHandler)` (Phase 3 wiring).
+ */
+export interface ThinkingHandler {
+    /**
+     * Stable identifier used for `runtimeStageId`, telemetry, narrative
+     * entries, and the `agentfootprint.agent.thinking_parse_failed` event
+     * payload's `subflowId` field. Convention: lowercase + dash, e.g.
+     * `'anthropic'`, `'openai'`, `'mock'`.
+     */
+    readonly id: string;
+    /**
+     * Provider names this handler matches for auto-wire. The framework
+     * scans `SHIPPED_THINKING_HANDLERS` at chart build time and selects
+     * the first handler whose `providerNames` contains the active
+     * `provider.name`. Most handlers list one name; Bedrock-via-Anthropic
+     * style handlers may list multiple.
+     */
+    readonly providerNames: readonly string[];
+    /**
+     * Pure: raw provider data → normalized blocks.
+     *
+     * The framework wraps this call in a try/catch — throwing from
+     * `normalize()` does NOT abort the agent run. Instead the framework
+     * emits `agentfootprint.agent.thinking_parse_failed`, drops the
+     * thinking blocks (LLMMessage.thinkingBlocks remains undefined),
+     * and continues. Same graceful-failure pattern as v2.11.6
+     * `tools.discovery_failed`.
+     *
+     * Sync only in v2.14. Future widening to Promise return is a
+     * separate decision once a real consumer needs network-backed
+     * normalization.
+     *
+     * @param raw Provider-specific raw data — typically pulled from
+     *            `LLMResponse.providerRef`. Handler is responsible for
+     *            shape-checking; framework passes whatever the provider
+     *            stashed.
+     * @returns Normalized blocks in the order they appeared in the
+     *          response. Empty array when no thinking is present
+     *          (preferred over `undefined` for type stability).
+     */
+    normalize(raw: unknown): readonly ThinkingBlock[];
+    /**
+     * Optional streaming hot-path. When provided AND the provider streams,
+     * the framework calls `parseChunk(chunk)` per provider chunk and
+     * emits `agentfootprint.stream.thinking_delta` events for any
+     * `thinkingDelta` returned. Handlers without streaming support omit
+     * this field; the framework still calls `normalize()` on the
+     * response's terminal `LLMResponse.providerRef`.
+     *
+     * @param chunk Provider-specific chunk shape (Anthropic emits
+     *              `content_block_delta` events; OpenAI doesn't yet
+     *              stream reasoning content).
+     * @returns Object with optional `thinkingDelta` text — when set,
+     *          framework fires `stream.thinking_delta` event with the
+     *          content. Return `{}` (or omit) for chunks that contain
+     *          no thinking content.
+     */
+    parseChunk?(chunk: unknown): {
+        thinkingDelta?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/thinking/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/thinking/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,CAAC;IAEhD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3D;AAID;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAE1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,aAAa,EAAE,CAAC;IAElD;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACzD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "The explainable agent framework — build AI agents you can explain, audit, and trust. Built on footprintjs.",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -159,6 +159,11 @@
       "import": "./dist/esm/reliability/index.js",
       "require": "./dist/reliability/index.js"
     },
+    "./thinking": {
+      "types": "./dist/types/thinking/index.d.ts",
+      "import": "./dist/esm/thinking/index.js",
+      "require": "./dist/thinking/index.js"
+    },
     "./locales": {
       "types": "./dist/types/locales/index.d.ts",
       "import": "./dist/esm/locales/index.js",