@statelyai/agent 2.0.0-alpha.11 → 2.0.0-alpha.13

package/dist/{text-logic-CaKqgX4Y.d.mts → text-logic-BDxwQNsD.d.cts}

@@ -1,4 +1,5 @@
-import { C as StandardSchemaV1, b as InferOutput, f as AllowedEvents, m as ChosenEvent, o as AgentToolChoice, r as AgentMessage, u as AgentTools } from "./types-qm00QF91.mjs";
+import { _ as StandardSchemaV1, a as AgentToolChoice, c as AgentTools, d as ChosenEvent, h as InferOutput, l as AllowedEvents, n as AgentMessage } from "./types-QbEfCVny.cjs";
+import { t as AgentError } from "./errors-BQRk9eiZ.cjs";
 import { AnyMachineSnapshot, AsyncActorLogic, EventObject, LogicActorLogic, MachineSnapshot } from "xstate";
 
 //#region src/events.d.ts
@@ -9,13 +10,6 @@ type AgentEventToolNameResolver = (args: {
   eventType: string;
   defaultToolName: string;
 }) => string;
-/**
- * True when an event type matches an `allowedEvents` entry: an exact type,
- * `'*'` (every event), or a `'prefix.*'` wildcard matching any deeper
- * segment (`'todo.*'` matches `'todo.add'` and `'todo.list.clear'`, not
- * `'todo'` itself — mirroring xstate's partial wildcard events).
- */
-declare function matchesEventPattern(eventType: string, pattern: string): boolean;
 /** One candidate event a decision (or {@link getAcceptedEvents} caller) may choose: its type, the synthetic tool name a model can call to pick it, and its payload schema if one is registered. */
 interface AgentEventDescriptor {
   type: string;
@@ -31,21 +25,10 @@ interface AgentRequestOptions {
   snapshot?: AnyMachineSnapshot;
   events?: Record<string, StandardSchemaV1>;
   schemas?: AgentSchemas;
-  actorSources?: Record<string, unknown>;
+  actors?: Record<string, unknown>;
   /** Customize machine-event tool names. Defaults to send_event_<TYPE>. */
   eventToolName?: AgentEventToolNameResolver;
 }
-/**
- * Lists the events a snapshot can currently accept, as {@link AgentEventDescriptor}s
- * a model can be offered (via `resolveDecision`/an adapter's tool-per-event
- * mapping). **Filters by event TYPE only** — it does not evaluate guards, so
- * a type-legal-but-guard-rejected event can still appear here. Guard
- * legality is checked separately, at decision-resolution time, via
- * `snapshot.can(event)` (the `canTake` option of {@link resolveDecision} /
- * {@link ResolveDecisionOptions}). Pass `eventTypes` to further narrow to a
- * declared `allowedEvents` set — entries may be exact types or wildcard
- * patterns (`'*'`, `'todo.*'`; see {@link matchesEventPattern}).
- */
 /** Recovers a machine's event union from its snapshot type, so {@link parseAgentEvent} returns the machine-typed event without a downstream cast. @internal */
 type EventFromSnapshot<TSnapshot> = TSnapshot extends MachineSnapshot<any, infer TEvent, any, any, any, any, any, any> ? TEvent : EventObject;
 /**
@@ -72,6 +55,22 @@ type EventFromSnapshot<TSnapshot> = TSnapshot extends MachineSnapshot<any, infer
 declare function parseAgentEvent<TSnapshot extends AnyMachineSnapshot>(snapshot: TSnapshot, event: {
   type: string;
 } & Record<string, unknown>, options?: Pick<AgentRequestOptions, "events" | "schemas" | "eventToolName">): EventFromSnapshot<TSnapshot>;
+/**
+ * Lists the events a snapshot can currently accept, as {@link AgentEventDescriptor}s
+ * a model can be offered (via `resolveDecision`/an adapter's tool-per-event
+ * mapping). **Filters by event TYPE only** — it does not evaluate guards, so
+ * a type-legal-but-guard-rejected event can still appear here. Guard
+ * legality is checked separately, at decision-resolution time, via
+ * `snapshot.can(event)` (the `canTake` option of {@link resolveDecision} /
+ * {@link ResolveDecisionOptions}). Pass `eventTypes` to further narrow to a
+ * declared `allowedEvents` set — entries may be exact types or wildcard
+ * patterns (`'*'`, `'todo.*'`; see {@link matchesEventPattern}).
+ *
+ * XState-internal (`xstate.*`) and library-reserved
+ * ({@link RESERVED_AGENT_EVENT_PREFIX}) event types are always excluded, before
+ * any `allowedEvents` matching — a machine that handles `'@agent.usage'` still
+ * never offers it to a model.
+ */
 declare function getAcceptedEvents(snapshot: AnyMachineSnapshot, options?: Pick<AgentRequestOptions, "events" | "schemas" | "eventToolName"> & {
   eventTypes?: readonly string[];
 }): AgentEventDescriptor[];
@@ -209,21 +208,6 @@ interface DecisionLogicConfig<TInputSchema extends StandardSchemaV1 = StandardSc
   stopSequences?: ResolveTextLogicValue<string[] | undefined, InferOutput<TInputSchema>>;
   metadata?: ResolveTextLogicValue<TMetadata | undefined, InferOutput<TInputSchema>>;
 }
