@anvia/core 0.1.4 → 0.2.0

package/dist/agent/index.d.ts

@@ -1,18 +1,18 @@
 import { MemoryStore, MemoryOptions } from '../memory/index.js';
 export { MemoryAppendInput, MemoryContext, MemoryErrorInput, MemoryRegistration, MemorySavePolicy, ResolvedMemoryOptions, SessionOptions, resolveMemoryOptions } from '../memory/index.js';
-import { f as DynamicContextOptions, h as DynamicToolOptions, P as PromptHook, A as Agent } from '../agent-D5KKP9_z.js';
-export { a as AgentOptions, b as AgentSession, c as AgentStreamEvent, d as AgentToolOptions, C as CompletionCallHookArgs, e as CompletionResponseHookArgs, D as DEFAULT_MAX_TURNS, g as DynamicContextRegistration, i as DynamicToolRegistration, H as HookAction, j as HookResult, k as PromptRequest, l as PromptResponse, R as RunControl, T as ToolCallControl, m as ToolCallHookAction, n as ToolCallHookArgs, o as ToolCallHookResult, p as ToolHookArgs, q as ToolResultHookArgs, r as cancelPrompt, s as createHook, t as runControl, u as skipTool, v as toolCallControl } from '../agent-D5KKP9_z.js';
+import { m as DynamicContextOptions, o as DynamicToolOptions, P as PromptHook, d as AgentEventStore, f as AgentEventStoreOptions, A as Agent } from '../agent-CkVbMA1A.js';
+export { a as AgentChildStreamEvent, b as AgentEventAppendInput, c as AgentEventRecord, e as AgentEventStoreInclude, g as AgentEventStoreRegistration, h as AgentOptions, i as AgentSession, j as AgentStreamEvent, k as AgentToolOptions, C as CompletionCallHookArgs, l as CompletionResponseHookArgs, D as DEFAULT_MAX_TURNS, n as DynamicContextRegistration, p as DynamicToolRegistration, H as HookAction, q as HookResult, r as PromptRequest, s as PromptResponse, R as RunControl, T as ToolApprovalRequestOptions, t as ToolCallControl, u as ToolCallHookAction, v as ToolCallHookArgs, w as ToolCallHookResult, x as ToolHookArgs, y as ToolResultHookArgs, z as cancelPrompt, B as createHook, E as requestToolApproval, F as runControl, G as skipTool, I as toolCallControl } from '../agent-CkVbMA1A.js';
 import { b as CompletionModel, j as JsonValue, o as ToolChoice, M as Message } from '../types-BrxLd7ay.js';
-import { c as McpServer } from '../types-B5B8Sdl4.js';
+import { c as McpServer } from '../types-ChJoZ0OH.js';
 import { AgentObserver, ObserveOptions } from '../observability/index.js';
-import { b as ToolSearchDocument, c as ToolSet, T as ToolMiddleware, Z as ZodSchema } from '../zod-schema-Cq_9zlmJ.js';
-import { b as SkillSet } from '../types-HvopERm0.js';
-import { A as AnyTool } from '../tool-DhuBQ3yb.js';
+import { b as ToolSearchDocument, c as ToolSet, T as ToolMiddleware, Z as ZodSchema } from '../middleware-2iCGCsB6.js';
+import { b as SkillSet } from '../types-21n32ltl.js';
+import { A as AnyTool } from '../tool-DiWtAf_Q.js';
 import { VectorSearchIndex } from '../vector-store/index.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import '../embeddings/index.js';
 import 'zod';
+import '../embeddings/index.js';
 
 declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     private readonly completionModel;
@@ -34,6 +34,7 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     private dynamicToolRegistrations;
     private middlewareRegistrations;
     private memoryRegistration;
+    private eventStoreRegistration;
     private activeToolSet;
     constructor(agentId: string, completionModel: M);
     name(name: string): this;
@@ -57,6 +58,7 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     toolMiddlewares(middlewares: ToolMiddleware[]): this;
     observe(observer: AgentObserver, options?: ObserveOptions): this;
     memory(store: MemoryStore, options?: MemoryOptions): this;
+    eventStore(store: AgentEventStore, options?: AgentEventStoreOptions): this;
     outputSchema(schema: ZodSchema): this;
     build(): Agent<M>;
     private buildInstructions;
@@ -74,4 +76,4 @@ declare class PromptCancelledError extends Error {
     constructor(chatHistory: Message[], reason: string);
 }
 
