@opperai/agents 0.3.0 → 0.4.1

package/dist/index.d.cts

@@ -201,6 +201,8 @@ interface ToolSuccess<TOutput> {
     toolName: string;
     output: TOutput;
     metadata: Record<string, unknown>;
+    /** Optional usage statistics - only present for agent-as-tool, omitted for regular tools */
+    usage?: Usage;
     startedAt?: number;
     finishedAt?: number;
 }
@@ -209,14 +211,31 @@ interface ToolFailure {
     toolName: string;
     error: Error | string;
     metadata: Record<string, unknown>;
+    /** Optional usage statistics - included even on failure since partial work may have been done */
+    usage?: Usage;
     startedAt?: number;
     finishedAt?: number;
 }
 type ToolResult<TOutput = unknown> = ToolSuccess<TOutput> | ToolFailure;
+/**
+ * Example of a tool execution with input and expected output
+ */
+interface ToolExample<TInput, TOutput> {
+    /** Example input to the tool */
+    input: TInput;
+    /** Expected output from the tool */
+    output: TOutput;
+    /** Optional description of what this example demonstrates */
+    description?: string;
+}
 interface ToolDefinition<TInput, TOutput> {
     name: string;
     description?: string;
     schema?: ZodType<TInput>;
+    /** Optional schema describing the tool's output structure */
+    outputSchema?: ZodType<TOutput>;
+    /** Optional examples of tool usage to help the LLM understand expected behavior */
+    examples?: Array<ToolExample<TInput, TOutput>>;
     execute: (input: TInput, context: ToolExecutionContext) => MaybePromise<ToolResult<TOutput>>;
     metadata?: Record<string, unknown>;
     timeoutMs?: number;
@@ -229,6 +248,8 @@ interface ToolProvider {
 }
 interface ToolResultInit {
     metadata?: Record<string, unknown>;
+    /** Optional usage statistics - only for agent-as-tool */
+    usage?: Usage;
     startedAt?: number;
     finishedAt?: number;
 }
@@ -247,6 +268,55 @@ declare const normalizeToolEntries: (entries: Array<Tool<unknown, unknown> | Too
     providers: Array<ToolProvider>;
 };
 
+/**
+ * Base usage schema without breakdown (to avoid circular reference)
+ */
+declare const BaseUsageSchema: z.ZodObject<{
+    requests: z.ZodDefault<z.ZodNumber>;
+    inputTokens: z.ZodDefault<z.ZodNumber>;
+    outputTokens: z.ZodDefault<z.ZodNumber>;
+    totalTokens: z.ZodDefault<z.ZodNumber>;
+    cost: z.ZodDefault<z.ZodObject<{
+        generation: z.ZodDefault<z.ZodNumber>;
+        platform: z.ZodDefault<z.ZodNumber>;
+        total: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        generation: number;
+        platform: number;
+        total: number;
+    }, {
+        generation?: number | undefined;
+        platform?: number | undefined;
+        total?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cost: {
+        generation: number;
+        platform: number;
+        total: number;
+    };
+}, {
+    requests?: number | undefined;
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+    totalTokens?: number | undefined;
+    cost?: {
+        generation?: number | undefined;
+        platform?: number | undefined;
+        total?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Base usage type (without breakdown) - used for breakdown entries
+ */
+type BaseUsage = z.infer<typeof BaseUsageSchema>;
+/**
+ * Full usage schema with optional breakdown for nested agent tracking
+ */
 declare const UsageSchema: z.ZodObject<{
     requests: z.ZodDefault<z.ZodNumber>;
     inputTokens: z.ZodDefault<z.ZodNumber>;
@@ -265,6 +335,50 @@ declare const UsageSchema: z.ZodObject<{
         platform?: number | undefined;
         total?: number | undefined;
     }>>;
+} & {
+    /**
+     * Optional breakdown of usage by source (agent name).
+     * Only present when nested agents are used.
+     */
+    breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodObject<{
+        requests: z.ZodDefault<z.ZodNumber>;
+        inputTokens: z.ZodDefault<z.ZodNumber>;
+        outputTokens: z.ZodDefault<z.ZodNumber>;
+        totalTokens: z.ZodDefault<z.ZodNumber>;
+        cost: z.ZodDefault<z.ZodObject<{
+            generation: z.ZodDefault<z.ZodNumber>;
+            platform: z.ZodDefault<z.ZodNumber>;
+            total: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            generation: number;
+            platform: number;
+            total: number;
+        }, {
+            generation?: number | undefined;
+            platform?: number | undefined;
+            total?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        requests: number;
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        cost: {
+            generation: number;
+            platform: number;
+            total: number;
+        };
+    }, {
+        requests?: number | undefined;
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        totalTokens?: number | undefined;
+        cost?: {
+            generation?: number | undefined;
+            platform?: number | undefined;
+            total?: number | undefined;
+        } | undefined;
+    }>>>>;
 }, "strip", z.ZodTypeAny, {
     requests: number;
     inputTokens: number;
@@ -275,6 +389,17 @@ declare const UsageSchema: z.ZodObject<{
         platform: number;
         total: number;
     };
+    breakdown?: Record<string, {
+        requests: number;
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        cost: {
+            generation: number;
+            platform: number;
+            total: number;
+        };
+    }> | undefined;
 }, {
     requests?: number | undefined;
     inputTokens?: number | undefined;
@@ -285,8 +410,27 @@ declare const UsageSchema: z.ZodObject<{
         platform?: number | undefined;
         total?: number | undefined;
     } | undefined;
+    breakdown?: Record<string, {
+        requests?: number | undefined;
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        totalTokens?: number | undefined;
+        cost?: {
+            generation?: number | undefined;
+            platform?: number | undefined;
+            total?: number | undefined;
+        } | undefined;
+    }> | undefined;
 }>;
 type Usage = z.infer<typeof UsageSchema>;
+/**
+ * Create an empty usage object with all values set to 0
+ */
+declare function createEmptyUsage(): Usage;
+/**
+ * Add two usage objects together, returning a new usage object
+ */
+declare function addUsage(a: Usage, b: Usage): Usage;
 declare const ExecutionCycleSchema: z.ZodObject<{
     iteration: z.ZodNumber;
     thought: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
@@ -414,6 +558,21 @@ declare class AgentContext {
     updatedAt: number;
     constructor(options: AgentContextOptions);
     updateUsage(delta: Usage): void;
+    /**
+     * Update usage with source tracking for nested agent aggregation.
+     * This method updates the total usage AND tracks it by source in the breakdown.
+     *
+     * @param source - The source name (typically the agent/tool name)
+     * @param delta - The usage to add
+     */
+    updateUsageWithSource(source: string, delta: Usage): void;
+    /**
+     * Clean up the usage breakdown if it only contains the parent agent.
+     * This ensures breakdown is only present when there are nested agents.
+     *
+     * @param parentAgentName - The name of the parent agent to check for
+     */
+    cleanupBreakdownIfOnlyParent(parentAgentName: string): void;
     addCycle(cycle: ExecutionCycle): ExecutionCycle;
     recordToolCall(call: Omit<ToolCallRecord, "id">): ToolCallRecord;
     getContextSize(): number;
@@ -622,28 +781,6 @@ 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
  */
@@ -719,8 +856,8 @@ declare const MemoryEntrySchema: z.ZodObject<{
         updatedAt: number;
         accessCount: number;
     };
-    description: string;
     key: string;
+    description: string;
     value?: unknown;
 }, {
     metadata: {
@@ -728,8 +865,8 @@ declare const MemoryEntrySchema: z.ZodObject<{
         updatedAt: number;
         accessCount?: number | undefined;
     };
-    description: string;
     key: string;
+    description: string;
     value?: unknown;
 }>;
 type MemoryEntry = z.infer<typeof MemoryEntrySchema>;
@@ -885,19 +1022,19 @@ interface BaseAgentConfig<TInput, TOutput> {
     /**
      * Register a handler invoked when a streaming call starts.
      */
-    onStreamStart?: AgentEventListener<typeof HookEvents.StreamStart>;
+    onStreamStart?: HookHandler<typeof HookEvents.StreamStart>;
     /**
      * Register a handler invoked for each streaming chunk.
      */
-    onStreamChunk?: AgentEventListener<typeof HookEvents.StreamChunk>;
+    onStreamChunk?: HookHandler<typeof HookEvents.StreamChunk>;
     /**
      * Register a handler invoked when a streaming call ends.
      */
-    onStreamEnd?: AgentEventListener<typeof HookEvents.StreamEnd>;
+    onStreamEnd?: HookHandler<typeof HookEvents.StreamEnd>;
     /**
      * Register a handler invoked when streaming encounters an error.
      */
-    onStreamError?: AgentEventListener<typeof HookEvents.StreamError>;
+    onStreamError?: HookHandler<typeof HookEvents.StreamError>;
     /**
      * Enable memory subsystem
      * @default false
@@ -989,10 +1126,6 @@ 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
      */
@@ -1047,11 +1180,38 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
      * Main entry point for agent execution.
      * Orchestrates lifecycle: context initialization, hook triggering, loop execution, teardown.
      *
+     * **Note:** This method will be removed in a future update.
+     * Consider using {@link run} instead, which returns both result and usage statistics.
+     *
      * @param input - Input to process
      * @param parentSpanId - Optional parent span ID for tracing
      * @returns Processed output
      */
     process(input: TInput, parentSpanId?: string): Promise<TOutput>;
+    /**
+     * Process input and return both result and usage statistics.
+     * This is the recommended method for agent execution.
+     *
+     * @param input - Input to process
+     * @param parentSpanId - Optional parent span ID for tracing
+     * @returns Object containing the result and usage statistics
+     */
+    run(input: TInput, parentSpanId?: string): Promise<{
+        result: TOutput;
+        usage: Usage;
+    }>;
+    /**
+     * Internal method that executes the process and returns both result and usage.
+     * This is the core implementation shared by process() and run().
+     *
+     * @param input - Input to process
+     * @param parentSpanId - Optional parent span ID for tracing
+     * @returns Object containing the result and usage statistics
+     */
+    protected executeProcess(input: TInput, parentSpanId?: string): Promise<{
+        result: TOutput;
+        usage: Usage;
+    }>;
     /**
      * Abstract method implementing the agent's main loop logic.
      * Must be implemented by concrete agent classes.
@@ -1111,6 +1271,8 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
     addToolProvider(provider: ToolProvider): void;
     /**
      * Convert this agent into a tool that can be used by other agents.
+     * When used as a tool, the nested agent's usage statistics are propagated
+     * back to the parent agent for aggregation.
      *
      * @param toolName - Optional custom name for the tool (defaults to agent name)
      * @param toolDescription - Optional custom description (defaults to agent description)
@@ -1127,27 +1289,29 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
     registerHook<E extends HookEventName>(event: E, handler: HookHandler<E>): () => void;
     /**
      * Register an event listener.
+     * This is equivalent to registerHook() - both methods use the unified hook system.
      *
-     * @param event - Event name
+     * @param event - Event name (any HookEvents value)
      * @param listener - Listener callback
      * @returns Cleanup function to unregister the listener
      */
-    on<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): () => void;
+    on<E extends HookEventName>(event: E, listener: HookHandler<E>): () => void;
     /**
      * Register a one-time event listener that removes itself after the first call.
+     * This is equivalent to calling registerHook() with a self-removing handler.
      *
-     * @param event - Event name
+     * @param event - Event name (any HookEvents value)
      * @param listener - Listener callback
      * @returns Cleanup function (no-op once listener fires)
      */
-    once<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): () => void;
+    once<E extends HookEventName>(event: E, listener: HookHandler<E>): () => void;
     /**
      * Remove a previously registered event listener.
      *
-     * @param event - Event name
+     * @param event - Event name (any HookEvents value)
      * @param listener - Listener callback to remove
      */
-    off<E extends AgentEventName>(event: E, listener: AgentEventListener<E>): void;
+    off<E extends HookEventName>(event: E, listener: HookHandler<E>): void;
     /**
      * Trigger a hook event with a payload.
      * Swallows errors to prevent hook failures from breaking agent execution.
@@ -1156,13 +1320,6 @@ 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.
      *
@@ -1203,6 +1360,57 @@ declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> {
     visualizeFlow(options?: VisualizationOptions): Promise<string>;
 }
 
+/**
+ * Event system types for backwards compatibility.
+ *
+ * The agent.on(), agent.once(), and agent.off() methods now use the unified
+ * hook system internally. These type aliases are provided for backwards
+ * compatibility with existing code that imports from this module.
+ *
+ * @module events
+ */
+
+/**
+ * AgentEvents is an alias for HookEvents.
+ * All 17 hook events are available through agent.on() and agent.registerHook().
+ */
+declare const AgentEvents: {
+    readonly AgentStart: "agent:start";
+    readonly AgentEnd: "agent:end";
+    readonly LoopStart: "loop:start";
+    readonly LoopEnd: "loop:end";
+    readonly LlmCall: "llm:call";
+    readonly LlmResponse: "llm:response";
+    readonly ThinkEnd: "think:end";
+    readonly BeforeTool: "tool:before";
+    readonly AfterTool: "tool:after";
+    readonly ToolError: "tool:error";
+    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";
+};
+/**
+ * AgentEventName is an alias for HookEventName.
+ */
+type AgentEventName = HookEventName;
+/**
+ * AgentEventPayloadMap is an alias for HookPayloadMap.
+ */
+type AgentEventPayloadMap = HookPayloadMap;
+/**
+ * AgentEventPayload extracts the payload type for a specific event.
+ */
+type AgentEventPayload<E extends AgentEventName> = AgentEventPayloadMap[E];
+/**
+ * AgentEventListener is an alias for HookHandler.
+ * Handlers can return void or Promise<void>.
+ */
+type AgentEventListener<E extends AgentEventName> = HookHandler<E>;
+
 /**
  * Streaming chunk payload from Opper SSE responses.
  */
@@ -2128,7 +2336,7 @@ declare const createStreamAssembler: (options?: StreamAssemblerOptions) => Strea
 /**
  * Options for creating a tool from a function
  */
-interface ToolOptions<TInput> {
+interface ToolOptions<TInput, TOutput = unknown> {
     /**
      * Tool name (defaults to function name)
      */
@@ -2141,6 +2349,14 @@ interface ToolOptions<TInput> {
      * Input validation schema
      */
     schema?: ZodType<TInput>;
+    /**
+     * Output schema describing what the tool returns (exposed to LLM)
+     */
+    outputSchema?: ZodType<TOutput>;
+    /**
+     * Examples of tool usage to help the LLM understand expected behavior
+     */
+    examples?: Array<ToolExample<TInput, TOutput>>;
     /**
      * Execution timeout in milliseconds
      */
@@ -2172,11 +2388,15 @@ type ToolMethodDecorator<TInput, TOutput> = {
  *   {
  *     name: "add",
  *     description: "Add two numbers",
- *     schema: z.object({ a: z.number(), b: z.number() })
+ *     schema: z.object({ a: z.number(), b: z.number() }),
+ *     outputSchema: z.number(),
+ *     examples: [
+ *       { input: { a: 2, b: 3 }, output: 5, description: "Basic addition" },
+ *     ],
  *   }
  * );
  */
-declare function createFunctionTool<TInput, TOutput>(fn: ToolFunction<TInput, TOutput>, options?: ToolOptions<TInput>): Tool<TInput, TOutput>;
+declare function createFunctionTool<TInput, TOutput>(fn: ToolFunction<TInput, TOutput>, options?: ToolOptions<TInput, TOutput>): Tool<TInput, TOutput>;
 /**
  * Decorator factory for creating tools from methods.
  * Can be used with or without arguments.
@@ -2192,7 +2412,7 @@ declare function createFunctionTool<TInput, TOutput>(fn: ToolFunction<TInput, TO
  *   }
  * }
  */
-declare function tool<TInput = unknown, TOutput = unknown>(options?: ToolOptions<TInput>): ToolMethodDecorator<TInput, TOutput>;
+declare function tool<TInput = unknown, TOutput = unknown>(options?: ToolOptions<TInput, TOutput>): ToolMethodDecorator<TInput, TOutput>;
 /**
  * Extract all tools defined via @tool decorator from a class instance
  *
@@ -2310,4 +2530,4 @@ declare class ToolRunner {
     };
 }
 
-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, zodSchemaToJsonSchema };
+export { Agent, type AgentConfig, AgentContext, type AgentContextOptions, type AgentContextSnapshot, type AgentDecision, AgentDecisionSchema, type AgentEventListener, type AgentEventName, type AgentEventPayload, type AgentEventPayloadMap, AgentEvents, type AgentLogger, BaseAgent, type BaseAgentConfig, type BaseUsage, BaseUsageSchema, 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 ToolExample, 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, addUsage, coerceToolDefinition, createAgentDecisionWithOutputSchema, createEmptyUsage, createFunctionTool, createHookManager, createInMemoryStore, createMCPServerConfig, createOpperClient, createStreamAssembler, createToolCallRecord, err, extractTools, generateAgentFlowDiagram, getDefaultLogger, getSchemaDefault, isSchemaValid, isToolProvider, mcp, mergeSchemaDefaults, normalizeToolEntries, ok, schemaToJson, setDefaultLogger, tool, validateSchema, validateToolInput, zodSchemaToJsonSchema };