@anvia/core 0.1.3 → 0.1.5

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-wBc0uM9_.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 ToolCallControl, t as ToolCallHookAction, u as ToolCallHookArgs, v as ToolCallHookResult, w as ToolHookArgs, x as ToolResultHookArgs, y as cancelPrompt, z as createHook, B as runControl, E as skipTool, F as toolCallControl } from '../agent-wBc0uM9_.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

@@ -11,14 +11,14 @@ import {
   runControl,
   skipTool,
   toolCallControl
-} from "../chunk-BIJ5ZBCO.js";
+} from "../chunk-5OVEPVTH.js";
 import {
   resolveMemoryOptions
 } from "../chunk-XXT2UCAR.js";
 import "../chunk-YK4WAAS4.js";
+import "../chunk-3H7FVGHU.js";
+import "../chunk-445TT5Q5.js";
 import "../chunk-XUUY2L2D.js";
-import "../chunk-GNWMOSNR.js";
-import "../chunk-B4QHQN5K.js";
 import "../chunk-CP47FBJV.js";
 export {
   Agent,

package/dist/{agent-D5KKP9_z.d.ts → agent-wBc0uM9_.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 = {
@@ -74,7 +74,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 +108,7 @@ type AgentStreamEvent<RawResponse = unknown> = {
     response: CompletionResponse<RawResponse>;
 } | {
     type: "final";
+    runId: string;
     output: string;
     usage: Usage;
     messages: Message[];
@@ -116,6 +117,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 +155,7 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private executeToolCalls;
     private runToolResultMiddlewares;
     private startRunObservers;
+    private recordAgentEvent;
     private fetchDynamicContext;
     private fetchToolDefinitions;
     private recordToolError;
@@ -179,12 +191,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 +265,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 +273,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 +289,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, runControl as B, type CompletionCallHookArgs as C, DEFAULT_MAX_TURNS as D, skipTool as E, toolCallControl as F, type HookAction as H, type PromptHook as P, type RunControl as R, type ToolCallControl 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 ToolCallHookAction as t, type ToolCallHookArgs as u, type ToolCallHookResult as v, type ToolHookArgs as w, type ToolResultHookArgs as x, cancelPrompt as y, createHook 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-BIJ5ZBCO.js → chunk-5OVEPVTH.js}

@@ -4,16 +4,16 @@ import {
 import {
   isSkillTool
 } from "./chunk-YK4WAAS4.js";
-import {
-  toReadableStream
-} from "./chunk-XUUY2L2D.js";
 import {
   ToolSet
-} from "./chunk-GNWMOSNR.js";
+} from "./chunk-3H7FVGHU.js";
 import {
   createTool,
   toProviderJsonSchema
-} from "./chunk-B4QHQN5K.js";
+} from "./chunk-445TT5Q5.js";
+import {
+  toReadableStream
+} from "./chunk-XUUY2L2D.js";
 import {
   CompletionRequestBuilder,
   Message,
@@ -154,6 +154,18 @@ var ActiveToolObservers = class {
   }
   toolObservers;
   failOnObserverError;
+  async streamEvent(args) {
+    for (const observer of this.toolObservers) {
+      if (observer.streamEvent === void 0) {
+        continue;
+      }
+      try {
+        await observer.streamEvent(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
   async end(args) {
     for (const observer of this.toolObservers) {
       try {
@@ -559,10 +571,16 @@ var PromptRequest = class _PromptRequest {
           await runObservers.end(result);
           return result;
         }
-        const toolResults = await this.executeToolCalls(toolCalls, newMessages, void 0, {
-          turn: currentTurns,
-          runObservers
-        });
+        const toolResults = await this.executeToolCalls(
+          toolCalls,
+          newMessages,
+          void 0,
+          void 0,
+          {
+            turn: currentTurns,
+            runObservers
+          }
+        );
         const toolMessage = Message.tool(toolResults);
         newMessages.push(toolMessage);
         await this.commitMemoryMessages(runId, currentTurns, [toolMessage], pendingTurnMessages);
@@ -587,6 +605,10 @@ var PromptRequest = class _PromptRequest {
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
     const runObservers = await this.startRunObservers();
+    const emit = async (event) => {
+      await this.recordAgentEvent(runId, event);
+      return event;
+    };
     try {
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
@@ -596,12 +618,12 @@ var PromptRequest = class _PromptRequest {
         lastPrompt = prompt;
         currentTurns += 1;
         const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
-        yield {
+        yield await emit({
           type: "turn_start",
           turn: currentTurns,
           prompt,
           history: historyForRequest
-        };
+        });
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
         const ragText = extractRagText(prompt);
         const dynamicContext = await this.fetchDynamicContext(ragText);
@@ -625,7 +647,7 @@ var PromptRequest = class _PromptRequest {
               throw event.error;
             }
             if (mapped !== void 0) {
-              yield addTurn(currentTurns, mapped);
+              yield await emit(addTurn(currentTurns, mapped));
             }
           }
         } catch (error) {
@@ -652,9 +674,9 @@ var PromptRequest = class _PromptRequest {
           (item) => item.type === "tool_call"
         );
         for (const toolCall of toolCalls) {
-          yield { type: "tool_call", turn: currentTurns, toolCall };
+          yield await emit({ type: "tool_call", turn: currentTurns, toolCall });
         }
-        yield { type: "turn_end", turn: currentTurns, response };
+        yield await emit({ type: "turn_end", turn: currentTurns, response });
         if (toolCalls.length === 0) {
           const output = textFromAssistantContent(response.choice);
           await this.commitCompletedMemoryRun(
@@ -663,13 +685,14 @@ var PromptRequest = class _PromptRequest {
             newMessages,
             pendingTurnMessages
           );
-          yield {
+          yield await emit({
             type: "final",
+            runId,
             output,
             usage,
             messages: [...newMessages],
             trace: runObservers.trace
-          };
+          });
           await runObservers.end({ output, usage, messages: [...newMessages] });
           return;
         }
@@ -680,6 +703,9 @@ var PromptRequest = class _PromptRequest {
           (result) => {
             toolResultEvents.enqueue(result);
           },
+          (event) => {
+            toolResultEvents.enqueue(event);
+          },
           {
             turn: currentTurns,
             runObservers
@@ -690,7 +716,7 @@ var PromptRequest = class _PromptRequest {
           (error) => toolResultEvents.throw(error)
         );
         for await (const result of toolResultEvents) {
-          yield { type: "tool_result", turn: currentTurns, ...result };
+          yield await emit({ turn: currentTurns, ...result });
         }
         const toolResults = await toolResultsPromise;
         const toolMessage = Message.tool(toolResults);
@@ -702,7 +728,7 @@ var PromptRequest = class _PromptRequest {
     } catch (error) {
       await runObservers.error({ error, usage, messages: [...newMessages] });
       await this.recordMemoryError(runId, error, newMessages);
-      yield { type: "error", error };
+      yield await emit({ type: "error", error });
       throw error;
     }
   }
@@ -721,7 +747,7 @@ var PromptRequest = class _PromptRequest {
       throw error;
     }
   }
-  async executeToolCalls(toolCalls, newMessages, onResult, observation) {
+  async executeToolCalls(toolCalls, newMessages, onResult, onStreamEvent, observation) {
     return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
       const args = JSON.stringify(toolCall.function.arguments ?? {});
       const internalCallId = globalThis.crypto.randomUUID();
@@ -763,7 +789,23 @@ var PromptRequest = class _PromptRequest {
         skipped = true;
       } else {
         try {
-          output = await this.agent.callTool(toolCall.function.name, args);
+          output = await this.agent.callTool(toolCall.function.name, args, {
+            emitStreamEvent: async (event) => {
+              await toolObservers?.streamEvent({
+                turn: observation?.turn ?? 0,
+                toolCall,
+                toolName: toolCall.function.name,
+                internalCallId,
+                args,
+                ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
+                event
+              });
+              const payload = agentToolEventPayload(toolCall, internalCallId, event);
+              if (payload !== void 0) {
+                onStreamEvent?.(payload);
+              }
+            }
+          });
         } catch (error) {
           output = error instanceof Error ? error.toString() : String(error);
         }
@@ -795,6 +837,7 @@ var PromptRequest = class _PromptRequest {
         throw this.cancelled(newMessages, resultAction.reason);
       }
       const resultPayload = {
+        type: "tool_result",
         toolName: toolCall.function.name,
         internalCallId,
         args,
@@ -836,6 +879,30 @@ var PromptRequest = class _PromptRequest {
       failOnObserverError
     );
   }
+  async recordAgentEvent(runId, event) {
+    const registration = this.agent.eventStore;
+    if (registration === void 0) {
+      return;
+    }
+    if (registration.options.include === "agent_tool_events" && event.type !== "agent_tool_event") {
+      return;
+    }
+    const turn = "turn" in event ? event.turn : void 0;
+    const agentId = event.type === "agent_tool_event" ? event.agentId : this.agent.id;
+    const agentName = event.type === "agent_tool_event" ? event.agentName : this.agent.name;
+    await registration.store.append({
+      runId,
+      agentId,
+      ...agentName === void 0 ? {} : { agentName },
+      ...turn === void 0 ? {} : { turn },
+      ...event.type === "agent_tool_event" ? {
+        toolName: event.toolName,
+        ...event.toolCallId === void 0 ? {} : { toolCallId: event.toolCallId },
+        internalCallId: event.internalCallId
+      } : {},
+      event
+    });
+  }
   async fetchDynamicContext(ragText) {
     if (ragText === void 0 || ragText.length === 0 || this.agent.dynamicContexts.length === 0) {
       return [];
@@ -1019,6 +1086,20 @@ function normalizePromptInput(prompt) {
     history: prompt.slice(0, -1)
   };
 }
+function agentToolEventPayload(toolCall, internalCallId, event) {
+  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
+    return void 0;
+  }
+  return {
+    type: "agent_tool_event",
+    toolName: toolCall.function.name,
+    ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
+    internalCallId,
+    agentId: event.agentId,
+    ...event.agentName === void 0 ? {} : { agentName: event.agentName },
+    event: event.event
+  };
+}
 function createAsyncQueue() {
   const values = [];
   const waiters = [];
@@ -1130,6 +1211,7 @@ var Agent = class {
   dynamicTools;
   toolMiddlewares;
   memory;
+  eventStore;
   constructor(options) {
     this.id = normalizeAgentId(options.id);
     this.name = options.name;
@@ -1150,6 +1232,7 @@ var Agent = class {
     this.dynamicTools = options.dynamicTools ?? [];
     this.toolMiddlewares = options.toolMiddlewares ?? [];
     this.memory = options.memory;
+    this.eventStore = options.eventStore;
   }
   prompt(prompt) {
     return PromptRequest.fromAgent(this, prompt);
@@ -1177,9 +1260,24 @@ var Agent = class {
         prompt: z.string().describe("The prompt to send to the agent.")
       }),
       output: z.string(),
-      execute: async ({ prompt }) => {
+      execute: async ({ prompt }, context) => {
         const request = this.prompt(prompt);
-        const response = options.maxTurns === void 0 ? await request.send() : await request.maxTurns(options.maxTurns).send();
+        const childRequest = options.maxTurns === void 0 ? request : request.maxTurns(options.maxTurns);
+        if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
+          let output = "";
+          for await (const event of childRequest.stream()) {
+            await context.emitStreamEvent({
+              agentId: this.id,
+              ...this.name === void 0 ? {} : { agentName: this.name },
+              event
+            });
+            if (event.type === "final") {
+              output = event.output;
+            }
+          }
+          return output;
+        }
+        const response = await childRequest.send();
         return response.output;
       }
     });
@@ -1197,17 +1295,17 @@ var Agent = class {
     }
     return void 0;
   }
-  async callTool(toolName, args) {
+  async callTool(toolName, args, context) {
     if (this.toolSet.contains(toolName)) {
-      return this.toolSet.call(toolName, args);
+      return this.toolSet.call(toolName, args, context);
     }
     for (const registration of this.dynamicTools) {
       const toolSet = dynamicToolSetFromIndex(registration.index);
       if (toolSet?.contains(toolName)) {
-        return toolSet.call(toolName, args);
+        return toolSet.call(toolName, args, context);
       }
     }
-    return this.toolSet.call(toolName, args);
+    return this.toolSet.call(toolName, args, context);
   }
   shouldApplyToolMiddleware(toolName) {
     return !isSkillTool(this.getTool(toolName));
@@ -1281,6 +1379,7 @@ var AgentBuilder = class {
   dynamicToolRegistrations = [];
   middlewareRegistrations = [];
   memoryRegistration;
+  eventStoreRegistration;
   activeToolSet = new ToolSet();
   name(name) {
     this.agentName = name;
@@ -1380,6 +1479,15 @@ var AgentBuilder = class {
     };
     return this;
   }
+  eventStore(store, options = {}) {
+    this.eventStoreRegistration = {
+      store,
+      options: {
+        include: options.include ?? "all"
+      }
+    };
+    return this;
+  }
   outputSchema(schema) {
     this.schema = toProviderJsonSchema(schema);
     return this;
@@ -1404,7 +1512,8 @@ var AgentBuilder = class {
       dynamicContexts: this.dynamicContextRegistrations,
       dynamicTools: this.dynamicToolRegistrations,
       toolMiddlewares: this.middlewareRegistrations,
-      memory: this.memoryRegistration
+      memory: this.memoryRegistration,
+      eventStore: this.eventStoreRegistration
     });
   }
   buildInstructions() {
@@ -1439,4 +1548,4 @@ export {
   AgentSession,
   AgentBuilder
 };
-//# sourceMappingURL=chunk-BIJ5ZBCO.js.map
+//# sourceMappingURL=chunk-5OVEPVTH.js.map