@intx/inference 0.1.2 → 0.3.0

package/dist/retry-policy.d.ts

@@ -0,0 +1,31 @@
+import type { RetryPolicy } from "@intx/types/runtime";
+/**
+ * The default retry policy bundled with `@intx/inference`. Behaviour by
+ * `InferenceError.category`:
+ *
+ * - `credential_failure`, `context_overflow`, `fatal`, `aborted`,
+ *   `protocol_mismatch` — never retry. These categories describe a
+ *   deterministic per-call failure that re-issuing the identical
+ *   request cannot resolve: bad credentials stay bad, a too-large
+ *   context stays too large, a caller-driven abort is intentional,
+ *   and a wire-shape mismatch will repeat on the next response.
+ * - `retryable`, `timeout` — up to 3 attempts total. 500ms before
+ *   attempt 2, then 1000ms before attempt 3. Exponential rather than
+ *   constant so a server taking longer than usual to recover gets a
+ *   slightly larger window each time without compounding into a long
+ *   tail.
+ * - `quota_exhausted` — up to 3 attempts total. The delay is taken
+ *   from `error.retryAfterMs` when the provider returned one (the
+ *   server told us when it would be ready); otherwise a flat
+ *   `1000`ms baseline. The baseline does NOT grow across attempts —
+ *   if 1s isn't long enough for a rate limit to clear, exponential
+ *   backoff on top of the provider's own pacing instructions is more
+ *   likely to mask a config problem than help. Operators who need
+ *   exponential pacing for rate limits should supply a custom policy.
+ *
+ * The 3-attempt cap is the same across every retryable category: a
+ * single transient flake is plausible, two is rare, and a third
+ * failure across the backoff schedule is a real signal that the call
+ * is not going to succeed on its own.
+ */
+export declare function createDefaultRetryPolicy(): RetryPolicy;

package/{src/retry-policy.ts → dist/retry-policy.js}

@@ -7,21 +7,13 @@
 // transient-flake surface (TCP resets, 5xx, rate-limit jitter, half-
 // streamed connection drops) without masking a genuinely persistent
 // failure under a retry loop a human would never notice.
-
-import type {
-  RetryPolicy,
-  RetrySituation,
-  RetryDecision,
-} from "@intx/types/runtime";
-
 const MAX_ATTEMPTS = 3;
 // Indexed by the failed attempt number (1-indexed): the delay BEFORE
 // the attempt-after-this-one starts. Length must be `MAX_ATTEMPTS - 1`
 // because after the final attempt fails the policy aborts. Drives the
 // `retryable` and `timeout` schedules.
-const RETRYABLE_BACKOFF_BY_FAILED_ATTEMPT_MS: readonly number[] = [500, 1000];
+const RETRYABLE_BACKOFF_BY_FAILED_ATTEMPT_MS = [500, 1000];
 const QUOTA_DEFAULT_DELAY_MS = 1000;
-
 /**
  * The default retry policy bundled with `@intx/inference`. Behaviour by
  * `InferenceError.category`:
@@ -51,49 +43,45 @@ const QUOTA_DEFAULT_DELAY_MS = 1000;
  * failure across the backoff schedule is a real signal that the call
  * is not going to succeed on its own.
  */
