@statelyai/agent 2.0.0-alpha.24 → 2.0.0-alpha.25

package/dist/{text-logic-DJBK3LbG.d.mts → text-logic-BFEOxyxv.d.cts}

@@ -1,4 +1,4 @@
-import { _ as StandardSchemaV1, c as AllowedEvents, h as InferOutput, i as AgentToolChoice, n as AgentMessage, s as AgentTools, u as ChosenEvent } from "./types-DWA6X9R-.mjs";
+import { _ as StandardSchemaV1, c as AllowedEvents, h as InferOutput, i as AgentToolChoice, n as AgentMessage, s as AgentTools, u as ChosenEvent } from "./types-B1Qs2q3q.cjs";
 import { AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EventFromLogic, EventObject, MachineSnapshot } from "xstate";
 
 //#region src/errors.d.ts
@@ -21,7 +21,7 @@ declare class AgentError extends Error {
 /**
  * A model call ran out of output tokens before it produced anything usable.
  * Core never throws this: it is the adapter's signal that a `'length'` finish
- * reason left nothing to return — a structured request whose envelope never
+ * reason left nothing to return — a structured request whose JSON never
  * closed, say. A text request that WAS cut off still returns its text, with
  * `finishReason: 'length'`.
  *
@@ -68,11 +68,6 @@ declare class AgentInvalidEventPayloadError extends AgentError {
 }
 /** The invoke `src` of an {@link AgentRequest}/{@link AgentDecisionRequest} — a plain string, widened so literal `src` values still narrow in editor hints. */
 type AgentRequestSource = string & {};
-/** Customizes the tool name generated for a candidate event; see {@link AgentRequestOptions.eventToolName}. */
-type AgentEventToolNameResolver = (args: {
-  eventType: string;
-  defaultToolName: string;
-}) => string;
 /** 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;
@@ -91,8 +86,6 @@ interface AgentRequestOptions {
   events?: Record<string, StandardSchemaV1>;
   schemas?: AgentSchemas;
   actors?: Record<string, unknown>;
-  /** Customize machine-event tool names. Defaults to send_event_<TYPE>. */
-  eventToolName?: AgentEventToolNameResolver;
 }
 /** 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;
@@ -138,7 +131,7 @@ declare function parseAgentEvent<TSource extends AnyStateMachine | AnyMachineSna
  * 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"> & {
+declare function getAcceptedEvents(snapshot: AnyMachineSnapshot, options?: Pick<AgentRequestOptions, "events" | "schemas"> & {
   eventTypes?: readonly string[];
 }): AgentEventDescriptor[];
 //#endregion
@@ -367,7 +360,7 @@ declare function renderDecisionAttempts(request: Pick<AgentDecisionRequest, "eve
  * `runId`, `requestId`); `onChunk` is never set for a decision.
  * The optional `reason` is carried through to
  * `onResult`/event-sourcing but never affects validation. Like text
- * executors' `{ output, ...extras }` envelope, any extra keys (finish reason,
+ * executors' `{ result, ...extras }`, 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}.
@@ -429,7 +422,6 @@ interface ResolveDecisionOptions<TEvent extends ChosenEvent = ChosenEvent> {
 declare function resolveDecision<TEvent extends ChosenEvent = ChosenEvent>(request: AgentDecisionRequest, executors: Pick<Partial<AgentRequestExecutors>, "decide">, options?: ResolveDecisionOptions<TEvent>): Promise<TEvent>;
 //#endregion
 //#region src/text-logic.d.ts
-declare const USER_INPUT_ACTOR: "agent.userInput";
 declare const GENERATE_TEXT_ACTOR: "agent.generateText";
 declare const STREAM_TEXT_ACTOR: "agent.streamText";
 declare const DECIDE_ACTOR: "agent.decide";
@@ -443,21 +435,6 @@ type AgentModelMap = Record<string, unknown>;
  * adapter's models map / `resolveModel`) resolves them to a real model.
  */
 type AgentModelRef<TModels extends AgentModelMap = {}> = [keyof TModels] extends [never] ? string : keyof TModels & string;
