agentfootprint 13.0.0 → 14.0.0

package/dist/esm/events/payloads/stream.d.ts

@@ -0,0 +1,230 @@
+import type { LLMMessage, LLMProviderName, ToolProtocol, ToolResultStatus } from './dependencyTypes.js';
+export interface LLMStartPayload {
+    readonly iteration: number;
+    readonly provider: LLMProviderName;
+    readonly model: string;
+    readonly systemPromptChars: number;
+    /**
+     * The ASSEMBLED system prompt, verbatim as sent to the provider (9.50.0) —
+     * every injection piece joined exactly the way the wire saw it. **OPT-IN,
+     * default OFF**: present only when the run was built with
+     * `recordSystemPrompt: true` (`AgentOptions` / `LLMCallOptions`).
+     *
+     * PRIVACY: the assembled prompt routinely carries what its pieces carry —
+     * skill bodies, RAG passages, memory recalls, per-user instructions. With
+     * the dial on, all of it lands in every event sink and every recording
+     * (`recordRun` → `persistRecording`), so treat those artifacts as being as
+     * sensitive as the prompt itself. Absent, the event keeps its exact prior
+     * bytes: only `systemPromptChars` (the length) is recorded, and the
+     * assembled string is honestly NOT in the recording.
+     */
+    readonly systemPromptText?: string;
+    readonly messagesCount: number;
+    readonly toolsCount: number;
+    /**
+     * The tool CATALOG the model saw for this call — what was at its disposal when
+     * it chose (the menu behind its tool-selection reasoning). One `{ name,
+     * description }` per tool sent to the provider, in request order. Absent when
+     * the call had no tools. The structured "what the model saw" payload: pair it
+     * with the iteration's reasoning to debug WHY a tool was (or wasn't) picked.
+     * Names + descriptions only — full input schemas live in the snapshot.
+     */
+    readonly tools?: readonly {
+        readonly name: string;
+        readonly description?: string;
+    }[];
+    readonly estimatedPromptTokens?: number;
+    readonly temperature?: number;
+    readonly providerRequestRef?: string;
+    /**
+     * WHICH BRAIN answered, when a brain rung won (9.19.0 — "the cursor picks
+     * the brain"). `via: 'skill'` = the active skill's declared brain served
+     * this call (`skillId` names the tenure); `via: 'escalation'` = the turn
+     * crossed its declared refusal threshold and the escalation brain is
+     * serving the rest of it. ABSENT whenever the agent's own configured /
+     * default model answered — an agent without brains keeps its exact prior
+     * event bytes. `provider` + `model` above always report what was actually
+     * called, whichever rung supplied them.
+     */
+    readonly brain?: {
+        readonly via: 'skill' | 'escalation';
+        readonly skillId?: string;
+    };
+}
+export interface LLMEndPayload {
+    readonly iteration: number;
+    /** Draft text, or an empty string when contentWithheld is true. */
+    readonly content: string;
+    /** An output policy withheld draft text. This does not mean the model returned no text. */
+    readonly contentWithheld?: true;
+    readonly toolCallCount: number;
+    readonly usage: {
+        readonly input: number;
+        readonly output: number;
+        readonly cacheRead?: number;
+        readonly cacheWrite?: number;
+        /**
+         * 9.29.0 — reasoning tokens the model spent on this call, when the
+         * provider reports them (`LLMResponse.usage.thinking`).
+         *
+         * This field is the fix for a gap a field trial found by walking into it:
+         * a 256-token Gemini stream produced ONE visible chunk, and the run only
+         * made sense once the numbers were read — `input 21, output 9,
+         * thinking 243`. The provider had been reporting that third number all
+         * along and this payload's type dropped it, so the event that a consumer
+         * actually subscribes to could not explain its own run.
+         *
+         * **Not inside `output`.** On Gemini `candidatesTokenCount` counts visible
+         * tokens only; thinking is a separate, billed line item. A cost estimate
+         * built from `input + output` under-counts a thinking model by whatever it
+         * thought. `cost.tick` deliberately does NOT fold it in — `PricingTable`
+         * prices four kinds and thinking is not one of them, and inventing a rate
+         * would be this library guessing at somebody's invoice.
+         *
+         * Undefined when the provider does not report thinking tokens, which is
+         * most calls.
+         */
+        readonly thinking?: number;
+    };
+    readonly stopReason: string;
+    readonly durationMs: number;
+    readonly providerResponseRef?: string;
+}
+export interface LLMTokenPayload {
+    readonly iteration: number;
+    readonly tokenIndex: number;
+    readonly content: string;
+}
+export interface ToolStartPayload {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly args: Readonly<Record<string, unknown>>;
+    readonly parallelCount?: number;
+    readonly protocol?: ToolProtocol;
+    /**
+     * 9.113.0 — present only on the bracket of a call that was NEVER
+     * DISPATCHED: a batch paused on an earlier call, and the resume answered
+     * this one with a fixed sentence instead of running it
+     * (`core/agent/stages/toolCalls/batch/settlementOperations.ts` · `bracketSettled`, the one stamping
+     * site). `pausedCall` names the call in the same batch the run paused on.
+     * No gate judged this call and no tool ran; `args` are the ones it would
+     * have run with.
+     *
+     * The same fact, the same shape, as the history message's marker — typed off
+     * `LLMMessage.notDispatched`, so there is one definition. Read it rather than
+     * inferring anything from the bracket's `durationMs: 0` or its sentence.
+     *
+     * Absent on every other bracket.
+     */
+    readonly notDispatched?: LLMMessage['notDispatched'];
+}
+/**
+ * One progress report from inside a still-running tool call (9.52.0) — filed
+ * by `ctx.progress(payload)` from within `tool.execute`, in call order, always
+ * BETWEEN this call's `stream.tool_start` and its `stream.tool_end`.
+ *
+ * The split is deliberate: the three identity fields are stamped by the
+ * FRAMEWORK from the dispatch it is already holding (a tool cannot claim to be
+ * another call, another tool, or another iteration), and `payload` is the tool
+ * author's data forwarded verbatim. Nothing here is ever shown to the model —
+ * this is the telemetry channel, not the result channel.
+ *
+ * Absent entirely for every tool that never reports: a run whose tools call
+ * nothing files no `tool_progress` events at all.
+ */
+export interface ToolProgressPayload {
+    /** The invocation this report belongs to — matches `stream.tool_start.toolCallId`. */
+    readonly toolCallId: string;
+    /** The tool that reported. */
+    readonly toolName: string;
+    /** The ReAct iteration this call was dispatched on (`0` where there is no loop). */
+    readonly iteration: number;
+    /**
+     * The tool author's payload, verbatim — whatever shape they chose
+     * (`{ done: 3, total: 12 }`, a status string, a partial row). The library
+     * neither reads it nor normalizes it; it must survive `structuredClone`,
+     * because it lands in every event sink and every recording.
+     */
+    readonly payload: unknown;
+}
+export interface ToolEndPayload {
+    readonly toolCallId: string;
+    readonly result: unknown;
+    readonly error?: boolean;
+    readonly durationMs: number;
+    /**
+     * The tool's OWN declared outcome (9.19.0) — present only when the tool
+     * returned a result envelope carrying `status`. Normalized vocabulary
+     * (`'denied'` must never read like `'success'`); route edges key on it
+     * via `onToolStatus`. Absent for every tool that never opted in.
+     */
+    readonly status?: ToolResultStatus;
+    /**
+     * 9.113.0 — present only when this call was NEVER DISPATCHED: the batch
+     * settlement closed its bracket (`core/agent/stages/toolCalls/batch/settlementOperations.ts` ·
+     * `bracketSettled`). `result` is then the library's fixed sentence (the one
+     * the model read), `durationMs` is `0`, and `error` is ABSENT.
+     *
+     * `error` says a call FAILED — the tool threw or reported a failure, or the
+     * call could not run as written (an args-validation rejection, a `wants`
+     * block, a consent the tool needed and did not get, an unknown tool). A
+     * settled call did not fail: the library decided not to dispatch it, the
+     * way it decides for a call a permission policy denies or halts, whose
+     * brackets carry no `error` either. This field is the owner of WHY there is
+     * no result, and a reader that counts outcomes reads it: a bracket that
+     * carries it is neither a success nor a failure of the tool.
+     *
+     * Same shape as `ToolStartPayload.notDispatched` and as the history
+     * message's marker (typed off `LLMMessage.notDispatched`). Absent on every
+     * other bracket.
+     */
+    readonly notDispatched?: LLMMessage['notDispatched'];
+    /**
+     * What the MODEL read for this call, when it differs from `result`: an
+     * `onToolResult` link rewrote or denied it, the `maxToolResultChars` cap
+     * cut the model's channel alone, or the library removed the record-only
+     * coverage fields (`short`, `kind` — see `CoverageItem`) from a coverage
+     * envelope before serving it. `result` stays the tool's own answer — this
+     * is the other half of that split, which until now lived only in history.
+     * Absent when the model read `result` itself (the common case; the two
+     * channels are then one reference). Stamped on all five dispatch paths.
+     *
+     * Cost, stated: a call whose tool declares `short` or `kind` carries its
+     * envelope twice here (`result` + `modelResult`), so the extra bytes are
+     * the size of that envelope — about 4 KB for a typical absence, and as
+     * large as the payload a ledger wraps. Under result PLACEMENT a difference
+     * that is only this strip counts as one value: both channels carry the one
+     * ticket and nothing is stamped. A tool that declares neither gets no stamp
+     * and no new byte.
+     */
+    readonly modelResult?: unknown;
+    /**
+     * The NAMES of the argument keys whose value the tool ran with differs from
+     * the proposal `stream.tool_start` carried: set, rewritten or removed by an
+     * `onToolCall` link, or hidden by the tool's own redaction policy
+     * (`flowchartAsTool({ redact })`, `runbookAsTool({ redact })` —
+     * `core/toolShownArgs.ts` · `shownArgsOf`). Names only, never values: a
+     * link may ADD a value (a server-side key) the model never saw, and an event
+     * goes to every sink attached, each serializing what it gets. Taken BEFORE
+     * the tool runs, so nothing the tool writes into its arguments reaches it.
+     * A reader exporting the call's arguments shows these keys' values as
+     * withheld. Absent when the tool ran with the proposal as it was.
+     *
+     * Stamped on the batch-dispatch bracket only — the one whose `tool_start`
+     * precedes it in the same run.
+     */
+    readonly changedArgKeys?: readonly string[];
+    /**
+     * A configured RULE refused the call, so the tool never ran: a permission
+     * policy denied or halted it, or an `onToolCall` link denied it. `result` is
+     * then the refusal the model read, and `error` is absent — this field is
+     * what tells such a bracket from a tool that ran and answered.
+     *
+     * NOT a general "never ran" marker, and its absence proves nothing: a call
+     * that could not run with no rule involved (an unknown tool name, an args
+     * rejection, a `wants` or credential block) carries `error: true` instead,
+     * a settled bracket carries `notDispatched`, and a resumed leg's bracket
+     * carries neither. Batch-dispatch bracket only.
+     */
+    readonly notExecuted?: true;
+}

