@opperai/agents 0.1.3 → 0.3.0-beta

package/dist/index.d.ts

@@ -508,6 +508,10 @@ declare const HookEvents: {
     readonly MemoryRead: "memory:read";
     readonly MemoryWrite: "memory:write";
     readonly MemoryError: "memory:error";
+    readonly StreamStart: "stream:start";
+    readonly StreamChunk: "stream:chunk";
+    readonly StreamEnd: "stream:end";
+    readonly StreamError: "stream:error";
 };
 type HookEventName = (typeof HookEvents)[keyof typeof HookEvents];
 interface HookPayloadMap {
@@ -533,6 +537,7 @@ interface HookPayloadMap {
         context: AgentContext;
         callType: string;
         response: unknown;
+        parsed?: unknown;
     };
     [HookEvents.ThinkEnd]: {
         context: AgentContext;
@@ -570,6 +575,31 @@ interface HookPayloadMap {
         operation: "read" | "write" | "delete" | "clear";
         error: unknown;
     };
+    [HookEvents.StreamStart]: {
+        context: AgentContext;
+        callType: string;
+    };
+    [HookEvents.StreamChunk]: {
+        context: AgentContext;
+        callType: string;
+        chunkData: {
+            delta: unknown;
+            jsonPath?: string | null;
+            chunkType?: string | null;
+        };
+        accumulated: string;
+        fieldBuffers: Record<string, string>;
+    };
+    [HookEvents.StreamEnd]: {
+        context: AgentContext;
+        callType: string;
+        fieldBuffers: Record<string, string>;
+    };
+    [HookEvents.StreamError]: {
+        context: AgentContext;
+        callType: string;
+        error: unknown;
+    };
 }
 type HookPayload<E extends HookEventName> = HookPayloadMap[E];
 type HookHandler<E extends HookEventName> = (payload: HookPayload<E>) => void | Promise<void>;
@@ -592,6 +622,28 @@ declare class HookManager {
 }
 declare const createHookManager: (logger?: AgentLogger) => HookManager;
 
+declare const AgentEvents: {
+    readonly StreamStart: "stream:start";
+    readonly StreamChunk: "stream:chunk";
+    readonly StreamEnd: "stream:end";
+    readonly StreamError: "stream:error";
+};
+type AgentEventName = (typeof AgentEvents)[keyof typeof AgentEvents];
+type AgentEventPayloadMap = Pick<HookPayloadMap, AgentEventName>;
+type AgentEventPayload<E extends AgentEventName> = AgentEventPayloadMap[E];
+type AgentEventListener<E extends AgentEventName> = (payload: AgentEventPayload<E>) => void;
+declare class AgentEventEmitter {
+    private readonly registry;
+    private readonly logger;
+    constructor(logger?: AgentLogger);
+    on<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): () => void;
+    once<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): () => void;
+    off<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): void;
+    emit<E extends AgentEventName>(event: E, payload: AgentEventPayload<E>): void;
+    removeAllListeners(event?: AgentEventName): void;
+    listenerCount(event?: AgentEventName): number;
+}
+
 /**
  * Options for generating agent flow visualization
  */
