@nuvin/agent-core 0.0.0-rc.0

package/dist/types-BueDJWnx.d.ts

@@ -0,0 +1,675 @@
+type JsonPrimitive = boolean | number | string | null;
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type JsonValue = JsonObject | JsonPrimitive | JsonValue[];
+type JsonSchemaType = "array" | "boolean" | "number" | "object" | "string";
+interface JsonSchemaString {
+    type: "string";
+}
+interface JsonSchemaNumber {
+    type: "number";
+}
+interface JsonSchemaBoolean {
+    type: "boolean";
+}
+interface JsonSchemaArray<TItem extends JsonSchema = JsonSchema> {
+    type: "array";
+    items: TItem;
+}
+interface JsonSchemaObject<TProperties extends Record<string, JsonSchema> = Record<string, JsonSchema>, TRequired extends readonly string[] | undefined = readonly string[] | undefined> {
+    type: "object";
+    properties: TProperties;
+    required?: TRequired;
+}
+type JsonSchema = JsonSchemaArray | JsonSchemaBoolean | JsonSchemaNumber | JsonSchemaObject | JsonSchemaString;
+interface TextBlock {
+    type: "text";
+    text: string;
+}
+interface AnthropicThinkingBlock {
+    type: "anthropic_thinking";
+    thinking: string;
+    signature: string;
+}
+interface AnthropicRedactedThinkingBlock {
+    type: "anthropic_redacted_thinking";
+    data: string;
+}
+interface OpenAiReasoningSummaryText {
+    type: "summary_text";
+    text: string;
+}
+interface OpenAiReasoningBlock {
+    type: "openai_reasoning";
+    encryptedContent?: string;
+    id?: string;
+    summary: OpenAiReasoningSummaryText[];
+    text?: string;
+}
+interface ToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: JsonValue;
+}
+interface ToolResultBlock {
+    type: "tool_result";
+    tool_use_id: string;
+    content: JsonValue | string;
+    is_error: boolean;
+}
+interface AnthropicThinkingWireBlock {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+}
+interface AnthropicRedactedThinkingWireBlock {
+    type: "redacted_thinking";
+    data: string;
+}
+type AnthropicAssistantContentBlock = AnthropicRedactedThinkingWireBlock | AnthropicThinkingWireBlock | TextBlock | ToolUseBlock;
+type ReasoningVisibility = "continuity-only" | "user-visible";
+type AutoReasoningEffort = "low" | "medium" | "high";
+interface AutoReasoningConfig {
+    effort: AutoReasoningEffort;
+}
+type AnthropicThinkingDisplay = "omitted" | "summarized";
+type AnthropicThinkingEffort = "low" | "medium" | "high";
+interface AnthropicEnabledThinkingConfig {
+    type: "enabled";
+    budgetTokens: number;
+    display?: AnthropicThinkingDisplay;
+    interleaved?: boolean;
+}
+interface AnthropicAdaptiveThinkingConfig {
+    type: "adaptive";
+    display?: AnthropicThinkingDisplay;
+    effort?: AnthropicThinkingEffort;
+    interleaved?: boolean;
+}
+interface AnthropicDisabledThinkingConfig {
+    type: "disabled";
+}
+type AnthropicThinkingConfig = AnthropicAdaptiveThinkingConfig | AnthropicDisabledThinkingConfig | AnthropicEnabledThinkingConfig;
+type OpenAiReasoningEffort = "high" | "low" | "medium" | "minimal" | "none" | "xhigh";
+type OpenAiReasoningSummary = "auto" | "concise" | "detailed";
+interface OpenAiReasoningConfig {
+    effort?: OpenAiReasoningEffort;
+    includeEncryptedContent?: boolean;
+    summary?: OpenAiReasoningSummary;
+}
+interface ReasoningConfig {
+    auto?: AutoReasoningConfig;
+    anthropic?: AnthropicThinkingConfig;
+    openai?: OpenAiReasoningConfig;
+    visibility?: ReasoningVisibility;
+}
+interface MessageProviderState {
+    anthropicAssistantContent?: AnthropicAssistantContentBlock[];
+    openaiResponsesOutput?: OpenAiResponsesOutputItem[];
+    openaiResponsesResponseId?: string;
+}
+type AssistantContentBlock = AnthropicRedactedThinkingBlock | AnthropicThinkingBlock | OpenAiReasoningBlock | TextBlock | ToolUseBlock;
+type ContentBlock = AssistantContentBlock | ToolResultBlock;
+type ContentInput = ContentBlock[] | string | null | undefined;
+type MessageRole = "assistant" | "user";
+type SystemInput = TextBlock[] | string | null | undefined;
+interface Message {
+    id?: string;
+    role: MessageRole;
+    content: ContentBlock[];
+    providerState?: MessageProviderState;
+}
+interface IdentifiedMessage extends Message {
+    id: string;
+}
+interface MessageInput {
+    id?: string;
+    role: MessageRole;
+    content?: ContentInput;
+    providerState?: MessageProviderState;
+}
+interface ToolSchema {
+    name: string;
+    description: string;
+    input_schema: JsonSchemaObject;
+}
+interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens?: number;
+}
+interface ModelRequest {
+    model: string;
+    max_tokens: number;
+    reasoning?: ReasoningConfig;
+    system: TextBlock[];
+    messages: Message[];
+    tools: ToolSchema[];
+    metadata: {
+        session_id: string;
+        turn_id: string;
+    };
+}
+interface ModelResponse {
+    id: string;
+    type: "message";
+    role: "assistant";
+    content: AssistantContentBlock[];
+    stop_reason: "end_turn" | "tool_use";
+    stop_sequence: null | string;
+    usage: Usage;
+    providerState?: MessageProviderState;
+}
+interface ChatRequest {
+    model: string;
+    maxTokens: number;
+    reasoning?: ReasoningConfig;
+    system: TextBlock[];
+    messages: Message[];
+    tools: ToolSchema[];
+    metadata: {
+        sessionId: string;
+        turnId: string;
+    };
+}
+interface ChatResponse {
+    id: string;
+    content: AssistantContentBlock[];
+    stopReason: "end_turn" | "tool_use";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens?: number;
+    };
+    providerState?: MessageProviderState;
+}
+interface ContentDeltaChunk {
+    type: "content_delta";
+    index?: number;
+    text?: string;
+}
+interface ToolUseDeltaChunk {
+    type: "tool_use_delta";
+    id: string;
+    index: number;
+    inputDelta?: string;
+    name?: string;
+}
+interface AnthropicThinkingDeltaChunk {
+    type: "anthropic_thinking_delta";
+    index: number;
+    thinking: string;
+}
+interface AnthropicSignatureDeltaChunk {
+    type: "anthropic_signature_delta";
+    index: number;
+    signature: string;
+}
+interface OpenAiReasoningDeltaChunk {
+    type: "openai_reasoning_delta";
+    contentIndex: number;
+    delta: string;
+    itemId: string;
+    outputIndex: number;
+}
+interface OpenAiReasoningSummaryDeltaChunk {
+    type: "openai_reasoning_summary_delta";
+    delta: string;
+    itemId: string;
+    outputIndex: number;
+    summaryIndex: number;
+}
+interface ChatResponseChunk {
+    type: "anthropic_signature_delta" | "anthropic_thinking_delta" | "content_delta" | "done" | "openai_reasoning_delta" | "openai_reasoning_summary_delta" | "tool_use_delta";
+    contentIndex?: number;
+    delta?: string;
+    index?: number;
+    itemId?: string;
+    outputIndex?: number;
+    signature?: string;
+    summaryIndex?: number;
+    text?: string;
+    thinking?: string;
+    inputDelta?: string;
+    name?: string;
+    id?: string;
+    response?: ChatResponse;
+}
+interface ModelLimits {
+    contextWindow?: number;
+    maxOutput?: number;
+}
+interface ModelInfo {
+    id: string;
+    name: string;
+    limits?: ModelLimits;
+    supportedEndpoints?: string[];
+}
+interface ToolResultMeta {
+    truncated?: boolean;
+    originalBytes?: number;
+    transforms: string[];
+}
+interface ToolResultChunk {
+    output: string;
+    structured: JsonObject;
+}
+interface ToolOutputEnvelope {
+    output: string;
+    structured?: JsonObject;
+}
+interface ToolResult {
+    callId: string;
+    toolName: string;
+    status: "error" | "ok";
+    output: string;
+    structured: JsonObject;
+    chunks: ToolResultChunk[];
+    meta: ToolResultMeta;
+}
+interface TurnInput {
+    sessionId: string;
+    turnId: string;
+    streaming?: boolean;
+    signal?: AbortSignal;
+    system?: SystemInput;
+    messages?: MessageInput[];
+    message: MessageInput;
+}
+interface TurnState {
+    sessionId: string;
+    turnId: string;
+    system: TextBlock[];
+    messages: Message[];
+    lastResponse?: ChatResponse;
+    toolResults: ToolResult[];
+    finalMessage?: IdentifiedMessage;
+}
+type TurnResultStatus = "completed" | "aborted";
+interface TurnResult {
+    status: TurnResultStatus;
+    finalMessage?: IdentifiedMessage;
+    state: TurnState;
+}
+type ProviderCredentialKind = "api-key" | "oauth-token" | "session-token";
+interface ProviderCredential {
+    kind: ProviderCredentialKind;
+    value: string;
+}
+interface ProviderEndpoints {
+    api?: string;
+    originTracker?: string;
+    proxy?: string;
+    telemetry?: string;
+}
+interface ResolvedProviderSession {
+    credential: ProviderCredential;
+    endpoints?: ProviderEndpoints;
+    metadata?: Record<string, string>;
+}
+interface ProviderSessionResolver {
+    resolve(signal?: AbortSignal): Promise<ResolvedProviderSession>;
+}
+interface PrepareRequestInput {
+    sessionId: string;
+    turnId: string;
+    reasoning?: ReasoningConfig;
+    system: TextBlock[];
+    messages: Message[];
+    tools: ToolSchema[];
+    maxTokens?: number;
+}
+interface PreparedRequest {
+    request: ModelRequest;
+    session?: ResolvedProviderSession;
+}
+type ProviderRequestMutator = (preparedRequest: PreparedRequest) => PreparedRequest | Promise<PreparedRequest>;
+interface ChatModel {
+    prepareRequest(request: PrepareRequestInput): ModelRequest;
+    complete(request: ModelRequest): Promise<ModelResponse>;
+}
+interface ModelExecutionOptions {
+    signal?: AbortSignal;
+}
+interface EngineChatModel {
+    model: string;
+    maxTokens?: number;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream?(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    getModels?(signal?: AbortSignal): Promise<ModelInfo[]>;
+}
+interface BaseChatModelOptions {
+    model: string;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+}
+interface AgentEventContext {
+    sessionId: string;
+    turnId: string;
+    state: TurnState;
+}
+interface ToolExecutionContext extends AgentEventContext {
+    signal: AbortSignal;
+    toolCallId?: string;
+}
+interface ToolRuntimeStartedEvent {
+    type: "tool_started";
+    toolCall: ToolUseBlock;
+}
+interface ToolRuntimeOutputChunkEvent {
+    type: "tool_output_chunk";
+    toolCall: ToolUseBlock;
+    chunk: ToolResultChunk;
+}
+interface ToolRuntimeCompletedEvent {
+    type: "tool_completed";
+    toolCall: ToolUseBlock;
+    result: ToolResult;
+}
+interface ToolRuntimeRejectedEvent {
+    type: "tool_rejected";
+    toolCall: ToolUseBlock;
+    result: ToolResult;
+}
+type ToolRuntimeEvent = ToolRuntimeOutputChunkEvent | ToolRuntimeCompletedEvent | ToolRuntimeRejectedEvent | ToolRuntimeStartedEvent;
+interface AgentUserMessageEvent {
+    type: "user_message";
+    message: Message;
+}
+interface AgentModelRequestEvent {
+    type: "model_request";
+    request: ChatRequest;
+}
+interface AgentModelResponseEvent {
+    type: "model_response";
+    response: ChatResponse;
+}
+interface AgentAssistantMessageEvent {
+    type: "assistant_message";
+    message: IdentifiedMessage;
+}
+interface AgentAssistantChunkEvent {
+    type: "assistant_chunk";
+    index: number;
+    messageId: string;
+    chunk: ContentDeltaChunk;
+}
+interface AgentToolUseMessageEvent {
+    type: "tool_use_message";
+    message: IdentifiedMessage;
+}
+interface AgentToolUseChunkEvent {
+    type: "tool_use_chunk";
+    index: number;
+    messageId: string;
+    chunk: ToolUseDeltaChunk;
+}
+interface AgentReasoningMessageEvent {
+    type: "reasoning_message";
+    message: IdentifiedMessage;
+}
+interface AgentReasoningChunkEvent {
+    type: "reasoning_chunk";
+    index: number;
+    messageId: string;
+    chunk: AnthropicThinkingDeltaChunk | OpenAiReasoningDeltaChunk | OpenAiReasoningSummaryDeltaChunk;
+    text: string;
+}
+interface AgentToolCallEvent {
+    type: "tool_call";
+    toolCall: ToolUseBlock;
+}
+interface AgentToolResultEvent {
+    type: "tool_result";
+    result: ToolResult;
+}
+interface AgentToolResultMessageEvent {
+    type: "tool_result_message";
+    message: Message;
+}
+interface AgentFinalMessageEvent {
+    type: "final_message";
+    message: IdentifiedMessage;
+}
+interface AgentTurnCompleteEvent {
+    type: "turn_complete";
+    state: TurnState;
+}
+type AgentLifecycleEvent = AgentAssistantChunkEvent | AgentAssistantMessageEvent | AgentFinalMessageEvent | AgentModelRequestEvent | AgentModelResponseEvent | AgentReasoningChunkEvent | AgentReasoningMessageEvent | AgentToolCallEvent | AgentToolUseChunkEvent | AgentToolUseMessageEvent | AgentToolResultEvent | AgentToolResultMessageEvent | AgentTurnCompleteEvent | AgentUserMessageEvent;
+type AgentEvent = AgentLifecycleEvent | ToolRuntimeEvent;
+type ToolRuntimeDispatchDecision = {
+    action: "reject";
+    reason?: string;
+} | {
+    action: "run";
+};
+type ToolRuntimeToolCallHandler = (toolCall: ToolUseBlock, ctx: ToolExecutionContext) => Promise<ToolRuntimeDispatchDecision | undefined> | ToolRuntimeDispatchDecision | undefined;
+type ToolRuntimeEventHandler = (event: ToolRuntimeEvent, ctx: ToolExecutionContext) => Promise<void> | void;
+type AgentEventHandler = (event: AgentEvent, ctx: AgentEventContext) => Promise<void> | void;
+interface ToolRuntime {
+    listToolSchemas(): ToolSchema[];
+    executeCalls(toolCalls: ToolUseBlock[], ctx: ToolExecutionContext): Promise<ToolResult[]>;
+    execute(toolCall: ToolUseBlock, ctx: ToolExecutionContext): Promise<ToolResult>;
+}
+type InferJsonSchema<TSchema extends JsonSchema> = TSchema extends JsonSchemaString ? string : TSchema extends JsonSchemaNumber ? number : TSchema extends JsonSchemaBoolean ? boolean : TSchema extends JsonSchemaArray<infer TItem> ? InferJsonSchema<TItem>[] : TSchema extends JsonSchemaObject<infer TProperties, infer TRequired> ? Expand<RequiredProperties<TProperties, TRequired> & OptionalProperties<TProperties, TRequired>> : never;
+type Expand<TValue> = TValue extends infer TObject ? {
+    [TKey in keyof TObject]: TObject[TKey];
+} : never;
+type RequiredKeyUnion<TRequired extends readonly string[] | undefined> = TRequired extends readonly string[] ? TRequired[number] : never;
+type OptionalKeyUnion<TProperties extends Record<string, JsonSchema>, TRequired extends readonly string[] | undefined> = Exclude<keyof TProperties, RequiredKeyUnion<TRequired>>;
+type RequiredProperties<TProperties extends Record<string, JsonSchema>, TRequired extends readonly string[] | undefined> = {
+    [TKey in Extract<keyof TProperties, RequiredKeyUnion<TRequired>>]: InferJsonSchema<TProperties[TKey]>;
+};
+type OptionalProperties<TProperties extends Record<string, JsonSchema>, TRequired extends readonly string[] | undefined> = {
+    [TKey in OptionalKeyUnion<TProperties, TRequired>]?: InferJsonSchema<TProperties[TKey]>;
+};
+type ToolOutputValue = JsonValue | ToolOutputEnvelope;
+type ToolGenerator<TYield extends ToolOutputValue = ToolOutputValue, TReturn extends ToolOutputValue | undefined = ToolOutputValue | undefined> = AsyncGenerator<TYield, TReturn, void>;
+interface ToolDefinition<TInput extends JsonObject = JsonObject, TYield extends ToolOutputValue = ToolOutputValue, TReturn extends ToolOutputValue | undefined = ToolOutputValue | undefined, TSchema extends JsonSchemaObject = JsonSchemaObject> {
+    name: string;
+    description: string;
+    inputSchema: TSchema;
+    execute(input: TInput, ctx: ToolExecutionContext): ToolGenerator<TYield, TReturn>;
+}
+type AnyToolDefinition = ToolDefinition<JsonObject, ToolOutputValue, ToolOutputValue | undefined, JsonSchemaObject>;
+type Stage = "afterModelResponse" | "afterToolResult" | "afterTurnComplete" | "beforeAssistantAppend" | "beforeFinalOutput" | "beforeModelRequest" | "beforeToolExecution" | "beforeToolResultAppend" | "onUserMessage";
+interface PayloadByStage {
+    onUserMessage: Message;
+    beforeModelRequest: ChatRequest;
+    afterModelResponse: ChatResponse;
+    beforeToolExecution: ToolUseBlock;
+    afterToolResult: ToolResult;
+    beforeAssistantAppend: Message;
+    beforeFinalOutput: Message;
+    beforeToolResultAppend: Message;
+    afterTurnComplete: TurnState;
+}
+interface ExtensionContext {
+    state: TurnState;
+}
+type Transformer<S extends Stage> = (payload: PayloadByStage[S], ctx: ExtensionContext) => PayloadByStage[S] | Promise<PayloadByStage[S]>;
+type Observer<S extends Stage> = (payload: PayloadByStage[S], ctx: ExtensionContext) => Promise<void> | void;
+interface TransformerExtensionRegistration<S extends Stage = Stage> {
+    id: string;
+    stage: S;
+    kind: "transformer";
+    order: number;
+    enabled: boolean;
+    run: Transformer<S>;
+}
+interface ObserverExtensionRegistration<S extends Stage = Stage> {
+    id: string;
+    stage: S;
+    kind: "observer";
+    order: number;
+    enabled: boolean;
+    run: Observer<S>;
+}
+type ExtensionRegistration<S extends Stage = Stage> = ObserverExtensionRegistration<S> | TransformerExtensionRegistration<S>;
+type AnyExtensionRegistration = {
+    [S in Stage]: ExtensionRegistration<S>;
+}[Stage];
+interface ExtensionRegistry {
+    register(extension: AnyExtensionRegistration): void;
+    runTransformers<S extends Stage>(stage: S, payload: PayloadByStage[S], ctx: ExtensionContext): Promise<PayloadByStage[S]>;
+    runObservers<S extends Stage>(stage: S, payload: PayloadByStage[S], ctx: ExtensionContext): Promise<void>;
+}
+interface RunTurnDeps {
+    registry: ExtensionRegistry;
+    chatModel: EngineChatModel;
+    toolRuntime: ToolRuntime;
+    onEvent?: AgentEventHandler;
+}
+type AgentInput = MessageInput | string;
+interface AgentSendOptions {
+    streaming?: boolean;
+    signal?: AbortSignal;
+}
+interface AgentOptions {
+    sessionId?: string;
+    systemPrompt?: string;
+    messages?: MessageInput[];
+    message?: AgentInput;
+    onEvent?: AgentEventHandler;
+    onToolCall?: ToolRuntimeToolCallHandler;
+    registry?: ExtensionRegistry;
+    extensions?: AnyExtensionRegistration[];
+    chatModel?: EngineChatModel;
+    tools?: AnyToolDefinition[];
+}
+interface AgentDefinitionFactoryContext {
+    agentId: string;
+    parentSessionId?: string;
+    runId?: string;
+    toolCallId?: string;
+}
+interface AgentDefinition {
+    id: string;
+    description?: string;
+    enabled?: boolean;
+    allowedChildAgentIds?: string[];
+    createOptions(ctx?: AgentDefinitionFactoryContext): AgentOptions;
+}
+type ManagedRunStatus = "aborted" | "completed" | "failed" | "idle" | "running";
+interface ManagedRunError {
+    message: string;
+}
+interface ManagedAgentRun {
+    runId: string;
+    agentId: string;
+    sessionId: string;
+    status: ManagedRunStatus;
+    depth: number;
+    parentRunId?: string;
+    originToolCallId?: string;
+    result?: TurnResult;
+    error?: ManagedRunError;
+}
+interface ManagedAgentRunHandle {
+    readonly runId: string;
+    readonly agentId: string;
+    readonly sessionId: string;
+    send(input: AgentInput, options?: AgentSendOptions): Promise<TurnResult>;
+    snapshot(): ManagedAgentRun;
+    wait(signal?: AbortSignal): Promise<ManagedAgentRun>;
+}
+interface ManagedRunEvent {
+    runId: string;
+    agentId: string;
+    sessionId: string;
+    parentRunId?: string;
+    originToolCallId?: string;
+    event: AgentEvent;
+}
+type ManagedRunEventHandler = (event: ManagedRunEvent) => Promise<void> | void;
+interface RuntimeManagerOptions {
+    onEvent?: ManagedRunEventHandler;
+}
+interface CreateManagedRunInput {
+    agentId: string;
+    parentRunId?: string;
+    originToolCallId?: string;
+}
+interface CompileRequestInput {
+    sessionId: string;
+    turnId: string;
+    reasoning?: ReasoningConfig;
+    system?: SystemInput;
+    messages: MessageInput[];
+    tools?: ToolSchema[];
+    model?: string;
+    max_tokens?: number;
+}
+interface OpenAiInputText {
+    type: "input_text";
+    text: string;
+}
+interface OpenAiInputMessage {
+    type: "message";
+    role: MessageRole;
+    content: OpenAiInputText[];
+}
+interface OpenAiFunctionCall {
+    type: "function_call";
+    call_id: string;
+    name: string;
+    arguments: string;
+}
+interface OpenAiFunctionCallOutput {
+    type: "function_call_output";
+    call_id: string;
+    output: string;
+}
+interface OpenAiOutputTextPart {
+    type: "output_text";
+    text: string;
+}
+interface OpenAiRefusalPart {
+    type: "refusal";
+    refusal: string;
+}
+interface OpenAiOutputMessage {
+    type: "message";
+    content?: Array<OpenAiOutputTextPart | OpenAiRefusalPart>;
+    role?: string;
+    status?: string;
+}
+interface OpenAiReasoningOutputItem {
+    type: "reasoning";
+    content?: Array<{
+        text?: string;
+        type?: string;
+    }>;
+    encrypted_content?: string;
+    id?: string;
+    status?: string;
+    summary?: OpenAiReasoningSummaryText[];
+    text?: string;
+}
+type OpenAiResponsesOutputItem = JsonObject | OpenAiFunctionCall | OpenAiOutputMessage | OpenAiReasoningOutputItem;
+interface OpenAiResponsesReasoningParam {
+    effort?: OpenAiReasoningEffort;
+    generate_summary?: OpenAiReasoningSummary;
+    summary?: OpenAiReasoningSummary;
+}
+interface OpenAiFunctionTool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: JsonSchemaObject;
+}
+interface OpenAiResponsesRequest {
+    include?: string[];
+    model: string;
+    instructions: string;
+    input: Array<OpenAiFunctionCall | OpenAiFunctionCallOutput | OpenAiInputMessage | OpenAiResponsesOutputItem>;
+    max_output_tokens?: number;
+    reasoning?: OpenAiResponsesReasoningParam;
+    tools: OpenAiFunctionTool[];
+}
+
+export type { AnthropicThinkingWireBlock as $, AgentOptions as A, BaseChatModelOptions as B, ContentInput as C, AutoReasoningEffort as D, ExtensionRegistry as E, AnthropicThinkingConfig as F, OpenAiReasoningConfig as G, JsonObject as H, JsonValue as I, JsonPrimitive as J, JsonSchemaType as K, JsonSchemaString as L, Message as M, JsonSchemaNumber as N, OpenAiResponsesRequest as O, ProviderSessionResolver as P, JsonSchemaBoolean as Q, RunTurnDeps as R, SystemInput as S, TurnResult as T, JsonSchemaArray as U, JsonSchemaObject as V, JsonSchema as W, AnthropicThinkingBlock as X, AnthropicRedactedThinkingBlock as Y, OpenAiReasoningSummaryText as Z, OpenAiReasoningBlock as _, AgentInput as a, Stage as a$, AnthropicRedactedThinkingWireBlock as a0, AnthropicAssistantContentBlock as a1, ReasoningVisibility as a2, AutoReasoningConfig as a3, AnthropicThinkingDisplay as a4, AnthropicThinkingEffort as a5, AnthropicEnabledThinkingConfig as a6, AnthropicAdaptiveThinkingConfig as a7, AnthropicDisabledThinkingConfig as a8, OpenAiReasoningEffort as a9, ToolRuntimeEvent as aA, AgentUserMessageEvent as aB, AgentModelRequestEvent as aC, AgentModelResponseEvent as aD, AgentAssistantMessageEvent as aE, AgentAssistantChunkEvent as aF, AgentToolUseMessageEvent as aG, AgentToolUseChunkEvent as aH, AgentReasoningMessageEvent as aI, AgentReasoningChunkEvent as aJ, AgentToolCallEvent as aK, AgentToolResultEvent as aL, AgentToolResultMessageEvent as aM, AgentFinalMessageEvent as aN, AgentTurnCompleteEvent as aO, AgentLifecycleEvent as aP, AgentEvent as aQ, ToolRuntimeDispatchDecision as aR, ToolRuntimeToolCallHandler as aS, ToolRuntimeEventHandler as aT, AgentEventHandler as aU, ToolRuntime as aV, InferJsonSchema as aW, ToolOutputValue as aX, ToolGenerator as aY, ToolDefinition as aZ, AnyToolDefinition as a_, OpenAiReasoningSummary as aa, MessageProviderState as ab, AssistantContentBlock as ac, MessageRole as ad, IdentifiedMessage as ae, ToolSchema as af, Usage as ag, ContentDeltaChunk as ah, ToolUseDeltaChunk as ai, AnthropicThinkingDeltaChunk as aj, AnthropicSignatureDeltaChunk as ak, OpenAiReasoningDeltaChunk as al, OpenAiReasoningSummaryDeltaChunk as am, ModelLimits as an, ToolResultMeta as ao, ToolResultChunk as ap, ToolOutputEnvelope as aq, TurnResultStatus as ar, PrepareRequestInput as as, ChatModel as at, AgentEventContext as au, ToolExecutionContext as av, ToolRuntimeStartedEvent as aw, ToolRuntimeOutputChunkEvent as ax, ToolRuntimeCompletedEvent as ay, ToolRuntimeRejectedEvent as az, AgentSendOptions as b, PayloadByStage as b0, ExtensionContext as b1, Transformer as b2, Observer as b3, TransformerExtensionRegistration as b4, ObserverExtensionRegistration as b5, ExtensionRegistration as b6, AnyExtensionRegistration as b7, AgentDefinitionFactoryContext as b8, AgentDefinition as b9, ManagedRunStatus as ba, ManagedRunError as bb, ManagedAgentRun as bc, ManagedAgentRunHandle as bd, ManagedRunEvent as be, ManagedRunEventHandler as bf, RuntimeManagerOptions as bg, CreateManagedRunInput as bh, OpenAiInputText as bi, OpenAiInputMessage as bj, OpenAiFunctionCall as bk, OpenAiFunctionCallOutput as bl, OpenAiOutputTextPart as bm, OpenAiRefusalPart as bn, OpenAiOutputMessage as bo, OpenAiReasoningOutputItem as bp, OpenAiResponsesOutputItem as bq, OpenAiResponsesReasoningParam as br, OpenAiFunctionTool as bs, TurnInput as c, TurnState as d, TextBlock as e, ContentBlock as f, MessageInput as g, CompileRequestInput as h, ModelRequest as i, ChatRequest as j, ModelResponse as k, ChatResponse as l, ToolUseBlock as m, ToolResultBlock as n, ToolResult as o, ResolvedProviderSession as p, ProviderRequestMutator as q, PreparedRequest as r, ProviderCredential as s, EngineChatModel as t, ReasoningConfig as u, ChatResponseChunk as v, ModelExecutionOptions as w, ModelInfo as x, ProviderCredentialKind as y, ProviderEndpoints as z };