package/dist/esm/events/payloads/stream.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stream.js.map

package/dist/esm/events/payloads/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../../../src/events/payloads/stream.ts"],"names":[],"mappings":""}

package/dist/esm/events/payloads/thinking.d.ts

@@ -0,0 +1,118 @@
+import type { ThinkingBlock } from './dependencyTypes.js';
+export interface EmbeddingGeneratedPayload {
+    readonly model: string;
+    readonly provider: 'openai' | 'cohere' | 'voyage' | 'local' | 'custom';
+    readonly inputKind: 'query' | 'document';
+    readonly dimension: number;
+    readonly count: number;
+    readonly durationMs: number;
+    readonly tokensSpent?: number;
+}
+/**
+ * Emitted (v2.14) per provider chunk that carries thinking-content
+ * tokens. Lives in `stream.*` domain — parallel to `stream.token` for
+ * visible-content tokens.
+ *
+ * **Provider behavior:**
+ * - Anthropic: fires for every `content_block_delta` with
+ *   `delta.type === 'thinking_delta'`. May fire 100s of times per turn.
+ * - OpenAI o1/o3: NEVER fires (OpenAI doesn't stream reasoning content
+ *   as of early 2026). Only `thinking_end` fires at response completion.
+ * - Custom providers: fire when `ThinkingHandler.parseChunk()` returns
+ *   a non-empty `thinkingDelta`.
+ *
+ * **Default consumer behavior:** thinking_delta events are emitted but
+ * not surfaced to end users unless a consumer explicitly subscribes to
+ * this event (e.g. for reasoning-as-it-streams UIs).
+ *
+ * **Sensitive data:** `content` is raw model thinking text. Use
+ * `RedactionPolicy.thinkingPatterns` (Phase 3) to scrub before audit-log
+ * adapters fire. Same risk profile as `stream.token`.
+ */
+export interface StreamThinkingDeltaPayload {
+    readonly iteration: number;
+    readonly tokenIndex: number;
+    /** Per-chunk delta text, NOT accumulated. ~10–50 chars typical. */
+    readonly content: string;
+}
+/**
+ * Emitted (v2.14) once per LLM call where thinking blocks were
+ * produced. Pairs with the leading `stream.thinking_delta` events when
+ * streaming, OR fires standalone for non-streaming providers (OpenAI).
+ *
+ * Use this event for live per-iteration UIs (chat-bubble reasoning
+ * pills, retry-rate dashboards, telemetry). The `blocks` field carries
+ * the same content that lands on `LLMMessage.thinkingBlocks` — read it
+ * here for live display instead of post-walking `scope.history` after
+ * the run completes (the framework's "collect during traversal" rule).
+ *
+ * **`tokens` field population:**
+ * - Anthropic: `undefined` currently — Anthropic's `response.usage`
+ *   doesn't break out thinking tokens (bundled in `output_tokens`).
+ *   May change in future Anthropic API revisions.
+ * - OpenAI o1/o3: populated from
+ *   `response.usage.completion_tokens_details.reasoning_tokens`.
+ * - Custom providers: populated when handler computes it during
+ *   `normalize()`.
+ *
+ * **Sensitive data:** the `blocks` field carries reasoning content.
+ * Same risk profile as `stream.token` — wildcard (`*`) recorders
+ * piping to external sinks (Datadog, CloudWatch, OTel) will see this.
+ * Treat thinking content with the same redaction posture you give
+ * visible response tokens. `providerMeta` is already stripped by the
+ * framework before persistence (Phase 6 invariant), so the blocks
+ * here match the audit-log surface bytes-exactly.
+ */
+export interface StreamThinkingEndPayload {
+    readonly iteration: number;
+    readonly blockCount: number;
+    readonly totalChars: number;
+    readonly tokens?: number;
+    /**
+     * v2.14+ — the normalized thinking blocks for this LLM call.
+     *
+     * Same data the framework persists to `LLMMessage.thinkingBlocks`
+     * (post-`providerMeta` strip). Lets live consumers render the
+     * model's chain-of-thought per iteration without scope-walking
+     * after the run.
+     *
+     * Empty / undefined when no thinking content was produced this
+     * call (handler returned `[]`). Non-empty when at least one
+     * thinking or redacted_thinking block landed.
+     */
+    readonly blocks?: readonly ThinkingBlock[];
+}
+/**
+ * Emitted (v2.14) when a `ThinkingHandler.normalize()` call throws.
+ * The framework catches the throw, drops the thinking blocks (they
+ * don't land on `LLMMessage.thinkingBlocks`), and continues the agent
+ * run. Same graceful-failure pattern as v2.11.6
+ * `tools.discovery_failed`.
+ *
+ * Lives in `agent.*` domain (NOT `stream.*`) because parse failure is
+ * a turn-level error concern — recovery happens at the agent loop
+ * level, not at the SDK call level.
+ *
+ * **Anti-pattern (provider authors):** sanitize error messages before
+ * throwing. NEVER include raw unparsed thinking content in the error
+ * — the message ends up in audit logs and can leak reasoning content
+ * the consumer expected to be redacted. Same guidance as
+ * `tools.discovery_failed.error`.
+ */
+export interface AgentThinkingParseFailedPayload {
+    readonly providerName: string;
+    readonly subflowId: string;
+    readonly error: string;
+    readonly errorName: string;
+    readonly iteration: number;
+}
+/** One completed-turn thinking block omitted before a provider request. */
+export interface AgentThinkingOmittedPayload {
+    readonly providerName: string;
+    readonly model: string;
+    readonly messageIndex: number;
+    readonly blockIndex: number;
+    readonly reason: import('./dependencyTypes.js').ThinkingReplayReason;
+    /** Preparation is observable even when the subsequent transport fails. */
+    readonly phase: 'prepared';
+}