@@ -825,6 +877,27 @@ interface BaseAgentConfig<TInput, TOutput> {
      * Output schema for validation (Zod schema)
      */
     outputSchema?: ZodType<TOutput>;
+    /**
+     * Enable Opper streaming APIs for LLM calls
+     * @default false
+     */
+    enableStreaming?: boolean;
+    /**
+     * Register a handler invoked when a streaming call starts.
+     */
+    onStreamStart?: AgentEventListener<typeof HookEvents.StreamStart>;
+    /**
+     * Register a handler invoked for each streaming chunk.
+     */
+    onStreamChunk?: AgentEventListener<typeof HookEvents.StreamChunk>;
+    /**
+     * Register a handler invoked when a streaming call ends.
+     */
+    onStreamEnd?: AgentEventListener<typeof HookEvents.StreamEnd>;
+    /**
+     * Register a handler invoked when streaming encounters an error.
+     */
+    onStreamError?: AgentEventListener<typeof HookEvents.StreamError>;
     /**
      * Enable memory subsystem
      * @default false
@@ -900,6 +973,10 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
      * Whether memory is enabled
      */
     readonly enableMemory: boolean;
+    /**
+     * Whether streaming is enabled
+     */
+    readonly enableStreaming: boolean;
     /**
      * Memory instance for persistent storage (null if disabled or initialization failed)
      */
@@ -912,6 +989,10 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
      * Hook manager for lifecycle events
      */
     protected readonly hooks: HookManager;
+    /**
+     * Event dispatcher for runtime events (notably streaming)
+     */
+    protected readonly events: AgentEventEmitter;
     /**
      * Registry of available tools
      */
@@ -932,6 +1013,28 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
      * Opper client configuration
      */
     protected readonly opperConfig: OpperClientConfig;
+    /**
+     * Creates a new BaseAgent instance
+     *
+     * @param config - Agent configuration object
+     * @param config.name - Unique name identifying this agent (required)
+     * @param config.description - Human-readable description of the agent's purpose
+     * @param config.instructions - System instructions guiding agent behavior
+     * @param config.tools - Array of tools or tool providers available to the agent
+     * @param config.maxIterations - Maximum iterations before terminating the agent loop (default: 25)
+     * @param config.model - Model identifier(s). Single model or array for fallback (default: "gcp/gemini-flash-latest")
+     * @param config.inputSchema - Zod schema for input validation
+     * @param config.outputSchema - Zod schema for output validation
+     * @param config.enableStreaming - Enable Opper streaming APIs for LLM calls (default: false)
+     * @param config.enableMemory - Enable memory subsystem (default: false)
+     * @param config.memory - Custom memory implementation (defaults to InMemoryStore if enableMemory is true)
+     * @param config.metadata - Additional metadata for the agent
+     * @param config.opperConfig - Opper API configuration containing apiKey and baseUrl
+     * @param config.onStreamStart - Handler invoked when a streaming call starts
+     * @param config.onStreamChunk - Handler invoked for each streaming chunk
+     * @param config.onStreamEnd - Handler invoked when a streaming call ends
+     * @param config.onStreamError - Handler invoked when streaming encounters an error
+     */
     constructor(config: BaseAgentConfig<TInput, TOutput>);
     /**
      * Initialize memory subsystem with graceful degradation
@@ -1022,6 +1125,29 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
      * @returns Cleanup function to unregister the hook
      */
     registerHook<E extends HookEventName>(event: E, handler: HookHandler<E>): () => void;
+    /**
+     * Register an event listener.
+     *
+     * @param event - Event name
+     * @param listener - Listener callback
+     * @returns Cleanup function to unregister the listener
+     */
+    on<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): () => void;
+    /**
+     * Register a one-time event listener that removes itself after the first call.
+     *
+     * @param event - Event name
+     * @param listener - Listener callback
+     * @returns Cleanup function (no-op once listener fires)
+     */
+    once<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): () => void;
+    /**
+     * Remove a previously registered event listener.
+     *
+     * @param event - Event name
+     * @param listener - Listener callback to remove
+     */
+    off<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): void;
     /**
      * Trigger a hook event with a payload.
      * Swallows errors to prevent hook failures from breaking agent execution.
@@ -1030,6 +1156,13 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
      * @param payload - Event payload
      */
     protected triggerHook<E extends HookEventName>(event: E, payload: Parameters<HookHandler<E>>[0]): Promise<void>;
+    /**
+     * Emit a runtime event to listeners.
+     *
+     * @param event - Event name
+     * @param payload - Event payload
+     */
+    protected emitAgentEvent<E extends AgentEventName>(event: E, payload: AgentEventPayload<E>): void;
     /**
      * Execute a tool with proper context, hooks, and error handling.
      *
@@ -1070,6 +1203,31 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
     visualizeFlow(options?: VisualizationOptions): Promise<string>;
 }
 
+/**
+ * Streaming chunk payload from Opper SSE responses.
+ */
+interface OpperStreamChunk {
+    delta?: string | number | boolean | null | undefined;
+    jsonPath?: string | null | undefined;
+    spanId?: string | null | undefined;
+    chunkType?: string | null | undefined;
+}
+/**
+ * Server-sent event emitted during streaming calls.
+ */
+interface OpperStreamEvent {
+    id?: string;
+    event?: string;
+    retry?: number;
+    data?: OpperStreamChunk;
+}
+/**
+ * Structured response returned by Opper stream endpoints.
+ */
+interface OpperStreamResponse {
+    headers: Record<string, string[]>;
+    result: AsyncIterable<OpperStreamEvent>;
+}
 /**
  * Opper call response
  */