-/**
- * Actor logic for a decision: an async effect that resolves to exactly one
- * currently-legal {@link ChosenEvent} (never a plain value). Under `runAgent`
- * the chosen event is delivered to the invoking actor automatically — the
- * transition it triggers usually exits the invoking state and ends the invoke.
- * Built by {@link createDecisionLogic}. Register it under `actorSources:` to reuse/export/
- * test it standalone; for a state-local, zero-config decision, use the
- * `agent.decide` builtin invoke instead.
- */
-interface DecisionLogic<TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetadata extends Record<string, unknown> = Record<string, unknown>> extends AsyncActorLogic<ChosenEvent, InferOutput<TInputSchema>> {
-  readonly kind: "statelyai.decisionLogic";
-  readonly maxRetries: number;
-  request(input: InferOutput<TInputSchema>): AgentDecisionRequest;
-  withExecutor(execute: AgentDecisionExecutor): DecisionLogic<TInputSchema, TMetadata>;
-}
 /**
  * A decision request: resolves to exactly one currently-legal event. See
  * `resolveDecision`.
@@ -258,6 +242,15 @@ interface AgentDecisionRequest {
    * `info.signal`). Runtime-only — never serialized into a provider request.
    */
   signal?: AbortSignal;
+  /**
+   * The `runAgent` run this decision belongs to (`run_<n>`, matching trace
+   * events), injected by runAgent like `signal` (symmetric with the text
+   * executors' `info.runId`). Runtime-only correlation for executor
+   * middleware; unset off the runAgent path. Per-attempt context is already
+   * on the request: `id` is the durable invoke id and `attempts.length` is
+   * the current attempt index.
+   */
+  runId?: string;
 }
 /**
  * A single failed decision attempt, recorded by {@link resolveDecision} and
@@ -280,8 +273,8 @@ interface DecisionAttempt {
  * diagnostics; a machine typically routes this via the decision invoke's
  * `onError`.
  */
-declare class DecisionExhaustedError extends Error {
-  attempts: DecisionAttempt[];
+declare class AgentDecisionExhaustedError extends AgentError {
+  readonly attempts: DecisionAttempt[];
   constructor(attempts: DecisionAttempt[]);
 }
 /**
@@ -307,12 +300,15 @@ declare function renderDecisionAttempts(request: Pick<AgentDecisionRequest, "eve
  * adapter business; core only validates and retries the returned choice (see
  * {@link resolveDecision}). The optional `reason` is carried through to
  * `onResult`/event-sourcing but never affects validation. Like text
- * executors' `{ output, ...extras }` envelope, any extra keys (usage, finish
- * reason, …) flow untouched to `onResult`'s `raw`.
+ * executors' `{ output, ...extras }` envelope, any extra keys (finish reason,
+ * …) flow untouched to `onResult`'s `raw`; `usage` is the one core reads —
+ * report this attempt's tokens there and `runAgent` folds them into the run's
+ * aggregated {@link AgentUsage}.
  */
 type AgentDecisionExecutor = (request: AgentDecisionRequest) => PromiseLike<{
   event: ChosenEvent;
-  reason?: string;
+  reason?: string; /** This attempt's token usage, aggregated into the run result's {@link AgentUsage}. */
+  usage?: AgentCallUsage;
   [key: string]: unknown;
 }>;
 /**
@@ -354,7 +350,7 @@ interface ResolveDecisionOptions<TEvent extends ChosenEvent = ChosenEvent> {
  * the next attempt via `request.attempts`, so an adapter can render "your
  * last choice failed because X — try again" into the next model call; core
  * never rewrites the request itself. Exhausting all attempts throws
- * {@link DecisionExhaustedError} with the full attempts list.
+ * {@link AgentDecisionExhaustedError} with the full attempts list.
  *
  * @example
  * ```ts
@@ -450,6 +446,34 @@ interface AgentTextRequest<TMetadata = Record<string, unknown>> {
    */
   metadata?: TMetadata;
 }
