import { Schema } from "effect"; import { Prompt, Response, Tool } from "effect/unstable/ai"; import { type Event as ModelTelemetryEvent } from "../model/model-telemetry.js"; import type { CompletedModelResponse } from "../model/model-response-builder.js"; /** @experimental Escape-hatch metadata carried by loop events. */ export type Metadata = Readonly>; /** @experimental A model turn has started. `turn` is 0-based. */ export interface TurnStarted { readonly _tag: "TurnStarted"; readonly turn: number; readonly metadata?: Metadata; } /** * @experimental A raw model stream part, passed through unchanged. * `modelCallId`, `modelAttemptId`, and 0-based `attempt` join the part to its * model-call and attempt lifecycle events. */ export interface ModelPart { readonly _tag: "ModelPart"; readonly turn: number; readonly modelCallId: string; readonly modelAttemptId: string; readonly attempt: number; readonly part: Response.StreamPart>; readonly metadata?: Metadata; } /** @experimental One normalized model response after its durable operation commit. */ export interface ModelResponseCommitted { readonly _tag: "ModelResponseCommitted"; readonly turn: number; readonly operationKey: string; readonly modelCallId: string; readonly modelAttemptId: string; readonly attempt: number; readonly response: CompletedModelResponse>; readonly digest: string; readonly metadata?: Metadata; } /** @experimental A tool call is about to execute via the ToolExecutor service. */ export interface ToolExecutionStarted { readonly _tag: "ToolExecutionStarted"; readonly turn: number; readonly call: Response.ToolCallPart; readonly metadata?: Metadata; } /** @experimental An in-flight progress update from a running tool. */ export interface ToolProgress { readonly _tag: "ToolProgress"; readonly turn: number; readonly toolCallId: string; readonly message?: string; readonly data?: Record; readonly metadata?: Metadata; } /** @experimental A same-run handoff was requested. */ export interface HandoffRequested { readonly _tag: "HandoffRequested"; readonly turn: number; readonly handoffId: string; readonly source: string; readonly target: string; readonly reason?: string; readonly metadata?: Metadata; } /** @experimental A same-run handoff completed and switched the active agent. */ export interface HandoffCompleted { readonly _tag: "HandoffCompleted"; readonly turn: number; readonly handoffId: string; readonly source: string; readonly target: string; readonly metadata?: Metadata; } /** @experimental A same-run handoff was rejected before switching agents. */ export interface HandoffRejectedEvent { readonly _tag: "HandoffRejected"; readonly turn: number; readonly handoffId: string; readonly reason: string; readonly metadata?: Metadata; } /** @experimental A tool call finished; `result` is the part re-fed to the model. */ export interface ToolExecutionCompleted { readonly _tag: "ToolExecutionCompleted"; readonly turn: number; readonly call: Response.ToolCallPart; readonly result: Response.ToolResultPart; readonly metadata?: Metadata & { readonly toolProgress?: { readonly dropped: number; }; }; } /** @experimental Stable identity for one authorization request. */ export declare const ApprovalId: Schema.String; /** @experimental */ export type ApprovalId = typeof ApprovalId.Type; /** @experimental Canonical identity and payload for one authorization request. */ export declare const ApprovalRequest: Schema.Struct<{ readonly approvalId: Schema.String; readonly operation: Schema.String; readonly capability: Schema.String; readonly input: Schema.Unknown; }>; /** @experimental */ export type ApprovalRequest = typeof ApprovalRequest.Type; /** @experimental Emitted before resolving a permission ask or needsApproval tool. */ export interface ApprovalRequested { readonly _tag: "ApprovalRequested"; readonly turn: number; readonly call: Response.ToolCallPart; readonly request: ApprovalRequest; readonly metadata?: Metadata; } /** @experimental Steering queue whose inputs were consumed at a turn boundary. */ export type SteeringQueueName = "steering" | "followUp"; /** @experimental A steering or follow-up queue was drained into the next prompt. */ export interface SteeringDrained { readonly _tag: "SteeringDrained"; readonly turn: number; readonly queue: SteeringQueueName; readonly count: number; readonly metadata?: Metadata; } /** * @experimental Emitted after each model turn completes (after tool executions * for that turn). `transcript` is the full chat history at this point — hosts * that persist conversation state read it * from here. */ export interface TurnCompleted { readonly _tag: "TurnCompleted"; readonly turn: number; readonly transcript: Prompt.Prompt; readonly usage?: Response.Usage; readonly finishReason?: Response.FinishReason; readonly metadata?: Metadata; } /** @experimental Terminal structured turn produced a schema-validated value. */ export interface StructuredOutput { readonly _tag: "StructuredOutput"; readonly turn: number; readonly modelCallId: string; readonly modelAttemptId: string; readonly attempt: number; readonly value: unknown; readonly content: ReadonlyArray>>; readonly metadata?: Metadata; } /** @experimental Terminal event: the run finished without suspension. */ export interface Completed { readonly _tag: "Completed"; readonly turns: number; readonly text: string; readonly transcript: Prompt.Prompt; readonly usage?: Response.Usage; readonly metadata?: Metadata; } /** @experimental Fieldwise sum of upstream model usage values. */ export declare const addUsage: { (right: Response.Usage): (left: Response.Usage) => Response.Usage; (left: Response.Usage, right: Response.Usage): Response.Usage; }; /** @experimental Closed union of Baton loop events. */ export type Event = TurnStarted | ModelPart | ModelResponseCommitted | ToolExecutionStarted | ToolProgress | ToolExecutionCompleted | HandoffRequested | HandoffCompleted | HandoffRejectedEvent | ApprovalRequested | SteeringDrained | TurnCompleted | StructuredOutput | Completed | ModelTelemetryEvent; declare const AgentError_base: Schema.Class; readonly diagnostics: Schema.optionalKey; readonly durableEntryCount: Schema.Finite; readonly durableMessageCount: Schema.Finite; readonly authoritativeMessageCount: Schema.Finite; readonly alignmentCount: Schema.Finite; readonly commonPrefixLength: Schema.Finite; readonly lastDurableEntryTag: Schema.optionalKey; readonly firstDivergence: Schema.optionalKey; readonly authoritativeRole: Schema.optionalKey; readonly durablePartTypes: Schema.$Array; readonly authoritativePartTypes: Schema.$Array; readonly durableDigest: Schema.optionalKey; readonly authoritativeDigest: Schema.optionalKey; }>>; }>>; }>, import("effect/Cause").YieldableError>; /** @experimental The loop failed. `turn` is the 0-based turn that failed. */ export declare class AgentError extends AgentError_base { } declare const TurnLimitExceeded_base: Schema.Class>; }>, import("effect/Cause").YieldableError>; /** @experimental The turn policy declined another turn while tool results were still pending. */ export declare class TurnLimitExceeded extends TurnLimitExceeded_base { } declare const TurnPolicyStopped_base: Schema.Class; readonly limit: Schema.Finite; }>, Schema.Struct<{ readonly _tag: Schema.tag<"GoalSatisfied">; }>, Schema.Struct<{ readonly _tag: Schema.tag<"BudgetExhausted">; readonly budget: Schema.String; }>, Schema.Struct<{ readonly _tag: Schema.tag<"Policy">; readonly detail: Schema.String; }>]>; readonly pending: Schema.$Array>; }>, import("effect/Cause").YieldableError>; /** @experimental A turn policy successfully stopped for a reason other than a configured turn limit. */ export declare class TurnPolicyStopped extends TurnPolicyStopped_base { } declare const RunEndedWithoutOutput_base: Schema.Class>; readonly providerTextCharacters: Schema.Finite; readonly reasoningCharacters: Schema.Finite; }>, import("effect/Cause").YieldableError>; /** * @experimental The turn that would have ended the run left no assistant text, * so the run has no answer to report and never completes. `finishReason` is * what the provider reported for that turn: `"unknown"` means the provider * never said why it stopped, and an absent reason means no terminal event was * observed at all. `providerTextCharacters` and `reasoningCharacters` count * what the provider streamed across every attempt of that turn, before * middleware ran, so zero text with reasoning is a provider that stopped after * thinking and zero of both is a provider that produced nothing. Non-zero text * means text was streamed but never committed: a middleware chain removed it, * or the attempt that streamed it was discarded before release. */ export declare class RunEndedWithoutOutput extends RunEndedWithoutOutput_base { } declare const MiddlewareViolation_base: Schema.Class, import("effect/Cause").YieldableError>; /** @experimental A ModelMiddleware hook violated the loop contract. */ export declare class MiddlewareViolation extends MiddlewareViolation_base { } declare const DuplicateToolCallId_base: Schema.Class, import("effect/Cause").YieldableError>; /** @experimental A transformed model response reused a tool-call identifier. */ export declare class DuplicateToolCallId extends DuplicateToolCallId_base { } declare const ProgressOverflow_base: Schema.Class, import("effect/Cause").YieldableError>; /** @experimental An explicitly failing tool progress queue reached capacity. */ export declare class ProgressOverflow extends ProgressOverflow_base { } /** @experimental The origin of one tool declaration in an Agent run. */ export declare const ToolOrigin: Schema.Union, Schema.TaggedStruct<"Builtin", { readonly builtin: Schema.Literal<"activate_skill">; }>, Schema.TaggedStruct<"Skill", { readonly skill: Schema.String; }>, Schema.TaggedStruct<"Handoff", { readonly specialist: Schema.String; readonly mode: Schema.Literals; }>]>; /** @experimental */ export type ToolOrigin = typeof ToolOrigin.Type; declare const ToolNameCollision_base: Schema.Class, Schema.TaggedStruct<"Builtin", { readonly builtin: Schema.Literal<"activate_skill">; }>, Schema.TaggedStruct<"Skill", { readonly skill: Schema.String; }>, Schema.TaggedStruct<"Handoff", { readonly specialist: Schema.String; readonly mode: Schema.Literals; }>]>>; }>, import("effect/Cause").YieldableError>; /** @experimental The advertised tool set contains more than one declaration for a name. */ export declare class ToolNameCollision extends ToolNameCollision_base { } declare const AgentSuspended_base: Schema.Class; readonly tool_call_index: Schema.optional; readonly tool_call_id: Schema.String; readonly tool_name: Schema.String; readonly tool_params: Schema.Unknown; readonly tool_call_batch: Schema.$Array; readonly id: Schema.String; readonly name: Schema.String; readonly params: Schema.Unknown; readonly providerExecuted: Schema.Boolean; readonly metadata: Schema.$Record>>; }>>; readonly active_tools: Schema.optional>; readonly activated_skills: Schema.optional>; readonly invocation_path: Schema.optional>; }>, import("effect/Cause").YieldableError>; /** * @experimental The run suspended: a tool outcome was `Suspend` or an approval * decision was `Pending`. The run did NOT finish; the host resolves `token` * out-of-band and re-enters via `RunOptions.resume` with this exact suspension. * Field shape deliberately mirrors a tool call so durable hosts can persist it. */ export declare class AgentSuspended extends AgentSuspended_base { } declare const ResumeMismatch_base: Schema.Class; readonly expected: Schema.optional; readonly received: typeof AgentSuspended; }>, import("effect/Cause").YieldableError>; /** @experimental A resume identity did not match the current authoritative suspension checkpoint. */ export declare class ResumeMismatch extends ResumeMismatch_base { } export {};