-/**
- * Splits a portable `"provider/model-id"` model ref (the convention JSON
- * workflows and registry-less hosts use, e.g. `"openai/gpt-5.4-mini"`) into
- * its parts. A ref with no `/` has no provider — `modelId` is the whole ref.
- * The standard building block for a host's `resolveModel`:
- *
- * @example
- * ```ts
- * const resolveModel = (ref: string) => openai(parseModelRef(ref).modelId);
- * ```
- */
-declare function parseModelRef(modelRef: string): {
-  provider: string | undefined;
-  modelId: string;
-};
 /**
  * Portable, provider-agnostic input a text request passes to a host
  * executor (`generateText`/`streamText` on {@link AgentRequestExecutors}).
@@ -489,7 +466,7 @@ interface AgentTextRequest<TMetadata = Record<string, unknown>, TMessage = any>
   /**
    * Opt-in reasoning for a structured-output request: when `true`, adapters add
    * an optional string `reasoning` property (listed BEFORE `result`) to the
-   * structured-output envelope schema, nudging the model to reason before
+   * provider output schema, nudging the model to reason before
    * committing to the result. The reasoning is surfaced on the executor's raw
    * result (never in machine context/output). Ignored for text-mode requests.
    *
@@ -583,15 +560,15 @@ declare function getCallFinishReason(raw: unknown): AgentFinishReason | undefine
  * Reads a settled call's per-call {@link AgentCallUsage} off a RAW executor
  * result's `usage` field, keeping only finite numbers — the same normalization
  * `runAgent` applies before it delivers `'@agent.usage'`. Returns `undefined`
- * when the result reports no usage at all. Works for our `{ output, usage }`
- * envelope, for a raw Vercel AI SDK result (its `LanguageModelUsage` carries
+ * when the result reports no usage at all. Works for our `{ result, usage }`
+ * shape, for a raw Vercel AI SDK result (its `LanguageModelUsage` carries
  * the same flat field names), and for any custom executor that follows the
  * shape.
  *
  * The seam for the step-loop path, where the host holds the raw result itself:
  *
  * ```ts
- * const { output, raw } = await executeAgentRequest(effect, executors);
+ * const { result, messages } = await executeAgentRequest(effect, executors);
  * const usage = getCallUsage(raw);
  * if (usage) append({ type: AGENT_USAGE_EVENT_TYPE, usage }); // journal + transition, like any event
  * append(effect.toDoneEvent(output));
@@ -601,21 +578,28 @@ declare function getCallFinishReason(raw: unknown): AgentFinishReason | undefine
  */
 declare function getCallUsage(raw: unknown): AgentCallUsage | undefined;
 /**
- * Inline input for the `agent.userInput` builtin actor — a human-input request
- * (CLI prompt, chat reply, …) that resolves to the `string` the human typed.
- * See {@link RunAgentOptions.userInput}. For structured input, parse/classify
- * the string in a follow-up state, or register a custom actor source; host
- * rendering hints (a form spec, say) belong in `metadata`.
+ * What a text request's invoke resolves to: the validated `result` (the
+ * request's `outputSchema` type, or a string) and the response `messages`
+ * the executor returned (empty when it returned none). Read it in `onDone`:
+ *
+ * ```ts
+ * onDone: ({ context, output }) => ({
+ *   context: {
+ *     draft: output.result,
+ *     messages: [...context.messages, ...output.messages],
+ *   },
+ * }),
+ * ```
  */