+/**
+ * Aggregated model-call usage for ONE `runAgent` call — the run-level total
+ * attached to every settled {@link RunAgentResult} (and therefore to
+ * `generateResult`'s `{ output, snapshot, events, usage }`).
+ *
+ * - `modelCalls` counts every model/decision call this run made (each decision
+ *   retry counts separately) — the same seam `maxModelCalls` budgets. Always a
+ *   number, even when no executor reported tokens.
+ * - Token fields are OPTIONAL and are PARTIAL SUMS: each one sums only the
+ *   calls that reported it, and stays `undefined` when NO call reported it.
+ *   Executors that report nothing (custom hosts, test mocks) simply do not
+ *   contribute — a run mixing reporting and non-reporting calls yields a sum
+ *   over the reporting subset, not `undefined`.
+ * - Aggregation is per-run: a resumed run counts only ITS OWN calls, never the
+ *   history behind `snapshot`/`events`. Add prior runs' totals yourself if you
+ *   want a conversation-wide figure.
+ */
+interface AgentUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+  cachedInputTokens?: number;
+  /** Model/decision calls made by this run (decision retries count separately). */
+  modelCalls: number;
+}
+/** One model call's reported usage — {@link AgentUsage} without the run-level `modelCalls` count. What an executor puts on its result's `usage` field. */
+type AgentCallUsage = Omit<AgentUsage, "modelCalls">;
 /**
  * Inline input for the `agent.userInput` builtin actor — a human-input request
  * (CLI prompt, chat reply, …) that resolves to the `string` the human typed.
@@ -486,13 +510,19 @@ type ResolveTextLogicValue<TValue, TInput> = TValue | ((args: {
  * that validate it. Each request-shaping field (`model`, `system`, `prompt`,
  * …) is either a static value or a `({ input }) => value` resolver.
  */