@@ -1133,6 +1291,10 @@ interface OpperCallOptions<TInput = unknown, TOutput = unknown> {
      * Parent span ID for tracing
      */
     parentSpanId?: string;
+    /**
+     * Abort signal used to cancel the underlying HTTP request.
+     */
+    signal?: AbortSignal;
 }
 /**
  * Span information
@@ -1150,6 +1312,7 @@ interface CreateSpanOptions {
     name: string;
     input?: unknown;
     parentSpanId?: string;
+    type?: string;
 }
 /**
  * Retry configuration
@@ -1191,6 +1354,10 @@ declare class OpperClient {
      * Make a call to Opper with retry logic
      */
     call<TInput = unknown, TOutput = unknown>(options: OpperCallOptions<TInput, TOutput>): Promise<OpperCallResponse<TOutput>>;
+    /**
+     * Stream a call to Opper with retry logic
+     */
+    stream<TInput = unknown, TOutput = unknown>(options: OpperCallOptions<TInput, TOutput>): Promise<OpperStreamResponse>;
     /**
      * Create a span for tracing
      */
@@ -1200,6 +1367,10 @@ declare class OpperClient {
      */
     updateSpan(spanId: string, output: unknown, options?: {
         error?: string;
+        startTime?: Date;
+        endTime?: Date;
+        meta?: Record<string, unknown>;
+        name?: string;
     }): Promise<void>;
     /**
      * Get the underlying Opper client
@@ -1231,7 +1402,33 @@ declare function createOpperClient(apiKey?: string, options?: {
 }): OpperClient;
 
 /**
- * Configuration for the core Agent
+ * Configuration for the core Agent.
+ *
+ * Extends {@link BaseAgentConfig} with additional options for Opper client, logging, and verbosity.
+ *
+ * @template TInput - The expected input type for the agent
+ * @template TOutput - The expected output type from the agent
+ *
+ * @property {string} name - Unique name identifying this agent (required)
+ * @property {string} [description] - Human-readable description of the agent's purpose
+ * @property {string} [instructions] - System instructions guiding agent behavior
+ * @property {Array<Tool<any, any> | ToolProvider>} [tools] - Tools available to the agent
+ * @property {number} [maxIterations=25] - Maximum iterations before terminating
+ * @property {string | readonly string[]} [model='gcp/gemini-flash-latest'] - Model identifier(s)
+ * @property {ZodType<TInput>} [inputSchema] - Zod schema for input validation
+ * @property {ZodType<TOutput>} [outputSchema] - Zod schema for output validation
+ * @property {boolean} [enableStreaming=false] - Enable streaming for LLM calls
+ * @property {boolean} [enableMemory=false] - Enable memory subsystem
+ * @property {Memory} [memory] - Custom memory implementation
+ * @property {Record<string, unknown>} [metadata] - Additional metadata
+ * @property {OpperClientConfig} [opperConfig] - Opper API configuration (apiKey, baseUrl)
+ * @property {OpperClient} [opperClient] - Custom Opper client instance
+ * @property {AgentLogger} [logger] - Logger instance for debugging
+ * @property {boolean} [verbose=false] - Enable verbose logging
+ * @property {Function} [onStreamStart] - Handler invoked when streaming starts
+ * @property {Function} [onStreamChunk] - Handler invoked for each streaming chunk
+ * @property {Function} [onStreamEnd] - Handler invoked when streaming ends
+ * @property {Function} [onStreamError] - Handler invoked on streaming errors
  */
 interface AgentConfig<TInput, TOutput> extends BaseAgentConfig<TInput, TOutput> {
     /**
@@ -1239,22 +1436,86 @@ interface AgentConfig<TInput, TOutput> extends BaseAgentConfig<TInput, TOutput>
      */
     opperClient?: OpperClient;
     /**
-     * Logger instance
+     * Logger instance for debugging and monitoring
      */
     logger?: AgentLogger;
     /**
-     * Verbose logging
+     * Enable verbose logging (default: false)
      */
     verbose?: boolean;
 }
 /**
  * Core Agent implementation with "while tools > 0" loop.
  * Implements think → tool execution → memory handling cycle.
+ *
+ * @template TInput - The expected input type for the agent
+ * @template TOutput - The expected output type from the agent
+ *
+ * @example
+ * ```typescript
+ * import { Agent } from 'opperai-agent-sdk-node';
+ *
+ * const agent = new Agent({
+ *   name: 'my-agent',
+ *   instructions: 'You are a helpful assistant',
+ *   model: 'gpt-4',
+ *   tools: [myTool],
+ *   maxIterations: 10,
+ *   enableMemory: true,
+ * });
+ *
+ * const result = await agent.process('Hello!');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With typed input/output and schemas
+ * import { Agent } from 'opperai-agent-sdk-node';
+ * import { z } from 'zod';
+ *
+ * const inputSchema = z.object({ query: z.string() });
+ * const outputSchema = z.object({ answer: z.string(), confidence: z.number() });
+ *
+ * const agent = new Agent<
+ *   z.infer<typeof inputSchema>,
+ *   z.infer<typeof outputSchema>
+ * >({
+ *   name: 'typed-agent',
+ *   instructions: 'Answer questions with confidence scores',
+ *   inputSchema,
+ *   outputSchema,
+ * });
+ * ```
  */
 declare class Agent<TInput = unknown, TOutput = unknown> extends BaseAgent<TInput, TOutput> {
     private readonly opperClient;
     private readonly logger;
     private readonly verbose;
+    /**
+     * Creates a new Agent instance
+     *
+     * @param config - Agent configuration object
+     * @param config.name - Unique name identifying this agent (required)
+     * @param config.description - Human-readable description of the agent's purpose
+     * @param config.instructions - System instructions guiding agent behavior
+     * @param config.tools - Array of tools or tool providers available to the agent
+     * @param config.maxIterations - Maximum iterations before terminating (default: 25)
+     * @param config.model - Model identifier(s) as string or array for fallback (default: "gcp/gemini-flash-latest")
+     * @param config.inputSchema - Zod schema for input validation
+     * @param config.outputSchema - Zod schema for output validation
+     * @param config.enableStreaming - Enable streaming for LLM calls (default: false)
+     * @param config.enableMemory - Enable memory subsystem (default: false)
+     * @param config.memory - Custom memory implementation (defaults to InMemoryStore if enableMemory is true)
+     * @param config.metadata - Additional metadata for the agent
+     * @param config.opperConfig - Opper API configuration (apiKey, baseUrl)
+     * @param config.opperClient - Custom Opper client instance (for testing or custom configuration)
+     * @param config.logger - Logger instance for debugging
+     * @param config.verbose - Enable verbose logging (default: false)
+     * @param config.onStreamStart - Handler invoked when streaming starts
+     * @param config.onStreamChunk - Handler invoked for each streaming chunk
+     * @param config.onStreamEnd - Handler invoked when streaming ends
+     * @param config.onStreamError - Handler invoked on streaming errors
+     */
     constructor(config: AgentConfig<TInput, TOutput>);
     /**
      * Serialize input for passing to LLM or spans
@@ -1268,6 +1529,7 @@ declare class Agent<TInput = unknown, TOutput = unknown> extends BaseAgent<TInpu
      * Think step: Call LLM to decide next action
      */
     private think;
+    private thinkStreaming;
     /**
      * Build static instructions for the think step
      */
@@ -1289,6 +1551,8 @@ declare class Agent<TInput = unknown, TOutput = unknown> extends BaseAgent<TInpu
      * Generate final result based on execution history
      */
     private generateFinalResult;
+    private generateFinalResultStreaming;
+    private trackStreamingUsageBySpan;
     /**
      * Log helper
      */
@@ -1387,6 +1651,10 @@ declare const AgentDecisionSchema: z.ZodObject<{
      * Agent's internal reasoning
      */
     reasoning: z.ZodString;
+    /**
+     * Status message for the user (e.g., "Searching for information...", "Processing results...")
+     */
+    userMessage: z.ZodDefault<z.ZodString>;
     /**
      * Tool calls to execute (if any)
      * Empty array signals task completion
@@ -1442,6 +1710,16 @@ declare const AgentDecisionSchema: z.ZodObject<{
         metadata?: Record<string, unknown> | undefined;
         description?: string | undefined;
     }>>>;
+    /**
+     * Whether the task is complete and finalResult is available
+     * (single LLM call pattern)
+     */
+    isComplete: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * The final result when isComplete=true
+     * Should match outputSchema if specified
+     */
+    finalResult: z.ZodOptional<z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
     toolCalls: {
         id: string;
@@ -1449,12 +1727,15 @@ declare const AgentDecisionSchema: z.ZodObject<{
         arguments?: unknown;
     }[];
     reasoning: string;
+    userMessage: string;
     memoryReads: string[];
     memoryUpdates: Record<string, {
         value?: unknown;
         metadata?: Record<string, unknown> | undefined;
         description?: string | undefined;
     }>;
+    isComplete: boolean;
+    finalResult?: unknown;
 }, {
     reasoning: string;
     toolCalls?: {
@@ -1462,14 +1743,28 @@ declare const AgentDecisionSchema: z.ZodObject<{
         toolName: string;
         arguments?: unknown;
     }[] | undefined;
+    userMessage?: string | undefined;
     memoryReads?: string[] | undefined;
     memoryUpdates?: Record<string, {
         value?: unknown;
         metadata?: Record<string, unknown> | undefined;
         description?: string | undefined;
     }> | undefined;
+    isComplete?: boolean | undefined;
+    finalResult?: unknown;
 }>;
 type AgentDecision = z.infer<typeof AgentDecisionSchema>;
+/**
+ * Create an AgentDecision schema with typed finalResult field.
+ *
+ * When outputSchema is provided, the finalResult field will be typed
+ * to that schema, allowing Opper to enforce the correct structure.
+ * When finalResult is undefined/null, it passes through without validation.
+ *
+ * @param outputSchema - Optional Zod schema for the final result
+ * @returns AgentDecision schema (original or dynamically created variant)
+ */
+declare function createAgentDecisionWithOutputSchema<T>(outputSchema?: z.ZodType<T>): z.ZodObject<z.ZodRawShape>;
 /**
  * Schema for tool execution result summary
  */
@@ -1793,6 +2088,37 @@ declare const schemaToJson: (schema: ZodTypeAny, options?: JsonSchemaOptions) =>
 declare const getSchemaDefault: <T>(schema: Schema<T>) => T | undefined;
 declare const mergeSchemaDefaults: <T extends Record<string, unknown>>(schema: Schema<T>, value: Partial<T>) => T;
 
+declare const STREAM_ROOT_PATH = "_root";
+interface StreamAssemblerOptions {
+    schema?: ZodTypeAny;
+}
+interface StreamFeedResult {
+    path: string;
+    accumulated: string;
+    snapshot: Record<string, string>;
+}
+interface StreamFinalizeResult {
+    type: "root" | "structured" | "empty";
+    rootText?: string;
+    structured?: unknown;
+}
+declare class StreamAssembler {
+    private readonly displayBuffers;
+    private readonly valueBuffers;
+    private readonly schema;
+    constructor(options?: StreamAssemblerOptions);
+    feed(chunk: {
+        delta?: unknown;
+        jsonPath?: string | null | undefined;
+    }): StreamFeedResult | null;
+    snapshot(): Record<string, string>;
+    hasStructuredFields(): boolean;
+    finalize(): StreamFinalizeResult;
+    getFieldBuffers(): Map<string, string>;
+    private reconstructStructured;
+}
+declare const createStreamAssembler: (options?: StreamAssemblerOptions) => StreamAssembler;
+
 /**
  * Options for creating a tool from a function
  */
@@ -1978,4 +2304,4 @@ declare class ToolRunner {
     };
 }
 
-export { Agent, type AgentConfig, AgentContext, type AgentContextOptions, type AgentContextSnapshot, type AgentDecision, AgentDecisionSchema, type AgentLogger, BaseAgent, type BaseAgentConfig, ConsoleLogger, type CreateSpanOptions, DEFAULT_MODEL, DEFAULT_RETRY_CONFIG, type ExecutionCycle, ExecutionCycleSchema, type Failure, type HookEventName, HookEvents, type HookHandler, HookManager, type HookPayload, type HookPayloadMap, type HookRegistration, InMemoryStore, type IterationSummary, type JsonSchemaOptions, LogLevel, MCPClient, type MCPClientOptions, type MCPServerConfig, type MCPServerConfigInput, MCPServerConfigSchema, type MCPTool, MCPToolProvider, type MCPToolProviderOptions, MCPconfig, type MaybePromise, type Memory, type MemoryCatalogEntry, type MemoryEntry, type MemoryEntryMetadata, MemoryEntryMetadataSchema, MemoryEntrySchema, type MemoryUpdate, MemoryUpdateSchema, type OpperCallOptions, type OpperCallResponse, OpperClient, type OpperClientConfig, type OpperSpan, Result, type RetryConfig, type Schema, SchemaValidationError, type SchemaValidationOptions, SilentLogger, type Success, type Thought, ThoughtSchema, type Tool, type ToolCall, type ToolCallRecord, ToolCallRecordSchema, ToolCallSchema, type ToolDefinition, type ToolExecutionContext, type ToolExecutionSummary, ToolExecutionSummarySchema, type ToolFailure, type ToolFunction, ToolMetadataSchema, type ToolOptions, type ToolProvider, type ToolResult, type ToolResultData, ToolResultFactory, ToolResultFailureSchema, type ToolResultInit, ToolResultSchema, ToolResultSuccessSchema, type ToolRunOptions, ToolRunner, type ToolSuccess, type UnregisterHook, type Usage, UsageSchema, type VisualizationOptions, coerceToolDefinition, createFunctionTool, createHookManager, createInMemoryStore, createMCPServerConfig, createOpperClient, createToolCallRecord, err, extractTools, generateAgentFlowDiagram, getDefaultLogger, getSchemaDefault, isSchemaValid, isToolProvider, mcp, mergeSchemaDefaults, normalizeToolEntries, ok, schemaToJson, setDefaultLogger, tool, validateSchema, validateToolInput };
+export { Agent, type AgentConfig, AgentContext, type AgentContextOptions, type AgentContextSnapshot, type AgentDecision, AgentDecisionSchema, AgentEventEmitter, type AgentEventListener, type AgentEventName, type AgentEventPayload, type AgentEventPayloadMap, AgentEvents, type AgentLogger, BaseAgent, type BaseAgentConfig, ConsoleLogger, type CreateSpanOptions, DEFAULT_MODEL, DEFAULT_RETRY_CONFIG, type ExecutionCycle, ExecutionCycleSchema, type Failure, type HookEventName, HookEvents, type HookHandler, HookManager, type HookPayload, type HookPayloadMap, type HookRegistration, InMemoryStore, type IterationSummary, type JsonSchemaOptions, LogLevel, MCPClient, type MCPClientOptions, type MCPServerConfig, type MCPServerConfigInput, MCPServerConfigSchema, type MCPTool, MCPToolProvider, type MCPToolProviderOptions, MCPconfig, type MaybePromise, type Memory, type MemoryCatalogEntry, type MemoryEntry, type MemoryEntryMetadata, MemoryEntryMetadataSchema, MemoryEntrySchema, type MemoryUpdate, MemoryUpdateSchema, type OpperCallOptions, type OpperCallResponse, OpperClient, type OpperClientConfig, type OpperSpan, type OpperStreamChunk, type OpperStreamEvent, type OpperStreamResponse, Result, type RetryConfig, STREAM_ROOT_PATH, type Schema, SchemaValidationError, type SchemaValidationOptions, SilentLogger, StreamAssembler, type StreamAssemblerOptions, type StreamFeedResult, type StreamFinalizeResult, type Success, type Thought, ThoughtSchema, type Tool, type ToolCall, type ToolCallRecord, ToolCallRecordSchema, ToolCallSchema, type ToolDefinition, type ToolExecutionContext, type ToolExecutionSummary, ToolExecutionSummarySchema, type ToolFailure, type ToolFunction, ToolMetadataSchema, type ToolOptions, type ToolProvider, type ToolResult, type ToolResultData, ToolResultFactory, ToolResultFailureSchema, type ToolResultInit, ToolResultSchema, ToolResultSuccessSchema, type ToolRunOptions, ToolRunner, type ToolSuccess, type UnregisterHook, type Usage, UsageSchema, type VisualizationOptions, coerceToolDefinition, createAgentDecisionWithOutputSchema, createFunctionTool, createHookManager, createInMemoryStore, createMCPServerConfig, createOpperClient, createStreamAssembler, createToolCallRecord, err, extractTools, generateAgentFlowDiagram, getDefaultLogger, getSchemaDefault, isSchemaValid, isToolProvider, mcp, mergeSchemaDefaults, normalizeToolEntries, ok, schemaToJson, setDefaultLogger, tool, validateSchema, validateToolInput };