@opperai/agents 0.1.3 → 0.2.0

package/dist/index.js

@@ -392,7 +392,11 @@ var HookEvents = {
   ToolError: "tool:error",
   MemoryRead: "memory:read",
   MemoryWrite: "memory:write",
-  MemoryError: "memory:error"
+  MemoryError: "memory:error",
+  StreamStart: "stream:start",
+  StreamChunk: "stream:chunk",
+  StreamEnd: "stream:end",
+  StreamError: "stream:error"
 };
 var HookManager = class {
   registry = /* @__PURE__ */ new Map();
@@ -464,6 +468,82 @@ var HookManager = class {
 };
 var createHookManager = (logger) => new HookManager(logger);
 
+// src/base/events.ts
+var AgentEvents = {
+  StreamStart: HookEvents.StreamStart,
+  StreamChunk: HookEvents.StreamChunk,
+  StreamEnd: HookEvents.StreamEnd,
+  StreamError: HookEvents.StreamError
+};
+var AgentEventEmitter = class {
+  registry = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? getDefaultLogger();
+  }
+  on(event, listener) {
+    const listeners = this.registry.get(event) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.registry.set(event, listeners);
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const wrapper = (payload) => {
+      try {
+        listener(payload);
+      } finally {
+        this.off(event, wrapper);
+      }
+    };
+    return this.on(event, wrapper);
+  }
+  off(event, listener) {
+    const listeners = this.registry.get(event);
+    if (!listeners) {
+      return;
+    }
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+      this.registry.delete(event);
+    }
+  }
+  emit(event, payload) {
+    const listeners = Array.from(
+      this.registry.get(event) ?? /* @__PURE__ */ new Set()
+    );
+    if (listeners.length === 0) {
+      return;
+    }
+    for (const listener of listeners) {
+      try {
+        listener(payload);
+      } catch (error) {
+        this.logger.warn(`Agent event listener failed for "${event}"`, {
+          event,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.registry.delete(event);
+      return;
+    }
+    this.registry.clear();
+  }
+  listenerCount(event) {
+    if (event) {
+      return this.registry.get(event)?.size ?? 0;
+    }
+    let total = 0;
+    for (const listeners of this.registry.values()) {
+      total += listeners.size;
+    }
+    return total;
+  }
+};
+
 // src/base/agent.ts
 init_tool();
 function sanitizeId(name) {
@@ -823,6 +903,10 @@ var BaseAgent = class {
    * Whether memory is enabled
    */
   enableMemory;
+  /**
+   * Whether streaming is enabled
+   */
+  enableStreaming;
   /**
    * Memory instance for persistent storage (null if disabled or initialization failed)
    */
@@ -835,6 +919,10 @@ var BaseAgent = class {
    * Hook manager for lifecycle events
    */
   hooks;
+  /**
+   * Event dispatcher for runtime events (notably streaming)
+   */
+  events;
   /**
    * Registry of available tools
    */
@@ -864,12 +952,26 @@ var BaseAgent = class {
     this.inputSchema = config.inputSchema;
     this.outputSchema = config.outputSchema;
     this.enableMemory = config.enableMemory ?? false;
+    this.enableStreaming = config.enableStreaming ?? false;
     this.metadata = { ...config.metadata ?? {} };
     this.hooks = new HookManager();
+    this.events = new AgentEventEmitter();
     this.tools = /* @__PURE__ */ new Map();
     this.baseTools = /* @__PURE__ */ new Map();
     this.toolProviders = /* @__PURE__ */ new Set();
     this.providerToolRegistry = /* @__PURE__ */ new Map();
+    if (config.onStreamStart) {
+      this.on(HookEvents.StreamStart, config.onStreamStart);
+    }
+    if (config.onStreamChunk) {
+      this.on(HookEvents.StreamChunk, config.onStreamChunk);
+    }
+    if (config.onStreamEnd) {
+      this.on(HookEvents.StreamEnd, config.onStreamEnd);
+    }
+    if (config.onStreamError) {
+      this.on(HookEvents.StreamError, config.onStreamError);
+    }
     this.opperConfig = {
       apiKey: config.opperConfig?.apiKey ?? process.env["OPPER_API_KEY"],
       baseUrl: config.opperConfig?.baseUrl,
@@ -1051,6 +1153,35 @@ var BaseAgent = class {
   registerHook(event, handler) {
     return this.hooks.on(event, handler);
   }
+  /**
+   * Register an event listener.
+   *
+   * @param event - Event name
+   * @param listener - Listener callback
+   * @returns Cleanup function to unregister the listener
+   */
+  on(event, listener) {
+    return this.events.on(event, listener);
+  }
+  /**
+   * 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(event, listener) {
+    return this.events.once(event, listener);
+  }
+  /**
+   * Remove a previously registered event listener.
+   *
+   * @param event - Event name
+   * @param listener - Listener callback to remove
+   */
+  off(event, listener) {
+    this.events.off(event, listener);
+  }
   /**
    * Trigger a hook event with a payload.
    * Swallows errors to prevent hook failures from breaking agent execution.
@@ -1065,6 +1196,15 @@ var BaseAgent = class {
       console.warn(`Hook error for event ${event}:`, error);
     }
   }
+  /**
+   * Emit a runtime event to listeners.
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   */
+  emitAgentEvent(event, payload) {
+    this.events.emit(event, payload);
+  }
   /**
    * Execute a tool with proper context, hooks, and error handling.
    *
@@ -1338,7 +1478,7 @@ var ToolExecutionSummarySchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.1.3"};
+  version: "0.2.0"};
 
 // src/utils/version.ts
 var SDK_NAME = "@opperai/agents";
@@ -1401,7 +1541,7 @@ var OpperClient = class {
     return this.withRetry(async () => {
       const inputSchema = this.toJsonSchema(options.inputSchema);
       const outputSchema = this.toJsonSchema(options.outputSchema);
-      const response = await this.client.call({
+      const callPayload = {
         name: options.name,
         instructions: options.instructions,
         input: options.input,
@@ -1409,7 +1549,8 @@ var OpperClient = class {
         ...outputSchema && { outputSchema },
         ...options.model && { model: options.model },
         ...options.parentSpanId && { parentSpanId: options.parentSpanId }
-      });
+      };
+      const response = options.signal ? await this.client.call(callPayload, { signal: options.signal }) : await this.client.call(callPayload);
       const usagePayload = extractUsage(response);
       const costPayload = extractCost(response);
       const usage = {
@@ -1427,6 +1568,36 @@ var OpperClient = class {
       return result;
     }, options.name);
   }
+  /**
+   * Stream a call to Opper with retry logic
+   */
+  async stream(options) {
+    return this.withRetry(async () => {
+      const inputSchema = this.toJsonSchema(options.inputSchema);
+      const outputSchema = this.toJsonSchema(options.outputSchema);
+      const streamPayload = {
+        name: options.name,
+        instructions: options.instructions,
+        input: options.input,
+        ...inputSchema && { inputSchema },
+        ...outputSchema && { outputSchema },
+        ...options.model && { model: options.model },
+        ...options.parentSpanId && { parentSpanId: options.parentSpanId }
+      };
+      const response = options.signal ? await this.client.stream(streamPayload, { signal: options.signal }) : await this.client.stream(streamPayload);
+      const iterable = {
+        async *[Symbol.asyncIterator]() {
+          for await (const event of response.result) {
+            yield event;
+          }
+        }
+      };
+      return {
+        headers: response.headers,
+        result: iterable
+      };
+    }, `stream:${options.name}`);
+  }
   /**
    * Create a span for tracing
    */
@@ -1595,6 +1766,189 @@ var mergeSchemaDefaults = (schema, value) => {
   return validateSchema(schema, value);
 };
 
+// src/utils/streaming.ts
+var STREAM_ROOT_PATH = "_root";
+var NUMERIC_TOKEN_PATTERN = /^\d+$/;
+var BRACKET_TOKEN_PATTERN = /\[(\d+)\]/g;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var coercePrimitive = (value) => {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return value;
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower === "true") {
+    return true;
+  }
+  if (lower === "false") {
+    return false;
+  }
+  if (lower === "null") {
+    return null;
+  }
+  if (/^-?\d+$/.test(trimmed)) {
+    const intValue = Number.parseInt(trimmed, 10);
+    return Number.isNaN(intValue) ? value : intValue;
+  }
+  if (/^-?\d+\.\d+$/.test(trimmed)) {
+    const floatValue = Number.parseFloat(trimmed);
+    return Number.isNaN(floatValue) ? value : floatValue;
+  }
+  return value;
+};
+var toDisplayString = (value) => {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return String(value);
+};
+var parsePathSegments = (path) => {
+  return path.replace(BRACKET_TOKEN_PATTERN, (_, index) => `.${index}`).split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+};
+var setNestedValue = (target, path, value) => {
+  const segments = parsePathSegments(path);
+  if (segments.length === 0) {
+    return;
+  }
+  let current = target;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (segment === void 0) {
+      return;
+    }
+    const existing = current[segment];
+    if (!isRecord(existing)) {
+      const nextLevel = {};
+      current[segment] = nextLevel;
+      current = nextLevel;
+      continue;
+    }
+    current = existing;
+  }
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment === void 0) {
+    return;
+  }
+  current[lastSegment] = value;
+};
+var normalizeIndexed = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeIndexed(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const normalizedEntries = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    normalizedEntries[key] = normalizeIndexed(entryValue);
+  }
+  const keys = Object.keys(normalizedEntries);
+  if (keys.length > 0 && keys.every((key) => NUMERIC_TOKEN_PATTERN.test(key))) {
+    const parsedIndices = keys.map((key) => Number.parseInt(key, 10)).filter((index) => Number.isFinite(index) && index >= 0);
+    if (parsedIndices.length === 0) {
+      return normalizedEntries;
+    }
+    const maxIndex = Math.max(...parsedIndices);
+    const result = new Array(maxIndex + 1).fill(void 0);
+    for (const [key, entryValue] of Object.entries(normalizedEntries)) {
+      const index = Number.parseInt(key, 10);
+      if (!Number.isFinite(index) || index < 0) {
+        continue;
+      }
+      result[index] = entryValue;
+    }
+    return result.map(
+      (item) => item === void 0 ? null : item
+    );
+  }
+  return normalizedEntries;
+};
+var resolveFieldValue = (path, displayBuffers, valueBuffers) => {
+  const values = valueBuffers.get(path) ?? [];
+  if (values.length === 0) {
+    return displayBuffers.get(path) ?? "";
+  }
+  const last = values[values.length - 1];
+  if (typeof last === "number" || typeof last === "boolean") {
+    return last;
+  }
+  if (last === null) {
+    return null;
+  }
+  const joined = displayBuffers.get(path) ?? values.map((value) => toDisplayString(value)).join("");
+  return coercePrimitive(joined);
+};
+var StreamAssembler = class {
+  displayBuffers = /* @__PURE__ */ new Map();
+  valueBuffers = /* @__PURE__ */ new Map();
+  schema;
+  constructor(options = {}) {
+    this.schema = options.schema;
+  }
+  feed(chunk) {
+    const { delta } = chunk;
+    if (delta === null || delta === void 0) {
+      return null;
+    }
+    const path = chunk.jsonPath === null || chunk.jsonPath === void 0 ? STREAM_ROOT_PATH : chunk.jsonPath;
+    const existingDisplay = this.displayBuffers.get(path) ?? "";
+    const nextDisplay = `${existingDisplay}${toDisplayString(delta)}`;
+    this.displayBuffers.set(path, nextDisplay);
+    const existingValues = this.valueBuffers.get(path) ?? [];
+    existingValues.push(delta);
+    this.valueBuffers.set(path, existingValues);
+    return {
+      path,
+      accumulated: nextDisplay,
+      snapshot: this.snapshot()
+    };
+  }
+  snapshot() {
+    return Object.fromEntries(this.displayBuffers.entries());
+  }
+  hasStructuredFields() {
+    const keys = Array.from(this.displayBuffers.keys());
+    return keys.some((key) => key !== STREAM_ROOT_PATH);
+  }
+  finalize() {
+    if (this.displayBuffers.size === 0) {
+      return { type: "empty" };
+    }
+    if (!this.hasStructuredFields()) {
+      const root = this.displayBuffers.get(STREAM_ROOT_PATH) ?? "";
+      return { type: "root", rootText: root };
+    }
+    const structured = this.reconstructStructured();
+    let coerced = structured;
+    if (this.schema !== void 0) {
+      try {
+        coerced = this.schema.parse(structured);
+      } catch {
+        coerced = structured;
+      }
+    }
+    return { type: "structured", structured: coerced };
+  }
+  getFieldBuffers() {
+    return new Map(this.displayBuffers);
+  }
+  reconstructStructured() {
+    const result = {};
+    for (const path of this.valueBuffers.keys()) {
+      if (path === STREAM_ROOT_PATH) {
+        continue;
+      }
+      const value = resolveFieldValue(path, this.displayBuffers, this.valueBuffers);
+      setNestedValue(result, path, value);
+    }
+    return normalizeIndexed(result);
+  }
+};
+var createStreamAssembler = (options) => new StreamAssembler(options);
+
 // src/core/agent.ts
 var isToolSuccessResult = (value) => {
   if (typeof value !== "object" || value === null) {
@@ -1721,6 +2075,9 @@ var Agent = class extends BaseAgent {
     const spanName = "think";
     this.log("Think step", { iteration: context.iteration });
     await this.triggerHook(HookEvents.LlmCall, { context, callType: "think" });
+    if (this.enableStreaming) {
+      return this.thinkStreaming(input, context);
+    }
     try {
       const instructions = this.buildThinkInstructions();
       const thinkContext = await this.buildThinkContext(input, context);
@@ -1763,6 +2120,132 @@ var Agent = class extends BaseAgent {
       );
     }
   }
+  async thinkStreaming(input, context) {
+    const spanName = "think";
+    const instructions = this.buildThinkInstructions();
+    const thinkContext = await this.buildThinkContext(input, context);
+    const assembler = createStreamAssembler({
+      schema: AgentDecisionSchema
+    });
+    let streamSpanId;
+    await this.triggerHook(HookEvents.StreamStart, {
+      context,
+      callType: "think"
+    });
+    this.emitAgentEvent(HookEvents.StreamStart, {
+      context,
+      callType: "think"
+    });
+    try {
+      const streamResponse = await this.opperClient.stream({
+        name: spanName,
+        instructions,
+        input: thinkContext,
+        outputSchema: AgentDecisionSchema,
+        model: this.model,
+        ...context.parentSpanId && { parentSpanId: context.parentSpanId }
+      });
+      for await (const event of streamResponse.result) {
+        const data = event?.data;
+        if (!data) {
+          continue;
+        }
+        if (!streamSpanId && typeof data.spanId === "string" && data.spanId) {
+          streamSpanId = data.spanId;
+        }
+        const feedResult = assembler.feed({
+          delta: data.delta,
+          jsonPath: data.jsonPath
+        });
+        if (!feedResult) {
+          continue;
+        }
+        const chunkPayload = {
+          context,
+          callType: "think",
+          chunkData: {
+            delta: data.delta,
+            jsonPath: data.jsonPath ?? null,
+            chunkType: data.chunkType ?? null
+          },
+          accumulated: feedResult.accumulated,
+          fieldBuffers: feedResult.snapshot
+        };
+        await this.triggerHook(HookEvents.StreamChunk, chunkPayload);
+        this.emitAgentEvent(HookEvents.StreamChunk, chunkPayload);
+      }
+      const fieldBuffers = assembler.snapshot();
+      const endPayload = {
+        context,
+        callType: "think",
+        fieldBuffers
+      };
+      await this.triggerHook(HookEvents.StreamEnd, endPayload);
+      this.emitAgentEvent(HookEvents.StreamEnd, endPayload);
+      const finalize = assembler.finalize();
+      let decision;
+      if (finalize.type === "structured" && finalize.structured) {
+        decision = AgentDecisionSchema.parse(
+          finalize.structured
+        );
+      } else {
+        decision = AgentDecisionSchema.parse({
+          reasoning: finalize.type === "root" ? finalize.rootText ?? "" : ""
+        });
+      }
+      const usageTracked = await this.trackStreamingUsageBySpan(
+        context,
+        streamSpanId
+      );
+      if (!usageTracked) {
+        context.updateUsage({
+          requests: 1,
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0,
+          cost: { generation: 0, platform: 0, total: 0 }
+        });
+      }
+      await this.triggerHook(HookEvents.LlmResponse, {
+        context,
+        callType: "think",
+        response: streamResponse,
+        parsed: decision
+      });
+      await this.triggerHook(HookEvents.ThinkEnd, {
+        context,
+        thought: { reasoning: decision.reasoning }
+      });
+      this.log("Think result", {
+        reasoning: decision.reasoning,
+        toolCalls: decision.toolCalls.length,
+        memoryReads: decision.memoryReads?.length ?? 0,
+        memoryWrites: Object.keys(decision.memoryUpdates ?? {}).length
+      });
+      const resultPayload = {
+        decision
+      };
+      if (streamSpanId) {
+        resultPayload.spanId = streamSpanId;
+      }
+      return resultPayload;
+    } catch (error) {
+      await this.triggerHook(HookEvents.StreamError, {
+        context,
+        callType: "think",
+        error
+      });
+      this.emitAgentEvent(HookEvents.StreamError, {
+        context,
+        callType: "think",
+        error
+      });
+      this.logger.error("Think step failed", error);
+      throw new Error(
+        `Think step failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   /**
    * Build static instructions for the think step
    */
@@ -2076,6 +2559,13 @@ The memory you write persists across all process() calls on this agent.`;
     };
     const instructions = `Generate the final result based on the execution history.
 Follow any instructions provided for formatting and style.`;
+    if (this.enableStreaming) {
+      return this.generateFinalResultStreaming(
+        context,
+        finalContext,
+        instructions
+      );
+    }
     try {
       const callOptions = {
         name: "generate_final_result",
@@ -2111,6 +2601,170 @@ Follow any instructions provided for formatting and style.`;
       );
     }
   }
+  async generateFinalResultStreaming(context, finalContext, instructions) {
+    const assembler = createStreamAssembler(
+      this.outputSchema ? { schema: this.outputSchema } : void 0
+    );
+    let streamSpanId;
+    await this.triggerHook(HookEvents.StreamStart, {
+      context,
+      callType: "final_result"
+    });
+    this.emitAgentEvent(HookEvents.StreamStart, {
+      context,
+      callType: "final_result"
+    });
+    try {
+      const streamResponse = await this.opperClient.stream({
+        name: "generate_final_result",
+        instructions,
+        input: finalContext,
+        model: this.model,
+        ...context.parentSpanId && { parentSpanId: context.parentSpanId },
+        ...this.outputSchema && { outputSchema: this.outputSchema }
+      });
+      for await (const event of streamResponse.result) {
+        const data = event?.data;
+        if (!data) {
+          continue;
+        }
+        if (!streamSpanId && typeof data.spanId === "string" && data.spanId) {
+          streamSpanId = data.spanId;
+        }
+        const feedResult = assembler.feed({
+          delta: data.delta,
+          jsonPath: data.jsonPath
+        });
+        if (!feedResult) {
+          continue;
+        }
+        const chunkPayload = {
+          context,
+          callType: "final_result",
+          chunkData: {
+            delta: data.delta,
+            jsonPath: data.jsonPath ?? null,
+            chunkType: data.chunkType ?? null
+          },
+          accumulated: feedResult.accumulated,
+          fieldBuffers: feedResult.snapshot
+        };
+        await this.triggerHook(HookEvents.StreamChunk, chunkPayload);
+        this.emitAgentEvent(HookEvents.StreamChunk, chunkPayload);
+      }
+      const fieldBuffers = assembler.snapshot();
+      const endPayload = {
+        context,
+        callType: "final_result",
+        fieldBuffers
+      };
+      await this.triggerHook(HookEvents.StreamEnd, endPayload);
+      this.emitAgentEvent(HookEvents.StreamEnd, endPayload);
+      const finalize = assembler.finalize();
+      let result;
+      if (this.outputSchema) {
+        if (finalize.type !== "structured" || finalize.structured === void 0) {
+          throw new Error(
+            "Streaming response did not provide structured data for the configured output schema."
+          );
+        }
+        result = this.outputSchema.parse(
+          finalize.structured
+        );
+      } else if (finalize.type === "root") {
+        result = finalize.rootText ?? "";
+      } else if (finalize.type === "structured" && finalize.structured) {
+        result = JSON.stringify(finalize.structured);
+      } else {
+        result = "";
+      }
+      const usageTracked = await this.trackStreamingUsageBySpan(
+        context,
+        streamSpanId
+      );
+      if (!usageTracked) {
+        context.updateUsage({
+          requests: 1,
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0,
+          cost: { generation: 0, platform: 0, total: 0 }
+        });
+      }
+      await this.triggerHook(HookEvents.LlmResponse, {
+        context,
+        callType: "final_result",
+        response: streamResponse,
+        parsed: result
+      });
+      this.log(
+        this.outputSchema ? "Final result generated (streaming, schema-validated)" : "Final result generated (streaming)"
+      );
+      return result;
+    } catch (error) {
+      await this.triggerHook(HookEvents.StreamError, {
+        context,
+        callType: "final_result",
+        error
+      });
+      this.emitAgentEvent(HookEvents.StreamError, {
+        context,
+        callType: "final_result",
+        error
+      });
+      this.logger.error("Failed to generate final result", error);
+      throw new Error(
+        `Failed to generate final result: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async trackStreamingUsageBySpan(context, spanId) {
+    if (!spanId) {
+      return false;
+    }
+    try {
+      const span = await this.opperClient.getClient().spans.get(spanId);
+      const traceId = span?.traceId ?? span?.trace_id;
+      if (!traceId) {
+        return false;
+      }
+      const trace = await this.opperClient.getClient().traces.get(traceId);
+      const spans = trace?.spans;
+      if (!Array.isArray(spans)) {
+        return false;
+      }
+      for (const entry of spans) {
+        const entryId = entry?.id ?? entry["id"];
+        if (entryId !== spanId) {
+          continue;
+        }
+        const data = entry?.data;
+        if (!data) {
+          continue;
+        }
+        const record = data;
+        const primaryTotal = record["totalTokens"];
+        const fallbackTotal = record["total_tokens"];
+        const totalTokensRaw = typeof primaryTotal === "number" && Number.isFinite(primaryTotal) ? primaryTotal : typeof fallbackTotal === "number" && Number.isFinite(fallbackTotal) ? fallbackTotal : void 0;
+        if (totalTokensRaw !== void 0) {
+          context.updateUsage({
+            requests: 1,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: totalTokensRaw,
+            cost: { generation: 0, platform: 0, total: 0 }
+          });
+          return true;
+        }
+      }
+    } catch (error) {
+      this.logger.warn("Could not fetch streaming usage", {
+        spanId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return false;
+  }
   /**
    * Log helper
    */
@@ -2327,7 +2981,7 @@ var createMCPServerConfig = MCPconfig;
 
 // src/mcp/provider.ts
 init_tool();
-var isRecord = (value) => typeof value === "object" && value !== null;
+var isRecord2 = (value) => typeof value === "object" && value !== null;
 var MCPToolProvider = class {
   configs;
   namePrefix;
@@ -2418,7 +3072,7 @@ var MCPToolProvider = class {
       },
       execute: async (input, context) => {
         const startedAt = Date.now();
-        const args = isRecord(input) ? input : input === void 0 ? {} : { value: input };
+        const args = isRecord2(input) ? input : input === void 0 ? {} : { value: input };
         try {
           const result = await client.callTool(mcpTool.name, args);
           return ToolResultFactory.success(toolName, result, {
@@ -2876,6 +3530,6 @@ var ToolRunner = class {
   }
 };
 
-export { Agent, AgentContext, AgentDecisionSchema, BaseAgent, ConsoleLogger, DEFAULT_MODEL, DEFAULT_RETRY_CONFIG, ExecutionCycleSchema, HookEvents, HookManager, InMemoryStore, LogLevel, MCPClient, MCPServerConfigSchema, MCPToolProvider, MCPconfig, MemoryEntryMetadataSchema, MemoryEntrySchema, MemoryUpdateSchema, OpperClient, Result, SchemaValidationError, SilentLogger, ThoughtSchema, ToolCallRecordSchema, ToolCallSchema, ToolExecutionSummarySchema, ToolMetadataSchema, ToolResultFactory, ToolResultFailureSchema, ToolResultSchema, ToolResultSuccessSchema, ToolRunner, UsageSchema, 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, AgentContext, AgentDecisionSchema, AgentEventEmitter, AgentEvents, BaseAgent, ConsoleLogger, DEFAULT_MODEL, DEFAULT_RETRY_CONFIG, ExecutionCycleSchema, HookEvents, HookManager, InMemoryStore, LogLevel, MCPClient, MCPServerConfigSchema, MCPToolProvider, MCPconfig, MemoryEntryMetadataSchema, MemoryEntrySchema, MemoryUpdateSchema, OpperClient, Result, STREAM_ROOT_PATH, SchemaValidationError, SilentLogger, StreamAssembler, ThoughtSchema, ToolCallRecordSchema, ToolCallSchema, ToolExecutionSummarySchema, ToolMetadataSchema, ToolResultFactory, ToolResultFailureSchema, ToolResultSchema, ToolResultSuccessSchema, ToolRunner, UsageSchema, coerceToolDefinition, createFunctionTool, createHookManager, createInMemoryStore, createMCPServerConfig, createOpperClient, createStreamAssembler, createToolCallRecord, err, extractTools, generateAgentFlowDiagram, getDefaultLogger, getSchemaDefault, isSchemaValid, isToolProvider, mcp, mergeSchemaDefaults, normalizeToolEntries, ok, schemaToJson, setDefaultLogger, tool, validateSchema, validateToolInput };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map