package/dist/esm/events/payloads/thinking.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=thinking.js.map

package/dist/esm/events/payloads/thinking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.js","sourceRoot":"","sources":["../../../../src/events/payloads/thinking.ts"],"names":[],"mappings":""}

package/dist/esm/events/payloads/toolCatalog.d.ts

@@ -0,0 +1,157 @@
+export interface ToolsOfferedPayload {
+    readonly availableIds: readonly string[];
+    readonly withheldIds: readonly string[];
+    readonly withheldReasons: Readonly<Record<string, 'permission' | 'skill_inactive' | 'gated' | 'cost_guard'>>;
+    readonly reason: string;
+}
+export interface ToolsActivatedPayload {
+    readonly toolId: string;
+    readonly reason: 'skill_activated' | 'autoActivate' | 'permission_granted';
+    readonly source?: string;
+}
+export interface ToolsDeactivatedPayload {
+    readonly toolId: string;
+    readonly reason: 'skill_deactivated' | 'permission_revoked';
+}
+/**
+ * Emitted at the start of a `ToolProvider.list(ctx)` call inside the
+ * Discover stage. Pairs with `tools.discovery_completed` (success) or
+ * `tools.discovery_failed` (error). Use the pair to measure async-
+ * provider latency per iteration without joining stages by hand.
+ */
+export interface ToolsDiscoveryStartedPayload {
+    readonly providerId: string | undefined;
+    readonly iteration: number;
+}
+/**
+ * Emitted when `ToolProvider.list(ctx)` resolves successfully. The
+ * `durationMs` is the wall-clock between `tools.discovery_started` and
+ * resolution; `toolCount` is the size of the returned tool list. For
+ * sync providers `durationMs` is ~0; for async hub-backed providers
+ * this is your observability hook for catalog-fetch latency.
+ */
+export interface ToolsDiscoveryCompletedPayload {
+    readonly providerId: string | undefined;
+    readonly iteration: number;
+    readonly durationMs: number;
+    readonly toolCount: number;
+}
+/**
+ * Emitted when a custom `ToolProvider.list(ctx)` throws or rejects.
+ * The iteration is aborted; a configured `reliability` rule decides
+ * whether to retry, fall back, or fail-fast. `providerId` lets
+ * consumers route alerts to the right hub adapter (rube / mcp /
+ * custom-discovery). `durationMs` measures how long the failed call
+ * spent before throwing, so timeouts vs immediate rejections are
+ * distinguishable.
+ */
+export interface ToolsDiscoveryFailedPayload {
+    readonly providerId: string | undefined;
+    readonly error: string;
+    readonly errorName: string;
+    readonly iteration: number;
+    readonly durationMs: number;
+}
+/**
+ * The parties that can put a tool name on the wire or answer to one — the
+ * vocabulary `tools.shadowed` and `tools.claim_swallowed` name them in (9.92.0).
+ *
+ *   • `registry`  — a static `.tool()` registration;
+ *   • `provider`  — a `ToolProvider` (`.toolProvider()`, MCP through `staticTools`,
+ *                   `.selfExplain()`'s trace pack — its id says which);
+ *   • `skill`     — a skill's `tools:[]`, always-visible or scoped;
+ *   • `framework` — an auto-attach the framework owns: `read_skill`, `present`,
+ *                   `skip_step`.
+ */
+export type ToolNameChannel = 'provider' | 'registry' | 'skill' | 'framework';
+/**
+ * Emitted, per iteration, for a tool name that two parties BOTH put forward
+ * for the wire and only one could win (8.7.0; re-subjected 9.92.0).
+ *
+ * Until 9.92.0 the two halves of a call could come from different parties:
+ * the tools slot merges `[static, provider, skill, step]` first-wins while the
+ * dispatcher resolved a build-time map first, so the model read one contract
+ * and called another implementation. Since 9.92.0 dispatch FOLLOWS THE OFFER —
+ * the party whose contract is on the wire is the party that answers — so
+ * `schemaFrom` and `dispatchTo` name the same party, and both are the wire's.
+ * The event still fires because the collision is still real: the losing
+ * party's contract was hidden behind the winner's on this iteration, and a
+ * rename is still the fix. The loser is named by the companion
+ * `tools.claim_swallowed`, which fires for every party that lost a name whether
+ * or not its contract competed this iteration.
+ *
+ * Not an error event: the run continues and a tool really executes. It fires
+ * once per contested name PER ITERATION, because a provider list is resolved
+ * per iteration and a collision can begin mid-run.
+ *
+ * Carries names only — never args, never results, never a description body.
+ */
+export interface ToolsShadowedPayload {
+    /** The contested tool name. */
+    readonly toolName: string;
+    readonly iteration: number;
+    /** Which party's CONTRACT the model was shown — the wire's party. */
+    readonly schemaFrom: ToolNameChannel;
+    /** That party's id — the `ToolProvider.id` or the skill id, when it has one. */
+    readonly schemaFromId?: string;
+    /** Which party's IMPLEMENTATION answers a call to this name — since 9.92.0
+     *  always the wire's party, so it equals `schemaFrom`. Kept because a
+     *  consumer that branched on it keeps working and the sentence stays true. */
+    readonly dispatchTo: ToolNameChannel;
+    /** That party's id, when it has one. */
+    readonly dispatchToId?: string;
+}
+/**
+ * Emitted, per iteration, for a party whose claim to a tool name is DEAD on
+ * that iteration: another party holds the name on the wire, and since dispatch
+ * follows the offer the loser's implementation cannot be reached by any call
+ * (9.92.0 — the `claim-swallowed` family of the divergence walk).
+ *
+ * It fires whether or not the loser's contract competed for the wire this
+ * iteration — a provider tool whose name a static `.tool()` already holds, a
+ * skill tool named after a framework auto-attach, a never-activated scoped
+ * skill's tool whose name a provider serves. Silence about a dead claim is the
+ * defect this event exists to end: the party registered a tool the model can
+ * never reach, and the trace said nothing.
+ *
+ * Carries names only — never args, never results, never a description body.
+ */
+export interface ToolsClaimSwallowedPayload {
+    /** The contested tool name. */
+    readonly toolName: string;
+    readonly iteration: number;
+    /** The party whose claim is dead this iteration. */
+    readonly lostBy: ToolNameChannel;
+    /** That party's id — the `ToolProvider.id` or the skill id, when it has one. */
+    readonly lostById?: string;
+    /** The party holding the name on the wire — and therefore answering it. */
+    readonly wonBy: ToolNameChannel;
+    /** That party's id, when it has one. */
+    readonly wonById?: string;
+}
+/**
+ * Emitted when the dispatcher hands a call to a tool whose name was NOT on
+ * this iteration's wire (9.92.0).
+ *
+ * The capability law keeps a registry-routed tool dispatchable after a
+ * narrowing takes it off the offer — a later step's tool, a parked map's tool,
+ * a scoped skill's tool named from a restored transcript — and that is
+ * deliberate. What was missing was the record: a call answered by a tool the
+ * model was not shown on THIS call looked exactly like one that was. This is
+ * that record, once per such call. It fires ONLY when the answering party is
+ * the one the model last read this name under (or the name's only claimant
+ * when it was never served); a name whose last-served contract belonged to a
+ * party that can no longer answer is refused as a recorded tool result
+ * instead (`toolCalls/helpers/dispatchRefusals.ts` · `notServedResult`), never handed to somebody else.
+ *
+ * Carries names only — never args, never results.
+ */
+export interface ToolsAnsweredOffWirePayload {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly iteration: number;
+    /** The party whose implementation answered. */
+    readonly answeredBy: ToolNameChannel;
+    /** That party's id — the skill id or the `ToolProvider.id`, when it has one. */
+    readonly answeredById?: string;
+}

