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

package/dist/{types-3UUDPpJs.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,122 +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 ModelRequest {
+export interface OutputFormat {
+    type: "json_schema";
+    name?: string;
+    schema: JsonSchemaObject;
+    strict?: boolean;
+}
+export interface ModelRequest {
     model: string;
     max_tokens: number;
     reasoning?: ReasoningConfig;
@@ -162,8 +168,9 @@ interface ModelRequest {
         session_id: string;
         turn_id: string;
     };
+    outputFormat?: OutputFormat;
 }
-interface ModelResponse {
+export interface ModelResponse {
     id: string;
     type: "message";
     role: "assistant";
@@ -173,7 +180,7 @@ interface ModelResponse {
     usage: Usage;
     providerState?: MessageProviderState;
 }
-interface ChatRequest {
+export interface ChatRequest {
     model: string;
     maxTokens: number;
     reasoning?: ReasoningConfig;
@@ -184,8 +191,9 @@ interface ChatRequest {
         sessionId: string;
         turnId: string;
     };
+    outputFormat?: OutputFormat;
 }
-interface ChatResponse {
+export interface ChatResponse {
     id: string;
     content: AssistantContentBlock[];
     stopReason: "end_turn" | "tool_use";
@@ -198,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;
@@ -243,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";
@@ -283,7 +291,7 @@ interface ToolResult {
     chunks: ToolResultChunk[];
     meta: ToolResultMeta;
 }
-interface TurnInput {
+export interface TurnInput {
     sessionId: string;
     turnId: string;
     streaming?: boolean;
@@ -292,7 +300,7 @@ interface TurnInput {
     messages?: MessageInput[];
     message: MessageInput;
 }
-interface TurnState {
+export interface TurnState {
     sessionId: string;
     turnId: string;
     system: TextBlock[];
@@ -302,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;
@@ -336,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;
@@ -503,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;
@@ -527,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";
@@ -540,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";
@@ -548,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;
@@ -566,13 +574,14 @@ interface RunTurnDeps {
     setTopic?: (topic: string) => void;
     onEvent?: AgentEventHandler;
     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[];
@@ -587,25 +596,26 @@ interface AgentOptions {
     setTopic?: (topic: string) => void;
     getContextWindowLimit?: (request: ChatRequest) => number | undefined;
     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;
@@ -616,7 +626,7 @@ interface ManagedAgentRun {
     result?: TurnResult;
     error?: ManagedRunError;
 }
-interface ManagedAgentRunHandle {
+export interface ManagedAgentRunHandle {
     readonly runId: string;
     readonly agentId: string;
     readonly sessionId: string;
@@ -624,7 +634,7 @@ interface ManagedAgentRunHandle {
     snapshot(): ManagedAgentRun;
     wait(signal?: AbortSignal): Promise<ManagedAgentRun>;
 }
-interface ManagedRunEvent {
+export interface ManagedRunEvent {
     runId: string;
     agentId: string;
     sessionId: string;
@@ -632,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;
@@ -651,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;
@@ -702,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;
@@ -723,5 +733,5 @@ interface OpenAiResponsesRequest {
     reasoning?: OpenAiResponsesReasoningParam;
     tools: OpenAiFunctionTool[];
 }
-
-export type { ImageBlock as $, AgentEvent as A, BaseChatModelOptions as B, ChatRequest as C, ModelLimits as D, EngineChatModel as E, ProviderCredentialKind as F, ProviderEndpoints as G, AutoReasoningEffort as H, AnthropicThinkingConfig as I, OpenAiReasoningConfig as J, JsonPrimitive as K, JsonObject as L, Message as M, JsonValue as N, OpenAiResponsesRequest as O, ProviderSessionResolver as P, JsonSchemaType as Q, RunTurnDeps as R, SystemInput as S, TurnResult as T, JsonSchemaString as U, JsonSchemaNumber as V, JsonSchemaBoolean as W, JsonSchemaArray as X, JsonSchemaObject as Y, JsonSchema as Z, ImageMediaType as _, AgentOptions as a, AgentProviderRetryEvent as a$, ToolResultContentBlock as a0, ToolResultContent as a1, AnthropicThinkingBlock as a2, AnthropicRedactedThinkingBlock as a3, OpenAiReasoningSummaryText as a4, OpenAiReasoningBlock as a5, AnthropicThinkingWireBlock as a6, AnthropicRedactedThinkingWireBlock as a7, AnthropicAssistantContentBlock as a8, ReasoningVisibility as a9, PrepareRequestInput as aA, ChatModel as aB, AgentEventContext as aC, AskUserOption as aD, AskUserQuestion as aE, AskUserAnswers as aF, AskUserQuestionRequest as aG, ToolExecutionContext as aH, ToolRuntimeStartedEvent as aI, ToolRuntimeOutputChunkEvent as aJ, ToolRuntimeCompletedEvent as aK, ToolRuntimeRejectedEvent as aL, ToolRuntimeEvent as aM, AgentUserMessageEvent as aN, AgentModelRequestEvent as aO, AgentModelResponseEvent as aP, AgentAssistantMessageEvent as aQ, AgentAssistantChunkEvent as aR, AgentToolUseMessageEvent as aS, AgentToolUseChunkEvent as aT, AgentReasoningMessageEvent as aU, AgentReasoningChunkEvent as aV, AgentToolCallEvent as aW, AgentToolResultEvent as aX, AgentToolResultMessageEvent as aY, AgentFinalMessageEvent as aZ, AgentTurnCompleteEvent as a_, AutoReasoningConfig as aa, AnthropicThinkingDisplay as ab, AnthropicThinkingEffort as ac, AnthropicEnabledThinkingConfig as ad, AnthropicAdaptiveThinkingConfig as ae, AnthropicDisabledThinkingConfig as af, OpenAiReasoningEffort as ag, OpenAiReasoningSummary as ah, MessageProviderState as ai, AssistantContentBlock as aj, MessageRole as ak, IdentifiedMessage as al, ToolSchema as am, Usage as an, ContentDeltaChunk as ao, ToolUseDeltaChunk as ap, AnthropicThinkingDeltaChunk as aq, AnthropicSignatureDeltaChunk as ar, OpenAiReasoningDeltaChunk as as, OpenAiReasoningSummaryDeltaChunk as at, ProviderRetryChunk as au, DoneChunk as av, ToolResultMeta as aw, ToolResultChunk as ax, ToolOutputEnvelope as ay, TurnResultStatus as az, AgentInput as b, AgentLifecycleEvent as b0, ToolRuntimeDispatchDecision as b1, ToolRuntimeToolCallHandler as b2, ToolRuntimeEventHandler as b3, AgentEventHandler as b4, ToolRuntime as b5, InferJsonSchema as b6, ToolOutputValue as b7, ToolGenerator as b8, ToolDefinition as b9, OpenAiRefusalPart as bA, OpenAiOutputMessage as bB, OpenAiReasoningOutputItem as bC, OpenAiResponsesOutputItem as bD, OpenAiResponsesReasoningParam as bE, OpenAiFunctionTool as bF, AnyToolDefinition as ba, TransformableStage as bb, ObserverOnlyStage as bc, Stage as bd, PayloadByStage as be, ExtensionContext as bf, Transformer as bg, Observer as bh, ObserverExtensionRegistration as bi, AnyExtensionRegistration as bj, AgentDefinitionFactoryContext as bk, AgentDefinition as bl, ManagedRunStatus as bm, ManagedRunError as bn, ManagedAgentRun as bo, ManagedAgentRunHandle as bp, ManagedRunEvent as bq, ManagedRunEventHandler as br, RuntimeManagerOptions as bs, CreateManagedRunInput as bt, OpenAiInputText as bu, OpenAiInputImage as bv, OpenAiInputMessage as bw, OpenAiFunctionCall as bx, OpenAiFunctionCallOutput as by, OpenAiOutputTextPart as bz, AgentSendOptions as c, ExtensionRegistry as d, TransformerExtensionRegistration as e, TurnInput as f, TurnState as g, ContentBlock as h, TextBlock as i, ContentInput as j, MessageInput as k, CompileRequestInput as l, ModelRequest as m, ModelResponse as n, ChatResponse as o, ToolUseBlock as p, ToolResultBlock as q, ToolResult as r, ResolvedProviderSession as s, ProviderRequestMutator as t, PreparedRequest as u, ProviderCredential as v, ReasoningConfig as w, ChatResponseChunk as x, ModelExecutionOptions as y, ModelInfo as z };
+export {};
+//# sourceMappingURL=types.d.ts.map