-interface AgentUserInput<TMetadata = Record<string, unknown>> {
-  prompt?: string;
-  metadata?: TMetadata;
+interface AgentTextResult<TOutput = unknown, TMessage = AgentMessage> {
+  result: TOutput;
+  /** Framework-native response messages, exactly as the executor returned them. */
+  messages: TMessage[];
 }
-/** The four `agent.*` builtin actor logics every setupAgent-built machine registers. @internal */
+/** The three `agent.*` builtin actor logics every setupAgent-built machine registers. @internal */
 type BuiltinAgentActors<TEvent extends string = string, TModel extends string = string> = {
-  [GENERATE_TEXT_ACTOR]: AsyncActorLogic<unknown, AgentTextRequest>;
-  [STREAM_TEXT_ACTOR]: AsyncActorLogic<unknown, AgentTextRequest>;
-  [USER_INPUT_ACTOR]: AsyncActorLogic<string, AgentUserInput>;
+  [GENERATE_TEXT_ACTOR]: AsyncActorLogic<AgentTextResult, AgentTextRequest>;
+  [STREAM_TEXT_ACTOR]: AsyncActorLogic<AgentTextResult, AgentTextRequest>;
   [DECIDE_ACTOR]: AsyncActorLogic<ChosenEvent, AgentDecisionInput<TEvent, Record<string, unknown>, TModel>>;
 };
 /**
@@ -656,7 +640,7 @@ interface TextLogicConfig<TInputSchema extends StandardSchemaV1 = StandardSchema
   messages?: ResolveTextLogicValue<any[] | undefined, InferOutput<TInputSchema>>;
   tools?: ResolveTextLogicValue<AgentTools | undefined, InferOutput<TInputSchema>>;
   toolChoice?: ResolveTextLogicValue<AgentToolChoice | undefined, InferOutput<TInputSchema>>;
-  /** Opt into the structured-output envelope's `reasoning` field (see {@link AgentTextRequest.includeReasoning}). */
+  /** Opt into the provider output's `reasoning` field (see {@link AgentTextRequest.includeReasoning}). */
   includeReasoning?: ResolveTextLogicValue<boolean | undefined, InferOutput<TInputSchema>>;
   temperature?: ResolveTextLogicValue<number | undefined, InferOutput<TInputSchema>>;
   maxOutputTokens?: ResolveTextLogicValue<number | undefined, InferOutput<TInputSchema>>;
@@ -677,7 +661,7 @@ interface TextLogicExecuteArgs<TInput, TMetadata = Record<string, unknown>> {
   self: unknown;
   emit: (emitted: EventObject) => void;
 }
-/** Host implementation bound to a specific {@link TextLogic} via `withExecutor`/`createTextLogic`'s second argument — resolves one text request to an `{ output }` envelope typed from the logic's output schema (`{ output: T }`). Passthrough fields (usage, raw, …) are allowed alongside `output`. */
+/** Host implementation bound to a specific {@link TextLogic} via `withExecutor`/`createTextLogic`'s second argument — resolves one text request to a `{ result }` typed from the logic's output schema (`{ result: T }`). Passthrough fields (messages, usage, raw, …) are allowed alongside `result`. */
 type TextLogicExecutor<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetadata = unknown> = (args: TextLogicExecuteArgs<InferOutput<TInputSchema>, TMetadata>) => PromiseLike<AgentRequestExecutorResult<InferOutput<TOutputSchema>>> | AgentRequestExecutorResult<InferOutput<TOutputSchema>>;
 /**
  * Actor logic for a text request: an async effect that resolves typed input
@@ -687,7 +671,7 @@ type TextLogicExecutor<TInputSchema extends StandardSchemaV1, TOutputSchema exte
  * `agent.streamText` builtins and `setupAgent({ requests })` entries are
  * both `TextLogic` under the hood.
  */
-interface TextLogic<TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetadata = Record<string, unknown>> extends AsyncActorLogic<InferOutput<TOutputSchema>, InferOutput<TInputSchema>> {
+interface TextLogic<TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetadata = Record<string, unknown>> extends AsyncActorLogic<AgentTextResult<InferOutput<TOutputSchema>>, InferOutput<TInputSchema>> {
   readonly kind: "statelyai.textLogic";
   readonly mode: AgentRequestMode;
   readonly schemas: {
@@ -695,7 +679,8 @@ interface TextLogic<TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TO
     readonly output: TOutputSchema;
   };
   request(input: InferOutput<TInputSchema>): AgentTextRequest<TMetadata>;
-  execute(input: InferOutput<TInputSchema>, executors: AgentRequestExecutors): Promise<InferOutput<TOutputSchema>>;
+  /** Runs this request once against `executors`; resolves the same `{ result, messages }` the invoke's `onDone` would receive. */
+  execute(input: InferOutput<TInputSchema>, executors: AgentRequestExecutors): Promise<AgentTextResult<InferOutput<TOutputSchema>>>;
   withExecutor(execute: TextLogicExecutor<TInputSchema, TOutputSchema, TMetadata>): TextLogic<TInputSchema, TOutputSchema, TMetadata>;
 }
 /**
@@ -724,7 +709,7 @@ declare function createTextLogic<TInputSchema extends StandardSchemaV1 = Standar
  * {@link AgentRequestExecutor} (the `generateText`/`streamText` shape hosts
  * implement). Encapsulates the `withExecutor` idiom child agents repeat:
  * default the request's `tools` to `{}`, forward the actor `signal`, call the
- * executor, and return its `{ output }` envelope. Use this to share ONE
+ * executor, and return its `{ result }`. Use this to share ONE
  * executor across a parent and its nested children.
  *
  * @example
@@ -738,11 +723,13 @@ declare function createTextLogic<TInputSchema extends StandardSchemaV1 = Standar
  */
 declare function bindRequestExecutor<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetadata>(logic: TextLogic<TInputSchema, TOutputSchema, TMetadata>, executor: AgentRequestExecutor, info?: Pick<AgentRequestExecutorInfo, "onChunk">): TextLogic<TInputSchema, TOutputSchema, TMetadata>;
 /**
- * The envelope an {@link AgentRequestExecutor} must return: `{ output }` where
- * `output` is the request's value (a text string or a structured object).
- * 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.
+ * What an {@link AgentRequestExecutor} returns: the same `{ result, messages }`
+ * shape the machine receives in the invoke's `onDone` (see
+ * {@link AgentTextResult}), with `messages` optional. `result` is the
+ * request's value (a text string or a structured object). Passthrough fields
+ * (toolCalls, finishReason, raw, …) are allowed alongside it and preserved on
+ * the raw result. {@link normalizeGeneratorResult} unwraps `result`; a return
+ * without it 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
@@ -750,7 +737,7 @@ declare function bindRequestExecutor<TInputSchema extends StandardSchemaV1, TOut
  * toward `modelCalls`.
  */
 type AgentRequestExecutorResult<TOutput = unknown, TMessage = unknown> = {
-  output: TOutput; /** Framework-native response messages, preserved without normalization. */
+  result: TOutput; /** The provider's response messages for this call (the assistant turn, tool calls and results). */
   messages?: TMessage[]; /** This call's token usage, aggregated into the run result's {@link AgentUsage}. */
   usage?: AgentCallUsage; /** Why this call stopped, normalized (see {@link AgentFinishReason}). Surfaced on the `request.end` trace event. */
   finishReason?: AgentFinishReason;
@@ -798,84 +785,22 @@ interface AgentRequestExecutorInfo {
   callKey?: string;
 }
 /**
- * A raw Vercel AI SDK `generateText` result shape: resolves `{ text }` (a
- * string or a promise of one) instead of the `{ output }`
- * {@link AgentRequestExecutorResult} envelope. Admitted directly as an executor
- * return type so `ai`'s `generateText` passes to `runAgent`/executors without a
- * cast — {@link normalizeGeneratorResult} unwraps `text` at runtime (text-only;
- * structured output is best-effort JSON parsing against the request's
- * `outputSchema`). Extra fields (`content`, `usage`, …) are ignored.
- */
-type AiSdkShapedTextResult = {
-  text: string | PromiseLike<string>;
-  output?: unknown;
-  usage?: unknown;
-  reasoning?: unknown;
-  finishReason?: unknown;
-  toolCalls?: unknown;
-  toolResults?: unknown;
-};
-/**
- * A raw Vercel AI SDK `streamText` result shape: exposes a `textStream` async
- * iterable of string chunks (and, optionally, a `text` promise for the final
- * text) instead of the `{ output }` {@link AgentRequestExecutorResult} envelope.
- * Admitted directly as an executor return type so `ai`'s `streamText` passes to
- * `runAgent`/executors without a cast — {@link normalizeGeneratorResult}
- * iterates `textStream`, forwarding chunks, then resolves the final text
- * (text-only; structured output is best-effort). Extra fields are ignored.
- */
-type AiSdkShapedStreamResult = {
-  textStream: AsyncIterable<string>;
-  text?: PromiseLike<string>;
-  output?: unknown;
-  usage?: unknown;
-  reasoning?: unknown;
-  finishReason?: unknown;
-  toolCalls?: unknown;
-  toolResults?: unknown;
+ * The lowered request as an {@link AgentRequestExecutor} receives it: the
+ * {@link AgentTextRequest} core built, with `name` resolved and the request's
+ * `tools` merged in. Exactly one of `prompt`/`messages` is set.
+ */
+type AgentExecutorTextRequest<TMetadata = Record<string, unknown>> = Omit<AgentTextRequest<TMetadata>, "name" | "tools"> & {
+  /** Semantic request identity; always resolved before an executor is called. */name: string;
+  tools: AgentTools;
 };
 /**
- * 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
- *   framework-native shapes may be branded 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.
+ * Host implementation of one text call (`generateText` or `streamText`):
+ * resolves a lowered {@link AgentExecutorTextRequest} to a `{ result, messages? }`
+ * (see {@link AgentRequestExecutorResult}). Adapters such as
+ * `createAiSdkExecutors` and `createOpenAiExecutors` produce this shape; a
+ * hand-written executor is a plain async function returning it.
  */
-type AgentExecutorTextRequest<TMetadata = Record<string, unknown>> = Omit<AgentTextRequest<TMetadata>, "name" | "prompt" | "messages" | "tools" | "toolChoice"> & {
-  /** Semantic request identity; always resolved before an executor is called. */name: string;
-  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 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;
+type AgentRequestExecutor<TResult extends AgentRequestExecutorResult = AgentRequestExecutorResult> = (request: AgentExecutorTextRequest, info?: AgentRequestExecutorInfo) => TResult | PromiseLike<TResult>;
 /**
  * The full set of host executors a machine's agent actors are resolved
  * with — passed to `runAgent`, `executeAgentRequest`, and
@@ -903,15 +828,15 @@ type AgentOutputMode = "structured" | "text";
  * as `'text'`.
  */
 declare function getAgentOutputMode(schema?: StandardSchemaV1): AgentOutputMode;
-/** The unwrapped shape a {@link buildEnvelopeSchema} validate returns: the inner
+/** What a {@link providerOutputSchema} validate returns: the declared schema's
  * `result` value plus, when opted in and present, the model's `reasoning`. */
-interface StructuredOutputEnvelope {
+interface ProviderStructuredOutput {
   result: unknown;
   reasoning?: string;
 }
 /**
- * Builds the uniform structured-output envelope schema every structured request
- * is sent to the provider as: a root object `{ result: <inner> }`, plus — when
+ * Builds the schema every structured request is sent to the provider as: a
+ * root object `{ result: <inner> }` wrapping the declared schema, plus — when
  * `options.reasoning` is `true` — an optional string `reasoning` property listed
  * BEFORE `result` (property order nudges the model to reason first). This is THE
  * wire contract for structured output: a root object is universally accepted as
@@ -919,23 +844,22 @@ interface StructuredOutputEnvelope {
  * reject.
  *
  * The returned {@link StandardSchemaV1} validates the `{ reasoning?, result }`
- * envelope (unwrapping `result` through the original schema, capturing a string
- * `reasoning` when present) and exposes the enveloped JSON Schema. Adapters read
- * `.result` off the provider output before the machine validates it — so this is
- * transparent: user-facing output types stay the declared (un-enveloped) schema,
- * and `reasoning` is surfaced only on the raw executor result, never in machine
- * context/output.
- */
-declare function buildEnvelopeSchema(inner: StandardSchemaV1, options?: {
+ * object (validating `result` through the original schema, capturing a string
+ * `reasoning` when present) and exposes the wrapped JSON Schema. An executor
+ * returns the parsed `{ result, reasoning? }` as-is: `result` is what the
+ * machine validates against the declared schema, and `reasoning` stays on the
+ * raw executor result, never in machine context/output.
+ */
+declare function providerOutputSchema(inner: StandardSchemaV1, options?: {
   reasoning?: boolean;
-}): StandardSchemaV1<StructuredOutputEnvelope>;
+}): StandardSchemaV1<ProviderStructuredOutput>;
 /**
- * Validates a raw provider value against the structured-output envelope for
+ * Validates a raw provider value against the provider output schema for
  * `request` and returns the unwrapped `{ result, reasoning? }` — the checked
- * replacement for `raw as StructuredOutputEnvelope` in hand-written hosts.
- * Pair with {@link buildEnvelopeSchema} (which produced the schema the
+ * replacement for `raw as ProviderStructuredOutput` in hand-written hosts.
+ * Pair with {@link providerOutputSchema} (which produced the schema the
  * provider was asked to satisfy).
  */
-declare function parseStructuredEnvelope(request: Pick<AgentTextRequest, "outputSchema" | "includeReasoning">, value: unknown): StructuredOutputEnvelope;
+declare function parseProviderOutput(request: Pick<AgentTextRequest, "outputSchema" | "includeReasoning">, value: unknown): ProviderStructuredOutput;
 //#endregion
-export { getAcceptedEvents as $, parseOutput as A, DecisionLogicConfig as B, bindRequestExecutor as C, getCallFinishReason as D, getAgentOutputMode as E, AgentDecisionRequest as F, resolveDecision as G, createDecisionLogic as H, AgentExecutorDecisionRequest as I, AgentInvalidEventPayloadError as J, AgentEventDescriptor as K, CreateDecisionRequestOptions as L, AgentDecisionExecutor as M, AgentDecisionExhaustedError as N, getCallUsage as O, AgentDecisionInput as P, EventFromSnapshot as Q, DecisionAttempt as R, TextLogicExecutor as S, createTextLogic as T, createDecisionRequest as U, ResolveDecisionOptions as V, renderDecisionAttempts as W, AgentRequestSource as X, AgentRequestOptions as Y, AgentSchemas as Z, BuiltinAgentActors as _, AgentModelRef as a, TextLogicConfig as b, AgentRequestExecutorInfo as c, AgentRequestMode as d, parseAgentEvent as et, AgentTextRequest as f, AiSdkShapedTextResult as g, AiSdkShapedStreamResult as h, AgentModelMap as i, parseStructuredEnvelope as j, parseModelRef as k, AgentRequestExecutorResult as l, AgentUserInput as m, AgentExecutorTextRequest as n, AgentTruncatedError as nt, AgentOutputMode as o, AgentUsage as p, AgentEventToolNameResolver as q, AgentFinishReason as r, AgentRequestExecutor as s, AgentCallUsage as t, AgentError as tt, AgentRequestExecutors as u, StructuredOutputEnvelope as v, buildEnvelopeSchema as w, TextLogicExecuteArgs as x, TextLogic as y, DecisionLogic as z };
+export { AgentDecisionExhaustedError as A, createDecisionRequest as B, getAgentOutputMode as C, parseProviderOutput as D, parseOutput as E, DecisionAttempt as F, AgentRequestOptions as G, resolveDecision as H, DecisionLogic as I, EventFromSnapshot as J, AgentRequestSource as K, DecisionLogicConfig as L, AgentDecisionRequest as M, AgentExecutorDecisionRequest as N, providerOutputSchema as O, CreateDecisionRequestOptions as P, AgentTruncatedError as Q, ResolveDecisionOptions as R, createTextLogic as S, getCallUsage as T, AgentEventDescriptor as U, renderDecisionAttempts as V, AgentInvalidEventPayloadError as W, parseAgentEvent as X, getAcceptedEvents as Y, AgentError as Z, TextLogic as _, AgentModelRef as a, TextLogicExecutor as b, AgentRequestExecutorInfo as c, AgentRequestMode as d, AgentTextRequest as f, ProviderStructuredOutput as g, BuiltinAgentActors as h, AgentModelMap as i, AgentDecisionInput as j, AgentDecisionExecutor as k, AgentRequestExecutorResult as l, AgentUsage as m, AgentExecutorTextRequest as n, AgentOutputMode as o, AgentTextResult as p, AgentSchemas as q, AgentFinishReason as r, AgentRequestExecutor as s, AgentCallUsage as t, AgentRequestExecutors as u, TextLogicConfig as v, getCallFinishReason as w, bindRequestExecutor as x, TextLogicExecuteArgs as y, createDecisionLogic as z };