@nuvin/agent-core 0.0.0-rc.18 → 0.0.0-rc.19

package/dist/{types-11Znykt2.d.ts → shared/types.d.ts}

@@ -1,34 +1,34 @@
-type JsonPrimitive = boolean | number | string | null;
-interface JsonObject {
+export type JsonPrimitive = boolean | number | string | null;
+export interface JsonObject {
     [key: string]: JsonValue;
 }
-type JsonValue = JsonObject | JsonPrimitive | JsonValue[];
-type JsonSchemaType = "array" | "boolean" | "number" | "object" | "string";
-interface JsonSchemaString {
+export type JsonValue = JsonObject | JsonPrimitive | JsonValue[];
+export type JsonSchemaType = "array" | "boolean" | "number" | "object" | "string";
+export interface JsonSchemaString {
     type: "string";
 }
-interface JsonSchemaNumber {
+export interface JsonSchemaNumber {
     type: "number";
 }
-interface JsonSchemaBoolean {
+export interface JsonSchemaBoolean {
     type: "boolean";
 }
-interface JsonSchemaArray<TItem extends JsonSchema = JsonSchema> {
+export 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> {
+export 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 {
+export type JsonSchema = JsonSchemaArray | JsonSchemaBoolean | JsonSchemaNumber | JsonSchemaObject | JsonSchemaString;
+export interface TextBlock {
     type: "text";
     text: string;
 }
-type ImageMediaType = "image/gif" | "image/jpeg" | "image/png" | "image/webp";
-interface ImageBlock {
+export type ImageMediaType = "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+export interface ImageBlock {
     type: "image";
     source: {
         type: "base64";
@@ -36,128 +36,128 @@ interface ImageBlock {
         data: string;
     };
 }
-type ToolResultContentBlock = ImageBlock | TextBlock;
-type ToolResultContent = string | ToolResultContentBlock[];
-interface AnthropicThinkingBlock {
+export type ToolResultContentBlock = ImageBlock | TextBlock;
+export type ToolResultContent = string | ToolResultContentBlock[];
+export interface AnthropicThinkingBlock {
     type: "anthropic_thinking";
     thinking: string;
     signature: string;
 }
-interface AnthropicRedactedThinkingBlock {
+export interface AnthropicRedactedThinkingBlock {
     type: "anthropic_redacted_thinking";
     data: string;
 }
-interface OpenAiReasoningSummaryText {
+export interface OpenAiReasoningSummaryText {
     type: "summary_text";
     text: string;
 }
-interface OpenAiReasoningBlock {
+export interface OpenAiReasoningBlock {
     type: "openai_reasoning";
     encryptedContent?: string;
     id?: string;
     summary: OpenAiReasoningSummaryText[];
     text?: string;
 }
-interface ToolUseBlock {
+export interface ToolUseBlock {
     type: "tool_use";
     id: string;
     name: string;
     input: JsonValue;
 }
-interface ToolResultBlock {
+export interface ToolResultBlock {
     type: "tool_result";
     tool_use_id: string;
     content: ToolResultContent;
     is_error: boolean;
 }
-interface AnthropicThinkingWireBlock {
+export interface AnthropicThinkingWireBlock {
     type: "thinking";
     thinking: string;
     signature: string;
 }
-interface AnthropicRedactedThinkingWireBlock {
+export 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 {
+export type AnthropicAssistantContentBlock = AnthropicRedactedThinkingWireBlock | AnthropicThinkingWireBlock | TextBlock | ToolUseBlock;
+export type ReasoningVisibility = "continuity-only" | "user-visible";
+export type AutoReasoningEffort = "low" | "medium" | "high";
+export interface AutoReasoningConfig {
     effort: AutoReasoningEffort;
 }
-type AnthropicThinkingDisplay = "omitted" | "summarized";
-type AnthropicThinkingEffort = "low" | "medium" | "high";
-interface AnthropicEnabledThinkingConfig {
+export type AnthropicThinkingDisplay = "omitted" | "summarized";
+export type AnthropicThinkingEffort = "low" | "medium" | "high";
+export interface AnthropicEnabledThinkingConfig {
     type: "enabled";
     budgetTokens: number;
     display?: AnthropicThinkingDisplay;
     interleaved?: boolean;
 }
-interface AnthropicAdaptiveThinkingConfig {
+export interface AnthropicAdaptiveThinkingConfig {
     type: "adaptive";
     display?: AnthropicThinkingDisplay;
     effort?: AnthropicThinkingEffort;
     interleaved?: boolean;
 }
-interface AnthropicDisabledThinkingConfig {
+export interface AnthropicDisabledThinkingConfig {
     type: "disabled";
 }
-type AnthropicThinkingConfig = AnthropicAdaptiveThinkingConfig | AnthropicDisabledThinkingConfig | AnthropicEnabledThinkingConfig;
-type OpenAiReasoningEffort = "high" | "low" | "medium" | "minimal" | "none" | "xhigh";
-type OpenAiReasoningSummary = "auto" | "concise" | "detailed";
-interface OpenAiReasoningConfig {
+export type AnthropicThinkingConfig = AnthropicAdaptiveThinkingConfig | AnthropicDisabledThinkingConfig | AnthropicEnabledThinkingConfig;
+export type OpenAiReasoningEffort = "high" | "low" | "medium" | "minimal" | "none" | "xhigh";
+export type OpenAiReasoningSummary = "auto" | "concise" | "detailed";
+export interface OpenAiReasoningConfig {
     effort?: OpenAiReasoningEffort;
     includeEncryptedContent?: boolean;
     summary?: OpenAiReasoningSummary;
 }
-interface ReasoningConfig {
+export interface ReasoningConfig {
     auto?: AutoReasoningConfig;
     anthropic?: AnthropicThinkingConfig;
     openai?: OpenAiReasoningConfig;
     visibility?: ReasoningVisibility;
 }
-interface MessageProviderState {
+export interface MessageProviderState {
     anthropicAssistantContent?: AnthropicAssistantContentBlock[];
     openaiResponsesOutput?: OpenAiResponsesOutputItem[];
     openaiResponsesResponseId?: string;
 }
-type AssistantContentBlock = AnthropicRedactedThinkingBlock | AnthropicThinkingBlock | OpenAiReasoningBlock | TextBlock | ToolUseBlock;
-type ContentBlock = AssistantContentBlock | ImageBlock | ToolResultBlock;
-type ContentInput = ContentBlock[] | string | null | undefined;
-type MessageRole = "assistant" | "user";
-type SystemInput = TextBlock[] | string | null | undefined;
-interface Message {
+export type AssistantContentBlock = AnthropicRedactedThinkingBlock | AnthropicThinkingBlock | OpenAiReasoningBlock | TextBlock | ToolUseBlock;
+export type ContentBlock = AssistantContentBlock | ImageBlock | ToolResultBlock;
+export type ContentInput = ContentBlock[] | string | null | undefined;
+export type MessageRole = "assistant" | "user";
+export type SystemInput = TextBlock[] | string | null | undefined;
+export interface Message {
     id?: string;
     role: MessageRole;
     content: ContentBlock[];
     providerState?: MessageProviderState;
 }
-interface IdentifiedMessage extends Message {
+export interface IdentifiedMessage extends Message {
     id: string;
 }
-interface MessageInput {
+export interface MessageInput {
     id?: string;
     role: MessageRole;
     content?: ContentInput;
     providerState?: MessageProviderState;
 }
-interface ToolSchema {
+export interface ToolSchema {
     name: string;
     description: string;
     input_schema: JsonSchemaObject;
 }
-interface Usage {
+export interface Usage {
     input_tokens: number;
     output_tokens: number;
     reasoning_tokens?: number;
 }
-interface OutputFormat {
+export interface OutputFormat {
     type: "json_schema";
     name?: string;
     schema: JsonSchemaObject;
     strict?: boolean;
 }
-interface ModelRequest {
+export interface ModelRequest {
     model: string;
     max_tokens: number;
     reasoning?: ReasoningConfig;
@@ -170,7 +170,7 @@ interface ModelRequest {
     };
     outputFormat?: OutputFormat;
 }
-interface ModelResponse {
+export interface ModelResponse {
     id: string;
     type: "message";
     role: "assistant";
@@ -180,7 +180,7 @@ interface ModelResponse {
     usage: Usage;
     providerState?: MessageProviderState;
 }
-interface ChatRequest {
+export interface ChatRequest {
     model: string;
     maxTokens: number;
     reasoning?: ReasoningConfig;
@@ -193,7 +193,7 @@ interface ChatRequest {
     };
     outputFormat?: OutputFormat;
 }
-interface ChatResponse {
+export interface ChatResponse {
     id: string;
     content: AssistantContentBlock[];
     stopReason: "end_turn" | "tool_use";
@@ -206,43 +206,43 @@ interface ChatResponse {
     };
     providerState?: MessageProviderState;
 }
-interface ContentDeltaChunk {
+export interface ContentDeltaChunk {
     type: "content_delta";
     index?: number;
     text?: string;
 }
-interface ToolUseDeltaChunk {
+export interface ToolUseDeltaChunk {
     type: "tool_use_delta";
     id: string;
     index: number;
     inputDelta?: string;
     name?: string;
 }
-interface AnthropicThinkingDeltaChunk {
+export interface AnthropicThinkingDeltaChunk {
     type: "anthropic_thinking_delta";
     index: number;
     thinking: string;
 }
-interface AnthropicSignatureDeltaChunk {
+export interface AnthropicSignatureDeltaChunk {
     type: "anthropic_signature_delta";
     index: number;
     signature: string;
 }
-interface OpenAiReasoningDeltaChunk {
+export interface OpenAiReasoningDeltaChunk {
     type: "openai_reasoning_delta";
     contentIndex: number;
     delta: string;
     itemId: string;
     outputIndex: number;
 }
-interface OpenAiReasoningSummaryDeltaChunk {
+export interface OpenAiReasoningSummaryDeltaChunk {
     type: "openai_reasoning_summary_delta";
     delta: string;
     itemId: string;
     outputIndex: number;
     summaryIndex: number;
 }
-interface ProviderRetryChunk {
+export interface ProviderRetryChunk {
     type: "provider_retry";
     attempt: number;
     maxAttempts: number;
@@ -251,37 +251,37 @@ interface ProviderRetryChunk {
     reason: "http_status" | "stream_error" | "transport_error";
     status?: number;
 }
-interface DoneChunk {
+export interface DoneChunk {
     type: "done";
     response: ChatResponse;
 }
-type ChatResponseChunk = AnthropicSignatureDeltaChunk | AnthropicThinkingDeltaChunk | ContentDeltaChunk | DoneChunk | OpenAiReasoningDeltaChunk | OpenAiReasoningSummaryDeltaChunk | ProviderRetryChunk | ToolUseDeltaChunk;
-interface ModelLimits {
+export type ChatResponseChunk = AnthropicSignatureDeltaChunk | AnthropicThinkingDeltaChunk | ContentDeltaChunk | DoneChunk | OpenAiReasoningDeltaChunk | OpenAiReasoningSummaryDeltaChunk | ProviderRetryChunk | ToolUseDeltaChunk;
+export interface ModelLimits {
     contextWindow?: number;
     maxOutput?: number;
 }
-interface ModelInfo {
+export interface ModelInfo {
     id: string;
     name: string;
     limits?: ModelLimits;
     supportedEndpoints?: string[];
 }
-interface ToolResultMeta {
+export interface ToolResultMeta {
     truncated?: boolean;
     originalBytes?: number;
     transforms: string[];
 }
-interface ToolResultChunk {
+export interface ToolResultChunk {
     output: string;
     structured: JsonObject;
     content?: ToolResultContent;
 }
-interface ToolOutputEnvelope {
+export interface ToolOutputEnvelope {
     output: string;
     structured?: JsonObject;
     content?: ToolResultContent;
 }
-interface ToolResult {
+export interface ToolResult {
     callId: string;
     toolName: string;
     status: "error" | "ok";
@@ -291,7 +291,7 @@ interface ToolResult {
     chunks: ToolResultChunk[];
     meta: ToolResultMeta;
 }
-interface TurnInput {
+export interface TurnInput {
     sessionId: string;
     turnId: string;
     streaming?: boolean;
@@ -300,7 +300,7 @@ interface TurnInput {
     messages?: MessageInput[];
     message: MessageInput;
 }
-interface TurnState {
+export interface TurnState {
     sessionId: string;
     turnId: string;
     system: TextBlock[];
@@ -310,32 +310,32 @@ interface TurnState {
     finalMessage?: IdentifiedMessage;
     sessionDir?: string;
 }
-type TurnResultStatus = "completed" | "aborted";
-interface TurnResult {
+export type TurnResultStatus = "completed" | "aborted";
+export interface TurnResult {
     status: TurnResultStatus;
     finalMessage?: IdentifiedMessage;
     state: TurnState;
 }
-type ProviderCredentialKind = "api-key" | "oauth-token" | "session-token";
-interface ProviderCredential {
+export type ProviderCredentialKind = "api-key" | "oauth-token" | "session-token";
+export interface ProviderCredential {
     kind: ProviderCredentialKind;
     value: string;
 }
-interface ProviderEndpoints {
+export interface ProviderEndpoints {
     api?: string;
     originTracker?: string;
     proxy?: string;
     telemetry?: string;
 }
-interface ResolvedProviderSession {
+export interface ResolvedProviderSession {
     credential: ProviderCredential;
     endpoints?: ProviderEndpoints;
     metadata?: Record<string, string>;
 }
-interface ProviderSessionResolver {
+export interface ProviderSessionResolver {
     resolve(signal?: AbortSignal): Promise<ResolvedProviderSession>;
 }
-interface PrepareRequestInput {
+export interface PrepareRequestInput {
     sessionId: string;
     turnId: string;
     reasoning?: ReasoningConfig;
@@ -344,162 +344,162 @@ interface PrepareRequestInput {
     tools: ToolSchema[];
     maxTokens?: number;
 }
-interface PreparedRequest {
+export interface PreparedRequest {
     request: ModelRequest;
     session?: ResolvedProviderSession;
 }
-type ProviderRequestMutator = (preparedRequest: PreparedRequest) => PreparedRequest | Promise<PreparedRequest>;
-interface ChatModel {
+export type ProviderRequestMutator = (preparedRequest: PreparedRequest) => PreparedRequest | Promise<PreparedRequest>;
+export interface ChatModel {
     prepareRequest(request: PrepareRequestInput): ModelRequest;
     complete(request: ModelRequest): Promise<ModelResponse>;
 }
-interface ModelExecutionOptions {
+export interface ModelExecutionOptions {
     signal?: AbortSignal;
 }
-interface EngineChatModel {
+export 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 {
+export interface BaseChatModelOptions {
     model: string;
     maxTokens?: number;
     reasoning?: ReasoningConfig;
     providerSessionResolver?: ProviderSessionResolver;
     requestMutators?: ProviderRequestMutator[];
 }
-interface AgentEventContext {
+export interface AgentEventContext {
     sessionId: string;
     turnId: string;
     state: TurnState;
 }
-type AskUserOption = {
+export type AskUserOption = {
     label: string;
     description: string;
 };
-type AskUserQuestion = {
+export type AskUserQuestion = {
     id: string;
     question: string;
     topic: string;
     options: AskUserOption[];
     multiSelect: boolean;
 };
-type AskUserAnswers = Record<string, string | string[]>;
-type AskUserQuestionRequest = {
+export type AskUserAnswers = Record<string, string | string[]>;
+export type AskUserQuestionRequest = {
     questionId: string;
     questions: AskUserQuestion[];
 };
-interface ToolExecutionContext extends AgentEventContext {
+export interface ToolExecutionContext extends AgentEventContext {
     signal: AbortSignal;
     toolCallId?: string;
     askUser?: (request: AskUserQuestionRequest) => Promise<AskUserAnswers>;
     setTopic?: (topic: string) => void;
 }
-interface ToolRuntimeStartedEvent {
+export interface ToolRuntimeStartedEvent {
     type: "tool_started";
     toolCall: ToolUseBlock;
 }
-interface ToolRuntimeOutputChunkEvent {
+export interface ToolRuntimeOutputChunkEvent {
     type: "tool_output_chunk";
     toolCall: ToolUseBlock;
     chunk: ToolResultChunk;
 }
-interface ToolRuntimeCompletedEvent {
+export interface ToolRuntimeCompletedEvent {
     type: "tool_completed";
     toolCall: ToolUseBlock;
     result: ToolResult;
 }
-interface ToolRuntimeRejectedEvent {
+export interface ToolRuntimeRejectedEvent {
     type: "tool_rejected";
     toolCall: ToolUseBlock;
     result: ToolResult;
 }
-type ToolRuntimeEvent = ToolRuntimeOutputChunkEvent | ToolRuntimeCompletedEvent | ToolRuntimeRejectedEvent | ToolRuntimeStartedEvent;
-interface AgentUserMessageEvent {
+export type ToolRuntimeEvent = ToolRuntimeOutputChunkEvent | ToolRuntimeCompletedEvent | ToolRuntimeRejectedEvent | ToolRuntimeStartedEvent;
+export interface AgentUserMessageEvent {
     type: "user_message";
     message: Message;
 }
-interface AgentModelRequestEvent {
+export interface AgentModelRequestEvent {
     type: "model_request";
     request: ChatRequest;
 }
-interface AgentModelResponseEvent {
+export interface AgentModelResponseEvent {
     type: "model_response";
     response: ChatResponse;
 }
-interface AgentAssistantMessageEvent {
+export interface AgentAssistantMessageEvent {
     type: "assistant_message";
     message: IdentifiedMessage;
 }
-interface AgentAssistantChunkEvent {
+export interface AgentAssistantChunkEvent {
     type: "assistant_chunk";
     index: number;
     messageId: string;
     chunk: ContentDeltaChunk;
 }
-interface AgentToolUseMessageEvent {
+export interface AgentToolUseMessageEvent {
     type: "tool_use_message";
     message: IdentifiedMessage;
 }
-interface AgentToolUseChunkEvent {
+export interface AgentToolUseChunkEvent {
     type: "tool_use_chunk";
     index: number;
     messageId: string;
     chunk: ToolUseDeltaChunk;
 }
-interface AgentReasoningMessageEvent {
+export interface AgentReasoningMessageEvent {
     type: "reasoning_message";
     message: IdentifiedMessage;
 }
-interface AgentReasoningChunkEvent {
+export interface AgentReasoningChunkEvent {
     type: "reasoning_chunk";
     index: number;
     messageId: string;
     chunk: AnthropicThinkingDeltaChunk | OpenAiReasoningDeltaChunk | OpenAiReasoningSummaryDeltaChunk;
     text: string;
 }
-interface AgentToolCallEvent {
+export interface AgentToolCallEvent {
     type: "tool_call";
     toolCall: ToolUseBlock;
 }
-interface AgentToolResultEvent {
+export interface AgentToolResultEvent {
     type: "tool_result";
     result: ToolResult;
 }
-interface AgentToolResultMessageEvent {
+export interface AgentToolResultMessageEvent {
     type: "tool_result_message";
     message: Message;
 }
-interface AgentFinalMessageEvent {
+export interface AgentFinalMessageEvent {
     type: "final_message";
     message: IdentifiedMessage;
 }
-interface AgentTurnCompleteEvent {
+export interface AgentTurnCompleteEvent {
     type: "turn_complete";
     state: TurnState;
 }
-interface AgentProviderRetryEvent extends ProviderRetryChunk {
+export interface AgentProviderRetryEvent extends ProviderRetryChunk {
 }
-type AgentLifecycleEvent = AgentAssistantChunkEvent | AgentAssistantMessageEvent | AgentFinalMessageEvent | AgentModelRequestEvent | AgentModelResponseEvent | AgentProviderRetryEvent | AgentReasoningChunkEvent | AgentReasoningMessageEvent | AgentToolCallEvent | AgentToolUseChunkEvent | AgentToolUseMessageEvent | AgentToolResultEvent | AgentToolResultMessageEvent | AgentTurnCompleteEvent | AgentUserMessageEvent;
-type AgentEvent = AgentLifecycleEvent | ToolRuntimeEvent;
-type ToolRuntimeDispatchDecision = {
+export type AgentLifecycleEvent = AgentAssistantChunkEvent | AgentAssistantMessageEvent | AgentFinalMessageEvent | AgentModelRequestEvent | AgentModelResponseEvent | AgentProviderRetryEvent | AgentReasoningChunkEvent | AgentReasoningMessageEvent | AgentToolCallEvent | AgentToolUseChunkEvent | AgentToolUseMessageEvent | AgentToolResultEvent | AgentToolResultMessageEvent | AgentTurnCompleteEvent | AgentUserMessageEvent;
+export type AgentEvent = AgentLifecycleEvent | ToolRuntimeEvent;
+export 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 {
+export type ToolRuntimeToolCallHandler = (toolCall: ToolUseBlock, ctx: ToolExecutionContext) => Promise<ToolRuntimeDispatchDecision | undefined> | ToolRuntimeDispatchDecision | undefined;
+export type ToolRuntimeEventHandler = (event: ToolRuntimeEvent, ctx: ToolExecutionContext) => Promise<void> | void;
+export type AgentEventHandler = (event: AgentEvent, ctx: AgentEventContext) => Promise<void> | void;
+export interface ToolRuntime {
     listToolSchemas(): ToolSchema[];
     setTools(tools: AnyToolDefinition[]): void;
     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;
+export 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;
@@ -511,19 +511,19 @@ type RequiredProperties<TProperties extends Record<string, JsonSchema>, TRequire
 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> {
+export type ToolOutputValue = JsonValue | ToolOutputEnvelope;
+export type ToolGenerator<TYield extends ToolOutputValue = ToolOutputValue, TReturn extends ToolOutputValue | undefined = ToolOutputValue | undefined> = AsyncGenerator<TYield, TReturn, void>;
+export 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 TransformableStage = "afterModelResponse" | "afterToolResult" | "beforeAssistantAppend" | "beforeFinalOutput" | "beforeModelRequest" | "beforeToolExecution" | "beforeToolResultAppend" | "onUserMessage";
-type ObserverOnlyStage = "afterMessageAppend" | "afterTurnComplete";
-type Stage = ObserverOnlyStage | TransformableStage;
-interface PayloadByStage {
+export type AnyToolDefinition = ToolDefinition<JsonObject, ToolOutputValue, ToolOutputValue | undefined, JsonSchemaObject>;
+export type TransformableStage = "afterModelResponse" | "afterToolResult" | "beforeAssistantAppend" | "beforeFinalOutput" | "beforeModelRequest" | "beforeToolExecution" | "beforeToolResultAppend" | "onUserMessage";
+export type ObserverOnlyStage = "afterMessageAppend" | "afterTurnComplete";
+export type Stage = ObserverOnlyStage | TransformableStage;
+export interface PayloadByStage {
     afterMessageAppend: Message;
     onUserMessage: Message;
     beforeModelRequest: ChatRequest;
@@ -535,12 +535,12 @@ interface PayloadByStage {
     beforeToolResultAppend: Message;
     afterTurnComplete: TurnState;
 }
-interface ExtensionContext {
+export interface ExtensionContext {
     state: TurnState;
 }
-type Transformer<S extends TransformableStage> = (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 TransformableStage = TransformableStage> {
+export type Transformer<S extends TransformableStage> = (payload: PayloadByStage[S], ctx: ExtensionContext) => PayloadByStage[S] | Promise<PayloadByStage[S]>;
+export type Observer<S extends Stage> = (payload: PayloadByStage[S], ctx: ExtensionContext) => Promise<void> | void;
+export interface TransformerExtensionRegistration<S extends TransformableStage = TransformableStage> {
     id: string;
     stage: S;
     kind: "transformer";
@@ -548,7 +548,7 @@ interface TransformerExtensionRegistration<S extends TransformableStage = Transf
     enabled: boolean;
     run: Transformer<S>;
 }
-interface ObserverExtensionRegistration<S extends Stage = Stage> {
+export interface ObserverExtensionRegistration<S extends Stage = Stage> {
     id: string;
     stage: S;
     kind: "observer";
@@ -556,17 +556,17 @@ interface ObserverExtensionRegistration<S extends Stage = Stage> {
     enabled: boolean;
     run: Observer<S>;
 }
-type AnyExtensionRegistration = {
+export type AnyExtensionRegistration = {
     [S in Stage]: ObserverExtensionRegistration<S>;
 }[Stage] | {
     [S in TransformableStage]: TransformerExtensionRegistration<S>;
 }[TransformableStage];
-interface ExtensionRegistry {
+export interface ExtensionRegistry {
     register(extension: AnyExtensionRegistration): void;
     runTransformers<S extends TransformableStage>(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 {
+export interface RunTurnDeps {
     registry: ExtensionRegistry;
     chatModel: EngineChatModel;
     toolRuntime: ToolRuntime;
@@ -576,12 +576,12 @@ interface RunTurnDeps {
     sessionDir?: string | (() => string | undefined);
     outputFormat?: OutputFormat;
 }
-type AgentInput = MessageInput | string;
-interface AgentSendOptions {
+export type AgentInput = MessageInput | string;
+export interface AgentSendOptions {
     streaming?: boolean;
     signal?: AbortSignal;
 }
-interface AgentOptions {
+export interface AgentOptions {
     sessionId?: string;
     systemPrompt?: string;
     messages?: MessageInput[];
@@ -598,24 +598,24 @@ interface AgentOptions {
     sessionDir?: string | (() => string | undefined);
     outputFormat?: OutputFormat;
 }
-interface AgentDefinitionFactoryContext {
+export interface AgentDefinitionFactoryContext {
     agentId: string;
     parentSessionId?: string;
     runId?: string;
     toolCallId?: string;
 }
-interface AgentDefinition {
+export interface AgentDefinition {
     id: string;
     description?: string;
     enabled?: boolean;
     allowedChildAgentIds?: string[];
     createOptions(ctx?: AgentDefinitionFactoryContext): AgentOptions;
 }
-type ManagedRunStatus = "aborted" | "completed" | "failed" | "idle" | "running";
-interface ManagedRunError {
+export type ManagedRunStatus = "aborted" | "completed" | "failed" | "idle" | "running";
+export interface ManagedRunError {
     message: string;
 }
-interface ManagedAgentRun {
+export interface ManagedAgentRun {
     runId: string;
     agentId: string;
     sessionId: string;
@@ -626,7 +626,7 @@ interface ManagedAgentRun {
     result?: TurnResult;
     error?: ManagedRunError;
 }
-interface ManagedAgentRunHandle {
+export interface ManagedAgentRunHandle {
     readonly runId: string;
     readonly agentId: string;
     readonly sessionId: string;
@@ -634,7 +634,7 @@ interface ManagedAgentRunHandle {
     snapshot(): ManagedAgentRun;
     wait(signal?: AbortSignal): Promise<ManagedAgentRun>;
 }
-interface ManagedRunEvent {
+export interface ManagedRunEvent {
     runId: string;
     agentId: string;
     sessionId: string;
@@ -642,16 +642,16 @@ interface ManagedRunEvent {
     originToolCallId?: string;
     event: AgentEvent;
 }
-type ManagedRunEventHandler = (event: ManagedRunEvent) => Promise<void> | void;
-interface RuntimeManagerOptions {
+export type ManagedRunEventHandler = (event: ManagedRunEvent) => Promise<void> | void;
+export interface RuntimeManagerOptions {
     onEvent?: ManagedRunEventHandler;
 }
-interface CreateManagedRunInput {
+export interface CreateManagedRunInput {
     agentId: string;
     parentRunId?: string;
     originToolCallId?: string;
 }
-interface CompileRequestInput {
+export interface CompileRequestInput {
     sessionId: string;
     turnId: string;
     reasoning?: ReasoningConfig;
@@ -661,46 +661,46 @@ interface CompileRequestInput {
     model?: string;
     max_tokens?: number;
 }
-interface OpenAiInputText {
+export interface OpenAiInputText {
     type: "input_text";
     text: string;
 }
-interface OpenAiInputImage {
+export interface OpenAiInputImage {
     type: "input_image";
     image_url: string;
     detail?: string;
 }
-interface OpenAiInputMessage {
+export interface OpenAiInputMessage {
     type: "message";
     role: MessageRole;
     content: Array<OpenAiInputImage | OpenAiInputText | OpenAiOutputTextPart>;
 }
-interface OpenAiFunctionCall {
+export interface OpenAiFunctionCall {
     type: "function_call";
     call_id: string;
     name: string;
     arguments: string;
 }
-interface OpenAiFunctionCallOutput {
+export interface OpenAiFunctionCallOutput {
     type: "function_call_output";
     call_id: string;
     output: string;
 }
-interface OpenAiOutputTextPart {
+export interface OpenAiOutputTextPart {
     type: "output_text";
     text: string;
 }
-interface OpenAiRefusalPart {
+export interface OpenAiRefusalPart {
     type: "refusal";
     refusal: string;
 }
-interface OpenAiOutputMessage {
+export interface OpenAiOutputMessage {
     type: "message";
     content?: Array<OpenAiOutputTextPart | OpenAiRefusalPart>;
     role?: string;
     status?: string;
 }
-interface OpenAiReasoningOutputItem {
+export interface OpenAiReasoningOutputItem {
     type: "reasoning";
     content?: Array<{
         text?: string;
@@ -712,19 +712,19 @@ interface OpenAiReasoningOutputItem {
     summary?: OpenAiReasoningSummaryText[];
     text?: string;
 }
-type OpenAiResponsesOutputItem = JsonObject | OpenAiFunctionCall | OpenAiOutputMessage | OpenAiReasoningOutputItem;
-interface OpenAiResponsesReasoningParam {
+export type OpenAiResponsesOutputItem = JsonObject | OpenAiFunctionCall | OpenAiOutputMessage | OpenAiReasoningOutputItem;
+export interface OpenAiResponsesReasoningParam {
     effort?: OpenAiReasoningEffort;
     generate_summary?: OpenAiReasoningSummary;
     summary?: OpenAiReasoningSummary;
 }
-interface OpenAiFunctionTool {
+export interface OpenAiFunctionTool {
     type: "function";
     name: string;
     description: string;
     parameters: JsonSchemaObject;
 }
-interface OpenAiResponsesRequest {
+export interface OpenAiResponsesRequest {
     include?: string[];
     model: string;
     instructions: string;
@@ -733,5 +733,5 @@ interface OpenAiResponsesRequest {
     reasoning?: OpenAiResponsesReasoningParam;
     tools: OpenAiFunctionTool[];
 }
-
-export type { ImageMediaType as $, AgentEvent as A, BaseChatModelOptions as B, ChatRequest as C, ModelInfo as D, EngineChatModel as E, ModelLimits as F, ProviderCredentialKind as G, ProviderEndpoints as H, AutoReasoningEffort as I, JsonSchemaObject as J, AnthropicThinkingConfig as K, OpenAiReasoningConfig as L, Message as M, JsonPrimitive as N, OpenAiResponsesRequest as O, ProviderSessionResolver as P, JsonObject as Q, RunTurnDeps as R, SystemInput as S, ToolSchema as T, JsonValue as U, JsonSchemaType as V, JsonSchemaString as W, JsonSchemaNumber as X, JsonSchemaBoolean as Y, JsonSchemaArray as Z, JsonSchema as _, AgentOptions as a, AgentTurnCompleteEvent as a$, ImageBlock as a0, ToolResultContentBlock as a1, ToolResultContent as a2, AnthropicThinkingBlock as a3, AnthropicRedactedThinkingBlock as a4, OpenAiReasoningSummaryText as a5, OpenAiReasoningBlock as a6, AnthropicThinkingWireBlock as a7, AnthropicRedactedThinkingWireBlock as a8, AnthropicAssistantContentBlock as a9, TurnResultStatus as aA, PrepareRequestInput as aB, ChatModel as aC, AgentEventContext as aD, AskUserOption as aE, AskUserQuestion as aF, AskUserAnswers as aG, AskUserQuestionRequest as aH, ToolExecutionContext as aI, ToolRuntimeStartedEvent as aJ, ToolRuntimeOutputChunkEvent as aK, ToolRuntimeCompletedEvent as aL, ToolRuntimeRejectedEvent as aM, ToolRuntimeEvent as aN, AgentUserMessageEvent as aO, AgentModelRequestEvent as aP, AgentModelResponseEvent as aQ, AgentAssistantMessageEvent as aR, AgentAssistantChunkEvent as aS, AgentToolUseMessageEvent as aT, AgentToolUseChunkEvent as aU, AgentReasoningMessageEvent as aV, AgentReasoningChunkEvent as aW, AgentToolCallEvent as aX, AgentToolResultEvent as aY, AgentToolResultMessageEvent as aZ, AgentFinalMessageEvent as a_, ReasoningVisibility as aa, AutoReasoningConfig as ab, AnthropicThinkingDisplay as ac, AnthropicThinkingEffort as ad, AnthropicEnabledThinkingConfig as ae, AnthropicAdaptiveThinkingConfig as af, AnthropicDisabledThinkingConfig as ag, OpenAiReasoningEffort as ah, OpenAiReasoningSummary as ai, MessageProviderState as aj, AssistantContentBlock as ak, MessageRole as al, IdentifiedMessage as am, Usage as an, OutputFormat as ao, ContentDeltaChunk as ap, ToolUseDeltaChunk as aq, AnthropicThinkingDeltaChunk as ar, AnthropicSignatureDeltaChunk as as, OpenAiReasoningDeltaChunk as at, OpenAiReasoningSummaryDeltaChunk as au, ProviderRetryChunk as av, DoneChunk as aw, ToolResultMeta as ax, ToolResultChunk as ay, ToolOutputEnvelope as az, AgentInput as b, AgentProviderRetryEvent as b0, AgentLifecycleEvent as b1, ToolRuntimeDispatchDecision as b2, ToolRuntimeToolCallHandler as b3, ToolRuntimeEventHandler as b4, AgentEventHandler as b5, ToolRuntime as b6, InferJsonSchema as b7, ToolOutputValue as b8, ToolGenerator as b9, OpenAiOutputTextPart as bA, OpenAiRefusalPart as bB, OpenAiOutputMessage as bC, OpenAiReasoningOutputItem as bD, OpenAiResponsesOutputItem as bE, OpenAiResponsesReasoningParam as bF, OpenAiFunctionTool as bG, ToolDefinition as ba, AnyToolDefinition as bb, TransformableStage as bc, ObserverOnlyStage as bd, Stage as be, PayloadByStage as bf, ExtensionContext as bg, Transformer as bh, Observer as bi, ObserverExtensionRegistration as bj, AnyExtensionRegistration as bk, AgentDefinitionFactoryContext as bl, AgentDefinition as bm, ManagedRunStatus as bn, ManagedRunError as bo, ManagedAgentRun as bp, ManagedAgentRunHandle as bq, ManagedRunEvent as br, ManagedRunEventHandler as bs, RuntimeManagerOptions as bt, CreateManagedRunInput as bu, OpenAiInputText as bv, OpenAiInputImage as bw, OpenAiInputMessage as bx, OpenAiFunctionCall as by, OpenAiFunctionCallOutput as bz, AgentSendOptions as c, TurnResult as d, ExtensionRegistry as e, TransformerExtensionRegistration as f, TurnInput as g, TurnState as h, ContentBlock as i, TextBlock as j, ContentInput as k, MessageInput as l, CompileRequestInput as m, ModelRequest as n, ModelResponse as o, ChatResponse as p, ToolUseBlock as q, ToolResultBlock as r, ToolResult as s, ResolvedProviderSession as t, ProviderRequestMutator as u, PreparedRequest as v, ProviderCredential as w, ReasoningConfig as x, ChatResponseChunk as y, ModelExecutionOptions as z };
+export {};
+//# sourceMappingURL=types.d.ts.map