@nuvin/agent-core 0.0.0-rc.8 → 0.0.0

package/dist/{types-mpqTRf_e.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[];
@@ -300,33 +308,34 @@ interface TurnState {
     lastResponse?: ChatResponse;
     toolResults: ToolResult[];
     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;
@@ -335,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 {
-    onProviderRetry?: (event: ProviderRetryChunk) => Promise<void> | void;
+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;
-    header: 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;
@@ -502,17 +511,20 @@ 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 Stage = "afterModelResponse" | "afterToolResult" | "afterTurnComplete" | "beforeAssistantAppend" | "beforeFinalOutput" | "beforeModelRequest" | "beforeToolExecution" | "beforeToolResultAppend" | "onUserMessage";
-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;
     afterModelResponse: ChatResponse;
@@ -523,12 +535,12 @@ interface PayloadByStage {
     beforeToolResultAppend: Message;
     afterTurnComplete: TurnState;
 }
-interface ExtensionContext {
+export 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> {
+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";
@@ -536,7 +548,7 @@ interface TransformerExtensionRegistration<S extends Stage = Stage> {
     enabled: boolean;
     run: Transformer<S>;
 }
-interface ObserverExtensionRegistration<S extends Stage = Stage> {
+export interface ObserverExtensionRegistration<S extends Stage = Stage> {
     id: string;
     stage: S;
     kind: "observer";
@@ -544,28 +556,32 @@ interface ObserverExtensionRegistration<S extends Stage = Stage> {
     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 {
+export type AnyExtensionRegistration = {
+    [S in Stage]: ObserverExtensionRegistration<S>;
+}[Stage] | {
+    [S in TransformableStage]: TransformerExtensionRegistration<S>;
+}[TransformableStage];
+export interface ExtensionRegistry {
     register(extension: AnyExtensionRegistration): void;
-    runTransformers<S extends Stage>(stage: S, payload: PayloadByStage[S], ctx: ExtensionContext): Promise<PayloadByStage[S]>;
+    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;
     askUser?: (request: AskUserQuestionRequest) => Promise<AskUserAnswers>;
+    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[];
@@ -577,26 +593,29 @@ interface AgentOptions {
     chatModel?: EngineChatModel;
     tools?: AnyToolDefinition[];
     askUser?: (request: AskUserQuestionRequest) => Promise<AskUserAnswers>;
+    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;
@@ -607,7 +626,7 @@ interface ManagedAgentRun {
     result?: TurnResult;
     error?: ManagedRunError;
 }
-interface ManagedAgentRunHandle {
+export interface ManagedAgentRunHandle {
     readonly runId: string;
     readonly agentId: string;
     readonly sessionId: string;
@@ -615,7 +634,7 @@ interface ManagedAgentRunHandle {
     snapshot(): ManagedAgentRun;
     wait(signal?: AbortSignal): Promise<ManagedAgentRun>;
 }
-interface ManagedRunEvent {
+export interface ManagedRunEvent {
     runId: string;
     agentId: string;
     sessionId: string;
@@ -623,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;
@@ -642,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>;
+    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;
@@ -693,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;
@@ -714,5 +733,5 @@ interface OpenAiResponsesRequest {
     reasoning?: OpenAiResponsesReasoningParam;
     tools: OpenAiFunctionTool[];
 }
-
-export type { ToolResultContentBlock as $, AgentEvent as A, BaseChatModelOptions as B, ChatRequest as C, ProviderCredentialKind as D, EngineChatModel as E, ProviderEndpoints as F, AutoReasoningEffort as G, AnthropicThinkingConfig as H, OpenAiReasoningConfig as I, JsonPrimitive as J, JsonObject as K, JsonValue as L, Message as M, JsonSchemaType as N, OpenAiResponsesRequest as O, ProviderSessionResolver as P, JsonSchemaString as Q, RunTurnDeps as R, SystemInput as S, TurnResult as T, JsonSchemaNumber as U, JsonSchemaBoolean as V, JsonSchemaArray as W, JsonSchemaObject as X, JsonSchema as Y, ImageMediaType as Z, ImageBlock as _, AgentOptions as a, AgentLifecycleEvent as a$, ToolResultContent as a0, AnthropicThinkingBlock as a1, AnthropicRedactedThinkingBlock as a2, OpenAiReasoningSummaryText as a3, OpenAiReasoningBlock as a4, AnthropicThinkingWireBlock as a5, AnthropicRedactedThinkingWireBlock as a6, AnthropicAssistantContentBlock as a7, ReasoningVisibility as a8, AutoReasoningConfig as a9, ChatModel as aA, AgentEventContext as aB, AskUserOption as aC, AskUserQuestion as aD, AskUserAnswers as aE, AskUserQuestionRequest as aF, ToolExecutionContext as aG, ToolRuntimeStartedEvent as aH, ToolRuntimeOutputChunkEvent as aI, ToolRuntimeCompletedEvent as aJ, ToolRuntimeRejectedEvent as aK, ToolRuntimeEvent as aL, AgentUserMessageEvent as aM, AgentModelRequestEvent as aN, AgentModelResponseEvent as aO, AgentAssistantMessageEvent as aP, AgentAssistantChunkEvent as aQ, AgentToolUseMessageEvent as aR, AgentToolUseChunkEvent as aS, AgentReasoningMessageEvent as aT, AgentReasoningChunkEvent as aU, AgentToolCallEvent as aV, AgentToolResultEvent as aW, AgentToolResultMessageEvent as aX, AgentFinalMessageEvent as aY, AgentTurnCompleteEvent as aZ, AgentProviderRetryEvent as a_, AnthropicThinkingDisplay as aa, AnthropicThinkingEffort as ab, AnthropicEnabledThinkingConfig as ac, AnthropicAdaptiveThinkingConfig as ad, AnthropicDisabledThinkingConfig as ae, OpenAiReasoningEffort as af, OpenAiReasoningSummary as ag, MessageProviderState as ah, AssistantContentBlock as ai, MessageRole as aj, IdentifiedMessage as ak, ToolSchema as al, Usage as am, ContentDeltaChunk as an, ToolUseDeltaChunk as ao, AnthropicThinkingDeltaChunk as ap, AnthropicSignatureDeltaChunk as aq, OpenAiReasoningDeltaChunk as ar, OpenAiReasoningSummaryDeltaChunk as as, ProviderRetryChunk as at, DoneChunk as au, ToolResultMeta as av, ToolResultChunk as aw, ToolOutputEnvelope as ax, TurnResultStatus as ay, PrepareRequestInput as az, AgentInput as b, ToolRuntimeDispatchDecision as b0, ToolRuntimeToolCallHandler as b1, ToolRuntimeEventHandler as b2, AgentEventHandler as b3, ToolRuntime as b4, InferJsonSchema as b5, ToolOutputValue as b6, ToolGenerator as b7, ToolDefinition as b8, AnyToolDefinition as b9, OpenAiOutputMessage as bA, OpenAiReasoningOutputItem as bB, OpenAiResponsesOutputItem as bC, OpenAiResponsesReasoningParam as bD, OpenAiFunctionTool as bE, Stage as ba, PayloadByStage as bb, ExtensionContext as bc, Transformer as bd, Observer as be, TransformerExtensionRegistration as bf, ObserverExtensionRegistration as bg, ExtensionRegistration as bh, AnyExtensionRegistration as bi, AgentDefinitionFactoryContext as bj, AgentDefinition as bk, ManagedRunStatus as bl, ManagedRunError as bm, ManagedAgentRun as bn, ManagedAgentRunHandle as bo, ManagedRunEvent as bp, ManagedRunEventHandler as bq, RuntimeManagerOptions as br, CreateManagedRunInput as bs, OpenAiInputText as bt, OpenAiInputImage as bu, OpenAiInputMessage as bv, OpenAiFunctionCall as bw, OpenAiFunctionCallOutput as bx, OpenAiOutputTextPart as by, OpenAiRefusalPart as bz, AgentSendOptions as c, ExtensionRegistry as d, TurnInput as e, TurnState as f, ContentBlock as g, TextBlock as h, ContentInput as i, MessageInput as j, CompileRequestInput as k, ModelRequest as l, ModelResponse as m, ChatResponse as n, ToolUseBlock as o, ToolResultBlock as p, ToolResult as q, ResolvedProviderSession as r, ProviderRequestMutator as s, PreparedRequest as t, ProviderCredential as u, ReasoningConfig as v, ChatResponseChunk as w, ModelExecutionOptions as x, ModelInfo as y, ModelLimits as z };
+export {};
+//# sourceMappingURL=types.d.ts.map