-export { Agent, AgentBuilder, DynamicContextOptions, DynamicToolOptions, MaxTurnsError, MemoryOptions, MemoryStore, PromptCancelledError, PromptHook };
+export { Agent, AgentBuilder, AgentEventStore, AgentEventStoreOptions, DynamicContextOptions, DynamicToolOptions, MaxTurnsError, MemoryOptions, MemoryStore, PromptCancelledError, PromptHook };

package/dist/agent/index.js

@@ -8,16 +8,17 @@ import {
   PromptRequest,
   cancelPrompt,
   createHook,
+  requestToolApproval,
   runControl,
   skipTool,
   toolCallControl
-} from "../chunk-67X6U5HI.js";
+} from "../chunk-HGJDC56F.js";
 import {
   resolveMemoryOptions
 } from "../chunk-XXT2UCAR.js";
 import "../chunk-YK4WAAS4.js";
-import "../chunk-GNWMOSNR.js";
-import "../chunk-B4QHQN5K.js";
+import "../chunk-3H7FVGHU.js";
+import "../chunk-445TT5Q5.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-CP47FBJV.js";
 export {
@@ -30,6 +31,7 @@ export {
   PromptRequest,
   cancelPrompt,
   createHook,
+  requestToolApproval,
   resolveMemoryOptions,
   runControl,
   skipTool,

package/dist/{agent-D5KKP9_z.d.ts → agent-CkVbMA1A.d.ts}

@@ -1,8 +1,8 @@
 import { M as Message, e as CompletionResponse, b as CompletionModel, U as Usage, l as ReasoningContentType, n as ToolCall, D as Document, j as JsonValue, o as ToolChoice, J as JsonObject } from './types-BrxLd7ay.js';
 import { MemoryContext, MemoryRegistration, SessionOptions } from './memory/index.js';
 import { AgentTraceOptions, AgentTraceInfo, AgentObserverRegistration } from './observability/index.js';
-import { T as ToolMiddleware, c as ToolSet, b as ToolSearchDocument } from './zod-schema-Cq_9zlmJ.js';
-import { T as Tool, A as AnyTool } from './tool-DhuBQ3yb.js';
+import { T as ToolMiddleware, c as ToolSet, b as ToolSearchDocument } from './middleware-2iCGCsB6.js';
+import { T as Tool, A as AnyTool, d as ToolCallContext } from './tool-DiWtAf_Q.js';
 import { VectorSearchIndex, VectorFilter, VectorSearchResult } from './vector-store/index.js';
 
 type HookAction = {
@@ -11,6 +11,10 @@ type HookAction = {
     type: "terminate";
     reason: string;
 };
+type ToolApprovalRequestOptions = {
+    reason?: string;
+    rejectMessage?: string;
+};
 type ToolCallHookAction = {
     type: "continue";
 } | {
@@ -19,7 +23,9 @@ type ToolCallHookAction = {
 } | {
     type: "terminate";
     reason: string;
-};
+} | ({
+    type: "approval_request";
+} & ToolApprovalRequestOptions);
 type RunControl = {
     continue(): HookAction;
     cancel(reason: string): HookAction;
@@ -28,6 +34,7 @@ type ToolCallControl = {
     run(): ToolCallHookAction;
     skip(reason: string): ToolCallHookAction;
     cancel(reason: string): ToolCallHookAction;
+    requestApproval(options?: ToolApprovalRequestOptions): ToolCallHookAction;
 };
 type HookResult = HookAction | undefined;
 type ToolCallHookResult = ToolCallHookAction | undefined;
@@ -59,6 +66,7 @@ type ToolResultHookArgs = ToolHookArgs & {
 declare function createHook<RawResponse = unknown>(hook: PromptHook<RawResponse>): PromptHook<RawResponse>;
 declare function cancelPrompt(reason: string): HookAction;
 declare function skipTool(reason: string): ToolCallHookAction;
+declare function requestToolApproval(options?: ToolApprovalRequestOptions): ToolCallHookAction;
 declare const runControl: RunControl;
 declare const toolCallControl: ToolCallControl;
 interface PromptHook<RawResponse = unknown> {
@@ -74,7 +82,7 @@ type PromptResponse = {
     messages: Message[];
     trace?: AgentTraceInfo | undefined;
 };
-type AgentStreamEvent<RawResponse = unknown> = {
+type AgentChildStreamEvent<RawResponse = unknown> = {
     type: "turn_start";
     turn: number;
     prompt: Message;
@@ -108,6 +116,7 @@ type AgentStreamEvent<RawResponse = unknown> = {
     response: CompletionResponse<RawResponse>;
 } | {
     type: "final";
+    runId: string;
     output: string;
     usage: Usage;
     messages: Message[];
@@ -116,6 +125,16 @@ type AgentStreamEvent<RawResponse = unknown> = {
     type: "error";
     error: unknown;
 };
+type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse> | {
+    type: "agent_tool_event";
+    turn: number;
+    toolName: string;
+    toolCallId?: string;
+    internalCallId: string;
+    agentId: string;
+    agentName?: string;
+    event: AgentChildStreamEvent<RawResponse>;
+};
 declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private readonly agent;
     private readonly promptMessage;
@@ -144,6 +163,7 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private executeToolCalls;
     private runToolResultMiddlewares;
     private startRunObservers;
+    private recordAgentEvent;
     private fetchDynamicContext;
     private fetchToolDefinitions;
     private recordToolError;
@@ -179,12 +199,40 @@ type AgentOptions<M extends CompletionModel = CompletionModel> = {
     dynamicTools?: DynamicToolRegistration[] | undefined;
     toolMiddlewares?: ToolMiddleware[] | undefined;
     memory?: MemoryRegistration | undefined;
+    eventStore?: AgentEventStoreRegistration | undefined;
 };
 declare const DEFAULT_MAX_TURNS = 20;
 type AgentToolOptions = {
     name: string;
     description?: string | undefined;
     maxTurns?: number | undefined;
+    stream?: boolean | undefined;
+};
+type AgentEventStoreInclude = "all" | "agent_tool_events";
+type AgentEventStoreOptions = {
+    include?: AgentEventStoreInclude | undefined;
+};
+type AgentEventAppendInput = {
+    runId: string;
+    agentId: string;
+    agentName?: string | undefined;
+    turn?: number | undefined;
+    toolName?: string | undefined;
+    toolCallId?: string | undefined;
+    internalCallId?: string | undefined;
+    event: unknown;
+};
+type AgentEventRecord = AgentEventAppendInput & {
+    createdAt?: Date | undefined;
+};
+interface AgentEventStore {
+    append(input: AgentEventAppendInput): Promise<void>;
+    load(runId: string): Promise<AgentEventRecord[]>;
+    clear?(runId: string): Promise<void>;
+}
+type AgentEventStoreRegistration = {
+    store: AgentEventStore;
+    options: Required<AgentEventStoreOptions>;
 };
 type DynamicContextOptions<T = unknown> = {
     topK: number;
@@ -225,6 +273,7 @@ declare class Agent<M extends CompletionModel = CompletionModel> {
     readonly dynamicTools: DynamicToolRegistration[];
     readonly toolMiddlewares: ToolMiddleware[];
     readonly memory: MemoryRegistration | undefined;
+    readonly eventStore: AgentEventStoreRegistration | undefined;
     constructor(options: AgentOptions<M>);
     prompt(prompt: string | Message | Message[]): PromptRequest<M>;
     session(sessionId: string, options?: SessionOptions): AgentSession<M>;
@@ -232,7 +281,7 @@ declare class Agent<M extends CompletionModel = CompletionModel> {
         prompt: string;
     }, string>;
     getTool(toolName: string): AnyTool | undefined;
-    callTool(toolName: string, args: string): Promise<string>;
+    callTool(toolName: string, args: string, context?: ToolCallContext): Promise<string>;
     shouldApplyToolMiddleware(toolName: string): boolean;
 }
 declare class AgentSession<M extends CompletionModel = CompletionModel> {
@@ -248,4 +297,4 @@ declare class AgentSession<M extends CompletionModel = CompletionModel> {
     clear(): Promise<void>;
 }
 
-export { Agent as A, type CompletionCallHookArgs as C, DEFAULT_MAX_TURNS as D, type HookAction as H, type PromptHook as P, type RunControl as R, type ToolCallControl as T, type AgentOptions as a, AgentSession as b, type AgentStreamEvent as c, type AgentToolOptions as d, type CompletionResponseHookArgs as e, type DynamicContextOptions as f, type DynamicContextRegistration as g, type DynamicToolOptions as h, type DynamicToolRegistration as i, type HookResult as j, PromptRequest as k, type PromptResponse as l, type ToolCallHookAction as m, type ToolCallHookArgs as n, type ToolCallHookResult as o, type ToolHookArgs as p, type ToolResultHookArgs as q, cancelPrompt as r, createHook as s, runControl as t, skipTool as u, toolCallControl as v };
+export { Agent as A, createHook as B, type CompletionCallHookArgs as C, DEFAULT_MAX_TURNS as D, requestToolApproval as E, runControl as F, skipTool as G, type HookAction as H, toolCallControl as I, type PromptHook as P, type RunControl as R, type ToolApprovalRequestOptions as T, type AgentChildStreamEvent as a, type AgentEventAppendInput as b, type AgentEventRecord as c, type AgentEventStore as d, type AgentEventStoreInclude as e, type AgentEventStoreOptions as f, type AgentEventStoreRegistration as g, type AgentOptions as h, AgentSession as i, type AgentStreamEvent as j, type AgentToolOptions as k, type CompletionResponseHookArgs as l, type DynamicContextOptions as m, type DynamicContextRegistration as n, type DynamicToolOptions as o, type DynamicToolRegistration as p, type HookResult as q, PromptRequest as r, type PromptResponse as s, type ToolCallControl as t, type ToolCallHookAction as u, type ToolCallHookArgs as v, type ToolCallHookResult as w, type ToolHookArgs as x, type ToolResultHookArgs as y, cancelPrompt as z };

package/dist/{chunk-JDPPZCOY.js → chunk-2VCWYCPV.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-YK4WAAS4.js";
 import {
   createTool
-} from "./chunk-B4QHQN5K.js";
+} from "./chunk-445TT5Q5.js";
 
 // src/skills/instructions.ts
 function skillInstructions(skills) {
@@ -395,4 +395,4 @@ export {
   SkillValidationError,
   skill
 };
-//# sourceMappingURL=chunk-JDPPZCOY.js.map
+//# sourceMappingURL=chunk-2VCWYCPV.js.map

package/dist/{chunk-GNWMOSNR.js → chunk-3H7FVGHU.js}

@@ -79,7 +79,7 @@ var ToolSet = class _ToolSet {
     }
     return defs;
   }
-  async call(toolName, args) {
+  async call(toolName, args, context) {
     const tool = this.tools.get(toolName);
     if (tool === void 0) {
       throw new ToolNotFoundError(toolName);
@@ -91,7 +91,7 @@ var ToolSet = class _ToolSet {
       throw new ToolJsonError(`Invalid JSON arguments for tool ${toolName}`, error);
     }
     try {
-      const output = await tool.call(parsedArgs);
+      const output = await tool.call(parsedArgs, context);
       return serializeToolOutput(output);
     } catch (error) {
       if (error instanceof Error) {
@@ -110,4 +110,4 @@ export {
   parseToolArgs,
   ToolSet
 };
-//# sourceMappingURL=chunk-GNWMOSNR.js.map
+//# sourceMappingURL=chunk-3H7FVGHU.js.map

package/dist/chunk-3H7FVGHU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tool/errors.ts","../src/tool/tool.ts","../src/tool/tool-set.ts"],"sourcesContent":["export class ToolCallError extends Error {\n  constructor(\n    message: string,\n    readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"ToolCallError\";\n  }\n}\n\nexport class ToolNotFoundError extends Error {\n  constructor(readonly toolName: string) {\n    super(`Tool not found: ${toolName}`);\n    this.name = \"ToolNotFoundError\";\n  }\n}\n\nexport class ToolJsonError extends Error {\n  constructor(\n    message: string,\n    readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"ToolJsonError\";\n  }\n}\n","import type { JsonObject, JsonValue, ToolDefinition } from \"../completion/types\";\n\nexport type ToolApprovalRunContext = {\n  agentId: string;\n  runId: string;\n  sessionId?: string;\n  metadata?: JsonObject;\n};\n\nexport type ToolApprovalContext<Args = unknown> = {\n  toolName: string;\n  args: Args;\n  rawArgs: string;\n  toolCallId?: string;\n  internalCallId: string;\n  run: ToolApprovalRunContext;\n};\n\nexport type ToolApprovalPolicy<Args = unknown> = {\n  when(ctx: ToolApprovalContext<Args>): boolean | Promise<boolean>;\n  reason?: string | ((ctx: ToolApprovalContext<Args>) => string | Promise<string>);\n  rejectMessage?: string | ((ctx: ToolApprovalContext<Args>) => string | Promise<string>);\n};\n\nexport type ToolCallStreamEvent = {\n  agentId: string;\n  agentName?: string | undefined;\n  event: unknown;\n};\n\nexport type ToolCallContext = {\n  emitStreamEvent?(event: ToolCallStreamEvent): void | Promise<void>;\n};\n\nexport interface Tool<Args = unknown, Output = unknown> {\n  readonly name: string;\n  readonly approval?: ToolApprovalPolicy<Args>;\n  definition(prompt: string): ToolDefinition | Promise<ToolDefinition>;\n  call(args: Args, context?: ToolCallContext): Output | Promise<Output>;\n  parseApprovalArgs?(args: unknown): Args;\n}\n\nexport type AnyTool = Omit<Tool<unknown, unknown>, \"approval\"> & {\n  readonly approval?: unknown;\n};\n\nexport function serializeToolOutput(output: unknown): string {\n  if (typeof output === \"string\") {\n    return output;\n  }\n\n  const serialized = JSON.stringify(output);\n  return serialized === undefined ? String(output) : serialized;\n}\n\nexport function parseToolArgs(args: string): JsonValue {\n  if (args.trim() === \"\") {\n    return {};\n  }\n\n  return JSON.parse(args) as JsonValue;\n}\n","import type { ToolDefinition } from \"../completion/types\";\nimport { ToolCallError, ToolJsonError, ToolNotFoundError } from \"./errors\";\nimport { type AnyTool, parseToolArgs, serializeToolOutput, type ToolCallContext } from \"./tool\";\n\nexport class ToolSet {\n  private readonly tools = new Map<string, AnyTool>();\n\n  static fromTools(tools: AnyTool[]): ToolSet {\n    const toolSet = new ToolSet();\n    for (const tool of tools) {\n      toolSet.addTool(tool);\n    }\n    return toolSet;\n  }\n\n  addTool(tool: AnyTool): this {\n    this.tools.set(tool.name, tool);\n    return this;\n  }\n\n  addTools(tools: AnyTool[] | ToolSet): this {\n    const values = Array.isArray(tools) ? tools : tools.values();\n    for (const tool of values) {\n      this.addTool(tool);\n    }\n    return this;\n  }\n\n  deleteTool(toolName: string): boolean {\n    return this.tools.delete(toolName);\n  }\n\n  contains(toolName: string): boolean {\n    return this.tools.has(toolName);\n  }\n\n  get(toolName: string): AnyTool | undefined {\n    return this.tools.get(toolName);\n  }\n\n  values(): AnyTool[] {\n    return [...this.tools.values()];\n  }\n\n  async getToolDefinitions(prompt = \"\"): Promise<ToolDefinition[]> {\n    const defs: ToolDefinition[] = [];\n    for (const tool of this.tools.values()) {\n      defs.push(await tool.definition(prompt));\n    }\n    return defs;\n  }\n\n  async call(toolName: string, args: string, context?: ToolCallContext): Promise<string> {\n    const tool = this.tools.get(toolName);\n    if (tool === undefined) {\n      throw new ToolNotFoundError(toolName);\n    }\n\n    let parsedArgs: unknown;\n    try {\n      parsedArgs = parseToolArgs(args);\n    } catch (error) {\n      throw new ToolJsonError(`Invalid JSON arguments for tool ${toolName}`, error);\n    }\n\n    try {\n      const output = await tool.call(parsedArgs, context);\n      return serializeToolOutput(output);\n    } catch (error) {\n      if (error instanceof Error) {\n        throw new ToolCallError(error.message, error);\n      }\n      throw new ToolCallError(`Tool ${toolName} failed`, error);\n    }\n  }\n}\n"],"mappings":";AAAO,IAAM,gBAAN,cAA4B,MAAM;AAAA,EACvC,YACE,SACS,OACT;AACA,UAAM,OAAO;AAFJ;AAGT,SAAK,OAAO;AAAA,EACd;AAAA,EAJW;AAKb;AAEO,IAAM,oBAAN,cAAgC,MAAM;AAAA,EAC3C,YAAqB,UAAkB;AACrC,UAAM,mBAAmB,QAAQ,EAAE;AADhB;AAEnB,SAAK,OAAO;AAAA,EACd;AAAA,EAHqB;AAIvB;AAEO,IAAM,gBAAN,cAA4B,MAAM;AAAA,EACvC,YACE,SACS,OACT;AACA,UAAM,OAAO;AAFJ;AAGT,SAAK,OAAO;AAAA,EACd;AAAA,EAJW;AAKb;;;ACqBO,SAAS,oBAAoB,QAAyB;AAC3D,MAAI,OAAO,WAAW,UAAU;AAC9B,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,KAAK,UAAU,MAAM;AACxC,SAAO,eAAe,SAAY,OAAO,MAAM,IAAI;AACrD;AAEO,SAAS,cAAc,MAAyB;AACrD,MAAI,KAAK,KAAK,MAAM,IAAI;AACtB,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,KAAK,MAAM,IAAI;AACxB;;;ACzDO,IAAM,UAAN,MAAM,SAAQ;AAAA,EACF,QAAQ,oBAAI,IAAqB;AAAA,EAElD,OAAO,UAAU,OAA2B;AAC1C,UAAM,UAAU,IAAI,SAAQ;AAC5B,eAAW,QAAQ,OAAO;AACxB,cAAQ,QAAQ,IAAI;AAAA,IACtB;AACA,WAAO;AAAA,EACT;AAAA,EAEA,QAAQ,MAAqB;AAC3B,SAAK,MAAM,IAAI,KAAK,MAAM,IAAI;AAC9B,WAAO;AAAA,EACT;AAAA,EAEA,SAAS,OAAkC;AACzC,UAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,MAAM,OAAO;AAC3D,eAAW,QAAQ,QAAQ;AACzB,WAAK,QAAQ,IAAI;AAAA,IACnB;AACA,WAAO;AAAA,EACT;AAAA,EAEA,WAAW,UAA2B;AACpC,WAAO,KAAK,MAAM,OAAO,QAAQ;AAAA,EACnC;AAAA,EAEA,SAAS,UAA2B;AAClC,WAAO,KAAK,MAAM,IAAI,QAAQ;AAAA,EAChC;AAAA,EAEA,IAAI,UAAuC;AACzC,WAAO,KAAK,MAAM,IAAI,QAAQ;AAAA,EAChC;AAAA,EAEA,SAAoB;AAClB,WAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC;AAAA,EAChC;AAAA,EAEA,MAAM,mBAAmB,SAAS,IAA+B;AAC/D,UAAM,OAAyB,CAAC;AAChC,eAAW,QAAQ,KAAK,MAAM,OAAO,GAAG;AACtC,WAAK,KAAK,MAAM,KAAK,WAAW,MAAM,CAAC;AAAA,IACzC;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,KAAK,UAAkB,MAAc,SAA4C;AACrF,UAAM,OAAO,KAAK,MAAM,IAAI,QAAQ;AACpC,QAAI,SAAS,QAAW;AACtB,YAAM,IAAI,kBAAkB,QAAQ;AAAA,IACtC;AAEA,QAAI;AACJ,QAAI;AACF,mBAAa,cAAc,IAAI;AAAA,IACjC,SAAS,OAAO;AACd,YAAM,IAAI,cAAc,mCAAmC,QAAQ,IAAI,KAAK;AAAA,IAC9E;AAEA,QAAI;AACF,YAAM,SAAS,MAAM,KAAK,KAAK,YAAY,OAAO;AAClD,aAAO,oBAAoB,MAAM;AAAA,IACnC,SAAS,OAAO;AACd,UAAI,iBAAiB,OAAO;AAC1B,cAAM,IAAI,cAAc,MAAM,SAAS,KAAK;AAAA,MAC9C;AACA,YAAM,IAAI,cAAc,QAAQ,QAAQ,WAAW,KAAK;AAAA,IAC1D;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-B4QHQN5K.js → chunk-445TT5Q5.js}

@@ -19,9 +19,9 @@ function createTool(options) {
         parameters
       };
     },
-    async call(args) {
+    async call(args, context = {}) {
       const parsedArgs = options.input.parse(args);
-      const result = await options.execute(parsedArgs);
+      const result = await options.execute(parsedArgs, context);
       return options.output === void 0 ? result : options.output.parse(result);
     },
     parseApprovalArgs(args) {
@@ -34,4 +34,4 @@ export {
   toProviderJsonSchema,
   createTool
 };
-//# sourceMappingURL=chunk-B4QHQN5K.js.map
+//# sourceMappingURL=chunk-445TT5Q5.js.map

package/dist/chunk-445TT5Q5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema/zod-schema.ts","../src/tool/create-tool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport type { JsonObject } from \"../completion/index\";\n\nexport type ZodSchema<T = unknown> = z.ZodType<T>;\n\nexport function toProviderJsonSchema(schema: z.ZodType): JsonObject {\n  const jsonSchema = z.toJSONSchema(schema) as JsonObject;\n  const { $schema: _schema, ...providerSchema } = jsonSchema;\n  return providerSchema;\n}\n","import type { z } from \"zod\";\nimport { toProviderJsonSchema, type ZodSchema } from \"../schema/zod-schema\";\nimport type { Tool, ToolApprovalPolicy, ToolCallContext } from \"./tool\";\n\nexport type CreateToolOptions<\n  InputSchema extends ZodSchema,\n  OutputSchema extends ZodSchema | undefined = undefined,\n> = {\n  name: string;\n  description: string;\n  input: InputSchema;\n  output?: OutputSchema;\n  approval?: ToolApprovalPolicy<z.output<InputSchema>>;\n  execute(\n    args: z.output<InputSchema>,\n    context: ToolCallContext,\n  ): OutputSchema extends ZodSchema\n    ? z.input<OutputSchema> | Promise<z.input<OutputSchema>>\n    : unknown | Promise<unknown>;\n};\n\ntype ToolOutput<OutputSchema extends ZodSchema | undefined> = OutputSchema extends ZodSchema\n  ? z.output<OutputSchema>\n  : unknown;\n\nexport function createTool<\n  InputSchema extends ZodSchema,\n  OutputSchema extends ZodSchema | undefined = undefined,\n>(\n  options: CreateToolOptions<InputSchema, OutputSchema>,\n): Tool<z.output<InputSchema>, ToolOutput<OutputSchema>> {\n  const parameters = toProviderJsonSchema(options.input);\n\n  return {\n    name: options.name,\n    ...(options.approval === undefined ? {} : { approval: options.approval }),\n    definition() {\n      return {\n        name: options.name,\n        description: options.description,\n        parameters,\n      };\n    },\n    async call(args, context = {}): Promise<ToolOutput<OutputSchema>> {\n      const parsedArgs = options.input.parse(args);\n      const result = await options.execute(parsedArgs, context);\n      return (\n        options.output === undefined ? result : options.output.parse(result)\n      ) as ToolOutput<OutputSchema>;\n    },\n    parseApprovalArgs(args): z.output<InputSchema> {\n      return options.input.parse(args);\n    },\n  };\n}\n"],"mappings":";AAAA,SAAS,SAAS;AAKX,SAAS,qBAAqB,QAA+B;AAClE,QAAM,aAAa,EAAE,aAAa,MAAM;AACxC,QAAM,EAAE,SAAS,SAAS,GAAG,eAAe,IAAI;AAChD,SAAO;AACT;;;ACgBO,SAAS,WAId,SACuD;AACvD,QAAM,aAAa,qBAAqB,QAAQ,KAAK;AAErD,SAAO;AAAA,IACL,MAAM,QAAQ;AAAA,IACd,GAAI,QAAQ,aAAa,SAAY,CAAC,IAAI,EAAE,UAAU,QAAQ,SAAS;AAAA,IACvE,aAAa;AACX,aAAO;AAAA,QACL,MAAM,QAAQ;AAAA,QACd,aAAa,QAAQ;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,IACA,MAAM,KAAK,MAAM,UAAU,CAAC,GAAsC;AAChE,YAAM,aAAa,QAAQ,MAAM,MAAM,IAAI;AAC3C,YAAM,SAAS,MAAM,QAAQ,QAAQ,YAAY,OAAO;AACxD,aACE,QAAQ,WAAW,SAAY,SAAS,QAAQ,OAAO,MAAM,MAAM;AAAA,IAEvE;AAAA,IACA,kBAAkB,MAA6B;AAC7C,aAAO,QAAQ,MAAM,MAAM,IAAI;AAAA,IACjC;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-SXLGKGKJ.js → chunk-4ILKTES4.js}

@@ -1,9 +1,9 @@
 import {
   AgentBuilder
-} from "./chunk-67X6U5HI.js";
+} from "./chunk-HGJDC56F.js";
 import {
   createTool
-} from "./chunk-B4QHQN5K.js";
+} from "./chunk-445TT5Q5.js";
 import {
   CompletionCapabilityError,
   CompletionRequestBuilder,
@@ -139,4 +139,4 @@ export {
   Extractor,
   ExtractorBuilder
 };
-//# sourceMappingURL=chunk-SXLGKGKJ.js.map
+//# sourceMappingURL=chunk-4ILKTES4.js.map

package/dist/{chunk-S55WOHX5.js → chunk-BT3I6O56.js}

@@ -6,4 +6,4 @@ function createObserver(observer) {
 export {
   createObserver
 };
-//# sourceMappingURL=chunk-S55WOHX5.js.map
+//# sourceMappingURL=chunk-BT3I6O56.js.map

package/dist/chunk-BT3I6O56.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/observability/types.ts"],"sourcesContent":["import type {\n  CompletionRequest,\n  CompletionResponse,\n  Message,\n  ToolCall,\n  Usage,\n} from \"../completion\";\nimport type { ToolCallStreamEvent } from \"../tool\";\n\nexport type AgentTraceInfo = {\n  traceId?: string | undefined;\n  observationId?: string | undefined;\n};\n\nexport type AgentTraceOptions = {\n  name?: string | undefined;\n  userId?: string | undefined;\n  sessionId?: string | undefined;\n  metadata?: Record<string, unknown> | undefined;\n  tags?: string[] | undefined;\n  version?: string | undefined;\n  traceId?: string | undefined;\n  failOnObserverError?: boolean | undefined;\n};\n\nexport type AgentRunStartArgs = {\n  agentName?: string | undefined;\n  agentDescription?: string | undefined;\n  instructions?: string | undefined;\n  trace?: AgentTraceOptions | undefined;\n  prompt: Message;\n  history: Message[];\n  maxTurns: number;\n};\n\nexport type AgentRunEndArgs = {\n  output: string;\n  usage: Usage;\n  messages: Message[];\n};\n\nexport type AgentRunErrorArgs = {\n  error: unknown;\n  usage: Usage;\n  messages: Message[];\n};\n\nexport type AgentGenerationStartArgs = {\n  turn: number;\n  request: CompletionRequest;\n};\n\nexport type AgentGenerationEndArgs<RawResponse = unknown> = {\n  turn: number;\n  response: CompletionResponse<RawResponse>;\n  firstDeltaMs?: number | undefined;\n};\n\nexport type AgentGenerationErrorArgs = {\n  turn: number;\n  error: unknown;\n};\n\nexport type AgentToolStartArgs = {\n  turn: number;\n  toolCall: ToolCall;\n  toolName: string;\n  args: string;\n  internalCallId: string;\n  toolCallId?: string | undefined;\n};\n\nexport type AgentToolEndArgs = AgentToolStartArgs & {\n  result: string;\n  skipped: boolean;\n};\n\nexport type AgentToolErrorArgs = AgentToolStartArgs & {\n  error: unknown;\n};\n\nexport type AgentToolStreamEventArgs = AgentToolStartArgs & {\n  event: ToolCallStreamEvent;\n};\n\nexport interface AgentGenerationObserver {\n  end(args: AgentGenerationEndArgs): void | Promise<void>;\n  error?(args: AgentGenerationErrorArgs): void | Promise<void>;\n}\n\nexport interface AgentToolObserver {\n  streamEvent?(args: AgentToolStreamEventArgs): void | Promise<void>;\n  end(args: AgentToolEndArgs): void | Promise<void>;\n  error?(args: AgentToolErrorArgs): void | Promise<void>;\n}\n\nexport interface AgentRunObserver {\n  readonly trace?: AgentTraceInfo | undefined;\n  startGeneration?(\n    args: AgentGenerationStartArgs,\n  ): AgentGenerationObserver | undefined | Promise<AgentGenerationObserver | undefined>;\n  startTool?(\n    args: AgentToolStartArgs,\n  ): AgentToolObserver | undefined | Promise<AgentToolObserver | undefined>;\n  end(args: AgentRunEndArgs): void | Promise<void>;\n  error?(args: AgentRunErrorArgs): void | Promise<void>;\n}\n\nexport interface AgentObserver {\n  startRun(\n    args: AgentRunStartArgs,\n  ): AgentRunObserver | undefined | Promise<AgentRunObserver | undefined>;\n  flush?(): void | Promise<void>;\n  shutdown?(): void | Promise<void>;\n}\n\nexport type AgentObserverRegistration = {\n  observer: AgentObserver;\n  failOnObserverError?: boolean | undefined;\n};\n\nexport type ObserveOptions = {\n  failOnObserverError?: boolean | undefined;\n};\n\nexport function createObserver(observer: AgentObserver): AgentObserver {\n  return observer;\n}\n"],"mappings":";AA6HO,SAAS,eAAe,UAAwC;AACrE,SAAO;AACT;","names":[]}