package/dist/esm/events/payloads/toolCatalog.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toolCatalog.js.map

package/dist/esm/events/payloads/toolCatalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolCatalog.js","sourceRoot":"","sources":["../../../../src/events/payloads/toolCatalog.ts"],"names":[],"mappings":""}

package/dist/esm/events/payloads/toolChoice.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A classifier picked a tool for one model call (9.105.0, `.toolChoice()`):
+ * the provider's pick among the OFFERED tools (the merged wire minus the
+ * always-served doors), its confidence, how many were offered and how many
+ * were served, whether the served list was narrowed to the top-N, and the
+ * cost. The row (`ToolChoiceRow`) holds the whole distribution and the
+ * provider's model string in the committed `toolChoices`; this payload
+ * carries identities (tool names), enums, numbers and a boolean — never the
+ * descriptions the classifier read, never the user's message. Fired by
+ * `recordToolChoice` from the tools slot, BEFORE the model call.
+ */
+export interface ToolChoicePickedPayload {
+    readonly iteration: number;
+    readonly chosen?: string;
+    readonly confidence: number;
+    readonly offered: number;
+    readonly served: number;
+    readonly narrowed: boolean;
+    readonly narrowedSkipped?: 'unavailable' | 'too-few' | 'after-miss' | 'wrap-up' | 'evidence-revision';
+    readonly latencyMs: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+}
+/**
+ * What the model DID on the call the pick was made for (9.105.0): the tools
+ * it called in order (empty on an answer), whether its first call is the
+ * classifier's pick (`firstAgrees`, absent when either side is absent) and
+ * the names it asked for outside a NARROWED served list (`missed`). Fired by
+ * `recordToolChoice` from `callLLM`, after the reply.
+ */
+export interface ToolChoiceOutcomePayload {
+    readonly iteration: number;
+    readonly called: readonly string[];
+    readonly firstAgrees?: boolean;
+    readonly missed?: readonly string[];
+}
+/**
+ * The classifier was asked which tool and produced no answer (9.105.0): the
+ * provider's HTTP status when there was one and the latency spent. The
+ * error text lives on the `ToolChoiceErrorRow`; the full tool set was served
+ * (fail open, never fail narrow) and the run continues.
+ */
+export interface ToolChoiceFailedPayload {
+    readonly iteration: number;
+    readonly status?: number;
+    readonly latencyMs: number;
+}
+/**
+ * The declared ontology was served on one model call (9.106.0,
+ * `.ontology()`): the map's identities (`id`, `version`, the declaration's
+ * `hash`) and its three counts. The map itself is the run constant
+ * `AgentState.ontology`; the served text is on the receipt and rebuilt by
+ * `servedAt`. This payload carries identities and numbers only — never a
+ * meaning, a coverage sentence or a node name. Fired by `callLLM` at
+ * request assembly, once per call that served the piece.
+ */
+export interface OntologyServedPayload {
+    readonly iteration: number;
+    readonly id: string;
+    readonly version: string;
+    readonly hash: string;
+    readonly nodes: number;
+    readonly sources: number;
+    readonly edges: number;
+}

package/dist/esm/events/payloads/toolChoice.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toolChoice.js.map

package/dist/esm/events/payloads/toolChoice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolChoice.js","sourceRoot":"","sources":["../../../../src/events/payloads/toolChoice.ts"],"names":[],"mappings":""}