-interface TextLogicConfig<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetadata = Record<string, unknown>, TModel extends string = string> {
+interface TextLogicConfig<TInputSchema extends StandardSchemaV1 = StandardSchemaV1<undefined>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<string>, TMetadata = Record<string, unknown>, TModel extends string = string> {
   mode?: AgentRequestMode;
   /** Stamped onto every lowered request as {@link AgentTextRequest.name}. `setupAgent({ requests })` sets this to the request's key. */
   name?: ResolveTextLogicValue<string | undefined, InferOutput<TInputSchema>>;
-  schemas: {
-    input: TInputSchema;
-    output: TOutputSchema;
+  /**
+   * The request's input/output schemas. Both are optional:
+   * - `output` defaults to a string schema (a plain text request).
+   * - `input` defaults to a schema that accepts (and types) `undefined`, so
+   *   the request takes no `input` at the invoke site.
+   */
+  schemas?: {
+    input?: TInputSchema;
+    output?: TOutputSchema;
   };
   model: ResolveTextLogicValue<TModel, InferOutput<TInputSchema>>;
   system?: ResolveTextLogicValue<string | undefined, InferOutput<TInputSchema>>;
@@ -524,7 +554,7 @@ type TextLogicExecutor<TInputSchema extends StandardSchemaV1, TOutputSchema exte
 /**
  * Actor logic for a text request: an async effect that resolves typed input
  * to typed, schema-validated output via a model call. Built by
- * {@link createTextLogic}; register under `actorSources:` and invoke by name, or
+ * {@link createTextLogic}; register under `actors:` and invoke by name, or
  * bind an executor later with `withExecutor`. The `agent.generateText`/
  * `agent.streamText` builtins and `setupAgent({ requests })` entries are
  * both `TextLogic` under the hood.
@@ -540,14 +570,10 @@ interface TextLogic<TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TO
   execute(input: InferOutput<TInputSchema>, executors: AgentRequestExecutors): Promise<InferOutput<TOutputSchema>>;
   withExecutor(execute: TextLogicExecutor<TInputSchema, TOutputSchema, TMetadata>): TextLogic<TInputSchema, TOutputSchema, TMetadata>;
 }
-/** Extracts a {@link TextLogic}'s validated input type. */
-type TextLogicInput<TLogic extends TextLogic> = TLogic extends TextLogic<infer TInputSchema, StandardSchemaV1, infer _TMetadata> ? InferOutput<TInputSchema> : never;
-/** Extracts a {@link TextLogic}'s validated output type. */
-type TextLogicOutput<TLogic extends TextLogic> = TLogic extends TextLogic<StandardSchemaV1, infer TOutputSchema, infer _TMetadata> ? InferOutput<TOutputSchema> : never;
 /**
  * Creates reusable, standalone {@link TextLogic}: an actor that, when run,
  * resolves typed input to typed output via a model call. Register the
- * result under `actorSources:` and invoke it by name (equivalent to what
+ * result under `actors:` and invoke it by name (equivalent to what
  * `setupAgent({ requests })` builds internally for each request entry). Pass
  * `execute` here, or bind it later with `.withExecutor(...)`, a runtime
  * adapter's `machine.provide(...)`, or `runAgent`'s `generateText`/
@@ -564,7 +590,7 @@ type TextLogicOutput<TLogic extends TextLogic> = TLogic extends TextLogic<Standa
  * });
  * ```
  */
-declare function createTextLogic<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetadata = Record<string, unknown>, TModel extends string = string>(config: TextLogicConfig<TInputSchema, TOutputSchema, TMetadata, TModel>, execute?: TextLogicExecutor<TInputSchema, TOutputSchema, TMetadata>): TextLogic<TInputSchema, TOutputSchema, TMetadata>;
+declare function createTextLogic<TInputSchema extends StandardSchemaV1 = StandardSchemaV1<undefined>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<string>, TMetadata = Record<string, unknown>, TModel extends string = string>(config: TextLogicConfig<TInputSchema, TOutputSchema, TMetadata, TModel>, execute?: TextLogicExecutor<TInputSchema, TOutputSchema, TMetadata>): TextLogic<TInputSchema, TOutputSchema, TMetadata>;
 /**
  * Binds a child machine's {@link TextLogic} to a raw
  * {@link AgentRequestExecutor} (the `generateText`/`streamText` shape hosts
@@ -576,7 +602,7 @@ declare function createTextLogic<TInputSchema extends StandardSchemaV1, TOutputS
  * @example
  * ```ts
  * childMachine.provide({
- *   actorSources: {
+ *   actors: {
  *     researchTopic: bindRequestExecutor(setup.requests.researchTopic, generateText),
  *   },
  * });
@@ -586,12 +612,18 @@ declare function bindRequestExecutor<TInputSchema extends StandardSchemaV1, TOut
 /**
  * The envelope an {@link AgentRequestExecutor} must return: `{ output }` where
  * `output` is the request's value (a text string or a structured object).
- * Passthrough fields (usage, toolCalls, finishReason, raw, …) are allowed
- * alongside `output` and preserved on the raw result. {@link normalizeGeneratorResult}
+ * Passthrough fields (toolCalls, finishReason, raw, …) are allowed alongside
+ * `output` and preserved on the raw result. {@link normalizeGeneratorResult}
  * unwraps `output`; a non-envelope return is a runtime error.
+ *
+ * `usage` is the one passthrough field core reads: report this call's tokens
+ * there and `runAgent` folds them into the run's aggregated
+ * {@link AgentUsage}. Optional — an executor that reports nothing still counts
+ * toward `modelCalls`.
  */
 type AgentRequestExecutorResult<TOutput = unknown> = {
-  output: TOutput;
+  output: TOutput; /** This call's token usage, aggregated into the run result's {@link AgentUsage}. */
+  usage?: AgentCallUsage;
   [key: string]: unknown;
 };
 /**
@@ -602,6 +634,20 @@ type AgentRequestExecutorResult<TOutput = unknown> = {
 interface AgentRequestExecutorInfo {
   onChunk?: (chunk: string) => void;
   signal?: AbortSignal;
+  /**
+   * The `runAgent` run this call belongs to (`run_<n>`, matching trace
+   * events). Undefined off the runAgent path (bare `provideExecutors` /
+   * direct `TextLogic.execute`). Lets executor middleware (caching, rate
+   * limits, span parenting) correlate calls without side channels.
+   */
+  runId?: string;
+  /**
+   * The durable invoke id of the request making this call (e.g.
+   * `'0.(machine).asking'`) — stable across resume/replay, and it encodes the
+   * invoking state, so per-state middleware can key on it. Undefined when the
+   * call has no invoking actor.
+   */
+  requestId?: string;
 }
 /**
  * A raw Vercel AI SDK `generateText` result shape: resolves `{ text }` (a
@@ -614,7 +660,12 @@ interface AgentRequestExecutorInfo {
  */
 type AiSdkShapedTextResult = {
   text: string | PromiseLike<string>;
-  [key: string]: unknown;
+  output?: unknown;
+  usage?: unknown;
+  reasoning?: unknown;
+  finishReason?: unknown;
+  toolCalls?: unknown;
+  toolResults?: unknown;
 };
 /**
  * A raw Vercel AI SDK `streamText` result shape: exposes a `textStream` async
@@ -628,21 +679,55 @@ type AiSdkShapedTextResult = {
 type AiSdkShapedStreamResult = {
   textStream: AsyncIterable<string>;
   text?: PromiseLike<string>;
-  [key: string]: unknown;
+  output?: unknown;
+  usage?: unknown;
+  reasoning?: unknown;
+  finishReason?: unknown;
+  toolCalls?: unknown;
+  toolResults?: unknown;
 };
+/**
+ * The lowered request as an {@link AgentRequestExecutor} receives it. At
+ * runtime this is exactly the {@link AgentTextRequest} core built (plus the
+ * merged `tools` map); the TYPE is deliberately shaped so the Vercel AI SDK's
+ * own `generateText`/`streamText` are directly assignable as executors
+ * (function parameters are contravariant, so this type must be assignable to
+ * `ai`'s options type):
+ *
+ * - `prompt`/`messages` are mutually exclusive, matching `ai`'s `Prompt`
+ *   union (core always sets exactly one).
+ * - `tools`, `toolChoice`, and `messages` are widened to `any` — their
+ *   portable shapes ({@link AgentTools}, {@link AgentToolChoice},
+ *   {@link AgentMessage}) are structural supersets of `ai`'s branded types
+ *   and would otherwise fail the contravariant check.
+ *
+ * Hand-written executors that want the precise shapes can annotate their
+ * parameter as `AgentTextRequest & { tools: AgentTools }` — that wider
+ * parameter type keeps the executor assignable.
+ */
+type AgentExecutorTextRequest<TMetadata = Record<string, unknown>> = Omit<AgentTextRequest<TMetadata>, "prompt" | "messages" | "tools" | "toolChoice"> & {
+  tools: any;
+  toolChoice?: any;
+} & ({
+  prompt: string;
+  messages?: undefined;
+} | {
+  prompt?: undefined;
+  messages: any[];
+});
 /**
  * Host implementation of one text call (`generateText` or `streamText`) —
- * resolves a lowered {@link AgentTextRequest} to an `{ output }` envelope (see
- * {@link AgentRequestExecutorResult}), unwrapped by
- * {@link normalizeGeneratorResult}. The return type is widened to also admit the
- * raw Vercel AI SDK shapes ({@link AiSdkShapedTextResult} /
- * {@link AiSdkShapedStreamResult}) so `ai`'s own `generateText`/`streamText`
- * pass through without a cast; `normalizeGeneratorResult` checks for `{ output }`
- * first, then falls back to those shapes at runtime.
- */
-type AgentRequestExecutor<TResult extends AgentRequestExecutorResult = AgentRequestExecutorResult> = (request: AgentTextRequest & {
-  tools: AgentTools;
-}, info?: AgentRequestExecutorInfo) => PromiseLike<TResult | AiSdkShapedTextResult | AiSdkShapedStreamResult> | TResult | AiSdkShapedTextResult | AiSdkShapedStreamResult;
+ * resolves a lowered {@link AgentExecutorTextRequest} to an `{ output }`
+ * envelope (see {@link AgentRequestExecutorResult}), unwrapped by
+ * {@link normalizeGeneratorResult}. Both sides are shaped so `ai`'s own
+ * `generateText`/`streamText` pass through without a cast: the request
+ * parameter is assignable to `ai`'s options (see
+ * {@link AgentExecutorTextRequest}), and the return type is widened to also
+ * admit the raw Vercel AI SDK shapes ({@link AiSdkShapedTextResult} /
+ * {@link AiSdkShapedStreamResult}) — `normalizeGeneratorResult` checks for
+ * `{ output }` first, then falls back to those shapes at runtime.
+ */
+type AgentRequestExecutor<TResult extends AgentRequestExecutorResult = AgentRequestExecutorResult> = (request: AgentExecutorTextRequest, info?: AgentRequestExecutorInfo) => PromiseLike<TResult | AiSdkShapedTextResult | AiSdkShapedStreamResult> | TResult | AiSdkShapedTextResult | AiSdkShapedStreamResult;
 /**
  * The full set of host executors a machine's agent actors are resolved
  * with — passed to `runAgent`, `executeAgentRequest`, and
@@ -670,8 +755,6 @@ type AgentOutputMode = "structured" | "text";
  * as `'text'`.
  */
 declare function getAgentOutputMode(schema?: StandardSchemaV1): AgentOutputMode;
-/** True when {@link getAgentOutputMode} classifies `schema` as `'structured'`. */
-declare function isStructuredOutputSchema(schema?: StandardSchemaV1): boolean;
 /** The unwrapped shape a {@link buildEnvelopeSchema} validate returns: the inner
  * `result` value plus, when opted in and present, the model's `reasoning`. */
 interface StructuredOutputEnvelope {
@@ -707,4 +790,4 @@ declare function buildEnvelopeSchema(inner: StandardSchemaV1, options?: {
  */
 declare function parseStructuredEnvelope(request: Pick<AgentTextRequest, "outputSchema" | "reasoning">, value: unknown): StructuredOutputEnvelope;
 //#endregion
-export { AgentDecisionInput as A, ResolveDecisionOptions as B, createTextLogic as C, parseOutput as D, parseModelRef as E, DecisionExhaustedError as F, AgentRequestOptions as G, resolveDecision as H, DecisionLogic as I, matchesEventPattern as J, AgentRequestSource as K, DecisionLogicConfig as L, AgentPlanInput as M, AgentPlanOutput as N, parseStructuredEnvelope as O, DecisionAttempt as P, PLAN_DONE_EVENT_TYPE as R, buildEnvelopeSchema as S, isStructuredOutputSchema as T, AgentEventDescriptor as U, renderDecisionAttempts as V, AgentEventToolNameResolver as W, parseAgentEvent as Y, TextLogicExecuteArgs as _, AgentRequestExecutorInfo as a, TextLogicOutput as b, AgentRequestMode as c, AiSdkShapedStreamResult as d, AiSdkShapedTextResult as f, TextLogicConfig as g, TextLogic as h, AgentRequestExecutor as i, AgentDecisionRequest as j, AgentDecisionExecutor as k, AgentTextRequest as l, StructuredOutputEnvelope as m, AgentModelRef as n, AgentRequestExecutorResult as o, BuiltinAgentActors as p, getAcceptedEvents as q, AgentOutputMode as r, AgentRequestExecutors as s, AgentModelMap as t, AgentUserInput as u, TextLogicExecutor as v, getAgentOutputMode as w, bindRequestExecutor as x, TextLogicInput as y, PlanLogic as z };
+export { AgentDecisionExhaustedError as A, renderDecisionAttempts as B, buildEnvelopeSchema as C, parseOutput as D, parseModelRef as E, DecisionAttempt as F, AgentRequestSource as G, AgentEventDescriptor as H, DecisionLogicConfig as I, getAcceptedEvents as K, PLAN_DONE_EVENT_TYPE as L, AgentDecisionRequest as M, AgentPlanInput as N, parseStructuredEnvelope as O, AgentPlanOutput as P, PlanLogic as R, bindRequestExecutor as S, getAgentOutputMode as T, AgentEventToolNameResolver as U, resolveDecision as V, AgentRequestOptions as W, StructuredOutputEnvelope as _, AgentOutputMode as a, TextLogicExecuteArgs as b, AgentRequestExecutorResult as c, AgentTextRequest as d, AgentUsage as f, BuiltinAgentActors as g, AiSdkShapedTextResult as h, AgentModelRef as i, AgentDecisionInput as j, AgentDecisionExecutor as k, AgentRequestExecutors as l, AiSdkShapedStreamResult as m, AgentExecutorTextRequest as n, AgentRequestExecutor as o, AgentUserInput as p, parseAgentEvent as q, AgentModelMap as r, AgentRequestExecutorInfo as s, AgentCallUsage as t, AgentRequestMode as u, TextLogic as v, createTextLogic as w, TextLogicExecutor as x, TextLogicConfig as y, ResolveDecisionOptions as z };