@zhivex-ai/core 0.5.0-next.0 → 0.5.0

package/dist/types.d.ts

@@ -28,19 +28,6 @@ export interface ToolExecutionResult {
     };
     isError: boolean;
 }
-export type ToolSandboxLevel = "read-only" | "write" | "network" | "admin";
-export type ToolSideEffectLevel = "none" | "low" | "medium" | "high";
-export interface ToolPolicy {
-    sandbox?: ToolSandboxLevel;
-    sideEffect?: ToolSideEffectLevel;
-    scopes?: string[];
-    tags?: string[];
-}
-export interface ToolProgressUpdate {
-    message?: string;
-    output?: JsonValue;
-    metadata?: Record<string, unknown>;
-}
 export type ToolChoice = "auto" | "none" | "required" | {
     type: "tool";
     toolName: string;
@@ -68,7 +55,12 @@ export interface ToolResultPart {
     type: "tool-result";
     toolResult: ToolExecutionResult;
 }
-export type ContentPart = TextPart | ImagePart | FilePart | ToolCallPart | ToolResultPart;
+export interface ProviderDataPart {
+    type: "provider-data";
+    provider: string;
+    data: JsonValue;
+}
+export type ContentPart = TextPart | ImagePart | FilePart | ToolCallPart | ToolResultPart | ProviderDataPart;
 export interface ModelMessage {
     role: MessageRole;
     parts: ContentPart[];
@@ -87,7 +79,27 @@ export interface ModelCapabilities {
     embeddings: boolean;
     reasoning: boolean;
     webSearch: boolean;
-}
+    realtime?: {
+        sessions: boolean;
+        audioInput: boolean;
+        audioOutput: boolean;
+        tools: boolean;
+        browserTokens: boolean;
+    };
+    agentCapabilities?: AgentCapabilities;
+}
+export interface AgentCapabilities {
+    supportTier: AgentSupportTier;
+    toolChoiceNone: boolean;
+    approvalRequests: boolean;
+    hostedWebSearch: boolean;
+    hostedFileSearch: boolean;
+    remoteMcp: boolean;
+    computerUse: boolean;
+    codeExecution: boolean;
+    toolsets: boolean;
+}
+export type AgentSupportTier = "tier-a" | "tier-b" | "tier-c";
 export interface RetryOptions {
     abortSignal?: AbortSignal;
     timeoutMs?: number;
@@ -100,22 +112,6 @@ export interface ToolExecutionOptions {
     timeoutMs?: number;
     stopOnError?: boolean;
 }
-export interface ToolExecutionContext {
-    runId: string;
-    sessionId: string;
-    step: number;
-    toolCallId: string;
-    toolName: string;
-    abortSignal?: AbortSignal;
-    metadata?: Record<string, unknown>;
-    session?: Pick<AgentSession, "id" | "status" | "summary" | "metadata" | "activeAgentStack">;
-    messages?: readonly ModelMessage[];
-    memory: {
-        search: (query?: string, options?: Omit<MemoryQuery, "query" | "sessionId">) => Promise<MemoryRecord[]>;
-        write?: (records: MemoryRecord | MemoryRecord[]) => Promise<void> | void;
-    };
-    emitProgress: (update: ToolProgressUpdate) => Promise<void> | void;
-}
 export interface StructuredOutputConfig<TSchema extends ZodTypeAny = ZodTypeAny> {
     schema: TSchema;
     mode: StructuredOutputMode;
@@ -138,6 +134,11 @@ export interface StreamToolResultEvent {
     type: "tool-result";
     toolResult: ToolExecutionResult;
 }
+export interface StreamProviderDataEvent {
+    type: "provider-data";
+    provider: string;
+    data: JsonValue;
+}
 export interface StreamFinishEvent {
     type: "finish";
     finishReason?: FinishReason;
@@ -148,7 +149,34 @@ export interface StreamErrorEvent {
     type: "error";
     error: Error;
 }
-export type StreamEvent = StreamTextDeltaEvent | StreamToolCallEvent | StreamToolResultEvent | StreamFinishEvent | StreamErrorEvent;
+export type StreamEvent = StreamTextDeltaEvent | StreamToolCallEvent | StreamToolResultEvent | StreamProviderDataEvent | StreamFinishEvent | StreamErrorEvent;
+export interface AgentRunStartEvent {
+    type: "agent-run-start";
+    currentStep: number;
+    maxSteps: number;
+}
+export interface AgentStepStartEvent {
+    type: "agent-step-start";
+    stepIndex: number;
+}
+export interface AgentStepFinishEvent {
+    type: "agent-step-finish";
+    step: AgentStep;
+}
+export interface AgentApprovalRequestEvent {
+    type: "agent-approval-request";
+    approval: AgentApprovalRequest;
+}
+export interface AgentApprovalResolvedEvent {
+    type: "agent-approval-resolved";
+    approval: AgentApprovalResponse;
+}
+export interface AgentRunFinishEvent {
+    type: "agent-run-finish";
+    status: AgentStatus;
+    state: AgentRunState;
+}
+export type AgentStreamEvent = StreamEvent | AgentRunStartEvent | AgentStepStartEvent | AgentStepFinishEvent | AgentApprovalRequestEvent | AgentApprovalResolvedEvent | AgentRunFinishEvent;
 export interface StreamObjectDeltaEvent {
     type: "object-delta";
     textDelta: string;
@@ -264,13 +292,131 @@ export interface SpeechModel<TProviderOptions extends ProviderOptions = Provider
     readonly capabilities: ModelCapabilities;
     generateSpeech(input: SpeechModelInput<TProviderOptions>): Promise<SpeechResult>;
 }
+export interface AudioFrame {
+    data: string | Uint8Array | ArrayBuffer;
+    mediaType: string;
+    sampleRateHz?: number;
+    channels?: number;
+    isFinal?: boolean;
+}
+export interface RealtimeConnectOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    subprotocols?: string[];
+}
+export interface RealtimeSessionConfig {
+    instructions?: string;
+    voice?: string;
+    tools?: ToolCollection;
+    toolChoice?: ToolChoice;
+    inputAudioMediaType?: string;
+    outputAudioMediaType?: string;
+    inputSampleRateHz?: number;
+    outputSampleRateHz?: number;
+    channels?: number;
+    turnDetection?: Record<string, unknown> | null;
+    providerOptions?: ProviderOptions;
+    metadata?: Record<string, JsonValue>;
+    autoResponse?: boolean;
+}
+export interface RealtimeTokenResult {
+    value: string;
+    expiresAtMs?: number;
+    rawResponse?: unknown;
+}
+export interface RealtimeSessionStartedEvent {
+    type: "realtime-start";
+    sessionId?: string;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeTextDeltaEvent {
+    type: "realtime-text-delta";
+    textDelta: string;
+    itemId?: string;
+    responseId?: string;
+    role?: "assistant";
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeAudioOutputEvent {
+    type: "realtime-audio-output";
+    audio: Uint8Array;
+    mediaType: string;
+    sampleRateHz?: number;
+    channels?: number;
+    itemId?: string;
+    responseId?: string;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeTranscriptEvent {
+    type: "realtime-transcript";
+    text: string;
+    role: "user" | "assistant";
+    isFinal: boolean;
+    itemId?: string;
+    responseId?: string;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeToolCallEvent {
+    type: "realtime-tool-call";
+    toolCall: ToolCall;
+}
+export interface RealtimeToolResultEvent {
+    type: "realtime-tool-result";
+    toolResult: ToolExecutionResult;
+}
+export interface RealtimeResponseCompleteEvent {
+    type: "realtime-response-complete";
+    reason?: string;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeSessionResumptionEvent {
+    type: "realtime-session-resumption";
+    handle?: string;
+    resumable?: boolean;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeGoAwayEvent {
+    type: "realtime-go-away";
+    timeLeftMs?: number;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeSessionEndedEvent {
+    type: "realtime-end";
+    reason?: string;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export interface RealtimeErrorEvent {
+    type: "realtime-error";
+    error?: Error;
+    message?: string;
+    providerMetadata?: Record<string, JsonValue>;
+}
+export type RealtimeEvent = RealtimeSessionStartedEvent | RealtimeTextDeltaEvent | RealtimeAudioOutputEvent | RealtimeTranscriptEvent | RealtimeToolCallEvent | RealtimeToolResultEvent | RealtimeResponseCompleteEvent | RealtimeSessionResumptionEvent | RealtimeGoAwayEvent | RealtimeSessionEndedEvent | RealtimeErrorEvent;
+export interface RealtimeSession {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly capabilities: ModelCapabilities;
+    readonly config: RealtimeSessionConfig;
+    sendAudio(frame: AudioFrame): Promise<void>;
+    sendText(text: string): Promise<void>;
+    sendToolResult(result: ToolExecutionResult): Promise<void>;
+    update(config: Partial<RealtimeSessionConfig>): Promise<void>;
+    eventStream(): AsyncIterable<RealtimeEvent>;
+    close(): Promise<void>;
+}
+export interface RealtimeModel {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly capabilities: ModelCapabilities;
+    connect(config?: RealtimeSessionConfig, options?: RealtimeConnectOptions): Promise<RealtimeSession>;
+    createBrowserToken?(config?: RealtimeSessionConfig, options?: RealtimeConnectOptions): Promise<RealtimeTokenResult>;
+}
 export interface GroundedLanguageModel<TProviderOptions extends ProviderOptions = ProviderOptions> {
     readonly provider: string;
     readonly modelId: string;
     readonly capabilities: ModelCapabilities;
     generate(input: GroundedModelGenerateInput<TProviderOptions>): Promise<GroundedGenerateResult>;
 }
-export type AgentModel<TProviderOptions extends ProviderOptions = ProviderOptions> = LanguageModel<TProviderOptions> | GroundedLanguageModel<TProviderOptions>;
 export interface EmbeddingModel {
     readonly provider: string;
     readonly modelId: string;
@@ -283,6 +429,7 @@ export interface ProviderAdapter {
     embeddingModel?: (modelId: string) => EmbeddingModel;
     transcriptionModel?: (modelId: string) => TranscriptionModel;
     speechModel?: (modelId: string) => SpeechModel;
+    realtimeModel?: (modelId: string) => RealtimeModel;
     groundedLanguageModel?: (modelId: string) => GroundedLanguageModel;
 }
 export type CallableProviderAdapter = ProviderAdapter & ((modelId: string) => LanguageModel);
@@ -290,18 +437,59 @@ export interface ToolDefinition<TSchema extends ZodTypeAny = ZodTypeAny, TResult
     name: string;
     description?: string;
     schema: TSchema;
+    metadata?: Record<string, JsonValue>;
     requiresApproval?: boolean;
-    policy?: ToolPolicy;
-    execute: (input: z.infer<TSchema>, context?: ToolExecutionContext) => Promise<TResult> | TResult;
+    execute: (input: z.infer<TSchema>) => Promise<TResult> | TResult;
 }
-export type ToolSet = Record<string, ToolDefinition>;
+export type HostedToolClass = "web-search" | "file-search" | "remote-mcp" | "computer-use" | "code-execution" | "toolset" | "custom";
+export interface HostedToolDefinition<TConfig extends JsonValue = JsonValue> {
+    kind: "hosted";
+    name: string;
+    provider?: string;
+    type: string;
+    config?: TConfig;
+    toolClass?: HostedToolClass;
+    requiresApproval?: boolean;
+    metadata?: Record<string, JsonValue>;
+}
+export type AnyToolDefinition = ToolDefinition | HostedToolDefinition;
+export type ToolSet = Record<string, AnyToolDefinition>;
+export interface ToolRegistryLike {
+    get(name: string): AnyToolDefinition | undefined;
+    has(name: string): boolean;
+    entries(): Iterable<[string, AnyToolDefinition]>;
+    toToolSet(): ToolSet;
+}
+export type ToolCollection = ToolSet | ToolRegistryLike;
+export interface ToolApprovalRequest {
+    toolCall: ToolCall;
+    tool: ToolDefinition;
+    input: JsonValue;
+    step: number;
+    model: LanguageModel | RealtimeModel;
+    request?: ModelGenerateInput;
+    realtimeConfig?: RealtimeSessionConfig;
+}
+export interface ToolApprovalDecision {
+    approved: boolean;
+    reason?: string;
+    metadata?: Record<string, JsonValue>;
+}
+export interface ToolApprovalEvent {
+    request: ToolApprovalRequest;
+    decision: ToolApprovalDecision;
+}
+export type ToolApprovalPolicy = (request: ToolApprovalRequest) => ToolApprovalDecision | boolean | Promise<ToolApprovalDecision | boolean>;
+export type ToolApprovalObserver = (event: ToolApprovalEvent) => void | Promise<void>;
 export type ProviderOptionsOf<TModel extends LanguageModel> = TModel extends LanguageModel<infer TProviderOptions> ? TProviderOptions : ProviderOptions;
 export type GenerateTextOptions<TModel extends LanguageModel = LanguageModel> = RetryOptions & GenerateInputSource & {
     model: TModel;
     system?: string;
-    tools?: ToolSet;
+    tools?: ToolCollection;
     toolChoice?: ToolChoice;
     toolExecution?: ToolExecutionOptions;
+    toolApprovalPolicy?: ToolApprovalPolicy;
+    onToolApprovalDecision?: ToolApprovalObserver;
     maxSteps?: number;
     temperature?: number;
     maxTokens?: number;
@@ -322,6 +510,336 @@ export interface GenerateTextOutput {
     messages: ModelMessage[];
     toolResults: ToolExecutionResult[];
 }
+export type AgentStatus = "running" | "completed" | "suspended" | "failed" | "cancelled";
+export type AgentStepStatus = "running" | "completed" | "suspended" | "failed";
+export interface AgentStepRequest {
+    messages: ModelMessage[];
+    toolChoice?: ToolChoice;
+    toolExecution?: ToolExecutionOptions;
+    temperature?: number;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+    providerOptions?: ProviderOptions;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryBackoffMs?: number;
+}
+export interface AgentStepResponse {
+    messages: ModelMessage[];
+    text?: string;
+    finishReason?: FinishReason;
+    providerFinishReason?: string;
+    usage?: TokenUsage;
+}
+export interface AgentStep {
+    index: number;
+    status: AgentStepStatus;
+    startedAt?: number;
+    finishedAt?: number;
+    request: AgentStepRequest;
+    response?: AgentStepResponse;
+    toolResults: ToolExecutionResult[];
+    error?: {
+        message: string;
+    };
+}
+export interface AgentRunState {
+    runId: string;
+    agentId?: string;
+    parentRunId?: string;
+    provider: string;
+    modelId: string;
+    status: AgentStatus;
+    messages: ModelMessage[];
+    steps: AgentStep[];
+    toolResults: ToolExecutionResult[];
+    currentStep: number;
+    maxSteps: number;
+    outputText: string;
+    finishReason?: FinishReason;
+    providerFinishReason?: string;
+    usage?: TokenUsage;
+    pendingApprovals: AgentApprovalRequest[];
+    metadata?: Record<string, JsonValue>;
+    handoff?: AgentHandoff;
+    startedAt?: number;
+    updatedAt?: number;
+    error?: {
+        message: string;
+    };
+}
+export interface AgentRunStore {
+    load(runId: string): Promise<AgentRunState | undefined> | AgentRunState | undefined;
+    save(state: AgentRunState): Promise<void> | void;
+    delete?(runId: string): Promise<void> | void;
+}
+export interface AgentMemoryContext {
+    runId: string;
+    agentId?: string;
+    state?: AgentRunState;
+    metadata?: Record<string, JsonValue>;
+}
+export interface AgentMemoryStore {
+    load(context: AgentMemoryContext): Promise<ModelMessage[]> | ModelMessage[];
+    save?(context: AgentMemoryContext & {
+        state: AgentRunState;
+    }): Promise<void> | void;
+}
+export interface SqliteStatementLike<TResult extends Record<string, unknown> = Record<string, unknown>> {
+    run(params?: readonly unknown[] | Record<string, unknown>): unknown;
+    get(params?: readonly unknown[] | Record<string, unknown>): TResult | undefined;
+}
+export interface SqliteDatabaseLike {
+    exec(sql: string): unknown;
+    prepare?<TResult extends Record<string, unknown> = Record<string, unknown>>(sql: string): SqliteStatementLike<TResult>;
+    query?<TResult extends Record<string, unknown> = Record<string, unknown>>(sql: string): SqliteStatementLike<TResult>;
+}
+export interface SqliteAgentRunStoreOptions {
+    db: SqliteDatabaseLike;
+    tableName?: string;
+}
+export interface SqliteAgentMemoryStoreOptions {
+    db: SqliteDatabaseLike;
+    tableName?: string;
+    key?: (context: AgentMemoryContext) => string;
+    selectMessages?: (state: AgentRunState) => ModelMessage[];
+}
+export interface PostgresQueryResultLike<TResult extends Record<string, unknown> = Record<string, unknown>> {
+    rows: TResult[];
+}
+export interface PostgresClientLike {
+    query<TResult extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<PostgresQueryResultLike<TResult>> | PostgresQueryResultLike<TResult>;
+}
+export interface PostgresAgentRunStoreOptions {
+    client: PostgresClientLike;
+    tableName?: string;
+}
+export interface PostgresAgentMemoryStoreOptions {
+    client: PostgresClientLike;
+    tableName?: string;
+    key?: (context: AgentMemoryContext) => string;
+    selectMessages?: (state: AgentRunState) => ModelMessage[];
+}
+export interface AgentHandoff {
+    id: string;
+    fromRunId: string;
+    fromAgentId?: string;
+    toAgentId?: string;
+    summary: string;
+    contextMessages: ModelMessage[];
+    metadata?: Record<string, JsonValue>;
+}
+export interface AgentTelemetryRunStartEvent {
+    type: "run-start";
+    runId: string;
+    agentId?: string;
+    provider: string;
+    modelId: string;
+    maxSteps: number;
+}
+export interface AgentTelemetryStepStartEvent {
+    type: "step-start";
+    runId: string;
+    agentId?: string;
+    stepIndex: number;
+}
+export interface AgentTelemetryStepFinishEvent {
+    type: "step-finish";
+    runId: string;
+    agentId?: string;
+    step: AgentStep;
+}
+export interface AgentTelemetryApprovalRequestEvent {
+    type: "approval-request";
+    runId: string;
+    agentId?: string;
+    approval: AgentApprovalRequest;
+}
+export interface AgentTelemetryApprovalResolvedEvent {
+    type: "approval-resolved";
+    runId: string;
+    agentId?: string;
+    approval: AgentApprovalResponse;
+}
+export interface AgentTelemetryToolApprovalEvent {
+    type: "tool-approval";
+    runId: string;
+    agentId?: string;
+    toolCall: ToolCall;
+    approved: boolean;
+    reason?: string;
+    metadata?: Record<string, JsonValue>;
+}
+export interface AgentTelemetryMemoryLoadedEvent {
+    type: "memory-loaded";
+    runId: string;
+    agentId?: string;
+    messageCount: number;
+}
+export interface AgentGuardrailTrigger {
+    triggered: true;
+    reason?: string;
+    metadata?: Record<string, JsonValue>;
+}
+export interface AgentInputGuardrailRequest {
+    runId: string;
+    agentId?: string;
+    messages: ModelMessage[];
+    metadata?: Record<string, JsonValue>;
+}
+export interface AgentOutputGuardrailRequest {
+    runId: string;
+    agentId?: string;
+    state: AgentRunState;
+    output: AgentRunOutput | LiveAgentRunOutput;
+    metadata?: Record<string, JsonValue>;
+}
+export type AgentInputGuardrail = (request: AgentInputGuardrailRequest) => AgentGuardrailTrigger | void | Promise<AgentGuardrailTrigger | void>;
+export type AgentOutputGuardrail = (request: AgentOutputGuardrailRequest) => AgentGuardrailTrigger | void | Promise<AgentGuardrailTrigger | void>;
+export interface AgentTelemetryGuardrailTriggeredEvent {
+    type: "guardrail-triggered";
+    runId: string;
+    agentId?: string;
+    stage: "input" | "output";
+    reason?: string;
+    metadata?: Record<string, JsonValue>;
+}
+export interface AgentTelemetryStateSavedEvent {
+    type: "state-saved";
+    runId: string;
+    agentId?: string;
+    status: AgentStatus;
+}
+export interface AgentTelemetryHandoffEvent {
+    type: "handoff";
+    runId: string;
+    agentId?: string;
+    handoff: AgentHandoff;
+}
+export interface AgentTelemetryRunFinishEvent {
+    type: "run-finish";
+    runId: string;
+    agentId?: string;
+    status: AgentStatus;
+    state: AgentRunState;
+}
+export type AgentTelemetryEvent = AgentTelemetryRunStartEvent | AgentTelemetryStepStartEvent | AgentTelemetryStepFinishEvent | AgentTelemetryApprovalRequestEvent | AgentTelemetryApprovalResolvedEvent | AgentTelemetryToolApprovalEvent | AgentTelemetryMemoryLoadedEvent | AgentTelemetryGuardrailTriggeredEvent | AgentTelemetryStateSavedEvent | AgentTelemetryHandoffEvent | AgentTelemetryRunFinishEvent;
+export type AgentTelemetryObserver = (event: AgentTelemetryEvent) => void | Promise<void>;
+export interface AgentDefinition<TModel extends LanguageModel = LanguageModel> {
+    id?: string;
+    model: TModel;
+    instructions?: string;
+    tools?: ToolCollection;
+    maxSteps?: number;
+    temperature?: number;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+    toolExecution?: ToolExecutionOptions;
+    toolApprovalPolicy?: ToolApprovalPolicy;
+    inputGuardrails?: AgentInputGuardrail[];
+    outputGuardrails?: AgentOutputGuardrail[];
+    providerOptions?: ProviderOptionsOf<TModel>;
+    metadata?: Record<string, JsonValue>;
+    store?: AgentRunStore;
+    memory?: AgentMemoryStore;
+    onTelemetryEvent?: AgentTelemetryObserver;
+}
+export interface LiveAgentDefinition<TModel extends RealtimeModel = RealtimeModel> {
+    id?: string;
+    model: TModel;
+    instructions?: string;
+    tools?: ToolCollection;
+    toolChoice?: ToolChoice;
+    toolExecution?: ToolExecutionOptions;
+    toolApprovalPolicy?: ToolApprovalPolicy;
+    inputGuardrails?: AgentInputGuardrail[];
+    outputGuardrails?: AgentOutputGuardrail[];
+    providerOptions?: ProviderOptions;
+    metadata?: Record<string, JsonValue>;
+    store?: AgentRunStore;
+    memory?: AgentMemoryStore;
+    onTelemetryEvent?: AgentTelemetryObserver;
+}
+export interface AgentApprovalRequest {
+    provider: string;
+    id: string;
+    name: string;
+    arguments: string;
+    serverLabel?: string;
+    rawData: JsonValue;
+}
+export interface AgentApprovalResponse {
+    provider: string;
+    approvalRequestId: string;
+    approve: boolean;
+    id?: string;
+    reason?: string;
+}
+export type AgentRunInput<TModel extends LanguageModel = LanguageModel> = RetryOptions & GenerateInputSource & {
+    runId?: string;
+    state?: AgentRunState;
+    approvals?: AgentApprovalResponse[];
+    handoff?: AgentHandoff;
+    system?: string;
+    tools?: ToolCollection;
+    toolChoice?: ToolChoice;
+    toolExecution?: ToolExecutionOptions;
+    toolApprovalPolicy?: ToolApprovalPolicy;
+    maxSteps?: number;
+    temperature?: number;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+    providerOptions?: ProviderOptionsOf<TModel>;
+    metadata?: Record<string, JsonValue>;
+};
+export interface AgentRunOutput {
+    status: AgentStatus;
+    outputText: string;
+    finishReason?: FinishReason;
+    providerFinishReason?: string;
+    usage?: TokenUsage;
+    messages: ModelMessage[];
+    steps: AgentStep[];
+    toolResults: ToolExecutionResult[];
+    state: AgentRunState;
+    error?: {
+        message: string;
+    };
+}
+export type LiveAgentRunInput = GenerateInputSource & RetryOptions & {
+    runId?: string;
+    system?: string;
+    tools?: ToolCollection;
+    toolChoice?: ToolChoice;
+    toolExecution?: ToolExecutionOptions;
+    toolApprovalPolicy?: ToolApprovalPolicy;
+    providerOptions?: ProviderOptions;
+    metadata?: Record<string, JsonValue>;
+    realtime?: RealtimeSessionConfig;
+    connectOptions?: RealtimeConnectOptions;
+};
+export interface LiveAgentRunOutput {
+    status: AgentStatus;
+    outputText: string;
+    messages: ModelMessage[];
+    toolResults: ToolExecutionResult[];
+    state: AgentRunState;
+    error?: {
+        message: string;
+    };
+}
+export interface AgentStreamResult {
+    eventStream: AsyncIterable<AgentStreamEvent>;
+    textStream: AsyncIterable<string>;
+    collect: () => Promise<AgentRunOutput>;
+}
+export type AgentLiveEvent = AgentStreamEvent | RealtimeEvent;
+export interface AgentLiveStreamResult {
+    eventStream: AsyncIterable<AgentLiveEvent>;
+    textStream: AsyncIterable<string>;
+    session: Promise<RealtimeSession>;
+    collect: () => Promise<LiveAgentRunOutput>;
+}
 export type TranscribeAudioOptions<TModel extends TranscriptionModel = TranscriptionModel> = RetryOptions & {
     model: TModel;
     audio: AudioInput;
@@ -500,6 +1018,13 @@ export interface UIMessageToolResultChunk {
     role: "tool";
     toolResult: ToolExecutionResult;
 }
+export interface UIMessageProviderDataChunk {
+    type: "provider-data";
+    messageId: string;
+    role: "assistant";
+    provider: string;
+    data: JsonValue;
+}
 export interface UIMessageFinishChunk {
     type: "finish";
     messageId: string;
@@ -514,7 +1039,33 @@ export interface UIMessageErrorChunk {
         message: string;
     };
 }
-export type UIMessageChunk = UIMessageTextChunk | UIMessageToolCallChunk | UIMessageToolResultChunk | UIMessageFinishChunk | UIMessageErrorChunk;
+export interface UIAgentRunStartChunk {
+    type: "agent-run-start";
+    currentStep: number;
+    maxSteps: number;
+}
+export interface UIAgentStepStartChunk {
+    type: "agent-step-start";
+    stepIndex: number;
+}
+export interface UIAgentStepFinishChunk {
+    type: "agent-step-finish";
+    step: AgentStep;
+}
+export interface UIAgentApprovalRequestChunk {
+    type: "agent-approval-request";
+    approval: AgentApprovalRequest;
+}
+export interface UIAgentApprovalResolvedChunk {
+    type: "agent-approval-resolved";
+    approval: AgentApprovalResponse;
+}
+export interface UIAgentRunFinishChunk {
+    type: "agent-run-finish";
+    status: AgentStatus;
+    state: AgentRunState;
+}
+export type UIMessageChunk = UIMessageTextChunk | UIMessageToolCallChunk | UIMessageToolResultChunk | UIMessageProviderDataChunk | UIMessageFinishChunk | UIMessageErrorChunk | UIAgentRunStartChunk | UIAgentStepStartChunk | UIAgentStepFinishChunk | UIAgentApprovalRequestChunk | UIAgentApprovalResolvedChunk | UIAgentRunFinishChunk;
 export interface EmbedInput {
     values: string[];
 }
@@ -525,466 +1076,4 @@ export interface EmbedOptions extends RetryOptions {
 export interface EmbedOutput extends EmbedResult {
     values: string[];
 }
-export type AgentRunStatus = "queued" | "running" | "paused" | "waiting-approval" | "delegating" | "handed-off" | "completed" | "failed" | "canceled";
-export type AgentStepType = "chat" | "plan" | "act" | "summarize" | "grounded";
-export type AgentApprovalKind = "tool" | "delegate" | "handoff";
-export type MemoryRecordKind = "note" | "summary" | "fact" | "result";
-export interface AgentBudget {
-    maxSteps?: number;
-    maxDepth?: number;
-    maxParallelDelegations?: number;
-    maxTokens?: number;
-    maxToolCalls?: number;
-    deadline?: number;
-}
-export interface MemoryRecord {
-    id: string;
-    sessionId?: string;
-    agentName?: string;
-    kind: MemoryRecordKind;
-    content: string;
-    metadata?: Record<string, unknown>;
-    createdAt: number;
-    updatedAt?: number;
-}
-export interface MemoryQuery {
-    sessionId?: string;
-    agentName?: string;
-    query?: string;
-    limit?: number;
-    kinds?: MemoryRecordKind[];
-    metadata?: Record<string, unknown>;
-}
-export interface MemoryStore {
-    search(query: MemoryQuery): Promise<MemoryRecord[]> | MemoryRecord[];
-    put(records: MemoryRecord | MemoryRecord[]): Promise<void> | void;
-    get?(id: string): Promise<MemoryRecord | undefined> | MemoryRecord | undefined;
-    delete?(id: string): Promise<void> | void;
-}
-export interface AgentMemoryConfig {
-    enabled?: boolean;
-    maxMessages?: number;
-    maxResults?: number;
-    summaryPrefix?: string;
-}
-export interface AgentApprovalPolicy {
-    requireApproval?: AgentApprovalKind[];
-    toolNames?: string[];
-    delegateAgents?: string[];
-    handoffAgents?: string[];
-}
-export interface AgentToolPolicy {
-    allowedToolNames?: string[];
-    blockedToolNames?: string[];
-    allowedScopes?: string[];
-    requiredTags?: string[];
-    maxSideEffect?: ToolSideEffectLevel;
-    allowedSandboxLevels?: ToolSandboxLevel[];
-}
-export interface ApprovalRecord {
-    id: string;
-    requestId: string;
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    kind: AgentApprovalKind;
-    status: "approved" | "rejected" | "edited" | "pending";
-    toolName?: string;
-    targetAgent?: string;
-    input: JsonValue;
-    approvedInput?: JsonValue;
-    reason?: string;
-    createdAt: number;
-    decidedAt?: number;
-}
-export interface AgentModelUsageSummary {
-    provider: string;
-    modelId: string;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    estimatedCostUsd?: number;
-}
-export interface AgentRunMetrics {
-    startedAt: number;
-    finishedAt?: number;
-    durationMs: number;
-    stepCount: number;
-    toolCallCount: number;
-    toolResultCount: number;
-    toolErrorCount: number;
-    approvalCount: number;
-    approvalPendingCount: number;
-    delegateCount: number;
-    handoffCount: number;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    estimatedCostUsd?: number;
-    models: AgentModelUsageSummary[];
-}
-export interface AgentSession {
-    id: string;
-    schemaVersion?: number;
-    status: AgentRunStatus;
-    ownerAgentName: string;
-    messages: ModelMessage[];
-    summary?: string;
-    metadata?: Record<string, unknown>;
-    activeAgentStack: string[];
-    runIds: string[];
-    toolResults: ToolExecutionResult[];
-    approvalHistory: ApprovalRecord[];
-    lastRunMetrics?: AgentRunMetrics;
-    createdAt: number;
-    updatedAt: number;
-}
-export interface AgentStepRoute {
-    stepType?: AgentStepType;
-    model?: AgentModel;
-    useWebSearch?: boolean;
-    reasoning?: ReasoningConfig;
-}
-export interface AgentStepRouterContext {
-    agent: AgentDefinition;
-    session: AgentSession;
-    step: number;
-    defaultStepType: AgentStepType;
-    budget: AgentBudget;
-    lastToolResults: ToolExecutionResult[];
-    metadata?: Record<string, unknown>;
-}
-export interface AgentStepRouter {
-    (context: AgentStepRouterContext): Promise<AgentStepRoute> | AgentStepRoute;
-}
-export interface AgentDefaults {
-    temperature?: number;
-    maxTokens?: number;
-    maxSteps?: number;
-    reasoning?: ReasoningConfig;
-    toolChoice?: ToolChoice;
-    toolExecution?: ToolExecutionOptions;
-}
-export interface AgentDefinition {
-    name: string;
-    instructions: string;
-    model: AgentModel;
-    tools?: ToolSet;
-    defaults?: AgentDefaults;
-    memory?: AgentMemoryConfig;
-    delegates?: string[];
-    handoffs?: string[];
-    approvalPolicy?: AgentApprovalPolicy;
-    toolPolicy?: AgentToolPolicy;
-    stepRouter?: AgentStepRouter;
-    outputSchema?: StructuredOutputConfig;
-    metadata?: Record<string, unknown>;
-}
-export interface AgentRegistry {
-    register(agent: AgentDefinition): void;
-    get(name: string): AgentDefinition | undefined;
-    list(): AgentDefinition[];
-}
-export type AgentInputSource = {
-    prompt: string;
-    messages?: never;
-} | {
-    prompt?: never;
-    messages: ModelMessage[];
-} | {
-    prompt?: undefined;
-    messages?: undefined;
-};
-export interface ApprovalRequest {
-    id: string;
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    kind: AgentApprovalKind;
-    toolName?: string;
-    targetAgent?: string;
-    input: JsonValue;
-    metadata?: Record<string, unknown>;
-    createdAt: number;
-}
-export type ApprovalDecision = {
-    type: "approve";
-    input?: JsonValue;
-    reason?: string;
-} | {
-    type: "reject";
-    reason?: string;
-} | {
-    type: "edit-input";
-    input: JsonValue;
-    reason?: string;
-};
-export interface AgentPendingAction {
-    kind: AgentApprovalKind;
-    step: number;
-    stepType: AgentStepType;
-    toolCalls: ToolCall[];
-    nextToolCallIndex: number;
-    pendingToolResults: ToolExecutionResult[];
-    requestMessages: ModelMessage[];
-    approvalRequest: ApprovalRequest;
-}
-export interface AgentCheckpoint {
-    id: string;
-    schemaVersion?: number;
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    status: AgentRunStatus;
-    step: number;
-    session: AgentSession;
-    steps: AgentRunStep[];
-    pendingApproval?: ApprovalRequest;
-    pendingAction?: AgentPendingAction;
-    metrics?: AgentRunMetrics;
-    metadata?: Record<string, unknown>;
-    createdAt: number;
-}
-export interface SessionStore {
-    get(id: string): Promise<AgentSession | undefined> | AgentSession | undefined;
-    set(session: AgentSession): Promise<void> | void;
-    update(id: string, updater: (session: AgentSession | undefined) => AgentSession): Promise<AgentSession> | AgentSession;
-    delete?(id: string): Promise<void> | void;
-}
-export interface CheckpointStore {
-    get(id: string): Promise<AgentCheckpoint | undefined> | AgentCheckpoint | undefined;
-    set(checkpoint: AgentCheckpoint): Promise<void> | void;
-    getLatest(runId: string): Promise<AgentCheckpoint | undefined> | AgentCheckpoint | undefined;
-    list(runId: string): Promise<AgentCheckpoint[]> | AgentCheckpoint[];
-}
-export interface AgentRunStep {
-    index: number;
-    type: AgentStepType;
-    startedAt: number;
-    finishedAt?: number;
-    model: {
-        provider: string;
-        modelId: string;
-    };
-    text?: string;
-    object?: JsonValue;
-    objectMode?: Exclude<StructuredOutputMode, "auto">;
-    finishReason?: FinishReason;
-    providerFinishReason?: string;
-    usage?: TokenUsage;
-    toolCalls: ToolCall[];
-    toolResults: ToolExecutionResult[];
-    delegatedTo?: string[];
-    handedOffTo?: string;
-}
-export type AgentRunInput = RetryOptions & AgentInputSource & {
-    sessionId?: string;
-    runId?: string;
-    parentRunId?: string;
-    metadata?: Record<string, unknown>;
-    budget?: AgentBudget;
-    resumeFromCheckpoint?: string;
-};
-export interface AgentRunResult {
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    status: AgentRunStatus;
-    text: string;
-    object?: JsonValue;
-    objectMode?: Exclude<StructuredOutputMode, "auto">;
-    messages: ModelMessage[];
-    steps: AgentRunStep[];
-    toolResults: ToolExecutionResult[];
-    approvals: ApprovalRecord[];
-    metrics: AgentRunMetrics;
-    session: AgentSession;
-    pendingApproval?: ApprovalRequest;
-    checkpointId?: string;
-    handoffTo?: string;
-    parentRunId?: string;
-}
-export interface AgentRunStartedEvent {
-    type: "run-started";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    timestamp: number;
-    parentRunId?: string;
-}
-export interface AgentStepStartedEvent {
-    type: "step-started";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    stepType: AgentStepType;
-    timestamp: number;
-}
-export interface AgentTextDeltaEvent {
-    type: "text-delta";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    textDelta: string;
-}
-export interface AgentObjectPartialEvent {
-    type: "object-partial";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    partialObject: PartialJsonValue;
-}
-export interface AgentObjectCompleteEvent {
-    type: "object-complete";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    object: JsonValue;
-}
-export interface AgentToolCallEvent {
-    type: "tool-call";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    toolCall: ToolCall;
-}
-export interface AgentToolProgressEvent {
-    type: "tool-progress";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    toolCallId: string;
-    toolName: string;
-    update: ToolProgressUpdate;
-}
-export interface AgentToolResultEvent {
-    type: "tool-result";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    toolResult: ToolExecutionResult;
-}
-export interface AgentApprovalRequiredEvent {
-    type: "approval-required";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    request: ApprovalRequest;
-}
-export interface AgentApprovalDecidedEvent {
-    type: "approval-decided";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    record: ApprovalRecord;
-}
-export interface AgentCheckpointSavedEvent {
-    type: "checkpoint-saved";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    checkpointId: string;
-    step: number;
-    timestamp: number;
-}
-export interface AgentMemoryWrittenEvent {
-    type: "memory-written";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    records: MemoryRecord[];
-}
-export interface AgentDelegateStartedEvent {
-    type: "delegate-started";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    targetAgent: string;
-}
-export interface AgentDelegateFinishedEvent {
-    type: "delegate-finished";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    targetAgent: string;
-    childRunId: string;
-    status: AgentRunStatus;
-}
-export interface AgentHandoffEvent {
-    type: "handoff";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    targetAgent: string;
-    childRunId: string;
-}
-export interface AgentStepFinishedEvent {
-    type: "step-finished";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    stepType: AgentStepType;
-    finishReason?: FinishReason;
-    providerFinishReason?: string;
-    usage?: TokenUsage;
-    timestamp: number;
-}
-export interface AgentRunFinishedEvent {
-    type: "run-finished";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    status: AgentRunStatus;
-    metrics: AgentRunMetrics;
-    timestamp: number;
-}
-export interface AgentRunErrorEvent {
-    type: "run-error";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    step: number;
-    error: {
-        message: string;
-    };
-    timestamp: number;
-}
-export interface AgentRunPausedEvent {
-    type: "run-paused";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    reason: "approval";
-    timestamp: number;
-}
-export interface AgentRunResumedEvent {
-    type: "run-resumed";
-    runId: string;
-    sessionId: string;
-    agentName: string;
-    checkpointId: string;
-    timestamp: number;
-}
-export type AgentEvent = AgentRunStartedEvent | AgentStepStartedEvent | AgentTextDeltaEvent | AgentObjectPartialEvent | AgentObjectCompleteEvent | AgentToolCallEvent | AgentToolProgressEvent | AgentToolResultEvent | AgentApprovalRequiredEvent | AgentApprovalDecidedEvent | AgentCheckpointSavedEvent | AgentMemoryWrittenEvent | AgentDelegateStartedEvent | AgentDelegateFinishedEvent | AgentHandoffEvent | AgentStepFinishedEvent | AgentRunFinishedEvent | AgentRunErrorEvent | AgentRunPausedEvent | AgentRunResumedEvent;
-export interface AgentStreamResult {
-    eventStream: AsyncIterable<AgentEvent>;
-    partialObjectStream: AsyncIterable<PartialJsonValue>;
-    textStream: AsyncIterable<string>;
-    collect: () => Promise<AgentRunResult>;
-}
 //# sourceMappingURL=types.d.ts.map