-export function createDefaultRetryPolicy(): RetryPolicy {
-  return (situation: RetrySituation): RetryDecision => {
-    const { error, attempt } = situation;
-
-    switch (error.category) {
-      case "credential_failure":
-      case "context_overflow":
-      case "fatal":
-      case "aborted":
-      case "protocol_mismatch":
-        return { kind: "abort" };
-
-      case "retryable":
-      case "timeout": {
-        if (attempt >= MAX_ATTEMPTS) return { kind: "abort" };
-        const delayMs = RETRYABLE_BACKOFF_BY_FAILED_ATTEMPT_MS[attempt - 1];
-        if (delayMs === undefined) {
-          // Unreachable in practice given the `attempt >= MAX_ATTEMPTS`
-          // guard above, but the explicit narrowing keeps the schedule
-          // table and the cap from drifting silently if anyone bumps
-          // `MAX_ATTEMPTS` without extending the table.
-          return { kind: "abort" };
+export function createDefaultRetryPolicy() {
+    return (situation) => {
+        const { error, attempt } = situation;
+        switch (error.category) {
+            case "credential_failure":
+            case "context_overflow":
+            case "fatal":
+            case "aborted":
+            case "protocol_mismatch":
+                return { kind: "abort" };
+            case "retryable":
+            case "timeout": {
+                if (attempt >= MAX_ATTEMPTS)
+                    return { kind: "abort" };
+                const delayMs = RETRYABLE_BACKOFF_BY_FAILED_ATTEMPT_MS[attempt - 1];
+                if (delayMs === undefined) {
+                    // Unreachable in practice given the `attempt >= MAX_ATTEMPTS`
+                    // guard above, but the explicit narrowing keeps the schedule
+                    // table and the cap from drifting silently if anyone bumps
+                    // `MAX_ATTEMPTS` without extending the table.
+                    return { kind: "abort" };
+                }
+                return { kind: "retry", delayMs };
+            }
+            case "quota_exhausted":
+                if (attempt >= MAX_ATTEMPTS)
+                    return { kind: "abort" };
+                return {
+                    kind: "retry",
+                    delayMs: error.retryAfterMs ?? QUOTA_DEFAULT_DELAY_MS,
+                };
+            default: {
+                // Exhaustiveness: if a new InferenceError.category lands
+                // without a clause here, the never-assignment fails at
+                // compile time rather than silently returning undefined
+                // from the policy callback.
+                const exhaustive = error.category;
+                throw new Error(`createDefaultRetryPolicy: unhandled error category ${String(exhaustive)}`);
+            }
         }
-        return { kind: "retry", delayMs };
-      }
-
-      case "quota_exhausted":
-        if (attempt >= MAX_ATTEMPTS) return { kind: "abort" };
-        return {
-          kind: "retry",
-          delayMs: error.retryAfterMs ?? QUOTA_DEFAULT_DELAY_MS,
-        };
-
-      default: {
-        // Exhaustiveness: if a new InferenceError.category lands
-        // without a clause here, the never-assignment fails at
-        // compile time rather than silently returning undefined
-        // from the policy callback.
-        const exhaustive: never = error.category;
-        throw new Error(
-          `createDefaultRetryPolicy: unhandled error category ${String(exhaustive)}`,
-        );
-      }
-    }
-  };
+    };
 }

package/dist/sse.d.ts

@@ -0,0 +1 @@
+export declare function parseSSE(stream: ReadableStream<Uint8Array>): AsyncIterable<string>;

package/dist/sse.js

@@ -0,0 +1,63 @@
+// Server-Sent Events byte stream parser.
+//
+// Converts a ReadableStream<Uint8Array> (the raw HTTP response body) into an
+// AsyncIterable<string> of SSE data payloads. Each yielded string is the
+// value of one `data:` field. Comments (`:`) and blank-line separators are
+// consumed internally. The `[DONE]` sentinel (OpenAI convention) terminates
+// the iteration.
+//
+// The parser buffers incomplete lines across chunk boundaries so split chunks
+// are handled correctly regardless of where chunk boundaries fall.
+const decoder = new TextDecoder();
+export async function* parseSSE(stream) {
+    const reader = stream.getReader();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // Flush any remaining content in the buffer as a final line.
+                if (buffer.length > 0) {
+                    const payload = extractDataPayload(buffer);
+                    if (payload !== null) {
+                        yield payload;
+                    }
+                }
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            // Process all complete lines (lines terminated by \n).
+            // A line ending in \r\n counts as terminated at the \n.
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+                const rawLine = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                // Strip trailing \r for CRLF line endings.
+                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+                // Blank lines and comment lines are ignored.
+                if (line === "" || line.startsWith(":")) {
+                    continue;
+                }
+                const payload = extractDataPayload(line);
+                if (payload === null) {
+                    continue;
+                }
+                if (payload === "[DONE]") {
+                    return;
+                }
+                yield payload;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function extractDataPayload(line) {
+    if (line.startsWith("data:")) {
+        // The spec allows an optional space after the colon.
+        const raw = line.slice(5);
+        return raw.startsWith(" ") ? raw.slice(1) : raw;
+    }
+    return null;
+}

package/dist/state.d.ts

@@ -0,0 +1,23 @@
+import type { ConversationTurn, LastCycleSource, PendingOperation, TokenUsage, ReactorState } from "@intx/types/runtime";
+import type { GateSnapshot } from "./gates.js";
+export type ReactorStateManager = ReturnType<typeof createStateManager>;
+/**
+ * Creates a mutable state container. All mutations go through explicit methods;
+ * the `snapshot()` method produces an immutable view for the director.
+ */
+export declare function createStateManager(sessionId: string, initialTurns: ConversationTurn[], initialOps: PendingOperation[], initialUsage: TokenUsage): {
+    appendTurn: (msg: ConversationTurn) => void;
+    replaceTurns: (next: ConversationTurn[]) => void;
+    addPendingOperation: (op: PendingOperation) => void;
+    removePendingOperation: (correlationId: string) => void;
+    accumUsage: (usage: TokenUsage) => void;
+    setLastCycleUsage: (usage: TokenUsage) => void;
+    setLastCycleSource: (source: LastCycleSource) => void;
+    setGatesSnapshot: (gates: GateSnapshot[]) => void;
+    addFork: (forkId: string, mode: "independent" | "child") => void;
+    removeFork: (forkId: string) => void;
+    getTurns: () => ConversationTurn[];
+    getPendingOperations: () => PendingOperation[];
+    getTokenUsage: () => TokenUsage;
+    snapshot: () => ReactorState;
+};

package/dist/state.js

@@ -0,0 +1,100 @@
+// Reactor state management: turn history, async operations, usage tracking.
+//
+// The state object is the authoritative view the director receives on every
+// decision. It is mutable by the reactor only — the director receives a
+// snapshot so it cannot corrupt the reactor's internal state.
+//
+// (INFERENCE.md § Agent Reactor › Director Decision Function)
+/**
+ * Creates a mutable state container. All mutations go through explicit methods;
+ * the `snapshot()` method produces an immutable view for the director.
+ */
+export function createStateManager(sessionId, initialTurns, initialOps, initialUsage) {
+    let turns = [...initialTurns];
+    const pendingOperations = new Map(initialOps.map((op) => [op.correlationId, op]));
+    const tokenUsage = { ...initialUsage };
+    let lastCycleUsage = null;
+    let lastCycleSource = null;
+    let activeGatesSnapshot = [];
+    const activeForks = [];
+    function appendTurn(msg) {
+        turns.push(msg);
+    }
+    function replaceTurns(next) {
+        turns = [...next];
+    }
+    function addPendingOperation(op) {
+        pendingOperations.set(op.correlationId, op);
+    }
+    function removePendingOperation(correlationId) {
+        pendingOperations.delete(correlationId);
+    }
+    function accumUsage(usage) {
+        tokenUsage.input += usage.input;
+        tokenUsage.output += usage.output;
+        tokenUsage.cacheRead += usage.cacheRead;
+        tokenUsage.cacheWrite += usage.cacheWrite;
+        tokenUsage.thinking += usage.thinking;
+    }
+    function setLastCycleUsage(usage) {
+        lastCycleUsage = { ...usage };
+    }
+    function setLastCycleSource(source) {
+        lastCycleSource = { ...source };
+    }
+    function setGatesSnapshot(gates) {
+        activeGatesSnapshot = gates;
+    }
+    function addFork(forkId, mode) {
+        activeForks.push({ forkId, mode });
+    }
+    function removeFork(forkId) {
+        const idx = activeForks.findIndex((f) => f.forkId === forkId);
+        if (idx !== -1)
+            activeForks.splice(idx, 1);
+    }
+    function getTurns() {
+        return turns;
+    }
+    function getPendingOperations() {
+        return Array.from(pendingOperations.values());
+    }
+    function getTokenUsage() {
+        return { ...tokenUsage };
+    }
+    function snapshot() {
+        return {
+            sessionId,
+            turns: turns.map((m) => ({
+                ...m,
+                content: m.content.map((b) => structuredClone(b)),
+            })),
+            pendingOperations: Array.from(pendingOperations.values()).map((op) => structuredClone(op)),
+            activeGates: activeGatesSnapshot.map((g) => ({
+                gateId: g.gateId,
+                type: g.type,
+                timeoutAt: g.timeoutAt,
+            })),
+            activeForks: activeForks.map((f) => ({ ...f })),
+            tokenUsage: { ...tokenUsage },
+            lastCycleUsage: lastCycleUsage !== null ? { ...lastCycleUsage } : null,
+            lastCycleSource: lastCycleSource !== null ? { ...lastCycleSource } : null,
+        };
+    }
+    return {
+        appendTurn,
+        replaceTurns,
+        addPendingOperation,
+        removePendingOperation,
+        accumUsage,
+        setLastCycleUsage,
+        setLastCycleSource,
+        setGatesSnapshot,
+        addFork,
+        removeFork,
+        getTurns,
+        getPendingOperations,
+        getTokenUsage,
+        snapshot,
+    };
+}

package/dist/tool-name.d.ts

@@ -0,0 +1,6 @@
+export type ToolNameLimit = {
+    readonly provider: string;
+    readonly maxLength: number;
+};
+export declare function encodeToolName(name: string, limit: ToolNameLimit): string;
+export declare function decodeToolName(wire: string): string;

package/dist/tool-name.js

@@ -0,0 +1,110 @@
+// Invertible codec for tool names on the provider wire.
+//
+// Internal tool names are package-qualified ids like
+// `@intx/tools-posix/sidecar-bundle:run_shell`. Provider function-name
+// charsets are narrow (OpenAI `^[a-zA-Z0-9_-]{1,64}$`, Anthropic 128, Gemini
+// with a leading-letter rule), and reject the `@`, `/`, `:`, and `.`
+// characters these ids carry. This codec maps such a name to a
+// wire-charset-safe form and back.
+//
+// Invariant: `decodeToolName(encodeToolName(x, ...)) === x`. It is
+// load-bearing. Tool-call dispatch keys on the exact prefixed name in two
+// places (the agent's `byName` map and the tool-package loader's per-bundle
+// `nameMap`), so a name that does not round-trip lands as an `unknown tool`
+// with no error at the point of the fault. The `encode`/`decode` naming
+// advertises the invertibility on purpose: a `sanitize`-style name invites a
+// future lossy "cleanup" that would break dispatch.
+//
+// Names that are already valid on the wire pass through untouched — the codec
+// only rewrites names that genuinely need it. Rewritten names carry a
+// distinctive `MARKER` prefix, and `decode` transforms only marker-prefixed
+// names, so an ordinary wire-valid name a provider echoes (a tool the model
+// named that never needed encoding, or a hallucination) is returned verbatim.
+// The marker is what makes the round-trip unambiguous: a name that is already
+// valid but happens to begin with the marker is force-encoded too, so a
+// marker prefix on the wire always denotes an encoding.
+//
+// Rewriting escapes each out-of-charset character (and, so the sentinel stays
+// unambiguous, each literal `-`) as `-XX`, its uppercase two-digit hex byte:
+// `@`->`-40`, `/`->`-2F`, `:`->`-3A`, `.`->`-2E`, `-`->`-2D`. A `base64url`
+// encoding (reusing `@intx/types/base64url`) was considered and rejected: it
+// renders every name fully opaque, hurting both model tool-selection and
+// debugging, and it would encode even the already-legible names this scheme
+// leaves alone.
+// A distinctive, letter-leading prefix that ordinary tool names do not start
+// with. Letter-leading satisfies providers (Gemini) that require a
+// letter/underscore leading character on every function name.
+const MARKER = "IX_";
+// Characters that survive a rewrite verbatim. `-` is deliberately excluded so
+// it can serve as the escape sentinel inside a rewritten name.
+const ESCAPE_PASSTHROUGH = /^[A-Za-z0-9_]$/;
+// The provider wire charset. A name already matching this, that starts with a
+// letter or underscore and does not collide with the marker, needs no rewrite.
+const WIRE_SAFE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+const HEX_PAIR = /^[0-9A-Fa-f]{2}$/;
+function needsRewrite(name) {
+    return !WIRE_SAFE.test(name) || name.startsWith(MARKER);
+}
+function rewrite(name) {
+    let out = MARKER;
+    for (const ch of name) {
+        if (ESCAPE_PASSTHROUGH.test(ch)) {
+            out += ch;
+            continue;
+        }
+        const code = ch.charCodeAt(0);
+        if (code > 0xff) {
+            throw new Error(`Cannot encode tool name "${name}": character "${ch}" is outside the ` +
+                `single-byte range the wire codec supports.`);
+        }
+        out += "-" + code.toString(16).toUpperCase().padStart(2, "0");
+    }
+    return out;
+}
+// Encode a tool name into a form valid for the provider's function-name
+// charset. Names already valid on the wire pass through unchanged. Throws if
+// the resulting wire name exceeds the provider's length limit — on the
+// passthrough path too, since an already-valid name can still be too long — so
+// a name too long for a provider surfaces as a fixable diagnostic rather than
+// truncation, a silent collision, or an opaque upstream 400.
+export function encodeToolName(name, limit) {
+    const wire = needsRewrite(name) ? rewrite(name) : name;
+    if (wire.length > limit.maxLength) {
+        throw new Error(`Tool name "${name}" is ${wire.length} chars on the wire, which ` +
+            `exceeds the ${limit.maxLength}-char limit for provider ` +
+            `"${limit.provider}". Shorten the tool bundle id or tool name.`);
+    }
+    return wire;
+}
+// Invert `encodeToolName`. Total: a wire name without the marker prefix, or a
+// marker-prefixed name whose body is not a valid escaping, is returned
+// unchanged. That covers both names that never needed encoding and
+// hallucinated or provider-mangled names, which then fall through to the
+// existing `unknown tool` handling — giving the model feedback to retry —
+// rather than throwing and tearing down the stream over a bad tool name.
+export function decodeToolName(wire) {
+    if (!wire.startsWith(MARKER)) {
+        return wire;
+    }
+    const body = wire.slice(MARKER.length);
+    let out = "";
+    let i = 0;
+    while (i < body.length) {
+        const ch = body.charAt(i);
+        if (ch === "-") {
+            const hex = body.slice(i + 1, i + 3);
+            if (!HEX_PAIR.test(hex)) {
+                return wire;
+            }
+            out += String.fromCharCode(parseInt(hex, 16));
+            i += 3;
+            continue;
+        }
+        if (!ESCAPE_PASSTHROUGH.test(ch)) {
+            return wire;
+        }
+        out += ch;
+        i += 1;
+    }
+    return out;
+}

package/dist/transform.d.ts

@@ -0,0 +1,11 @@
+import { type ConversationTurn } from "@intx/types/runtime";
+export type TransformOptions = {
+    targetModel: string;
+    keepThinkingForSameModel?: boolean;
+};
+export declare function transformMessages(messages: ConversationTurn[], options: TransformOptions): ConversationTurn[];
+export type IDNormalizer = {
+    normalize(providerId: string): string;
+    resolve(portableId: string): string | undefined;
+};
+export declare function createIDNormalizer(): IDNormalizer;

package/dist/transform.js

@@ -0,0 +1,132 @@
+// Cross-provider message transformation.
+//
+// When conversations cross provider boundaries the message history must be
+// adapted: thinking blocks are stripped for foreign models, orphaned tool
+// calls receive synthetic error results, and tool call IDs are normalized to
+// a portable format.
+//
+// Callers invoke transformMessages when switching models. Adapter
+// buildRequest paths also apply provider-specific history fixes. The
+// originating model is tracked per-message, not per-conversation.
+import { formatSafetyRatingText, } from "@intx/types/runtime";
+export function transformMessages(messages, options) {
+    const { targetModel, keepThinkingForSameModel = true } = options;
+    // First pass: strip thinking blocks and filter aborted assistant messages.
+    const filtered = messages
+        .map((msg) => {
+        if (msg.role === "assistant") {
+            const isSameModel = msg.model === targetModel;
+            const keepThinking = keepThinkingForSameModel && isSameModel;
+            const filteredContent = msg.content
+                .filter((block) => {
+                if (block.type === "thinking") {
+                    return keepThinking;
+                }
+                return true;
+            })
+                // safety_rating is output-only metadata. Convert it to text
+                // so cross-provider history keeps role alternation and a
+                // human-readable block reason without requiring every
+                // adapter to special-case the block.
+                .map((block) => {
+                if (block.type === "safety_rating") {
+                    return {
+                        type: "text",
+                        text: formatSafetyRatingText(block),
+                    };
+                }
+                return block;
+            });
+            // Filter out assistant messages that have no text or tool calls
+            // (aborted/error messages with only thinking blocks removed).
+            const hasUsableContent = filteredContent.some((b) => b.type === "text" || b.type === "tool_call");
+            if (!hasUsableContent && filteredContent.length === 0) {
+                return null;
+            }
+            return { ...msg, content: filteredContent };
+        }
+        return msg;
+    })
+        .filter((msg) => msg !== null);
+    // Second pass: inject synthetic tool results for orphaned tool calls.
+    return injectOrphanedToolResults(filtered);
+}
+function injectOrphanedToolResults(messages) {
+    const result = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg === undefined)
+            continue;
+        result.push(msg);
+        if (msg.role !== "assistant")
+            continue;
+        const toolCalls = msg.content.filter((b) => b.type === "tool_call");
+        if (toolCalls.length === 0)
+            continue;
+        // Collect tool call IDs from this assistant message.
+        const calledIds = new Set(toolCalls.map((tc) => tc.id));
+        // Check the following messages for results that cover these calls.
+        const coveredIds = new Set();
+        for (let j = i + 1; j < messages.length; j++) {
+            const next = messages[j];
+            if (next === undefined)
+                break;
+            if (next.role !== "user")
+                break;
+            for (const block of next.content) {
+                if (block.type === "tool_result") {
+                    coveredIds.add(block.callId);
+                }
+            }
+        }
+        // Find which tool calls have no corresponding result.
+        const orphanedIds = [...calledIds].filter((id) => !coveredIds.has(id));
+        if (orphanedIds.length === 0)
+            continue;
+        // Inject a synthetic user message with error tool results for each orphan.
+        const syntheticBlocks = orphanedIds.map((id) => ({
+            type: "tool_result",
+            callId: id,
+            content: [
+                {
+                    type: "text",
+                    text: "Tool execution was interrupted before completion.",
+                },
+            ],
+            isError: true,
+        }));
+        result.push({
+            role: "user",
+            content: syntheticBlocks,
+            timestamp: Date.now(),
+        });
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Tool call ID normalization
+//
+// OpenAI Responses API generates 450+ character IDs with pipes. Anthropic
+// has strict format requirements. IDs are normalized to a short portable
+// format with a bidirectional map for round-trip fidelity.
+// ---------------------------------------------------------------------------
+const PORTABLE_ID_PREFIX = "tc_";
+export function createIDNormalizer() {
+    const portableToProvider = new Map();
+    const providerToPortable = new Map();
+    let counter = 0;
+    return {
+        normalize(providerId) {
+            const existing = providerToPortable.get(providerId);
+            if (existing !== undefined)
+                return existing;
+            const portable = `${PORTABLE_ID_PREFIX}${(++counter).toString(36)}`;
+            providerToPortable.set(providerId, portable);
+            portableToProvider.set(portable, providerId);
+            return portable;
+        },
+        resolve(portableId) {
+            return portableToProvider.get(portableId);
+        },
+    };
+}

package/dist/transforms/index.d.ts

@@ -0,0 +1,2 @@
+export { createSizeCapTransform } from "./size-cap.js";
+export type { SizeCapTransformOptions } from "./size-cap.js";

package/dist/transforms/index.js

@@ -0,0 +1 @@
+export { createSizeCapTransform } from "./size-cap.js";

package/dist/transforms/size-cap.d.ts

@@ -0,0 +1,12 @@
+import type { ContextStore, ToolResultTransform } from "@intx/types/runtime";
+export type SizeCapTransformOptions = {
+    maxChars: number;
+    contextStore: Pick<ContextStore, "writeBlob">;
+};
+/**
+ * Create a `ToolResultTransform` that caps inline tool result content at
+ * `maxChars` characters. Oversized results are spilled to the context store
+ * via `writeBlob` and the inline content becomes a truncated marker
+ * referencing the spill by `tool-output:///{callId}` URI.
+ */
+export declare function createSizeCapTransform(options: SizeCapTransformOptions): ToolResultTransform;