@axlsdk/axl 0.13.8 → 0.15.0

package/dist/index.d.cts

@@ -274,14 +274,135 @@ type RaceOptions<T = unknown> = {
 };
 /** Execution status */
 type ExecutionStatus = 'running' | 'completed' | 'failed' | 'waiting';
-/** Trace event */
-type TraceEvent = {
+/** Trace event type. See `TraceEvent` for per-type data shapes. */
+type TraceEventType = 'agent_call' | 'tool_call' | 'verify' | 'handoff' | 'delegate' | 'tool_denied' | 'tool_approval' | 'log' | 'workflow_start' | 'workflow_end' | 'guardrail' | 'schema_check' | 'validate';
+/** Data shape for `agent_call` trace events. Populated on every LLM call (pass or fail). */
+type AgentCallTraceData = {
+    /** Original user prompt passed to `ctx.ask()`. Does not include retry feedback or tool results. */
+    prompt: string;
+    /** Final LLM response content for this turn. */
+    response: string;
+    /** Resolved system prompt (after evaluating dynamic system selectors). */
+    system?: string;
+    /** Reasoning/thinking content returned by the provider, when available. */
+    thinking?: string;
+    /** Resolved model parameters sent to the provider for this call. */
+    params?: {
+        temperature?: number;
+        maxTokens?: number;
+        effort?: Effort;
+        thinkingBudget?: number;
+        includeThoughts?: boolean;
+        toolChoice?: ToolChoice;
+        stop?: string[];
+    };
+    /** 1-indexed iteration of the tool-calling loop for this `ctx.ask()` call. */
+    turn?: number;
+    /** When set, this call is a retry triggered by a failed gate check on the previous turn. */
+    retryReason?: 'schema' | 'validate' | 'guardrail';
+    /** Full ChatMessage[] sent to the provider this turn. Only populated when `trace.level === 'full'`. */
+    messages?: ChatMessage[];
+};
+/** Data shape for `guardrail` trace events. */
+type GuardrailTraceData = {
+    guardrailType: 'input' | 'output';
+    blocked: boolean;
+    reason?: string;
+    /** 1-indexed attempt count (output guardrails only). */
+    attempt?: number;
+    /** Maximum attempts allowed before the guardrail throws. */
+    maxAttempts?: number;
+    /** The exact corrective message about to be injected into the conversation — only set when
+     *  this check failed and a retry is happening. Gives users visibility into what the LLM sees
+     *  between retry attempts. */
+    feedbackMessage?: string;
+};
+/** Data shape for `schema_check` trace events. Emitted on every schema parse (pass or fail). */
+type SchemaCheckTraceData = {
+    valid: boolean;
+    reason?: string;
+    attempt: number;
+    maxAttempts: number;
+    feedbackMessage?: string;
+};
+/** Data shape for `validate` trace events (post-schema business rule validation). */
+type ValidateTraceData = {
+    valid: boolean;
+    reason?: string;
+    attempt: number;
+    maxAttempts: number;
+    feedbackMessage?: string;
+};
+/** Data shape for `tool_approval` trace events. Emitted by the approval gate on both outcomes. */
+type ToolApprovalTraceData = {
+    approved: boolean;
+    args: unknown;
+    reason?: string;
+};
+/** Data shape for `tool_call` trace events. */
+type ToolCallTraceData = {
+    args: unknown;
+    result: unknown;
+    callId?: string;
+};
+/** Data shape for `handoff` trace events. */
+type HandoffTraceData = {
+    target: string;
+    mode: 'oneway' | 'roundtrip';
+    /** Wall-clock ms from handoff_to_X tool call to target agent completion.
+     *  Always emitted — the event only fires at the terminal point of the
+     *  handoff, so we always have a measurement. */
+    duration: number;
+    /** Source agent that initiated the handoff (mirrors the event's `agent` field
+     *  for convenience — lets consumers query the handoff chain without
+     *  stitching together event.agent and data.target). */
+    source?: string;
+    /** The `message` arg the source agent passed when invoking `handoff_to_X`
+     *  (roundtrip mode only). Gives observability into *why* the source chose
+     *  to delegate. Subject to `config.trace.redact`. */
+    message?: string;
+};
+/** Data shape for `delegate` trace events. */
+type DelegateTraceData = {
+    candidates: string[];
+    /** Set when the decision is known at emission time (single-agent short-circuit). */
+    selected?: string;
+    /** Router model used for multi-agent routing. */
+    routerModel?: string;
+    /** Why this delegate was emitted: 'routed' (multi-agent) or 'single_candidate'. */
+    reason: 'routed' | 'single_candidate';
+};
+/** Data shape for `verify` trace events. */
+type VerifyTraceData = {
+    attempts: number;
+    passed: boolean;
+    lastError?: string;
+};
+/** Data shape for `workflow_start` trace events. Emitted once per workflow execution. */
+type WorkflowStartTraceData = {
+    /** The validated input passed to the workflow handler. */
+    input: unknown;
+};
+/** Data shape for `workflow_end` trace events. Emitted once per workflow execution
+ *  on completion, failure, or cancellation. Distinguish cancellation via `aborted`. */
+type WorkflowEndTraceData = {
+    status: 'completed' | 'failed';
+    duration: number;
+    /** Workflow return value. Present on `status: 'completed'`. */
+    result?: unknown;
+    /** Error message. Present on `status: 'failed'`. */
+    error?: string;
+    /** True when the failure was an `AbortError` (user cancellation, budget hard_stop,
+     *  or consumer disconnect on streaming workflows). */
+    aborted?: boolean;
+};
+/** Common fields carried by every `TraceEvent` regardless of `type`. */
+type TraceEventBase = {
     executionId: string;
     step: number;
-    type: 'agent_call' | 'tool_call' | 'verify' | 'handoff' | 'delegate' | 'tool_denied' | 'log' | 'workflow_start' | 'workflow_end' | 'guardrail' | 'validate';
+    timestamp: number;
     workflow?: string;
     agent?: string;
-    tool?: string;
     promptVersion?: string;
     model?: string;
     cost?: number;
@@ -291,9 +412,62 @@ type TraceEvent = {
         reasoning?: number;
     };
     duration?: number;
-    data?: unknown;
-    timestamp: number;
+    /** When set, this event was emitted from a child context spawned by a tool
+     *  handler. The value is the `callId` of the outer `tool_call` that invoked
+     *  the tool. Lets consumers reconstruct agent-as-tool call graphs by
+     *  joining nested events to their parent `tool_call`. Undefined on top-level
+     *  events. */
+    parentToolCallId?: string;
 };
+/**
+ * Trace event. A discriminated union over `type` — consumers that narrow via
+ * `type` get statically-typed access to `data` and event-specific fields.
+ * When adding a new event type, extend this union AND the emitter in
+ * `WorkflowContext.emitTrace()` together so the compiler catches drift.
+ */
+type TraceEvent = (TraceEventBase & {
+    type: 'agent_call';
+    data?: AgentCallTraceData;
+}) | (TraceEventBase & {
+    type: 'tool_call';
+    tool: string;
+    data?: ToolCallTraceData;
+}) | (TraceEventBase & {
+    type: 'tool_approval';
+    tool: string;
+    data?: ToolApprovalTraceData;
+}) | (TraceEventBase & {
+    type: 'tool_denied';
+    tool: string;
+    data?: unknown;
+}) | (TraceEventBase & {
+    type: 'guardrail';
+    data?: GuardrailTraceData;
+}) | (TraceEventBase & {
+    type: 'schema_check';
+    data?: SchemaCheckTraceData;
+}) | (TraceEventBase & {
+    type: 'validate';
+    data?: ValidateTraceData;
+}) | (TraceEventBase & {
+    type: 'delegate';
+    data?: DelegateTraceData;
+}) | (TraceEventBase & {
+    type: 'handoff';
+    data?: HandoffTraceData;
+}) | (TraceEventBase & {
+    type: 'verify';
+    data?: VerifyTraceData;
+}) | (TraceEventBase & {
+    type: 'log';
+    data?: unknown;
+}) | (TraceEventBase & {
+    type: 'workflow_start';
+    data?: WorkflowStartTraceData;
+}) | (TraceEventBase & {
+    type: 'workflow_end';
+    data?: WorkflowEndTraceData;
+});
 /** Result of a guardrail check. */
 type GuardrailResult = {
     block: boolean;
@@ -571,6 +745,8 @@ interface StateStore {
     saveEvalResult?(entry: EvalHistoryEntry): Promise<void>;
     /** List eval history entries (most recent first). */
     listEvalResults?(limit?: number): Promise<EvalHistoryEntry[]>;
+    /** Delete an eval history entry by id. Returns true if an entry was deleted. */
+    deleteEvalResult?(id: string): Promise<boolean>;
     /** List all session IDs (used by Studio session browser). */
     listSessions?(): Promise<string[]>;
     close?(): Promise<void>;
@@ -649,9 +825,49 @@ interface VectorStore {
     delete(ids: string[]): Promise<void>;
     close?(): Promise<void>;
 }
+/**
+ * Usage info reported by an embedder for a single `embed()` call.
+ *
+ * Mirrors the provider `usage` namespace — nested rather than flat so
+ * future additions (latency, cache-hit info, rate-limit headers) extend
+ * this type without breaking the `Embedder` return shape.
+ *
+ * All fields are optional so embedders without cost/pricing knowledge
+ * (e.g. local models, self-hosted) can still conform to the interface.
+ */
+type EmbedUsage = {
+    /** Total input tokens consumed. */
+    tokens?: number;
+    /** Cost in USD, computed from tokens × per-model pricing. */
+    cost?: number;
+    /** The underlying model identifier (e.g. "text-embedding-3-small"). */
+    model?: string;
+};
+/**
+ * Result of an `Embedder.embed()` call.
+ *
+ * Always contains `vectors`. `usage` is optional so embedders can omit
+ * it entirely (non-OpenAI, local, test fakes).
+ */
+type EmbedResult = {
+    vectors: number[][];
+    usage?: EmbedUsage;
+};
 /** Embedder interface for converting text to vectors. */
 interface Embedder {
-    embed(texts: string[]): Promise<number[][]>;
+    /**
+     * Embed one or more texts into vectors.
+     *
+     * @param texts   Input strings to embed.
+     * @param signal  Optional `AbortSignal` — when triggered, the underlying
+     *                network call should abort. Passed through from
+     *                `ctx.remember` / `ctx.recall` so user cancellation and
+     *                hard_stop budget aborts propagate to the embedder fetch.
+     *                Impls are free to ignore it (the call just runs to
+     *                completion like before), but OpenAIEmbedder honors it
+     *                via `fetchWithRetry`.
+     */
+    embed(texts: string[], signal?: AbortSignal): Promise<EmbedResult>;
     readonly dimensions: number;
 }
 /** Memory configuration. */
@@ -909,6 +1125,28 @@ declare class McpManager {
     get serverCount(): number;
 }
 
+/**
+ * Result of a `MemoryManager.remember()` call.
+ *
+ * Exposes embedder `usage` so callers (WorkflowContext) can attribute
+ * cost to the current execution scope and surface it in trace events.
+ * `usage` is absent when no embedding happened (embed option not set,
+ * or no vector store configured).
+ */
+type RememberResult = {
+    usage?: EmbedUsage;
+};
+/**
+ * Result of a `MemoryManager.recall()` call.
+ *
+ * Wraps the original return shape (key-value payload or vector search
+ * results) with optional embedder `usage`. Semantic recall populates
+ * `usage` when the embedder reported it; key-value lookups never do.
+ */
+type RecallResult = {
+    data: unknown | VectorResult[] | null;
+    usage?: EmbedUsage;
+};
 /**
  * Coordinates key-value memory and vector store for semantic search.
  * All key-value operations delegate to the StateStore.
@@ -925,12 +1163,18 @@ declare class MemoryManager {
      * Store a key-value pair in memory.
      * If a vector store and embedder are configured and embed is true,
      * also embeds the value for semantic search.
+     *
+     * Returns `{ usage }` when embedding happened, carrying the embedder's
+     * cost/token reporting out to the caller for cost attribution.
      */
-    remember(key: string, value: unknown, stateStore: StateStore, sessionId: string | undefined, options?: RememberOptions): Promise<void>;
+    remember(key: string, value: unknown, stateStore: StateStore, sessionId: string | undefined, options?: RememberOptions, signal?: AbortSignal): Promise<RememberResult>;
     /**
      * Recall a value from memory by key, or perform semantic search if query is provided.
+     *
+     * Always returns `{ data }`; semantic recalls additionally include
+     * `usage` from the embedder (when the embedder reported it).
      */
-    recall(key: string, stateStore: StateStore, sessionId: string | undefined, options?: RecallOptions): Promise<unknown | VectorResult[] | null>;
+    recall(key: string, stateStore: StateStore, sessionId: string | undefined, options?: RecallOptions, signal?: AbortSignal): Promise<RecallResult>;
     /** Delete a memory entry. If a vector store is configured, also removes the embedding. */
     forget(key: string, stateStore: StateStore, sessionId: string | undefined, options?: {
         scope?: 'session' | 'global';
@@ -992,6 +1236,10 @@ type WorkflowContextInit = {
     }) => void;
     /** Callback fired after each ctx.ask() completes (once per ask invocation). */
     onAgentCallComplete?: (call: AgentCallInfo) => void;
+    /** Set by `createChildContext(parentToolCallId)` — stamped on every trace event
+     *  emitted from this child so consumers can join nested agent calls back to
+     *  the outer tool call that spawned them. */
+    parentToolCallId?: string;
 };
 /**
  * The central coordination object for all Axl primitives.
@@ -1029,6 +1277,7 @@ declare class WorkflowContext<TInput = unknown> {
     private awaitHumanHandler?;
     private onAgentStart?;
     private onAgentCallComplete?;
+    private parentToolCallId?;
     constructor(init: WorkflowContextInit);
     /**
      * Create a child context for nested agent invocations (e.g., agent-as-tool).
@@ -1036,8 +1285,13 @@ declare class WorkflowContext<TInput = unknown> {
      *         state store, span manager, memory manager, MCP manager, config,
      *         awaitHuman handler, pending decisions, tool overrides.
      * Isolates: session history, step counter, streaming callbacks (onToken, onAgentStart, onToolCall).
+     *
+     * @param parentToolCallId - The `callId` of the outer `tool_call` that
+     *   spawned this child. When set, every trace event emitted by the child
+     *   will carry this id as `parentToolCallId`, so consumers can join nested
+     *   agent calls back to the outer tool call that invoked them.
      */
-    createChildContext(): WorkflowContext;
+    createChildContext(parentToolCallId?: string): WorkflowContext;
     /**
      * Resolve the current abort signal.
      * Branch-scoped signals (from race/spawn/map/budget) in AsyncLocalStorage
@@ -1097,6 +1351,42 @@ declare class WorkflowContext<TInput = unknown> {
     private _mapImpl;
     awaitHuman(options: AwaitHumanOptions): Promise<HumanDecision>;
     private _awaitHumanImpl;
+    /**
+     * Compose an `AbortSignal` for a memory operation's underlying embedder
+     * fetch. Combines the parent context signal (user cancellation,
+     * `runtime.execute({ signal })`) with the budget hard_stop abort so
+     * that either cause correctly aborts an in-flight embed call.
+     *
+     * Returns `undefined` if there's nothing to cancel on — the embedder
+     * runs without a signal in that case, matching its prior behavior.
+     *
+     * @internal
+     */
+    private _composeMemorySignal;
+    /**
+     * Accumulate a cost amount into the active `budgetContext` and trip the
+     * `exceeded` flag if we've crossed the limit. On `hard_stop` policy,
+     * also fires the abort controller so in-flight operations cancel.
+     *
+     * Called from every code path that spends money: the `agent_call` loop,
+     * semantic memory operations (`ctx.remember({embed:true})`, `ctx.recall({query})`),
+     * and any future cost-emitting primitive. Centralizing the logic here
+     * means `ctx.budget({ limit, policy })` accurately enforces the limit
+     * across ALL cost sources — not just agent calls.
+     *
+     * @internal
+     */
+    private _accumulateBudgetCost;
+    /** @internal */
+    _emitWorkflowStart(input: unknown): void;
+    /** @internal */
+    _emitWorkflowEnd(info: {
+        status: 'completed' | 'failed';
+        duration: number;
+        result?: unknown;
+        error?: string;
+        aborted?: boolean;
+    }): void;
     log(event: string, data?: unknown): void;
     /**
      * Store a value in memory, scoped to the current session (default) or globally.
@@ -1123,6 +1413,12 @@ declare class WorkflowContext<TInput = unknown> {
      * @param options - Optional: schema, routerModel, metadata, retries
      */
     delegate<T = string>(agents: Agent[], prompt: string, options?: DelegateOptions<T>): Promise<T>;
+    /**
+     * Internal emitter input — intentionally loose so call sites don't need to
+     * build a perfectly-narrowed discriminated-union member. The resulting
+     * `TraceEvent` (exported type) remains strict, and TypeScript narrows it at
+     * consumer sites via the `type` discriminator.
+     */
     private emitTrace;
 }
 
@@ -1273,6 +1569,25 @@ declare class Session {
 
 type ExecuteOptions = {
     metadata?: Record<string, unknown>;
+    /** Handler for tool approval requests. When provided, tools with `requireApproval` resolve
+     *  via this handler instead of suspending the execution and registering a pending decision.
+     *  Useful for in-process testing and ad-hoc invocations where you don't want to poll
+     *  `runtime.getPendingDecisions()` and call `runtime.resolveDecision()`. */
+    awaitHumanHandler?: (options: AwaitHumanOptions) => Promise<HumanDecision>;
+};
+/**
+ * Shape of events forwarded to an eval `onProgress` callback. Mirrors
+ * `@axlsdk/eval`'s `EvalProgressEvent` so runtime consumers can type their
+ * callbacks without importing the optional peer dep.
+ */
+type EvalProgressEventShape = {
+    type: 'item_done';
+    itemIndex: number;
+    totalItems: number;
+} | {
+    type: 'run_done';
+    totalItems: number;
+    failures: number;
 };
 type CreateContextOptions = {
     metadata?: Record<string, unknown>;
@@ -1312,6 +1627,20 @@ declare class AxlRuntime extends EventEmitter {
     private evalHistory;
     private evalHistoryLoadPromise;
     constructor(config?: AxlConfig);
+    /**
+     * Whether `config.trace.redact` is enabled on this runtime. A narrow
+     * boolean getter is preferred over exposing the full config because:
+     * (a) `Readonly<AxlConfig>` is shallow so the config would be mutable
+     * at runtime through sub-objects, subverting any compliance guarantee;
+     * (b) observability consumers like Studio only need the boolean, not
+     * the whole config tree; (c) if future observability config needs to
+     * expand, each new flag gets its own narrow getter.
+     *
+     * Studio's server-side redaction helpers (executions, memory, sessions,
+     * evals, decisions, tools, playground, workflows) all route through
+     * this accessor to decide whether to scrub response payloads.
+     */
+    isRedactEnabled(): boolean;
     /**
      * Initialize MCP servers configured in the config.
      * Call this before executing workflows that use MCP tools.
@@ -1379,6 +1708,18 @@ declare class AxlRuntime extends EventEmitter {
     /** Run a registered eval by name. */
     runRegisteredEval(name: string, options?: {
         metadata?: Record<string, unknown>;
+        /** Called after each dataset item completes (execution + scoring). */
+        onProgress?: (event: EvalProgressEventShape) => void;
+        /** Abort signal — checked before starting each item. */
+        signal?: AbortSignal;
+        /**
+         * When `true`, populate `EvalItem.traces` on every item (success + failure
+         * paths). Forwards to `runEval({ captureTraces: true })`, which wraps each
+         * item's execution in `runtime.trackExecution({ captureTraces: true })`.
+         * Verbose-mode `agent_call.data.messages` snapshots are stripped from
+         * captured traces to keep memory bounded.
+         */
+        captureTraces?: boolean;
     }): Promise<unknown>;
     /** Get all execution info (running + completed + historical). */
     getExecutions(): Promise<ExecutionInfo[]>;
@@ -1409,6 +1750,14 @@ declare class AxlRuntime extends EventEmitter {
     getExecution(executionId: string): Promise<ExecutionInfo | undefined>;
     /** Save an eval result to history. */
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
+    /**
+     * Delete an eval history entry by id. Removes from in-memory cache and
+     * the configured StateStore. Returns true if an entry was actually removed.
+     *
+     * Ensures lazy-loaded history is loaded first so the in-memory cache and
+     * the store can't drift apart on the deletion path.
+     */
+    deleteEvalResult(id: string): Promise<boolean>;
     /** Get eval result history (most recent first). */
     getEvalHistory(): Promise<EvalHistoryEntry[]>;
     /** List pending human decisions. */
@@ -1447,6 +1796,10 @@ declare class AxlRuntime extends EventEmitter {
         concurrency?: number;
         budget?: string;
         metadata?: Record<string, unknown>;
+    }, options?: {
+        onProgress?: (event: EvalProgressEventShape) => void;
+        signal?: AbortSignal;
+        captureTraces?: boolean;
     }): Promise<unknown>;
     /**
      * Compare two evaluation results to detect regressions and improvements.
@@ -1474,20 +1827,58 @@ declare class AxlRuntime extends EventEmitter {
      * Returns cost (same as `trackCost`) plus metadata extracted from trace events:
      * models (unique URIs), tokens (input/output/reasoning sums), and agent call count.
      *
+     * ## Cost vs tokens semantics
+     *
+     * - `cost` is the full aggregate across EVERY event with a top-level
+     *   `event.cost` set: agent calls, tool calls, semantic memory ops, etc.
+     *   This is the number to reconcile against your provider bill.
+     *
+     * - `metadata.tokens` is narrowly scoped to **agent** prompt/completion/
+     *   reasoning tokens. Embedder tokens from semantic `ctx.remember({embed:true})`
+     *   / `ctx.recall({query})` are deliberately NOT summed here — they're a
+     *   different category (input-only, different pricing, different model).
+     *   Conflating them would make "prompt tokens" misleading in the UI. If you
+     *   need embedder token counts, subscribe to `runtime.on('trace', ...)` and
+     *   read `data.usage.tokens` on `memory_remember` / `memory_recall` events.
+     *
+     * Pass `{ captureTraces: true }` to also collect the raw `TraceEvent[]` observed
+     * during `fn()`. This is opt-in because it keeps every event in memory for the
+     * duration of the call — useful for eval per-item capture, debugging, and test
+     * assertions, but overhead grows with trace volume. When enabled, verbose-mode
+     * `agent_call.data.messages` snapshots are omitted from captured events (still
+     * broadcast via onTrace) to keep memory bounded — callers who need the full
+     * verbose snapshot should subscribe to `runtime.on('trace', ...)` directly.
+     *
      * Works with both `createContext()` and `execute()` calls inside `fn`.
      */
-    trackExecution<T>(fn: () => Promise<T>): Promise<{
+    trackExecution<T>(fn: () => Promise<T>, options?: {
+        captureTraces?: boolean;
+    }): Promise<{
         result: T;
         cost: number;
+        traces?: TraceEvent[];
         metadata: {
             models: string[];
             modelCallCounts?: Record<string, number>;
+            /**
+             * Agent token totals only — does not include embedder tokens from
+             * semantic memory operations. See the method-level JSDoc above.
+             */
             tokens: {
                 input: number;
                 output: number;
                 reasoning: number;
             };
             agentCalls: number;
+            /**
+             * Unique workflow names observed during execution, ordered by first
+             * appearance (outermost first for nested calls). Captured automatically
+             * from `workflow_start` trace events — callers don't need to declare
+             * anything. Parallel mechanism to `models`.
+             */
+            workflows: string[];
+            /** Call counts per workflow, if workflows.length > 0. */
+            workflowCallCounts?: Record<string, number>;
         };
     }>;
     /** Register an execution ID with the active cost scope for trackCost() attribution. */
@@ -1798,6 +2189,7 @@ declare class MemoryStore implements StateStore {
     listExecutions(limit?: number): Promise<ExecutionInfo[]>;
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
+    deleteEvalResult(id: string): Promise<boolean>;
     listSessions(): Promise<string[]>;
     close(): Promise<void>;
     deleteCheckpoints(executionId: string): Promise<void>;
@@ -1840,6 +2232,7 @@ declare class SQLiteStore implements StateStore {
     listExecutions(limit?: number): Promise<ExecutionInfo[]>;
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
+    deleteEvalResult(id: string): Promise<boolean>;
     listSessions(): Promise<string[]>;
     saveMemory(scope: string, key: string, value: unknown): Promise<void>;
     getMemory(scope: string, key: string): Promise<unknown | null>;
@@ -1903,6 +2296,7 @@ declare class RedisStore implements StateStore {
     listExecutions(limit?: number): Promise<ExecutionInfo[]>;
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
+    deleteEvalResult(id: string): Promise<boolean>;
     listSessions(): Promise<string[]>;
     /** Close the Redis connection. */
     close(): Promise<void>;
@@ -1924,7 +2318,7 @@ declare class OpenAIEmbedder implements Embedder {
         baseUrl?: string;
         dimensions?: number;
     });
-    embed(texts: string[]): Promise<number[][]>;
+    embed(texts: string[], signal?: AbortSignal): Promise<EmbedResult>;
 }
 
 /**
@@ -1975,4 +2369,4 @@ declare class NoopSpanManager implements SpanManager {
  */
 declare function createSpanManager(config?: TelemetryConfig): Promise<SpanManager>;
 
-export { type Agent, type AgentCallInfo, type AgentConfig, AnthropicProvider, type AskOptions, type AwaitHumanOptions, type AxlConfig, AxlError, AxlRuntime, AxlStream, BudgetExceededError, type BudgetOptions, type BudgetResult, type ChatMessage, type ChatOptions, type CreateContextOptions, type DelegateOptions, type Effort, type Embedder, type EvalHistoryEntry, type ExecutionInfo, type ExecutionState, GeminiProvider, type GuardrailBlockHandler, GuardrailError, type GuardrailResult, type GuardrailsConfig, type HandoffDescriptor, type HandoffRecord, type HumanDecision, InMemoryVectorStore, type InputGuardrail, type MapOptions, MaxTurnsError, McpManager, type McpServer, type McpServerConfig, type McpToolDefinition, type McpToolResult, type MemoryConfig, MemoryManager, MemoryStore, NoConsensus, NoopSpanManager, OpenAIEmbedder, OpenAIProvider, OpenAIResponsesProvider, type OutputGuardrail, type OutputValidator, type PendingDecision, type Provider, type ProviderAdapter, ProviderRegistry, type ProviderResponse, QuorumNotMet, type RaceOptions, type RecallOptions, RedisStore, type RememberOptions, type ResolvedThinkingOptions, type Result, type RetryPolicy, SQLiteStore, Session, type SessionOptions, type SpanHandle, type SpanManager, type SpawnOptions, SqliteVectorStore, type StateStore, type StreamChunk, type StreamEvent, type TelemetryConfig, TimeoutError, type Tool, type ToolCallMessage, type ToolChoice, type ToolConfig, ToolDenied, type ToolHooks, type TraceEvent, type ValidateResult, ValidationError, type VectorEntry, type VectorResult, type VectorStore, VerifyError, type VerifyOptions, type VerifyRetry, type VoteOptions, type Workflow, type WorkflowConfig, WorkflowContext, type WorkflowContextInit, agent, createSpanManager, defineConfig, extractJson, resolveThinkingOptions, tool, workflow, zodToJsonSchema };
+export { type Agent, type AgentCallInfo, type AgentCallTraceData, type AgentConfig, AnthropicProvider, type AskOptions, type AwaitHumanOptions, type AxlConfig, AxlError, AxlRuntime, AxlStream, BudgetExceededError, type BudgetOptions, type BudgetResult, type ChatMessage, type ChatOptions, type CreateContextOptions, type DelegateOptions, type DelegateTraceData, type Effort, type EmbedResult, type EmbedUsage, type Embedder, type EvalHistoryEntry, type ExecuteOptions, type ExecutionInfo, type ExecutionState, GeminiProvider, type GuardrailBlockHandler, GuardrailError, type GuardrailResult, type GuardrailTraceData, type GuardrailsConfig, type HandoffDescriptor, type HandoffRecord, type HandoffTraceData, type HumanDecision, InMemoryVectorStore, type InputGuardrail, type MapOptions, MaxTurnsError, McpManager, type McpServer, type McpServerConfig, type McpToolDefinition, type McpToolResult, type MemoryConfig, MemoryManager, MemoryStore, NoConsensus, NoopSpanManager, OpenAIEmbedder, OpenAIProvider, OpenAIResponsesProvider, type OutputGuardrail, type OutputValidator, type PendingDecision, type Provider, type ProviderAdapter, ProviderRegistry, type ProviderResponse, QuorumNotMet, type RaceOptions, type RecallOptions, type RecallResult, RedisStore, type RememberOptions, type RememberResult, type ResolvedThinkingOptions, type Result, type RetryPolicy, SQLiteStore, type SchemaCheckTraceData, Session, type SessionOptions, type SpanHandle, type SpanManager, type SpawnOptions, SqliteVectorStore, type StateStore, type StreamChunk, type StreamEvent, type TelemetryConfig, TimeoutError, type Tool, type ToolApprovalTraceData, type ToolCallMessage, type ToolCallTraceData, type ToolChoice, type ToolConfig, ToolDenied, type ToolHooks, type TraceEvent, type TraceEventType, type ValidateResult, type ValidateTraceData, ValidationError, type VectorEntry, type VectorResult, type VectorStore, VerifyError, type VerifyOptions, type VerifyRetry, type VerifyTraceData, type VoteOptions, type Workflow, type WorkflowConfig, WorkflowContext, type WorkflowContextInit, type WorkflowEndTraceData, type WorkflowStartTraceData, agent, createSpanManager, defineConfig, extractJson, resolveThinkingOptions, tool, workflow, zodToJsonSchema };