@anvia/core 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/chunk-IL3ZSNJI.js

@@ -1,3748 +0,0 @@
-import {
-  isSkillTool
-} from "./chunk-YK4WAAS4.js";
-import {
-  assertFiniteSearchThreshold,
-  assertPositiveSearchLimit,
-  isToolIndex
-} from "./chunk-6WGGTJE6.js";
-import {
-  ToolNotFoundError,
-  assertToolApprovalRequirement,
-  createTool,
-  parseToolArgs,
-  prepareToolCall,
-  toolMayRequireApproval,
-  toolResultContentToText
-} from "./chunk-R2LJSQUW.js";
-import {
-  MemoryCompactionConflictError,
-  MemoryCompactionError,
-  createMemoryCompactionSummary,
-  cumulativeCompactedMessageCount,
-  resolveMemoryOptions
-} from "./chunk-5XKDW36Z.js";
-import {
-  mapWithConcurrency
-} from "./chunk-DZ3CKYTH.js";
-import {
-  createCompletionRequest,
-  isStreamingCompletionModel
-} from "./chunk-M3IOWB4Y.js";
-import {
-  toProviderJsonSchema
-} from "./chunk-RFDVKCIE.js";
-import {
-  AssistantContent,
-  Message,
-  ToolContent,
-  Usage,
-  assertCompletionRequestSupported,
-  getAssistantGenerationMetadata,
-  isProviderTool,
-  textFromAssistantContent
-} from "./chunk-ADH7NNCS.js";
-import {
-  resolveRetryOptions,
-  retryDelayMs,
-  retryErrorAttributes,
-  waitForRetry
-} from "./chunk-A3UBYTJT.js";
-import {
-  appendGuardrailPolicies,
-  hasEnforcedOutputGuardrails,
-  runInputGuardrails,
-  runOutputGuardrails
-} from "./chunk-FNQB2JEH.js";
-
-// src/agent/errors.ts
-var MaxTurnsError = class extends Error {
-  constructor(maxTurns, chatHistory, prompt) {
-    super(`Reached max turn limit: ${maxTurns}`);
-    this.maxTurns = maxTurns;
-    this.chatHistory = chatHistory;
-    this.prompt = prompt;
-    this.name = "MaxTurnsError";
-  }
-  maxTurns;
-  chatHistory;
-  prompt;
-};
-var AgentRunCancelledError = class extends Error {
-  constructor(chatHistory, reason) {
-    super(`Agent run cancelled: ${reason}`);
-    this.chatHistory = chatHistory;
-    this.reason = reason;
-    this.name = "AgentRunCancelledError";
-  }
-  chatHistory;
-  reason;
-};
-
-// src/agent/tool-state.ts
-var agentToolStates = /* @__PURE__ */ new WeakMap();
-function registerAgentToolState(agent, publicState, toolsByName) {
-  agentToolStates.set(agent, { publicState, toolsByName });
-}
-function getAgentToolState(agent) {
-  return getStoredAgentToolState(agent).publicState;
-}
-function getRegisteredAgentTool(agent, toolName) {
-  return getStoredAgentToolState(agent).toolsByName.get(toolName);
-}
-function getStoredAgentToolState(agent) {
-  const state = agentToolStates.get(agent);
-  if (state === void 0) {
-    throw new TypeError("Agent tool state is unavailable.");
-  }
-  return state;
-}
-
-// src/hooks/control.ts
-function createHook(hook) {
-  return hook;
-}
-function cancelRun(reason) {
-  return { type: "terminate", reason };
-}
-function skipTool(reason) {
-  return { type: "skip", reason };
-}
-function requestToolApproval(options = {}) {
-  const action = {
-    type: "approval_request"
-  };
-  if (options.reason !== void 0) {
-    action.reason = options.reason;
-  }
-  if (options.rejectMessage !== void 0) {
-    action.rejectMessage = options.rejectMessage;
-  }
-  return action;
-}
-var runControl = {
-  continue() {
-    return { type: "continue" };
-  },
-  cancel(reason) {
-    return cancelRun(reason);
-  }
-};
-var toolCallControl = {
-  run() {
-    return { type: "continue" };
-  },
-  skip(reason) {
-    return skipTool(reason);
-  },
-  cancel(reason) {
-    return { type: "terminate", reason };
-  },
-  requestApproval(options) {
-    return requestToolApproval(options);
-  }
-};
-
-// src/internal/agent-runtime/approval-details.ts
-var approvalDetails = /* @__PURE__ */ new WeakMap();
-function registerAgentApprovalRequestDetails(approval, request) {
-  approvalDetails.set(approval, request);
-}
-function getAgentApprovalRequestDetails(approval) {
-  return approvalDetails.get(approval);
-}
-
-// src/agent/context-index.ts
-function createContextIndex(index, options) {
-  const topK = assertPositiveSearchLimit(options.topK);
-  const threshold = assertFiniteSearchThreshold(options.threshold);
-  return Object.freeze({
-    ...options,
-    topK,
-    ...threshold === void 0 ? {} : { threshold },
-    kind: "context-index",
-    index
-  });
-}
-function isContextIndex(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  if (candidate.kind !== "context-index" || typeof candidate.index !== "object") {
-    return false;
-  }
-  return candidate.index !== null && typeof candidate.index.search === "function";
-}
-
-// src/internal/agent-runtime/run-options.ts
-var internalAgentRunOptions = /* @__PURE__ */ Symbol("internalAgentRunOptions");
-function withInternalAgentRunOptions(options, internal) {
-  return {
-    ...options,
-    [internalAgentRunOptions]: internal
-  };
-}
-function getInternalAgentRunOptions(options) {
-  return options[internalAgentRunOptions];
-}
-
-// src/agent/agent.ts
-import { z } from "zod";
-
-// src/agent/lifecycle.ts
-function composeAgentLifecycle(first, second) {
-  if (first === void 0) return second;
-  if (second === void 0) return first;
-  return {
-    async onStart(event) {
-      await first.onStart?.(lifecycleSnapshot(event));
-      await second.onStart?.(lifecycleSnapshot(event));
-    },
-    async onStepFinish(event) {
-      await first.onStepFinish?.(lifecycleSnapshot(event));
-      await second.onStepFinish?.(lifecycleSnapshot(event));
-    },
-    async onToolStart(event) {
-      await first.onToolStart?.(lifecycleSnapshot(event));
-      await second.onToolStart?.(lifecycleSnapshot(event));
-    },
-    async onToolFinish(event) {
-      await first.onToolFinish?.(lifecycleSnapshot(event));
-      await second.onToolFinish?.(lifecycleSnapshot(event));
-    },
-    async onFinish(event) {
-      await first.onFinish?.(lifecycleSnapshot(event));
-      await second.onFinish?.(lifecycleSnapshot(event));
-    },
-    async onError(event) {
-      await first.onError?.(lifecycleSnapshot(event));
-      await second.onError?.(lifecycleSnapshot(event));
-    }
-  };
-}
-function lifecycleSnapshot(value) {
-  try {
-    return globalThis.structuredClone(value);
-  } catch {
-    return cloneLifecycleFallback(value, /* @__PURE__ */ new WeakMap());
-  }
-}
-function cloneLifecycleFallback(value, seen) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const existing = seen.get(value);
-  if (existing !== void 0) {
-    return existing;
-  }
-  if (Array.isArray(value)) {
-    const clone2 = [];
-    seen.set(value, clone2);
-    clone2.push(...value.map((item) => cloneLifecycleFallback(item, seen)));
-    return clone2;
-  }
-  if (Object.getPrototypeOf(value) !== Object.prototype) {
-    return value;
-  }
-  const clone = {};
-  seen.set(value, clone);
-  for (const [key, item] of Object.entries(value)) {
-    clone[key] = cloneLifecycleFallback(item, seen);
-  }
-  return clone;
-}
-
-// src/observability/snapshot.ts
-function observerSnapshot(value) {
-  if (containsError(value, /* @__PURE__ */ new WeakSet())) {
-    return cloneObserverFallback(value, /* @__PURE__ */ new WeakMap());
-  }
-  try {
-    return globalThis.structuredClone(value);
-  } catch {
-    return cloneObserverFallback(value, /* @__PURE__ */ new WeakMap());
-  }
-}
-function cloneObserverFallback(value, seen) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const existing = seen.get(value);
-  if (existing !== void 0) {
-    return existing;
-  }
-  if (Array.isArray(value)) {
-    const clone2 = [];
-    seen.set(value, clone2);
-    clone2.push(...value.map((item) => cloneObserverFallback(item, seen)));
-    return clone2;
-  }
-  if (value instanceof Date) {
-    return new Date(value.getTime());
-  }
-  if (value instanceof Error) {
-    const clone2 = Object.create(Object.getPrototypeOf(value));
-    seen.set(value, clone2);
-    Object.defineProperties(clone2, {
-      name: { configurable: true, writable: true, value: value.name },
-      message: { configurable: true, writable: true, value: value.message }
-    });
-    if (value.stack !== void 0) {
-      Object.defineProperty(clone2, "stack", {
-        configurable: true,
-        writable: true,
-        value: value.stack
-      });
-    }
-    if (value.cause !== void 0) {
-      Object.defineProperty(clone2, "cause", {
-        configurable: true,
-        writable: true,
-        value: cloneObserverFallback(value.cause, seen)
-      });
-    }
-    for (const key of Object.getOwnPropertyNames(value)) {
-      if (key === "name" || key === "message" || key === "stack" || key === "cause") continue;
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (descriptor === void 0) continue;
-      if ("value" in descriptor) {
-        descriptor.value = cloneObserverFallback(descriptor.value, seen);
-      }
-      Object.defineProperty(clone2, key, descriptor);
-    }
-    return clone2;
-  }
-  if (Object.getPrototypeOf(value) !== Object.prototype) {
-    return value;
-  }
-  const clone = {};
-  seen.set(value, clone);
-  for (const [key, item] of Object.entries(value)) {
-    clone[key] = cloneObserverFallback(item, seen);
-  }
-  return clone;
-}
-function containsError(value, seen) {
-  if (typeof value !== "object" || value === null) return false;
-  if (value instanceof Error) return true;
-  if (seen.has(value)) return false;
-  seen.add(value);
-  if (Array.isArray(value)) {
-    return value.some((item) => containsError(item, seen));
-  }
-  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
-  return Object.values(value).some((item) => containsError(item, seen));
-}
-
-// src/observability/group.ts
-async function startAgentRunObservers(registrations, args, failOnObserverError) {
-  const runObservers = [];
-  for (const registration of registrations) {
-    try {
-      const runObserver = await registration.observer.startRun(observerSnapshot(args));
-      if (runObserver !== void 0) {
-        runObservers.push(runObserver);
-      }
-    } catch (error) {
-      if (failOnObserverError || registration.failOnObserverError === true) {
-        throw error;
-      }
-    }
-  }
-  return new ActiveAgentRunObservers(runObservers, failOnObserverError);
-}
-var ActiveAgentRunObservers = class {
-  constructor(runObservers, failOnObserverError) {
-    this.runObservers = runObservers;
-    this.failOnObserverError = failOnObserverError;
-    this.trace = runObservers.find((observer) => observer.trace !== void 0)?.trace;
-  }
-  runObservers;
-  failOnObserverError;
-  trace;
-  async startGeneration(args) {
-    const generationObservers = [];
-    for (const runObserver of this.runObservers) {
-      if (runObserver.startGeneration === void 0) {
-        continue;
-      }
-      try {
-        const generationObserver = await runObserver.startGeneration(observerSnapshot(args));
-        if (generationObserver !== void 0) {
-          generationObservers.push(generationObserver);
-        }
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-    return new ActiveGenerationObservers(generationObservers, this.failOnObserverError);
-  }
-  async startTool(args) {
-    const toolObservers = [];
-    for (const runObserver of this.runObservers) {
-      if (runObserver.startTool === void 0) {
-        continue;
-      }
-      try {
-        const toolObserver = await runObserver.startTool(observerSnapshot(args));
-        if (toolObserver !== void 0) {
-          toolObservers.push(toolObserver);
-        }
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-    return new ActiveToolObservers(toolObservers, this.failOnObserverError);
-  }
-  async end(args) {
-    for (const runObserver of this.runObservers) {
-      try {
-        await runObserver.end(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async error(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.error === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.error(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async event(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.event === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.event(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
-  }
-};
-var ActiveGenerationObservers = class {
-  constructor(generationObservers, failOnObserverError) {
-    this.generationObservers = generationObservers;
-    this.failOnObserverError = failOnObserverError;
-  }
-  generationObservers;
-  failOnObserverError;
-  async end(args) {
-    for (const observer of this.generationObservers) {
-      try {
-        await observer.end(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async error(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.error === void 0) {
-        continue;
-      }
-      try {
-        await observer.error(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async update(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.update === void 0) {
-        continue;
-      }
-      try {
-        await observer.update(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
-  }
-};
-var ActiveToolObservers = class {
-  constructor(toolObservers, failOnObserverError) {
-    this.toolObservers = toolObservers;
-    this.failOnObserverError = failOnObserverError;
-  }
-  toolObservers;
-  failOnObserverError;
-  async streamEvent(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.streamEvent === void 0) {
-        continue;
-      }
-      try {
-        await observer.streamEvent(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async end(args) {
-    for (const observer of this.toolObservers) {
-      try {
-        await observer.end(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async error(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.error === void 0) {
-        continue;
-      }
-      try {
-        await observer.error(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
-  }
-};
-
-// src/internal/async-queue.ts
-function createAsyncQueue() {
-  const values = [];
-  const waiters = [];
-  let closed = false;
-  let error;
-  function flush() {
-    while (waiters.length > 0 && values.length > 0) {
-      const waiter = waiters.shift();
-      const value = values.shift();
-      if (waiter !== void 0) {
-        waiter.resolve({ value, done: false });
-      }
-    }
-    if (values.length > 0 || waiters.length === 0 || !closed) {
-      return;
-    }
-    while (waiters.length > 0) {
-      const waiter = waiters.shift();
-      if (waiter === void 0) {
-        continue;
-      }
-      if (error !== void 0) {
-        waiter.reject(error);
-      } else {
-        waiter.resolve({ value: void 0, done: true });
-      }
-    }
-  }
-  return {
-    enqueue(value) {
-      if (closed) {
-        return;
-      }
-      values.push(value);
-      flush();
-    },
-    close() {
-      closed = true;
-      flush();
-    },
-    throw(thrown) {
-      closed = true;
-      error = thrown;
-      flush();
-    },
-    [Symbol.asyncIterator]() {
-      return {
-        next() {
-          if (values.length > 0) {
-            const value = values.shift();
-            return Promise.resolve({ value, done: false });
-          }
-          if (error !== void 0) {
-            return Promise.reject(error);
-          }
-          if (closed) {
-            return Promise.resolve({ value: void 0, done: true });
-          }
-          return new Promise((resolve, reject) => {
-            waiters.push({ resolve, reject });
-          });
-        }
-      };
-    }
-  };
-}
-
-// src/internal/rag-text.ts
-function extractRagText(message) {
-  if (message.role === "user") {
-    return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
-  }
-  if (message.role === "tool") {
-    return message.content.flatMap((item) => item.content.flatMap((part) => part.type === "text" ? [part.text] : [])).join("\n");
-  }
-  return void 0;
-}
-
-// src/internal/agent-runtime/memory.ts
-var AgentRunMemory = class {
-  constructor(agent, memoryContext, initialHistory) {
-    this.agent = agent;
-    this.memoryContext = memoryContext;
-    this.initialHistory = initialHistory;
-  }
-  agent;
-  memoryContext;
-  initialHistory;
-  memoryPolicy() {
-    return this.memory()?.options.savePolicy;
-  }
-  pendingTurnMessages(newMessages) {
-    return this.memoryPolicy() === "turn" ? [...newMessages] : [];
-  }
-  async prepareHistory(runId, incomingMessageCount) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
-      return {
-        history: this.initialHistory,
-        usage: Usage.empty()
-      };
-    }
-    const preparation = await this.prepareStoredHistory(memory, runId, incomingMessageCount);
-    const memoryHistory = preparation.history;
-    const chatHistory = [...memoryHistory, ...this.initialHistory];
-    return {
-      ...preparation,
-      history: chatHistory
-    };
-  }
-  async commitAcceptedInput(runId, messages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "message" || messages.length === 0) {
-      return;
-    }
-    await memory.store.append({
-      context: this.memoryContext,
-      runId,
-      turn: 1,
-      messages
-    });
-  }
-  async commitMessages(runId, turn, messages, pendingTurnMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
-      return;
-    }
-    if (memory.options.savePolicy === "message") {
-      await memory.store.append({
-        context: this.memoryContext,
-        runId,
-        turn,
-        messages
-      });
-    } else if (memory.options.savePolicy === "turn") {
-      pendingTurnMessages.push(...messages);
-    }
-  }
-  async commitCompletedTurn(runId, turn, pendingTurnMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
-      return;
-    }
-    await memory.store.append({
-      context: this.memoryContext,
-      runId,
-      turn,
-      messages: [...pendingTurnMessages]
-    });
-    pendingTurnMessages.length = 0;
-  }
-  async commitCompletedRun(runId, turn, newMessages, pendingTurnMessages) {
-    await this.commitCompletedTurn(runId, turn, pendingTurnMessages);
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "run") {
-      return;
-    }
-    await memory.store.append({
-      context: this.memoryContext,
-      runId,
-      turn,
-      messages: [...newMessages]
-    });
-  }
-  async recordError(runId, error, newMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
-      return;
-    }
-    await memory.store.recordError?.({
-      context: this.memoryContext,
-      runId,
-      error,
-      messages: [...newMessages]
-    });
-  }
-  memory() {
-    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
-  }
-  async prepareStoredHistory(memory, runId, incomingMessageCount) {
-    const context = this.memoryContext;
-    if (context === void 0) {
-      return { history: [], usage: Usage.empty() };
-    }
-    const options = memory.options.compaction;
-    const capability = memory.store.compaction;
-    if (options === void 0 || capability === void 0) {
-      return {
-        history: await memory.store.load(context),
-        usage: Usage.empty()
-      };
-    }
-    let usage = Usage.empty();
-    let conflictRetries = 0;
-    for (let attempt = 0; attempt <= options.conflictRetries; attempt += 1) {
-      const snapshot = await capability.load(context);
-      const compactedMessageCount = compactedPrefixLength(
-        snapshot.messages,
-        incomingMessageCount,
-        options.maxMessages,
-        options.keepRecentUserTurns
-      );
-      if (compactedMessageCount === 0) {
-        return { history: snapshot.messages, usage };
-      }
-      const prefix = snapshot.messages.slice(0, compactedMessageCount);
-      let result;
-      try {
-        result = await options.compactor({
-          context,
-          messages: prefix
-        });
-      } catch (error) {
-        throw remappedCompactorError(error, usage);
-      }
-      if (result.usage !== void 0) {
-        usage = Usage.add(usage, result.usage);
-      }
-      const summaryText = result.summary.trim();
-      if (summaryText.length === 0) {
-        throw new MemoryCompactionError("Memory compactor returned an empty summary.", {
-          usage
-        });
-      }
-      const summary = createMemoryCompactionSummary(
-        summaryText,
-        cumulativeCompactedMessageCount(prefix)
-      );
-      let commit;
-      try {
-        commit = await capability.commit({
-          context,
-          revision: snapshot.revision,
-          compactedMessageCount,
-          summary,
-          runId: `memory-compaction:${runId}:${attempt + 1}`
-        });
-      } catch (error) {
-        throw new MemoryCompactionError("Memory compaction store commit failed.", {
-          cause: error,
-          usage
-        });
-      }
-      if (commit === "committed") {
-        const retained = snapshot.messages.slice(compactedMessageCount);
-        return {
-          history: [summary, ...retained],
-          usage,
-          compaction: {
-            originalMessageCount: snapshot.messages.length,
-            compactedMessageCount,
-            retainedMessageCount: retained.length,
-            conflictRetries
-          }
-        };
-      }
-      conflictRetries += 1;
-    }
-    throw new MemoryCompactionConflictError(options.conflictRetries + 1, usage);
-  }
-};
-function compactedPrefixLength(messages, incomingMessageCount, maxMessages, keepRecentUserTurns) {
-  if (messages.length + incomingMessageCount <= maxMessages) {
-    return 0;
-  }
-  const userMessageIndexes = messages.flatMap(
-    (message, index) => message.role === "user" ? [index] : []
-  );
-  if (userMessageIndexes.length <= keepRecentUserTurns) {
-    return 0;
-  }
-  return userMessageIndexes[userMessageIndexes.length - keepRecentUserTurns] ?? 0;
-}
-function remappedCompactorError(error, usage) {
-  if (error instanceof MemoryCompactionError) {
-    const mergedUsage = error.usage === void 0 ? usage : isEmptyUsage(usage) ? error.usage : Usage.add(usage, error.usage);
-    if (mergedUsage === error.usage || error.usage === void 0 && isEmptyUsage(usage)) {
-      return error;
-    }
-    return new MemoryCompactionError(error.message, {
-      cause: error,
-      usage: mergedUsage
-    });
-  }
-  return new MemoryCompactionError("Memory compactor failed.", {
-    cause: error,
-    usage
-  });
-}
-function isEmptyUsage(usage) {
-  return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.totalTokens === 0 && usage.cachedInputTokens === 0 && usage.cacheCreationInputTokens === 0;
-}
-
-// src/internal/agent-runtime/retrieval.ts
-async function fetchContextDocuments(agent, ragText) {
-  const documents = [];
-  for (const input of agent.context) {
-    if (!isContextIndex(input)) {
-      documents.push(input);
-      continue;
-    }
-    if (ragText === void 0 || ragText.length === 0) {
-      continue;
-    }
-    const results = await input.index.search({
-      query: ragText,
-      topK: input.topK,
-      threshold: input.threshold,
-      filter: input.filter
-    });
-    for (const result of results) {
-      const formatted = input.format?.(result);
-      if (formatted !== void 0) {
-        documents.push(formatted);
-      } else {
-        const metadata = formatMetadata(result.metadata);
-        const document = {
-          id: result.id,
-          text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2)
-        };
-        if (metadata !== void 0) {
-          document.additionalProps = metadata;
-        }
-        documents.push(document);
-      }
-    }
-  }
-  return documents;
-}
-async function fetchToolDefinitions(agent, ragText) {
-  const state = getAgentToolState(agent);
-  const staticDefinitions = await Promise.all(
-    state.staticTools.map((tool) => tool.definition(ragText ?? ""))
-  );
-  if (ragText === void 0 || ragText.length === 0 || state.toolIndexes.length === 0) {
-    return staticDefinitions;
-  }
-  const definitions = [...staticDefinitions];
-  const names = new Set(staticDefinitions.map((definition) => definition.name));
-  for (const index of state.toolIndexes) {
-    const results = await index.search({
-      query: ragText,
-      topK: index.topK,
-      threshold: index.threshold,
-      filter: index.filter
-    });
-    for (const result of results) {
-      const toolName = result.document.toolName;
-      if (names.has(toolName)) {
-        continue;
-      }
-      const tool = index.tools.find((candidate) => candidate.name === toolName);
-      if (tool === void 0) {
-        continue;
-      }
-      names.add(toolName);
-      definitions.push(await tool.definition(ragText));
-    }
-  }
-  return definitions;
-}
-function formatMetadata(metadata) {
-  if (metadata === void 0) {
-    return void 0;
-  }
-  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
-}
-
-// src/internal/agent-runtime/run-validation.ts
-function assertNonnegativeSafeInteger(value, name) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new TypeError(`${name} must be a nonnegative safe integer.`);
-  }
-  return value;
-}
-function assertPositiveSafeInteger(value, name) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive safe integer.`);
-  }
-  return value;
-}
-
-// src/internal/agent-runtime/stream-accumulator.ts
-var CompletionStreamAccumulator = class {
-  orderedParts = [];
-  textParts = /* @__PURE__ */ new Map();
-  reasoningByKey = /* @__PURE__ */ new Map();
-  reasoningKeyById = /* @__PURE__ */ new Map();
-  toolCalls = /* @__PURE__ */ new Map();
-  sources = /* @__PURE__ */ new Map();
-  providerToolCalls = /* @__PURE__ */ new Map();
-  finalResponse;
-  messageId;
-  nextTextKey = 0;
-  nextReasoningKey = 0;
-  accept(event) {
-    if (event.type === "text_delta") {
-      this.appendText(event.delta);
-      return { type: "text_delta", delta: event.delta };
-    }
-    if (event.type === "reasoning_delta") {
-      const reasoning = this.reasoningStateForEvent(event);
-      this.appendReasoning(reasoning, event);
-      return reasoningDeltaEvent(event);
-    }
-    if (event.type === "tool_call_delta") {
-      const toolCall = this.toolCallStateForId(event.id);
-      if (event.callId !== void 0 && event.callId.length > 0) toolCall.callId = event.callId;
-      if (event.name !== void 0 && event.name.length > 0) toolCall.name = event.name;
-      if (event.signature !== void 0) toolCall.signature = event.signature;
-      if (event.argumentsDelta !== void 0) {
-        if (event.argumentsMode === "replace") {
-          toolCall.argumentsText = event.argumentsDelta;
-        } else {
-          toolCall.argumentsText += event.argumentsDelta;
-        }
-      }
-      return void 0;
-    }
-    if (event.type === "tool_call") {
-      this.upsertToolCall(event.toolCall);
-      return { type: "tool_call", toolCall: event.toolCall };
-    }
-    if (event.type === "source") {
-      this.sources.set(sourceKey(event.source), event.source);
-      return { type: "source", source: event.source };
-    }
-    if (event.type === "provider_tool_call") {
-      this.providerToolCalls.set(event.toolCall.id, event.toolCall);
-      return { type: "provider_tool_call", toolCall: event.toolCall };
-    }
-    if (event.type === "message_id") {
-      this.messageId = event.id;
-      return void 0;
-    }
-    if (event.type === "final") {
-      this.finalResponse = event.response;
-      return void 0;
-    }
-    return void 0;
-  }
-  response() {
-    const accumulatedResponse = this.buildAccumulatedResponse();
-    if (this.finalResponse !== void 0) {
-      if (accumulatedResponse.choice.length === 0) {
-        return this.withAccumulatedArtifacts(this.finalResponse, accumulatedResponse);
-      }
-      return this.mergeFinalResponse(accumulatedResponse, this.finalResponse);
-    }
-    return accumulatedResponse;
-  }
-  buildAccumulatedResponse() {
-    const choice = [];
-    for (const part of this.orderedParts) {
-      if (part.type === "text") {
-        const text = this.textParts.get(part.key) ?? "";
-        if (text.length > 0) {
-          choice.push({ type: "text", text });
-        }
-        continue;
-      }
-      if (part.type === "reasoning") {
-        const reasoning = this.reasoningByKey.get(part.key);
-        if (reasoning !== void 0) {
-          choice.push(reasoningContent(reasoning));
-        }
-        continue;
-      }
-      const toolCall = this.toolCalls.get(part.key);
-      if (toolCall !== void 0) {
-        choice.push(
-          toolCallContent(toolCall, matchingFinalToolCall(toolCall, this.finalResponse?.choice))
-        );
-      }
-    }
-    const response = {
-      choice,
-      usage: Usage.empty(),
-      rawResponse: void 0
-    };
-    if (this.messageId !== void 0) {
-      response.messageId = this.messageId;
-    }
-    const sources = [...this.sources.values()];
-    if (sources.length > 0) {
-      response.sources = sources;
-    }
-    const providerToolCalls = [...this.providerToolCalls.values()];
-    if (providerToolCalls.length > 0) {
-      response.providerToolCalls = providerToolCalls;
-    }
-    return response;
-  }
-  upsertToolCall(toolCall) {
-    if (!this.toolCalls.has(toolCall.id)) {
-      this.orderedParts.push({ type: "tool_call", key: toolCall.id });
-    }
-    const partial = {
-      id: toolCall.id,
-      name: toolCall.function.name,
-      argumentsText: JSON.stringify(toolCall.function.arguments ?? {})
-    };
-    if (toolCall.callId !== void 0) {
-      partial.callId = toolCall.callId;
-    }
-    if (toolCall.signature !== void 0) {
-      partial.signature = toolCall.signature;
-    }
-    if (toolCall.additionalParams !== void 0) {
-      partial.additionalParams = toolCall.additionalParams;
-    }
-    this.toolCalls.set(toolCall.id, partial);
-  }
-  mergeFinalResponse(accumulatedResponse, finalResponse) {
-    if (finalResponse.choice.length === 0) {
-      const mergedResponse = {
-        ...accumulatedResponse,
-        usage: finalResponse.usage,
-        rawResponse: finalResponse.rawResponse
-      };
-      if (finalResponse.messageId !== void 0) {
-        mergedResponse.messageId = finalResponse.messageId;
-      }
-      return this.withAccumulatedArtifacts(mergedResponse, accumulatedResponse);
-    }
-    const finalById = /* @__PURE__ */ new Map();
-    const finalByCallId = /* @__PURE__ */ new Map();
-    for (const content of finalResponse.choice) {
-      if (content.type !== "tool_call") {
-        continue;
-      }
-      finalById.set(content.id, content);
-      if (content.callId !== void 0) {
-        finalByCallId.set(content.callId, content);
-      }
-    }
-    const matchedFinalToolCalls = /* @__PURE__ */ new Set();
-    const choice = accumulatedResponse.choice.map((content) => {
-      if (content.type !== "tool_call") {
-        return content;
-      }
-      const finalToolCall = finalById.get(content.id) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
-      if (finalToolCall === void 0) {
-        return content;
-      }
-      matchedFinalToolCalls.add(finalToolCall);
-      return mergeFinalToolCall(content, finalToolCall);
-    });
-    for (const content of finalResponse.choice) {
-      if (content.type !== "tool_call") {
-        continue;
-      }
-      if (!matchedFinalToolCalls.has(content)) {
-        choice.push(content);
-      }
-    }
-    return this.withAccumulatedArtifacts({ ...finalResponse, choice }, accumulatedResponse);
-  }
-  appendText(delta) {
-    const lastPart = this.orderedParts.at(-1);
-    const key = lastPart?.type === "text" ? lastPart.key : this.createTextKey();
-    if (lastPart?.type !== "text") {
-      this.orderedParts.push({ type: "text", key });
-    }
-    this.textParts.set(key, `${this.textParts.get(key) ?? ""}${delta}`);
-  }
-  reasoningStateForEvent(event) {
-    if (event.id !== void 0) {
-      const existingKey = this.reasoningKeyById.get(event.id);
-      if (existingKey !== void 0) {
-        const existing = this.reasoningByKey.get(existingKey);
-        if (existing !== void 0) {
-          return existing;
-        }
-      }
-      const key2 = this.createReasoningKey();
-      const reasoning2 = { id: event.id, text: "" };
-      this.reasoningKeyById.set(event.id, key2);
-      this.reasoningByKey.set(key2, reasoning2);
-      this.orderedParts.push({ type: "reasoning", key: key2 });
-      return reasoning2;
-    }
-    const lastPart = this.orderedParts.at(-1);
-    if (lastPart?.type === "reasoning") {
-      const lastReasoning = this.reasoningByKey.get(lastPart.key);
-      if (lastReasoning !== void 0 && lastReasoning.id === void 0) {
-        return lastReasoning;
-      }
-    }
-    const key = this.createReasoningKey();
-    const reasoning = { text: "" };
-    this.reasoningByKey.set(key, reasoning);
-    this.orderedParts.push({ type: "reasoning", key });
-    return reasoning;
-  }
-  toolCallStateForId(id) {
-    const existing = this.toolCalls.get(id);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const toolCall = {
-      id,
-      name: "",
-      argumentsText: ""
-    };
-    this.toolCalls.set(id, toolCall);
-    this.orderedParts.push({ type: "tool_call", key: id });
-    return toolCall;
-  }
-  withMessageIdFallback(response, accumulatedResponse) {
-    if (response.messageId !== void 0 || accumulatedResponse.messageId === void 0) {
-      return response;
-    }
-    return { ...response, messageId: accumulatedResponse.messageId };
-  }
-  withAccumulatedArtifacts(response, accumulatedResponse) {
-    const withMessageId = this.withMessageIdFallback(response, accumulatedResponse);
-    const sources = mergeSources(accumulatedResponse.sources, response.sources);
-    const providerToolCalls = mergeProviderToolCalls(
-      accumulatedResponse.providerToolCalls,
-      response.providerToolCalls
-    );
-    return {
-      ...withMessageId,
-      ...sources.length === 0 ? {} : { sources },
-      ...providerToolCalls.length === 0 ? {} : { providerToolCalls }
-    };
-  }
-  createTextKey() {
-    this.nextTextKey += 1;
-    return `text_${this.nextTextKey.toString()}`;
-  }
-  createReasoningKey() {
-    this.nextReasoningKey += 1;
-    return `reasoning_${this.nextReasoningKey.toString()}`;
-  }
-  appendReasoning(reasoning, event) {
-    const contentType = event.contentType ?? "text";
-    if (contentType === "text" || contentType === "summary") {
-      reasoning.text += event.delta;
-    }
-    if (event.contentType === void 0 && event.signature === void 0) {
-      return;
-    }
-    reasoning.content ??= [];
-    const last = reasoning.content.at(-1);
-    if (contentType === "text") {
-      if (last?.type === "text") {
-        last.text += event.delta;
-        if (event.signature !== void 0) {
-          last.signature = event.signature;
-        }
-      } else {
-        reasoning.content.push(
-          event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
-        );
-      }
-      return;
-    }
-    if (contentType === "summary") {
-      if (last?.type === "summary") {
-        last.text += event.delta;
-      } else {
-        reasoning.content.push({ type: "summary", text: event.delta });
-      }
-      return;
-    }
-    if (contentType === "encrypted") {
-      reasoning.content.push({ type: "encrypted", data: event.delta });
-      return;
-    }
-    reasoning.content.push({ type: "redacted", data: event.delta });
-  }
-};
-function sourceKey(source) {
-  return `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
-}
-function mergeSources(accumulated, final) {
-  const sources = /* @__PURE__ */ new Map();
-  for (const source of [...accumulated ?? [], ...final ?? []]) {
-    sources.set(sourceKey(source), source);
-  }
-  return [...sources.values()];
-}
-function mergeProviderToolCalls(accumulated, final) {
-  const toolCalls = /* @__PURE__ */ new Map();
-  for (const toolCall of [...accumulated ?? [], ...final ?? []]) {
-    toolCalls.set(toolCall.id, toolCall);
-  }
-  return [...toolCalls.values()];
-}
-function reasoningContent(reasoning) {
-  const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
-  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
-}
-function toolCallContent(toolCall, finalToolCall) {
-  const argumentsValue = finalToolCall !== void 0 && !isEmptyToolArguments(finalToolCall.function.arguments) ? finalToolCall.function.arguments : parseToolArguments(toolCall.id, toolCall.argumentsText);
-  const content = {
-    type: "tool_call",
-    id: toolCall.id,
-    function: {
-      name: toolCall.name,
-      arguments: argumentsValue
-    }
-  };
-  if (toolCall.callId !== void 0) {
-    content.callId = toolCall.callId;
-  }
-  if (toolCall.signature !== void 0) {
-    content.signature = toolCall.signature;
-  }
-  if (toolCall.additionalParams !== void 0) {
-    content.additionalParams = toolCall.additionalParams;
-  }
-  return content;
-}
-function matchingFinalToolCall(accumulated, finalChoice) {
-  const byId = finalChoice?.find(
-    (content) => content.type === "tool_call" && content.id === accumulated.id
-  );
-  if (byId !== void 0 || accumulated.callId === void 0) {
-    return byId;
-  }
-  return finalChoice?.find(
-    (content) => content.type === "tool_call" && content.callId === accumulated.callId
-  );
-}
-function mergeFinalToolCall(accumulated, finalToolCall) {
-  const argumentsValue = isEmptyToolArguments(finalToolCall.function.arguments) ? accumulated.function.arguments : finalToolCall.function.arguments;
-  return {
-    ...accumulated,
-    ...finalToolCall,
-    function: {
-      ...accumulated.function,
-      ...finalToolCall.function,
-      arguments: argumentsValue
-    }
-  };
-}
-function reasoningDeltaEvent(event) {
-  const mapped = { type: "reasoning_delta", delta: event.delta };
-  if (event.id !== void 0) mapped.id = event.id;
-  if (event.contentType !== void 0) mapped.contentType = event.contentType;
-  if (event.signature !== void 0) mapped.signature = event.signature;
-  return mapped;
-}
-function isEmptyToolArguments(value) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (typeof value === "string") {
-    return value.trim().length === 0;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  if (typeof value === "object") {
-    return Object.values(value).every((item) => item === void 0);
-  }
-  return false;
-}
-function parseToolArguments(toolCallId, text) {
-  if (text.trim().length === 0) {
-    return {};
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(
-      `Completion returned tool call "${toolCallId}" with malformed JSON arguments; this indicates invalid provider output or incomplete stream assembly.`
-    );
-  }
-}
-
-// src/internal/agent-runtime/stream-events.ts
-function addTurn(turn, event) {
-  if (event.type === "text_delta") {
-    return { type: "text_delta", turn, delta: event.delta };
-  }
-  if (event.type === "reasoning_delta") {
-    const mapped = { type: "reasoning_delta", turn, delta: event.delta };
-    if (event.id !== void 0) mapped.id = event.id;
-    if (event.contentType !== void 0) mapped.contentType = event.contentType;
-    if (event.signature !== void 0) mapped.signature = event.signature;
-    return mapped;
-  }
-  if (event.type === "source") {
-    return { type: "source", turn, source: event.source };
-  }
-  if (event.type === "provider_tool_call") {
-    return { type: "provider_tool_call", turn, toolCall: event.toolCall };
-  }
-  return { type: "tool_call", turn, toolCall: event.toolCall };
-}
-function addTurnToToolCallDelta(turn, event) {
-  const mapped = {
-    type: "tool_call_delta",
-    turn,
-    id: event.id
-  };
-  if (event.callId !== void 0) mapped.callId = event.callId;
-  if (event.name !== void 0) mapped.name = event.name;
-  if (event.argumentsDelta !== void 0) mapped.argumentsDelta = event.argumentsDelta;
-  if (event.argumentsMode !== void 0) mapped.argumentsMode = event.argumentsMode;
-  if (event.signature !== void 0) mapped.signature = event.signature;
-  return mapped;
-}
-function isGenerationDeltaEvent(type) {
-  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call" || type === "source" || type === "provider_tool_call";
-}
-
-// src/internal/agent-runtime/tool-execution.ts
-var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
-var ToolCallExecutor = class {
-  constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, includeToolCallDeltas, cancel) {
-    this.agent = agent;
-    this.activeHook = activeHook;
-    this.approvalHandler = approvalHandler;
-    this.lifecycle = lifecycle;
-    this.runContext = runContext;
-    this.concurrency = concurrency;
-    this.requestMiddlewares = requestMiddlewares;
-    this.includeToolCallDeltas = includeToolCallDeltas;
-    this.cancel = cancel;
-  }
-  agent;
-  activeHook;
-  approvalHandler;
-  lifecycle;
-  runContext;
-  concurrency;
-  requestMiddlewares;
-  includeToolCallDeltas;
-  cancel;
-  async execute(toolCalls, onResult, onStreamEvent, observation) {
-    for (const toolCall of toolCalls) {
-      if (toolCall.function.name.length === 0) {
-        throw new Error(
-          `Completion returned tool call "${toolCall.id}" with an empty function name; this indicates invalid provider output or provider mapping.`
-        );
-      }
-    }
-    return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
-      const args = JSON.stringify(toolCall.function.arguments ?? {});
-      const internalCallId = globalThis.crypto.randomUUID();
-      const hookArgs = {
-        toolName: toolCall.function.name,
-        internalCallId,
-        args
-      };
-      if (toolCall.callId !== void 0) {
-        hookArgs.toolCallId = toolCall.callId;
-      }
-      const tool = this.agent.getTool(toolCall.function.name);
-      const toolDefinition = observation?.toolDefinitions?.find(
-        (definition) => definition.name === toolCall.function.name
-      );
-      const toolMetadata = toolTraceMetadata(tool);
-      const toolStartArgs = {
-        turn: observation?.turn ?? 0,
-        toolCall,
-        toolName: toolCall.function.name,
-        internalCallId,
-        args,
-        ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
-        ...toolDefinition === void 0 ? {} : { toolDefinition },
-        ...toolMetadata === void 0 ? {} : { toolMetadata }
-      };
-      const toolObservers = await observation?.runObservers.startTool(toolStartArgs);
-      const toolObservation = new ToolObserverScope(toolObservers);
-      let output;
-      let skipped = false;
-      let toolExecutionFailed = false;
-      let effectiveArgs = args;
-      try {
-        const callAction = await this.activeHook?.onToolCall?.({
-          ...hookArgs,
-          tool: toolCallControl
-        });
-        if (callAction?.type === "terminate") {
-          throw this.cancel(callAction.reason);
-        }
-        if (callAction?.type === "skip") {
-          output = callAction.reason;
-          skipped = true;
-        } else {
-          try {
-            effectiveArgs = await this.runToolInputMiddlewares({
-              ...hookArgs,
-              turn: observation?.turn ?? 0,
-              originalArgs: args
-            });
-            hookArgs.args = effectiveArgs;
-            let prepared;
-            try {
-              prepared = this.prepareToolCall(tool, toolCall.function.name, effectiveArgs);
-            } catch (error) {
-              const outcome = await this.handleToolError(
-                toolCall,
-                hookArgs,
-                effectiveArgs,
-                error,
-                toolObservation,
-                observation
-              );
-              output = outcome.output;
-              toolExecutionFailed = outcome.failed;
-            }
-            if (prepared !== void 0) {
-              const approvalContext = createApprovalContext(
-                prepared.input,
-                hookArgs,
-                this.agent,
-                this.runContext
-              );
-              const approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(approvalContext, callAction, observation) : await this.evaluateToolApproval(tool, approvalContext, observation) ?? {
-                approved: true
-              };
-              if (!approvalDecision.approved) {
-                output = approvalDecision.result;
-                skipped = true;
-              } else {
-                const step = observation?.turn ?? 0;
-                const lifecycleEvent = {
-                  runId: this.runContext.runId,
-                  step,
-                  toolName: toolCall.function.name,
-                  input: lifecycleSnapshot(prepared.input),
-                  ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
-                };
-                await this.lifecycle?.onToolStart?.(lifecycleEvent);
-                const startedAt = Date.now();
-                const outcome = await this.runApprovedToolCall(
-                  prepared,
-                  toolCall,
-                  hookArgs,
-                  effectiveArgs,
-                  toolObservation,
-                  observation,
-                  onStreamEvent
-                );
-                output = outcome.output;
-                toolExecutionFailed = outcome.failed;
-                const durationMs = Date.now() - startedAt;
-                await this.lifecycle?.onToolFinish?.(
-                  outcome.failed ? {
-                    ...lifecycleEvent,
-                    durationMs,
-                    success: false,
-                    error: lifecycleSnapshot(outcome.error)
-                  } : {
-                    ...lifecycleEvent,
-                    durationMs,
-                    success: true,
-                    output: lifecycleSnapshot(output)
-                  }
-                );
-              }
-            }
-          } catch (error) {
-            await toolObservation.error(
-              toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
-            );
-            throw error;
-          }
-        }
-        if (output === void 0) {
-          throw new Error(`Tool "${toolCall.function.name}" did not produce an execution result.`);
-        }
-        let result = toolOutputToText(output);
-        let structuredResult = toolOutputToStructuredResult(output);
-        if (!isSkillTool(tool)) {
-          const middlewareReplacement = await this.runToolResultMiddlewares({
-            ...hookArgs,
-            args: effectiveArgs,
-            result,
-            originalResult: result,
-            structuredResult,
-            originalStructuredResult: structuredResult,
-            turn: observation?.turn ?? 0
-          });
-          if (middlewareReplacement !== void 0) {
-            output = middlewareReplacement;
-            result = toolOutputToText(middlewareReplacement);
-            structuredResult = toolOutputToStructuredResult(middlewareReplacement);
-          }
-        }
-        const resultAction = await this.activeHook?.onToolResult?.({
-          ...hookArgs,
-          args: effectiveArgs,
-          result,
-          structuredResult,
-          run: runControl
-        });
-        if (!toolExecutionFailed) {
-          await toolObservation.end({
-            turn: observation?.turn ?? 0,
-            toolCall,
-            toolName: toolCall.function.name,
-            internalCallId,
-            args: effectiveArgs,
-            result,
-            structuredResult,
-            skipped,
-            toolCallId: toolCall.callId
-          });
-        }
-        if (resultAction?.type === "terminate") {
-          throw this.cancel(resultAction.reason);
-        }
-        const resultPayload = {
-          type: "tool_result",
-          toolName: toolCall.function.name,
-          internalCallId,
-          args: effectiveArgs,
-          result,
-          structuredResult
-        };
-        if (toolCall.callId !== void 0) {
-          resultPayload.toolCallId = toolCall.callId;
-        }
-        onResult?.(resultPayload);
-        return ToolContent.toolResult(toolCall.id, output, {
-          callId: toolCall.callId,
-          toolName: toolCall.function.name
-        });
-      } catch (error) {
-        await toolObservation.error(
-          toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
-        );
-        throw error;
-      }
-    });
-  }
-  async runApprovedToolCall(prepared, toolCall, hookArgs, effectiveArgs, toolObservation, observation, onStreamEvent) {
-    try {
-      const toolContext = {
-        emitStreamEvent: async (event) => {
-          const streamEventArgs = {
-            turn: observation?.turn ?? 0,
-            toolCall,
-            toolName: toolCall.function.name,
-            internalCallId: hookArgs.internalCallId,
-            args: effectiveArgs,
-            event,
-            ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
-          };
-          await toolObservation.streamEvent(streamEventArgs);
-          const payload = agentToolEventPayload(toolCall, hookArgs.internalCallId, event);
-          if (payload !== void 0) {
-            onStreamEvent?.(payload);
-          }
-        }
-      };
-      toolContext.includeToolCallDeltas = this.includeToolCallDeltas;
-      return {
-        output: await prepared.call(toolContext),
-        failed: false
-      };
-    } catch (error) {
-      return this.handleToolError(
-        toolCall,
-        hookArgs,
-        effectiveArgs,
-        error,
-        toolObservation,
-        observation
-      );
-    }
-  }
-  prepareToolCall(tool, toolName, args) {
-    if (tool !== void 0) {
-      return prepareToolCall(tool, args);
-    }
-    const input = parseToolArgs(args);
-    return {
-      input,
-      call: (context) => this.agent.callTool(toolName, args, context)
-    };
-  }
-  async handleToolError(toolCall, hookArgs, args, error, toolObservation, observation) {
-    const errorAction = await this.activeHook?.onToolError?.({
-      ...hookArgs,
-      args,
-      error,
-      run: runControl
-    });
-    await toolObservation.error(
-      toolErrorArgs(observation?.turn ?? 0, toolCall, hookArgs.internalCallId, args, error)
-    );
-    if (errorAction?.type === "terminate") {
-      throw this.cancel(errorAction.reason);
-    }
-    return {
-      output: error instanceof Error ? error.toString() : String(error),
-      failed: true,
-      error
-    };
-  }
-  async runToolResultMiddlewares(args) {
-    let result = args.result;
-    let structuredResult = args.structuredResult;
-    let replaced = false;
-    for (const middleware of this.activeMiddlewares()) {
-      const outputReplacement = await middleware.onToolOutput?.({
-        ...args,
-        result,
-        structuredResult
-      });
-      if (outputReplacement !== void 0) {
-        const normalized = normalizeToolOutputMiddlewareResult(outputReplacement);
-        if (normalized.result !== void 0) {
-          result = normalized.result;
-          structuredResult = void 0;
-        }
-        if (normalized.structuredResult !== void 0) {
-          structuredResult = normalized.structuredResult;
-          result = toolResultContentToText(normalized.structuredResult);
-        }
-        replaced = true;
-      }
-    }
-    return replaced ? structuredResult ?? result : void 0;
-  }
-  async runToolInputMiddlewares(args) {
-    let current = args.args;
-    for (const middleware of this.activeMiddlewares()) {
-      const replacement = await middleware.onToolInput?.({
-        ...args,
-        args: current
-      });
-      if (replacement?.args !== void 0) {
-        current = typeof replacement.args === "string" ? replacement.args : JSON.stringify(replacement.args);
-      }
-    }
-    return current;
-  }
-  activeMiddlewares() {
-    return [...this.agent.middlewares, ...this.requestMiddlewares];
-  }
-  async evaluateToolApproval(tool, context, observation) {
-    const requirement = tool?.requiresApproval;
-    if (requirement === void 0) return void 0;
-    const resolved = typeof requirement === "function" ? await requirement(context.args, context) : requirement;
-    assertToolApprovalRequirement(resolved, { allowFunction: false });
-    if (resolved === false) return { approved: true };
-    const reason = resolved === true ? void 0 : resolved.reason;
-    return this.requestApproval(context, reason === void 0 ? {} : { reason }, observation);
-  }
-  async requestApproval(context, options, observation) {
-    const request = {
-      ...context,
-      id: globalThis.crypto.randomUUID()
-    };
-    if (options.reason !== void 0) {
-      request.reason = options.reason;
-    }
-    if (options.rejectMessage !== void 0) {
-      request.rejectMessage = options.rejectMessage;
-    }
-    await observation?.runObservers.event({
-      name: "tool.approval_requested",
-      attributes: approvalEventAttributes(request, observation.turn)
-    });
-    let decision;
-    try {
-      decision = await this.approvalHandler(request);
-    } catch (error) {
-      await observation?.runObservers.event({
-        name: "tool.approval_failed",
-        level: "ERROR",
-        attributes: {
-          ...approvalEventAttributes(request, observation.turn),
-          errorName: error instanceof Error ? error.name : typeof error
-        }
-      });
-      throw error;
-    }
-    await observation?.runObservers.event({
-      name: "tool.approval_resolved",
-      attributes: {
-        ...approvalEventAttributes(request, observation.turn),
-        approved: decision.approved,
-        ...decision.reason === void 0 ? {} : { decisionReason: decision.reason }
-      }
-    });
-    if (decision.approved) {
-      return { approved: true };
-    }
-    return {
-      approved: false,
-      result: decision.reason ?? request.rejectMessage ?? "Tool approval was rejected."
-    };
-  }
-};
-function createApprovalContext(input, hookArgs, agent, run) {
-  const approvalRun = {
-    agentId: agent.id,
-    runId: run.runId
-  };
-  if (run.sessionId !== void 0) {
-    approvalRun.sessionId = run.sessionId;
-  }
-  if (run.metadata !== void 0) {
-    approvalRun.metadata = run.metadata;
-  }
-  const context = {
-    toolName: hookArgs.toolName,
-    args: lifecycleSnapshot(input),
-    rawArgs: hookArgs.args,
-    internalCallId: hookArgs.internalCallId,
-    run: approvalRun
-  };
-  if (hookArgs.toolCallId !== void 0) {
-    context.toolCallId = hookArgs.toolCallId;
-  }
-  return context;
-}
-function approvalEventAttributes(request, turn) {
-  return {
-    turn,
-    approvalId: request.id,
-    toolName: request.toolName,
-    toolCallId: request.toolCallId,
-    internalCallId: request.internalCallId,
-    reason: request.reason
-  };
-}
-function normalizeToolOutputMiddlewareResult(result) {
-  if (typeof result === "string") {
-    return { result };
-  }
-  return result ?? {};
-}
-function toolTraceMetadata(tool) {
-  if (tool === void 0) {
-    return void 0;
-  }
-  const metadata = tool[MCP_TOOL_METADATA_KEY];
-  const mcpMetadata = typeof metadata === "object" && metadata !== null ? metadata : void 0;
-  const result = {
-    approvalRequired: toolMayRequireApproval(tool.requiresApproval)
-  };
-  if (typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0) {
-    result.mcpServerName = mcpMetadata.serverName;
-  }
-  return result;
-}
-function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
-  const observerArgs = {
-    turn,
-    toolCall,
-    toolName: toolCall.function.name,
-    internalCallId,
-    args,
-    error,
-    ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
-  };
-  return observerArgs;
-}
-var ToolObserverScope = class {
-  constructor(observers) {
-    this.observers = observers;
-  }
-  observers;
-  terminal = false;
-  streamEvent(args) {
-    return this.observers?.streamEvent(args);
-  }
-  async end(args) {
-    if (this.terminal) return;
-    this.terminal = true;
-    await this.observers?.end(args);
-  }
-  async error(args) {
-    if (this.terminal) return;
-    this.terminal = true;
-    await this.observers?.error(args);
-  }
-};
-function toolOutputToText(output) {
-  return typeof output === "string" ? output : toolResultContentToText(output);
-}
-function toolOutputToStructuredResult(output) {
-  return typeof output === "string" ? void 0 : output;
-}
-function agentToolEventPayload(toolCall, internalCallId, event) {
-  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
-    return void 0;
-  }
-  const payload = {
-    type: "agent_tool_event",
-    toolName: toolCall.function.name,
-    internalCallId,
-    agentId: event.agentId,
-    event: event.event
-  };
-  if (toolCall.callId !== void 0) {
-    payload.toolCallId = toolCall.callId;
-  }
-  if (event.agentName !== void 0) {
-    payload.agentName = event.agentName;
-  }
-  return payload;
-}
-
-// src/internal/agent-runtime/agent-run.ts
-function deferredSignal() {
-  let resolve = () => {
-  };
-  const promise = new Promise((done) => {
-    resolve = done;
-  });
-  return { promise, resolve };
-}
-async function settleFailureCleanup(operations) {
-  for (const operation of operations) {
-    try {
-      await operation();
-    } catch {
-    }
-  }
-}
-var AgentRun = class _AgentRun {
-  constructor(agent, promptMessage, initialHistory = [], options = {}) {
-    this.agent = agent;
-    this.promptMessage = promptMessage;
-    this.chatHistory = initialHistory;
-    this.maxTurnCount = assertNonnegativeSafeInteger(
-      options.maxTurns ?? agent.defaultMaxTurns ?? 0,
-      "maxTurns"
-    );
-    const internalOptions = getInternalAgentRunOptions(options);
-    this.activeHook = internalOptions?.hook;
-    this.requestedRunId = normalizeRequestedRunId(internalOptions?.runId);
-    this.activeLifecycle = composeAgentLifecycle(agent.lifecycle, options.lifecycle);
-    this.guardrailPolicies = options.guardrails === void 0 ? [...agent.guardrails] : appendGuardrailPolicies([...agent.guardrails], options.guardrails);
-    const configuredConcurrency = assertPositiveSafeInteger(
-      options.toolConcurrency ?? 1,
-      "toolConcurrency"
-    );
-    this.concurrency = this.activeHook !== void 0 || agent.tools.some((tool) => toolMayRequireApproval(tool.requiresApproval)) ? 1 : configuredConcurrency;
-    this.traceOptions = options.trace;
-    this.completionRetryOptions = options.retries === void 0 ? void 0 : resolveRetryOptions(options.retries);
-    this.requestMiddlewares = [...options.middlewares ?? []];
-    this.memoryContext = options.memoryContext;
-    this.memoryRecorder = new AgentRunMemory(agent, options.memoryContext, initialHistory);
-  }
-  agent;
-  promptMessage;
-  chatHistory;
-  maxTurnCount;
-  activeHook;
-  activeLifecycle;
-  guardrailPolicies;
-  guardrailDecisions = [];
-  concurrency;
-  traceOptions;
-  completionRetryOptions;
-  requestMiddlewares;
-  steeringMessages = [];
-  runState = "idle";
-  memoryRecorder;
-  memoryContext;
-  pendingApproval;
-  approvalSignal = deferredSignal();
-  activeRunId;
-  requestedRunId;
-  currentUsage = Usage.empty();
-  currentMessages = [];
-  cancellationError;
-  activeGeneration;
-  static fromAgent(agent, input, options = {}) {
-    const normalized = normalizeAgentInput(input);
-    return new _AgentRun(agent, normalized.prompt, normalized.history, options);
-  }
-  steer(input) {
-    if (this.isTerminal() || this.cancellationError !== void 0) {
-      return false;
-    }
-    this.steeringMessages.push(...normalizeSteeringInput(input));
-    return true;
-  }
-  waitForApproval() {
-    return this.pendingApproval === void 0 ? this.approvalSignal.promise : Promise.resolve();
-  }
-  approvalResult() {
-    const snapshot = this.approvalSnapshot();
-    return { status: "approval_required", ...snapshot };
-  }
-  approvalEvent() {
-    const snapshot = this.approvalSnapshot();
-    return { type: "approval_required", ...snapshot };
-  }
-  resolveApproval(decision) {
-    const pending = this.pendingApproval;
-    if (pending === void 0) {
-      throw new TypeError("Agent run has no pending tool approval.");
-    }
-    this.pendingApproval = void 0;
-    this.approvalSignal = deferredSignal();
-    pending.resolve(decision);
-  }
-  cancel(reason) {
-    if (this.isTerminal() || this.cancellationError !== void 0) {
-      return;
-    }
-    const messages = this.currentMessages.length === 0 ? [this.promptMessage] : [...this.currentMessages];
-    const error = new AgentRunCancelledError([...this.chatHistory, ...messages], reason);
-    this.cancellationError = error;
-    const pending = this.pendingApproval;
-    if (pending !== void 0) {
-      this.pendingApproval = void 0;
-      this.approvalSignal = deferredSignal();
-      pending.reject(error);
-    }
-  }
-  async generate() {
-    this.startRun();
-    const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
-    this.activeRunId = runId;
-    let usage = Usage.empty();
-    let currentTurns = 0;
-    let lastPrompt = this.promptMessage;
-    let newMessages = [this.promptMessage];
-    let runObservers;
-    try {
-      const memoryPreparation = await this.memoryRecorder.prepareHistory(runId, newMessages.length);
-      this.chatHistory = memoryPreparation.history;
-      usage = Usage.add(usage, memoryPreparation.usage);
-      runObservers = await this.startRunObservers(runId);
-      await this.recordMemoryCompaction(memoryPreparation, runObservers);
-      await this.activeLifecycle?.onStart?.({
-        runId,
-        input: lifecycleSnapshot(this.promptMessage),
-        history: lifecycleSnapshot(this.chatHistory),
-        maxTurns: this.maxTurnCount
-      });
-      const inputResult = await runInputGuardrails(this.guardrailPolicies, {
-        prompt: this.promptMessage,
-        history: this.chatHistory,
-        inputText: textFromMessage(this.promptMessage),
-        run: this.guardrailRunContext(runId)
-      });
-      for (const decision of inputResult.decisions) {
-        await this.recordGuardrailDecision(decision, runObservers);
-      }
-      this.promptMessage = inputResult.prompt;
-      if (inputResult.blocked) {
-        const output = inputResult.message ?? "The request was blocked by a guardrail.";
-        const result = {
-          status: "completed",
-          runId,
-          output,
-          usage,
-          messages: [this.promptMessage, Message.assistant(output)],
-          trace: runObservers.trace,
-          guardrails: [...this.guardrailDecisions]
-        };
-        await this.runLifecycleFinish(result);
-        await runObservers.end(result);
-        this.runState = "completed";
-        return result;
-      }
-      newMessages = [this.promptMessage];
-      await this.memoryRecorder.commitAcceptedInput(runId, newMessages);
-      const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
-      await this.runRunStartHook(newMessages);
-      while (currentTurns <= this.maxTurnCount + 1) {
-        const prompt = newMessages.at(-1);
-        if (prompt === void 0) {
-          throw new Error("AgentRun requires at least one message");
-        }
-        lastPrompt = prompt;
-        currentTurns += 1;
-        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
-        await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
-        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
-        const request = await this.createTurnRequest(prompt, historyForRequest, currentTurns);
-        let response;
-        try {
-          response = await this.runCompletion(request, currentTurns, runObservers);
-        } catch (error) {
-          await settleFailureCleanup([
-            () => this.runCompletionErrorHook(prompt, error, newMessages)
-          ]);
-          throw error;
-        }
-        response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
-        usage = Usage.add(usage, response.usage);
-        this.updateApprovalProgress(runId, usage, newMessages);
-        await this.runCompletionResponseHook(prompt, response, newMessages);
-        await this.runTurnEndHook(currentTurns, response, newMessages);
-        await this.activeLifecycle?.onStepFinish?.({
-          runId,
-          step: currentTurns,
-          response: lifecycleSnapshot(response),
-          usage: lifecycleSnapshot(usage)
-        });
-        const toolCalls = response.choice.filter(
-          (item) => item.type === "tool_call"
-        );
-        const assistantMessage = this.generatedAssistantMessage(response, request);
-        newMessages.push(assistantMessage);
-        if (toolCalls.length === 0) {
-          if (this.steeringMessages.length > 0) {
-            await this.memoryRecorder.commitMessages(
-              runId,
-              currentTurns,
-              [assistantMessage],
-              pendingTurnMessages
-            );
-          }
-          if (await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages)) {
-            await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
-            continue;
-          }
-          const guardedOutput = await this.runOutputGuardrailsForResponse(
-            runId,
-            usage,
-            response,
-            newMessages,
-            runObservers
-          );
-          response = guardedOutput.response;
-          const finalAssistantMessage = this.generatedAssistantMessage(response, request);
-          newMessages[newMessages.length - 1] = finalAssistantMessage;
-          await this.memoryRecorder.commitMessages(
-            runId,
-            currentTurns,
-            [finalAssistantMessage],
-            pendingTurnMessages
-          );
-          const result = {
-            status: "completed",
-            runId,
-            output: guardedOutput.output,
-            usage,
-            messages: [...newMessages],
-            trace: runObservers.trace,
-            guardrails: [...this.guardrailDecisions],
-            ...generationArtifacts(newMessages)
-          };
-          await this.runRunEndHook(result, newMessages);
-          await this.memoryRecorder.commitCompletedRun(
-            runId,
-            currentTurns,
-            newMessages,
-            pendingTurnMessages
-          );
-          await this.runLifecycleFinish(result);
-          await runObservers.end(result);
-          this.runState = "completed";
-          return result;
-        }
-        this.updateApprovalProgress(runId, usage, newMessages);
-        const toolResults = await this.executeToolCalls(
-          runId,
-          toolCalls,
-          newMessages,
-          void 0,
-          void 0,
-          {
-            turn: currentTurns,
-            runObservers,
-            toolDefinitions: request.tools
-          }
-        );
-        const toolMessage = Message.tool(toolResults);
-        newMessages.push(toolMessage);
-        await this.memoryRecorder.commitMessages(
-          runId,
-          currentTurns,
-          [assistantMessage, toolMessage],
-          pendingTurnMessages
-        );
-        await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages);
-        await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
-      }
-      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
-    } catch (error) {
-      if (error instanceof MemoryCompactionError && error.usage !== void 0) {
-        usage = Usage.add(usage, error.usage);
-      }
-      const reportedError = await this.reportRunFailure(
-        error,
-        runId,
-        usage,
-        newMessages,
-        runObservers
-      );
-      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
-      throw reportedError;
-    }
-  }
-  async *events(includeToolCallDeltas = true) {
-    if (!this.agent.model.capabilities.streaming || !isStreamingCompletionModel(this.agent.model)) {
-      throw new Error("This completion model does not support streaming");
-    }
-    this.startRun();
-    const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
-    this.activeRunId = runId;
-    let usage = Usage.empty();
-    let currentTurns = 0;
-    let lastPrompt = this.promptMessage;
-    let newMessages = [this.promptMessage];
-    const bufferOutputDeltas = hasEnforcedOutputGuardrails(this.guardrailPolicies);
-    let runObservers;
-    try {
-      const memoryPreparation = await this.memoryRecorder.prepareHistory(runId, newMessages.length);
-      this.chatHistory = memoryPreparation.history;
-      usage = Usage.add(usage, memoryPreparation.usage);
-      runObservers = await this.startRunObservers(runId);
-      await this.recordMemoryCompaction(memoryPreparation, runObservers);
-      await this.activeLifecycle?.onStart?.({
-        runId,
-        input: lifecycleSnapshot(this.promptMessage),
-        history: lifecycleSnapshot(this.chatHistory),
-        maxTurns: this.maxTurnCount
-      });
-      const inputResult = await runInputGuardrails(this.guardrailPolicies, {
-        prompt: this.promptMessage,
-        history: this.chatHistory,
-        inputText: textFromMessage(this.promptMessage),
-        run: this.guardrailRunContext(runId)
-      });
-      for (const decision of inputResult.decisions) {
-        await this.recordGuardrailDecision(decision, runObservers);
-        yield { type: "guardrail_decision", decision };
-      }
-      this.promptMessage = inputResult.prompt;
-      if (inputResult.blocked) {
-        const output = inputResult.message ?? "The request was blocked by a guardrail.";
-        const result = {
-          status: "completed",
-          runId,
-          output,
-          usage,
-          messages: [this.promptMessage, Message.assistant(output)],
-          trace: runObservers.trace,
-          guardrails: [...this.guardrailDecisions]
-        };
-        await this.runLifecycleFinish(result);
-        await runObservers.end(result);
-        this.runState = "completed";
-        yield {
-          type: "final",
-          runId,
-          output: result.output,
-          usage: result.usage,
-          messages: result.messages,
-          trace: result.trace,
-          guardrails: result.guardrails
-        };
-        return;
-      }
-      newMessages = [this.promptMessage];
-      await this.memoryRecorder.commitAcceptedInput(runId, newMessages);
-      const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
-      await this.runRunStartHook(newMessages);
-      while (currentTurns <= this.maxTurnCount + 1) {
-        const prompt = newMessages.at(-1);
-        if (prompt === void 0) {
-          throw new Error("AgentRun requires at least one message");
-        }
-        lastPrompt = prompt;
-        currentTurns += 1;
-        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
-        yield {
-          type: "turn_start",
-          turn: currentTurns,
-          prompt,
-          history: historyForRequest
-        };
-        await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
-        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
-        const request = await this.createTurnRequest(prompt, historyForRequest, currentTurns);
-        assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
-        const providerRequest = this.providerTraceRequest(request, { stream: true });
-        const generationStartArgs = this.generationStartArgs(
-          currentTurns,
-          request,
-          providerRequest
-        );
-        const generationObservers = await runObservers.startGeneration(generationStartArgs);
-        this.activeGeneration = { turn: currentTurns, observers: generationObservers };
-        const generationStartedAt = Date.now();
-        yield {
-          type: "generation_start",
-          turn: currentTurns,
-          request,
-          modelInfo: generationStartArgs.modelInfo
-        };
-        const bufferResponseEvents = this.shouldBufferStreamResponseEvents();
-        const completionState = {
-          response: void 0,
-          firstDeltaMs: void 0,
-          emittedToolCallIds: /* @__PURE__ */ new Set(),
-          providerErrorUsage: Usage.empty()
-        };
-        let response;
-        try {
-          try {
-            for await (const event of this.streamCompletion({
-              request,
-              turn: currentTurns,
-              includeToolCallDeltas,
-              bufferResponseEvents,
-              bufferOutputDeltas,
-              generationStartedAt,
-              generationObservers,
-              runObservers,
-              state: completionState
-            })) {
-              yield event;
-            }
-          } finally {
-            usage = Usage.add(usage, completionState.providerErrorUsage);
-          }
-          if (completionState.response === void 0) {
-            throw new Error("Streaming completion ended without a response.");
-          }
-          response = completionState.response;
-        } catch (error) {
-          await settleFailureCleanup([
-            () => this.closeActiveGeneration(error),
-            () => this.runCompletionErrorHook(prompt, error, newMessages)
-          ]);
-          throw error;
-        }
-        const { firstDeltaMs, emittedToolCallIds } = completionState;
-        const generationEndArgs = {
-          turn: currentTurns,
-          response,
-          ...firstDeltaMs === void 0 ? {} : { firstDeltaMs }
-        };
-        this.activeGeneration = void 0;
-        await generationObservers.end(generationEndArgs);
-        response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
-        usage = Usage.add(usage, response.usage);
-        this.updateApprovalProgress(runId, usage, newMessages);
-        await this.runCompletionResponseHook(prompt, response, newMessages);
-        await this.runTurnEndHook(currentTurns, response, newMessages);
-        await this.activeLifecycle?.onStepFinish?.({
-          runId,
-          step: currentTurns,
-          response: lifecycleSnapshot(response),
-          usage: lifecycleSnapshot(usage)
-        });
-        const toolCalls = response.choice.filter(
-          (item) => item.type === "tool_call"
-        );
-        const assistantMessage = this.generatedAssistantMessage(response, request);
-        newMessages.push(assistantMessage);
-        if (toolCalls.length === 0) {
-          let emittedTurnEnd = false;
-          if (!bufferOutputDeltas) {
-            if (bufferResponseEvents) {
-              for (const event of responseStreamEvents(currentTurns, response)) {
-                yield event;
-              }
-            }
-            yield {
-              type: "turn_end",
-              turn: currentTurns,
-              response,
-              firstDeltaMs
-            };
-            emittedTurnEnd = true;
-          }
-          if (this.steeringMessages.length > 0) {
-            await this.memoryRecorder.commitMessages(
-              runId,
-              currentTurns,
-              [assistantMessage],
-              pendingTurnMessages
-            );
-          }
-          if (await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages)) {
-            await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
-            continue;
-          }
-          for await (const event of this.completeStreamingRun({
-            runId,
-            turn: currentTurns,
-            request,
-            response,
-            firstDeltaMs,
-            usage,
-            newMessages,
-            pendingTurnMessages,
-            runObservers,
-            bufferResponseEvents,
-            bufferOutputDeltas,
-            emittedTurnEnd
-          })) {
-            yield event;
-          }
-          return;
-        }
-        if (bufferResponseEvents) {
-          for (const event of responseStreamEvents(currentTurns, response)) {
-            yield event;
-          }
-        } else {
-          for (const toolCall of toolCalls) {
-            if (!emittedToolCallIds.has(toolCall.id)) {
-              yield { type: "tool_call", turn: currentTurns, toolCall };
-            }
-          }
-        }
-        this.updateApprovalProgress(runId, usage, newMessages);
-        yield {
-          type: "turn_end",
-          turn: currentTurns,
-          response,
-          firstDeltaMs
-        };
-        const toolExecution = this.executeStreamingToolCalls(runId, toolCalls, newMessages, {
-          turn: currentTurns,
-          runObservers,
-          toolDefinitions: request.tools,
-          includeToolCallDeltas
-        });
-        for await (const result of toolExecution.events) {
-          yield { turn: currentTurns, ...result };
-        }
-        const toolResults = await toolExecution.results;
-        const toolMessage = Message.tool(toolResults);
-        newMessages.push(toolMessage);
-        await this.memoryRecorder.commitMessages(
-          runId,
-          currentTurns,
-          [assistantMessage, toolMessage],
-          pendingTurnMessages
-        );
-        await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages);
-        await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
-      }
-      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
-    } catch (error) {
-      if (error instanceof MemoryCompactionError && error.usage !== void 0) {
-        usage = Usage.add(usage, error.usage);
-      }
-      const reportedError = await this.reportRunFailure(
-        error,
-        runId,
-        usage,
-        newMessages,
-        runObservers
-      );
-      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
-      const finalUsage = usage;
-      yield { type: "error", error: reportedError, usage: finalUsage };
-      throw reportedError;
-    } finally {
-      if (this.runState === "running") {
-        const cancellation = this.cancellationError ?? new AgentRunCancelledError([...this.chatHistory, ...newMessages], "Agent stream closed.");
-        this.cancellationError = cancellation;
-        await settleFailureCleanup([() => this.closeActiveGeneration(cancellation)]);
-        await this.reportRunFailure(cancellation, runId, usage, newMessages, runObservers);
-        this.runState = "cancelled";
-      }
-    }
-  }
-  async runCompletion(request, turn, runObservers) {
-    assertCompletionRequestSupported(this.agent.model, request);
-    const providerRequest = this.providerTraceRequest(request);
-    const generationObservers = await runObservers.startGeneration(
-      this.generationStartArgs(turn, request, providerRequest)
-    );
-    try {
-      for (let attempt = 1; ; attempt += 1) {
-        let response;
-        try {
-          response = await this.agent.model.completion(request);
-        } catch (error) {
-          const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
-          if (retryOptions === void 0) {
-            throw error;
-          }
-          await this.scheduleCompletionRetry(
-            error,
-            attempt,
-            turn,
-            false,
-            retryOptions,
-            runObservers
-          );
-          continue;
-        }
-        await generationObservers.end({ turn, response });
-        return response;
-      }
-    } catch (error) {
-      await settleFailureCleanup([() => generationObservers.error({ turn, error })]);
-      throw error;
-    }
-  }
-  async createTurnRequest(prompt, history, turn) {
-    const ragText = extractRagText(prompt);
-    const documents = await fetchContextDocuments(this.agent, ragText);
-    const toolDefinitions = await fetchToolDefinitions(this.agent, ragText);
-    const request = createCompletionRequest([...history, prompt], {
-      model: this.agent.model,
-      instructions: this.agent.instructions,
-      documents,
-      tools: [...toolDefinitions, ...getAgentToolState(this.agent).providerTools],
-      temperature: this.agent.temperature,
-      maxTokens: this.agent.maxTokens,
-      additionalParams: this.agent.additionalParams,
-      toolChoice: this.agent.toolChoice,
-      outputSchema: this.agent.outputSchema
-    });
-    return await this.runCompletionRequestMiddlewares(request, turn);
-  }
-  async *streamCompletion(args) {
-    const model = this.agent.model;
-    if (!isStreamingCompletionModel(model)) {
-      throw new TypeError("Streaming completion requires a streaming-capable model.");
-    }
-    const accumulator = new CompletionStreamAccumulator();
-    for (let attempt = 1; ; attempt += 1) {
-      let hasProviderProgress = false;
-      try {
-        for await (const event of model.streamCompletion(args.request)) {
-          if (event.type === "error") {
-            if (event.usage !== void 0) {
-              args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, event.usage);
-            }
-            throw event.error;
-          }
-          hasProviderProgress = true;
-          if (args.state.firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
-            args.state.firstDeltaMs = Date.now() - args.generationStartedAt;
-          }
-          const mapped = accumulator.accept(event);
-          if (args.includeToolCallDeltas && event.type === "tool_call_delta") {
-            yield addTurnToToolCallDelta(args.turn, event);
-          }
-          if (mapped !== void 0) {
-            await args.generationObservers.update?.({ turn: args.turn, delta: mapped });
-            if (mapped.type === "tool_call") {
-              args.state.emittedToolCallIds.add(mapped.toolCall.id);
-            }
-            const shouldBuffer = args.bufferResponseEvents || args.bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
-            if (!shouldBuffer) {
-              yield addTurn(args.turn, mapped);
-            }
-          }
-        }
-        args.state.response = accumulator.response();
-        return;
-      } catch (error) {
-        const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, args.turn, true);
-        if (retryOptions === void 0) {
-          throw error;
-        }
-        await this.scheduleCompletionRetry(
-          error,
-          attempt,
-          args.turn,
-          true,
-          retryOptions,
-          args.runObservers
-        );
-      }
-    }
-  }
-  async *completeStreamingRun(args) {
-    const guardedOutput = await this.runOutputGuardrailsForResponse(
-      args.runId,
-      args.usage,
-      args.response,
-      args.newMessages,
-      args.runObservers
-    );
-    for (const decision of guardedOutput.decisions) {
-      yield { type: "guardrail_decision", decision };
-    }
-    const response = guardedOutput.response;
-    const assistantMessage = this.generatedAssistantMessage(response, args.request);
-    args.newMessages[args.newMessages.length - 1] = assistantMessage;
-    await this.memoryRecorder.commitMessages(
-      args.runId,
-      args.turn,
-      [assistantMessage],
-      args.pendingTurnMessages
-    );
-    if (!args.emittedTurnEnd && (args.bufferResponseEvents || args.bufferOutputDeltas)) {
-      for (const event of responseStreamEvents(args.turn, response, args.bufferResponseEvents)) {
-        yield event;
-      }
-    }
-    if (!args.emittedTurnEnd) {
-      yield {
-        type: "turn_end",
-        turn: args.turn,
-        response,
-        firstDeltaMs: args.firstDeltaMs
-      };
-    }
-    const result = {
-      status: "completed",
-      runId: args.runId,
-      output: guardedOutput.output,
-      usage: args.usage,
-      messages: [...args.newMessages],
-      trace: args.runObservers.trace,
-      guardrails: [...this.guardrailDecisions],
-      ...generationArtifacts(args.newMessages)
-    };
-    await this.runRunEndHook(result, args.newMessages);
-    await this.memoryRecorder.commitCompletedRun(
-      args.runId,
-      args.turn,
-      args.newMessages,
-      args.pendingTurnMessages
-    );
-    await this.runLifecycleFinish(result);
-    await args.runObservers.end(result);
-    this.runState = "completed";
-    yield {
-      type: "final",
-      runId: args.runId,
-      output: result.output,
-      usage: result.usage,
-      contextUsage: result.contextUsage,
-      messages: result.messages,
-      trace: result.trace,
-      guardrails: result.guardrails,
-      sources: result.sources,
-      providerToolCalls: result.providerToolCalls
-    };
-  }
-  generatedAssistantMessage(response, request) {
-    const metadata = {
-      anvia: {
-        generation: {
-          provider: this.agent.model.provider,
-          model: request.model ?? this.agent.model.defaultModel,
-          usage: { ...response.usage },
-          ...response.contextUsage === void 0 ? {} : { contextUsage: response.contextUsage },
-          ...response.sources === void 0 ? {} : { sources: response.sources },
-          ...response.providerToolCalls === void 0 ? {} : { providerToolCalls: response.providerToolCalls }
-        }
-      }
-    };
-    return Message.assistant(response.choice, {
-      ...response.messageId === void 0 ? {} : { id: response.messageId },
-      metadata
-    });
-  }
-  providerTraceRequest(request, options = {}) {
-    try {
-      return this.agent.model.traceRequest?.(request, options);
-    } catch (error) {
-      return {
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  generationStartArgs(turn, request, providerRequest) {
-    return {
-      turn,
-      request,
-      modelInfo: {
-        provider: this.agent.model.provider,
-        defaultModel: this.agent.model.defaultModel,
-        capabilities: this.agent.model.capabilities
-      },
-      ...providerRequest === void 0 ? {} : { providerRequest }
-    };
-  }
-  retryOptionsForFailure(error, attempt, turn, streaming) {
-    const options = this.completionRetryOptions;
-    if (options === void 0 || attempt >= options.maxAttempts) {
-      return void 0;
-    }
-    const shouldRetry = options.shouldRetry({
-      error,
-      attempt,
-      maxAttempts: options.maxAttempts,
-      turn,
-      streaming
-    });
-    return shouldRetry ? options : void 0;
-  }
-  async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers) {
-    const delayMs = retryDelayMs(options, attempt);
-    await runObservers.event({
-      name: "completion.retry",
-      level: "WARNING",
-      attributes: {
-        turn,
-        attempt,
-        nextAttempt: attempt + 1,
-        maxAttempts: options.maxAttempts,
-        delayMs,
-        streaming,
-        ...retryErrorAttributes(error)
-      }
-    });
-    await waitForRetry(delayMs);
-  }
-  async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
-    const executor = new ToolCallExecutor(
-      this.agent,
-      this.activeHook,
-      (request) => this.suspendForApproval(request),
-      this.activeLifecycle,
-      {
-        runId,
-        sessionId: this.memoryContext?.sessionId,
-        metadata: this.memoryContext?.metadata
-      },
-      this.concurrency,
-      this.requestMiddlewares,
-      observation?.includeToolCallDeltas ?? false,
-      (reason) => this.cancelled(newMessages, reason)
-    );
-    return executor.execute(toolCalls, onResult, onStreamEvent, observation);
-  }
-  executeStreamingToolCalls(runId, toolCalls, newMessages, observation) {
-    const events = createAsyncQueue();
-    const results = this.executeToolCalls(
-      runId,
-      toolCalls,
-      newMessages,
-      (result) => events.enqueue(result),
-      (event) => events.enqueue(event),
-      observation
-    );
-    results.then(
-      () => events.close(),
-      (error) => events.throw(error)
-    );
-    return { events, results };
-  }
-  suspendForApproval(request) {
-    if (this.cancellationError !== void 0) {
-      return Promise.reject(this.cancellationError);
-    }
-    if (this.pendingApproval !== void 0) {
-      throw new Error("Agent run already has a pending tool approval.");
-    }
-    return new Promise((resolve, reject) => {
-      this.pendingApproval = { request, resolve, reject };
-      this.approvalSignal.resolve();
-    });
-  }
-  async closeActiveGeneration(error) {
-    const active = this.activeGeneration;
-    if (active === void 0) {
-      return;
-    }
-    this.activeGeneration = void 0;
-    await active.observers.error({ turn: active.turn, error });
-  }
-  approvalSnapshot() {
-    const pending = this.pendingApproval;
-    const runId = this.activeRunId;
-    if (pending === void 0 || runId === void 0) {
-      throw new TypeError("Agent run has no pending tool approval.");
-    }
-    const approval = {
-      id: pending.request.id,
-      toolName: pending.request.toolName,
-      input: lifecycleSnapshot(pending.request.args),
-      ...pending.request.toolCallId === void 0 ? {} : { toolCallId: pending.request.toolCallId },
-      ...pending.request.reason === void 0 ? {} : { reason: pending.request.reason }
-    };
-    registerAgentApprovalRequestDetails(approval, pending.request);
-    return {
-      runId,
-      approval,
-      usage: lifecycleSnapshot(this.currentUsage),
-      messages: lifecycleSnapshot(this.currentMessages)
-    };
-  }
-  updateApprovalProgress(runId, usage, messages) {
-    this.activeRunId = runId;
-    this.currentUsage = usage;
-    this.currentMessages = [...messages];
-  }
-  async runLifecycleFinish(result) {
-    await this.activeLifecycle?.onFinish?.({
-      runId: result.runId,
-      output: result.output,
-      usage: lifecycleSnapshot(result.usage),
-      messages: lifecycleSnapshot(result.messages)
-    });
-  }
-  async runLifecycleError(error, runId, usage, messages) {
-    try {
-      await this.activeLifecycle?.onError?.({
-        runId,
-        error: lifecycleSnapshot(error),
-        usage: lifecycleSnapshot(usage),
-        messages: lifecycleSnapshot([...this.chatHistory, ...messages])
-      });
-      return void 0;
-    } catch (lifecycleError) {
-      return lifecycleError;
-    }
-  }
-  async reportRunFailure(error, runId, usage, messages, runObservers) {
-    const reportedError = await this.resolveReportedRunError(error, runId, usage, messages);
-    await settleFailureCleanup([
-      () => runObservers?.error({
-        error: reportedError,
-        usage,
-        messages: [...messages]
-      }),
-      () => this.memoryRecorder.recordError(runId, reportedError, messages)
-    ]);
-    return reportedError;
-  }
-  async resolveReportedRunError(error, runId, usage, messages) {
-    try {
-      await this.runRunErrorHook(error, usage, messages);
-    } catch {
-    }
-    await this.runLifecycleError(error, runId, usage, messages);
-    return error;
-  }
-  async runOutputGuardrailsForResponse(runId, usage, response, messages, runObservers) {
-    const originalOutput = textFromAssistantContent(response.choice);
-    const result = await runOutputGuardrails(this.guardrailPolicies, {
-      outputText: originalOutput,
-      messages: [...this.chatHistory, ...messages],
-      usage,
-      run: this.guardrailRunContext(runId)
-    });
-    for (const decision of result.decisions) {
-      await this.recordGuardrailDecision(decision, runObservers);
-    }
-    const output = result.blocked ? result.message ?? "The response was blocked by a guardrail." : result.outputText;
-    if (output === originalOutput) {
-      return { output, response, decisions: result.decisions };
-    }
-    return {
-      output,
-      response: {
-        ...response,
-        choice: [AssistantContent.text(output)]
-      },
-      decisions: result.decisions
-    };
-  }
-  async recordGuardrailDecision(decision, runObservers) {
-    this.guardrailDecisions.push(decision);
-    await runObservers.event({
-      name: "guardrail.decision",
-      level: decision.action === "block" ? "WARNING" : "DEFAULT",
-      attributes: guardrailDecisionAttributes(decision)
-    });
-  }
-  async recordMemoryCompaction(preparation, runObservers) {
-    const compaction = preparation.compaction;
-    if (compaction === void 0) {
-      return;
-    }
-    await runObservers.event({
-      name: "memory.compaction",
-      attributes: {
-        originalMessageCount: compaction.originalMessageCount,
-        compactedMessageCount: compaction.compactedMessageCount,
-        retainedMessageCount: compaction.retainedMessageCount,
-        conflictRetries: compaction.conflictRetries,
-        inputTokens: preparation.usage.inputTokens,
-        outputTokens: preparation.usage.outputTokens,
-        totalTokens: preparation.usage.totalTokens
-      }
-    });
-  }
-  guardrailRunContext(runId) {
-    const context = {
-      agentId: this.agent.id,
-      runId
-    };
-    if (this.memoryContext !== void 0) {
-      context.sessionId = this.memoryContext.sessionId;
-      if (this.memoryContext.metadata !== void 0) {
-        context.metadata = this.memoryContext.metadata;
-      }
-    }
-    return context;
-  }
-  async startRunObservers(runId) {
-    const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
-    return startAgentRunObservers(
-      this.agent.observers,
-      {
-        runId,
-        agentName: this.agent.name,
-        agentDescription: this.agent.description,
-        instructions: this.agent.instructions,
-        trace: this.traceOptions,
-        promptRef: this.traceOptions?.promptRef,
-        prompt: this.promptMessage,
-        history: this.chatHistory,
-        maxTurns: this.maxTurnCount
-      },
-      failOnObserverError
-    );
-  }
-  async runCompletionCallHook(prompt, history, newMessages) {
-    const action = await this.activeHook?.onCompletionCall?.({
-      prompt,
-      history,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runRunStartHook(newMessages) {
-    const action = await this.activeHook?.onRunStart?.({
-      prompt: this.promptMessage,
-      history: this.chatHistory,
-      maxTurns: this.maxTurnCount,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runRunEndHook(result, newMessages) {
-    const action = await this.activeHook?.onRunEnd?.({
-      output: result.output,
-      usage: result.usage,
-      messages: result.messages,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runRunErrorHook(error, usage, newMessages) {
-    const action = await this.activeHook?.onRunError?.({
-      error,
-      usage,
-      messages: [...this.chatHistory, ...newMessages],
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runTurnStartHook(turn, prompt, history, newMessages) {
-    const action = await this.activeHook?.onTurnStart?.({
-      turn,
-      prompt,
-      history,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runTurnEndHook(turn, response, newMessages) {
-    const action = await this.activeHook?.onTurnEnd?.({
-      turn,
-      response,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runCompletionRequestMiddlewares(request, turn) {
-    let current = request;
-    for (const middleware of this.activeMiddlewares()) {
-      const replacement = await middleware.onCompletionRequest?.({
-        turn,
-        request: current,
-        originalRequest: request
-      });
-      if (replacement?.request !== void 0) {
-        current = replacement.request;
-      }
-    }
-    return current;
-  }
-  async runCompletionResponseMiddlewares(request, response, turn) {
-    let current = response;
-    for (const middleware of this.activeMiddlewares()) {
-      const replacement = await middleware.onCompletionResponse?.({
-        turn,
-        request,
-        response: current,
-        originalResponse: response
-      });
-      if (replacement?.response !== void 0) {
-        current = replacement.response;
-      }
-    }
-    return current;
-  }
-  async runCompletionResponseHook(prompt, response, newMessages) {
-    const action = await this.activeHook?.onCompletionResponse?.({
-      prompt,
-      response,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  async runCompletionErrorHook(prompt, error, newMessages) {
-    const action = await this.activeHook?.onCompletionError?.({
-      prompt,
-      error,
-      run: runControl
-    });
-    if (action?.type === "terminate") {
-      throw this.cancelled(newMessages, action.reason);
-    }
-  }
-  activeMiddlewares() {
-    return [...this.agent.middlewares, ...this.requestMiddlewares];
-  }
-  shouldBufferStreamResponseEvents() {
-    return this.activeHook?.onCompletionResponse !== void 0 || this.activeMiddlewares().some((middleware) => middleware.onCompletionResponse !== void 0);
-  }
-  async drainSteeringMessages(runId, turn, newMessages, pendingTurnMessages) {
-    const messages = this.steeringMessages.splice(0);
-    if (messages.length === 0) {
-      return false;
-    }
-    newMessages.push(...messages);
-    await this.memoryRecorder.commitMessages(runId, turn, messages, pendingTurnMessages);
-    return true;
-  }
-  startRun() {
-    if (this.runState === "idle") {
-      this.runState = "running";
-      return;
-    }
-    if (this.runState === "running") {
-      throw new Error("Agent stream is already running.");
-    }
-    throw new Error("Agent stream has already been consumed.");
-  }
-  isTerminal() {
-    return this.runState === "completed" || this.runState === "errored" || this.runState === "cancelled";
-  }
-  cancelled(newMessages, reason) {
-    return new AgentRunCancelledError([...this.chatHistory, ...newMessages], reason);
-  }
-};
-function normalizeAgentInput(prompt) {
-  if (typeof prompt === "string") {
-    return { prompt: Message.user(prompt), history: [] };
-  }
-  if (!Array.isArray(prompt)) {
-    return { prompt, history: [] };
-  }
-  if (prompt.length === 0) {
-    throw new TypeError("Agent input transcript must contain at least one message.");
-  }
-  const activePrompt = prompt.at(-1);
-  if (activePrompt === void 0) {
-    throw new TypeError("Agent input transcript must contain at least one message.");
-  }
-  return {
-    prompt: activePrompt,
-    history: prompt.slice(0, -1)
-  };
-}
-function normalizeSteeringInput(input) {
-  if (typeof input === "string") {
-    return [Message.user(input)];
-  }
-  return Array.isArray(input) ? [...input] : [input];
-}
-function normalizeRequestedRunId(runId) {
-  if (runId === void 0) {
-    return void 0;
-  }
-  if (typeof runId !== "string" || runId.trim().length === 0) {
-    throw new TypeError("runId must be a non-empty string.");
-  }
-  return runId;
-}
-function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
-  const events = [];
-  for (const item of response.choice) {
-    if (item.type === "text") {
-      if (item.text.length > 0) {
-        events.push({ type: "text_delta", turn, delta: item.text });
-      }
-      continue;
-    }
-    if (item.type === "reasoning") {
-      if (item.content === void 0) {
-        if (item.text.length > 0) {
-          events.push(reasoningDeltaEvent2(turn, item.text, { id: item.id }));
-        }
-        continue;
-      }
-      for (const content of item.content) {
-        const delta = content.type === "encrypted" || content.type === "redacted" ? content.data : content.text;
-        events.push(
-          reasoningDeltaEvent2(turn, delta, {
-            id: item.id,
-            contentType: content.type,
-            signature: content.type === "text" ? content.signature : void 0
-          })
-        );
-      }
-      continue;
-    }
-    if (item.type === "tool_call") {
-      events.push({ type: "tool_call", turn, toolCall: item });
-    }
-  }
-  if (includeProviderArtifacts) {
-    for (const source of response.sources ?? []) {
-      events.push({ type: "source", turn, source });
-    }
-    for (const toolCall of response.providerToolCalls ?? []) {
-      events.push({ type: "provider_tool_call", turn, toolCall });
-    }
-  }
-  return events;
-}
-function generationArtifacts(messages) {
-  const sources = /* @__PURE__ */ new Map();
-  const providerToolCalls = /* @__PURE__ */ new Map();
-  let contextUsage;
-  for (const message of messages) {
-    const metadata = getAssistantGenerationMetadata(message);
-    if (metadata !== void 0) {
-      contextUsage = metadata.contextUsage;
-    }
-    for (const source of metadata?.sources ?? []) {
-      const key = `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
-      sources.set(key, source);
-    }
-    for (const toolCall of metadata?.providerToolCalls ?? []) {
-      providerToolCalls.set(toolCall.id, toolCall);
-    }
-  }
-  return {
-    ...sources.size === 0 ? {} : { sources: [...sources.values()] },
-    ...providerToolCalls.size === 0 ? {} : { providerToolCalls: [...providerToolCalls.values()] },
-    ...contextUsage === void 0 ? {} : { contextUsage }
-  };
-}
-function reasoningDeltaEvent2(turn, delta, details = {}) {
-  const event = {
-    type: "reasoning_delta",
-    turn,
-    delta
-  };
-  if (details.id !== void 0) {
-    event.id = details.id;
-  }
-  if (details.contentType !== void 0) {
-    event.contentType = details.contentType;
-  }
-  if (details.signature !== void 0) {
-    event.signature = details.signature;
-  }
-  return event;
-}
-function textFromMessage(message) {
-  if (message.role === "system") {
-    return message.content;
-  }
-  return message.content.flatMap((content) => {
-    if (content.type === "text") {
-      return [content.text];
-    }
-    if (content.type === "document" && content.source.type === "text") {
-      return [content.source.text];
-    }
-    return [];
-  }).join("\n");
-}
-function guardrailDecisionAttributes(decision) {
-  const attributes = {
-    policyId: decision.policyId,
-    guardrailId: decision.guardrailId,
-    boundary: decision.boundary,
-    mode: decision.mode,
-    action: decision.action,
-    applied: decision.applied,
-    latencyMs: decision.latencyMs
-  };
-  if (decision.reason !== void 0) {
-    attributes.reason = decision.reason;
-  }
-  if (decision.message !== void 0) {
-    attributes.message = decision.message;
-  }
-  return attributes;
-}
-
-// src/agent/ids.ts
-function normalizeAgentId(id) {
-  if (typeof id !== "string") {
-    throw new TypeError("Agent id must be a string.");
-  }
-  const normalized = id.trim();
-  if (normalized.length === 0) {
-    throw new TypeError("Agent id must be a non-empty string.");
-  }
-  return normalized;
-}
-
-// src/agent/agent.ts
-var DEFAULT_MAX_TURNS = 20;
-var Agent = class {
-  id;
-  name;
-  description;
-  model;
-  instructions;
-  context;
-  temperature;
-  maxTokens;
-  additionalParams;
-  tools;
-  toolChoice;
-  defaultMaxTurns;
-  lifecycle;
-  outputSchema;
-  observers;
-  guardrails;
-  middlewares;
-  memory;
-  constructor(options) {
-    const resolved = resolveAgentOptions(options);
-    this.id = normalizeAgentId(resolved.id);
-    this.name = resolved.name;
-    this.description = resolved.description;
-    this.model = resolved.model;
-    this.instructions = resolved.instructions;
-    const context = (resolved.context ?? []).map(snapshotContextInput);
-    assertValidContextIndexes(context);
-    this.context = Object.freeze(context);
-    this.temperature = resolved.temperature;
-    this.maxTokens = resolved.maxTokens;
-    this.additionalParams = cloneFrozenPlainData(resolved.additionalParams);
-    const staticTools = dedupeTools(resolved.tools ?? []);
-    const toolIndexes = (resolved.toolIndexes ?? []).map(snapshotToolIndex);
-    assertUniqueIndexedToolNames(toolIndexes);
-    const toolsByName = new Map(staticTools.map((tool) => [tool.name, tool]));
-    for (const index of toolIndexes) {
-      for (const tool of index.tools) {
-        if (!toolsByName.has(tool.name)) {
-          toolsByName.set(tool.name, tool);
-        }
-      }
-    }
-    this.tools = Object.freeze([...toolsByName.values()]);
-    const publicToolState = Object.freeze({
-      staticTools: Object.freeze(staticTools),
-      providerTools: Object.freeze((resolved.providerTools ?? []).map(snapshotProviderTool)),
-      toolIndexes: Object.freeze(toolIndexes)
-    });
-    registerAgentToolState(this, publicToolState, toolsByName);
-    this.toolChoice = cloneFrozenPlainData(resolved.toolChoice);
-    this.defaultMaxTurns = assertNonnegativeSafeInteger(
-      resolved.defaultMaxTurns ?? DEFAULT_MAX_TURNS,
-      "maxTurns"
-    );
-    this.lifecycle = resolved.lifecycle;
-    this.outputSchema = cloneFrozenPlainData(resolved.outputSchema);
-    this.observers = Object.freeze(
-      (resolved.observers ?? []).map((registration) => Object.freeze({ ...registration }))
-    );
-    this.guardrails = Object.freeze((resolved.guardrails ?? []).map(snapshotGuardrailPolicy));
-    this.middlewares = Object.freeze([...resolved.middlewares ?? []]);
-    this.memory = snapshotMemoryRegistration(resolved.memory);
-  }
-  generate(input, options = {}) {
-    return createGenerateExecution(this, AgentRun.fromAgent(this, input, options)).next();
-  }
-  stream(input, options = {}) {
-    return createStreamExecution(
-      this,
-      AgentRun.fromAgent(this, input, options),
-      options.includeToolCallDeltas !== false
-    );
-  }
-  resume(pending, decision) {
-    assertAgentApprovalDecision(decision);
-    const continuation = approvalContinuations.get(pending);
-    if (continuation === void 0 || continuation.agent !== this) {
-      throw new TypeError("Approval continuation does not belong to this agent.");
-    }
-    approvalContinuations.delete(pending);
-    continuation.run.resolveApproval(decision);
-    return continuation.mode === "generate" ? continuation.execution.next() : continuation.execution.segment();
-  }
-  session(sessionId, options = {}) {
-    if (this.memory === void 0) {
-      throw new Error(`Agent "${this.id}" has no memory store configured.`);
-    }
-    const normalized = sessionId.trim();
-    if (normalized.length === 0) {
-      throw new TypeError("Session id must be a non-empty string.");
-    }
-    const context = {
-      sessionId: normalized
-    };
-    if (options.userId !== void 0) {
-      context.userId = options.userId;
-    }
-    if (options.metadata !== void 0) {
-      context.metadata = cloneFrozenPlainData(options.metadata);
-    }
-    return new AgentSession(this, context);
-  }
-  asTool(options) {
-    const description = options.description ?? this.description ?? `Prompt the ${options.name} agent.`;
-    return createTool({
-      name: options.name,
-      description,
-      inputSchema: z.object({
-        prompt: z.string().describe("The prompt to send to the agent.")
-      }),
-      outputSchema: z.string(),
-      execute: async ({ prompt }, context) => {
-        if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
-          let output = "";
-          const childStream = this.stream(prompt, {
-            maxTurns: options.maxTurns,
-            includeToolCallDeltas: context.includeToolCallDeltas !== false
-          });
-          for await (const event of childStream) {
-            if (event.type === "approval_required") {
-              await cancelAgentApproval(
-                event,
-                `Agent tool "${options.name}" cannot suspend for tool approval.`
-              );
-              throw new Error(
-                `Agent tool "${options.name}" cannot suspend for tool approval. Run the agent directly to handle approvals.`
-              );
-            }
-            const streamEvent = {
-              agentId: this.id,
-              event
-            };
-            if (this.name !== void 0) {
-              streamEvent.agentName = this.name;
-            }
-            await context.emitStreamEvent(streamEvent);
-            if (event.type === "final") {
-              output = event.output;
-            }
-          }
-          return output;
-        }
-        const response = await this.generate(prompt, { maxTurns: options.maxTurns });
-        if (response.status === "approval_required") {
-          await cancelAgentApproval(
-            response,
-            `Agent tool "${options.name}" cannot suspend for tool approval.`
-          );
-          throw new Error(
-            `Agent tool "${options.name}" cannot suspend for tool approval. Run the agent directly to handle approvals.`
-          );
-        }
-        return response.output;
-      }
-    });
-  }
-  getTool(toolName) {
-    return getRegisteredAgentTool(this, toolName);
-  }
-  async callTool(toolName, args, context) {
-    const tool = this.getTool(toolName);
-    if (tool === void 0) {
-      throw new ToolNotFoundError(toolName);
-    }
-    return prepareToolCall(tool, args).call(context ?? {});
-  }
-};
-var resolvedAgentOptions = /* @__PURE__ */ Symbol("resolvedAgentOptions");
-function createResolvedAgent(options) {
-  return new Agent({
-    ...options,
-    [resolvedAgentOptions]: true
-  });
-}
-function getResolvedAgentOptions(agent) {
-  const toolState = getAgentToolState(agent);
-  return {
-    id: agent.id,
-    name: agent.name,
-    description: agent.description,
-    model: agent.model,
-    instructions: agent.instructions,
-    context: [...agent.context],
-    temperature: agent.temperature,
-    maxTokens: agent.maxTokens,
-    additionalParams: agent.additionalParams,
-    tools: [...toolState.staticTools],
-    providerTools: [...toolState.providerTools],
-    toolIndexes: [...toolState.toolIndexes],
-    toolChoice: agent.toolChoice,
-    defaultMaxTurns: agent.defaultMaxTurns,
-    lifecycle: agent.lifecycle,
-    outputSchema: agent.outputSchema,
-    observers: [...agent.observers],
-    guardrails: [...agent.guardrails],
-    middlewares: [...agent.middlewares],
-    memory: agent.memory
-  };
-}
-function resolveAgentOptions(options) {
-  if (isInternalAgentOptions(options)) {
-    return options;
-  }
-  const toolsByName = /* @__PURE__ */ new Map();
-  const providerTools = [];
-  const toolIndexes = [];
-  for (const tool of options.tools ?? []) {
-    if (isProviderTool(tool)) {
-      providerTools.push(tool);
-    } else if (isToolIndex(tool)) {
-      toolIndexes.push(tool);
-    } else if (tool.kind === "tool-index") {
-      throw new TypeError(
-        "Invalid tool index: search, searchIds, asTool, tools, and a numeric topK are required."
-      );
-    } else {
-      toolsByName.set(tool.name, tool);
-    }
-  }
-  for (const server of options.mcpServers ?? []) {
-    for (const tool of server.tools) {
-      toolsByName.set(tool.name, tool);
-    }
-  }
-  if (options.skills !== void 0) {
-    for (const tool of options.skills.tools) {
-      toolsByName.set(tool.name, tool);
-    }
-  }
-  const memory = resolveAgentMemory(options);
-  const instructions = [options.instructions, options.skills?.instructions].filter((part) => part !== void 0 && part.length > 0).join("\n\n");
-  return {
-    id: options.id,
-    name: options.name,
-    description: options.description,
-    model: options.model,
-    instructions: instructions.length === 0 ? void 0 : instructions,
-    context: [...options.context ?? []],
-    temperature: options.temperature,
-    maxTokens: options.maxTokens,
-    additionalParams: options.additionalParams,
-    tools: [...toolsByName.values()],
-    providerTools,
-    toolIndexes,
-    toolChoice: options.toolChoice,
-    defaultMaxTurns: options.maxTurns,
-    lifecycle: options.lifecycle,
-    outputSchema: options.outputSchema === void 0 ? void 0 : toProviderJsonSchema(options.outputSchema),
-    observers: (options.observers ?? []).map(
-      (input) => "observer" in input ? { observer: input.observer, failOnObserverError: input.failOnObserverError } : { observer: input }
-    ),
-    guardrails: options.guardrails === void 0 ? [] : appendGuardrailPolicies([], options.guardrails),
-    middlewares: [...options.middlewares ?? []],
-    memory
-  };
-}
-function assertUniqueIndexedToolNames(indexes) {
-  const owners = /* @__PURE__ */ new Map();
-  for (const [indexPosition, index] of indexes.entries()) {
-    if (!isToolIndex(index)) {
-      throw new TypeError(
-        "Invalid tool index: search, searchIds, asTool, tools, and a numeric topK are required."
-      );
-    }
-    assertPositiveSearchLimit(index.topK);
-    assertFiniteSearchThreshold(index.threshold);
-    for (const tool of index.tools) {
-      const existingPosition = owners.get(tool.name);
-      if (existingPosition !== void 0) {
-        if (existingPosition === indexPosition) {
-          throw new TypeError(
-            `Tool "${tool.name}" is registered more than once by tool index ${indexPosition + 1}. Tool names must be unique within each index.`
-          );
-        }
-        throw new TypeError(
-          `Tool "${tool.name}" is registered by multiple tool indexes (${existingPosition + 1} and ${indexPosition + 1}). Tool names must be unique across indexes.`
-        );
-      }
-      owners.set(tool.name, indexPosition);
-    }
-  }
-}
-function assertValidContextIndexes(inputs) {
-  for (const input of inputs) {
-    if (!isContextIndex(input)) continue;
-    assertPositiveSearchLimit(input.topK);
-    assertFiniteSearchThreshold(input.threshold);
-  }
-}
-function isInternalAgentOptions(options) {
-  return options[resolvedAgentOptions] === true;
-}
-function resolveAgentMemory(options) {
-  if (options.memory === void 0) {
-    return void 0;
-  }
-  const { store, ...memoryOptions } = options.memory;
-  const resolvedOptions = resolveMemoryOptions(memoryOptions);
-  if (resolvedOptions.compaction !== void 0 && store.compaction === void 0) {
-    throw new TypeError(
-      "Memory compaction requires a store with the optional compaction capability."
-    );
-  }
-  return { store, options: resolvedOptions };
-}
-var approvalContinuations = /* @__PURE__ */ new WeakMap();
-function assertAgentApprovalDecision(decision) {
-  if (typeof decision !== "object" || decision === null || typeof decision.approved !== "boolean") {
-    throw new TypeError("Approval decision must include an approved boolean.");
-  }
-  if (decision.reason !== void 0 && typeof decision.reason !== "string") {
-    throw new TypeError("Approval decision reason must be a string.");
-  }
-}
-function createGenerateExecution(agent, run) {
-  const completion = run.generate();
-  const execution = {
-    async next() {
-      const outcome = await Promise.race([
-        completion.then((result) => ({ type: "completed", result })),
-        run.waitForApproval().then(() => ({ type: "approval" }))
-      ]);
-      if (outcome.type === "completed") {
-        return outcome.result;
-      }
-      const pending = run.approvalResult();
-      approvalContinuations.set(pending, { agent, run, mode: "generate", execution });
-      return pending;
-    },
-    async cancel(reason) {
-      run.cancel(reason);
-      await completion.catch(() => void 0);
-    }
-  };
-  return execution;
-}
-var StreamExecution = class {
-  constructor(agent, run, includeToolCallDeltas) {
-    this.agent = agent;
-    this.run = run;
-    this.iterator = run.events(includeToolCallDeltas)[Symbol.asyncIterator]();
-  }
-  agent;
-  run;
-  iterator;
-  nextEvent;
-  phase = "active";
-  segment() {
-    if (this.phase === "approval") {
-      this.phase = "active";
-    }
-    return new DefaultAgentStream(this);
-  }
-  steer(input) {
-    return this.run.steer(input);
-  }
-  async *events() {
-    while (true) {
-      this.nextEvent ??= this.iterator.next();
-      let outcome;
-      try {
-        outcome = await Promise.race([
-          this.nextEvent.then((event) => ({ type: "event", event })),
-          this.run.waitForApproval().then(() => ({ type: "approval" }))
-        ]);
-      } catch (error) {
-        this.phase = "terminal";
-        throw error;
-      }
-      if (outcome.type === "approval") {
-        this.phase = "approval";
-        const pending = this.run.approvalEvent();
-        approvalContinuations.set(pending, {
-          agent: this.agent,
-          run: this.run,
-          mode: "stream",
-          execution: this
-        });
-        yield pending;
-        return;
-      }
-      this.nextEvent = void 0;
-      if (outcome.event.done) {
-        this.phase = "terminal";
-        return;
-      }
-      yield outcome.event.value;
-    }
-  }
-  shouldCancelActiveSegment() {
-    return this.phase === "active";
-  }
-  async cancel(reason) {
-    if (this.phase === "terminal" || this.phase === "cancelled") {
-      return;
-    }
-    this.phase = "cancelled";
-    this.run.cancel(reason);
-    try {
-      await this.iterator.return?.();
-    } catch {
-    }
-  }
-};
-function createStreamExecution(agent, run, includeToolCallDeltas) {
-  return new StreamExecution(agent, run, includeToolCallDeltas).segment();
-}
-var DefaultAgentStream = class {
-  constructor(execution) {
-    this.execution = execution;
-  }
-  execution;
-  consuming = false;
-  completed = false;
-  steer(input) {
-    return this.execution.steer(input);
-  }
-  [Symbol.asyncIterator]() {
-    return this.consume()[Symbol.asyncIterator]();
-  }
-  async *consume() {
-    if (this.completed) {
-      throw new Error("Agent stream has already been consumed.");
-    }
-    if (this.consuming) {
-      throw new Error("Agent stream is already running.");
-    }
-    this.consuming = true;
-    try {
-      for await (const event of this.execution.events()) {
-        yield event;
-      }
-    } finally {
-      if (this.execution.shouldCancelActiveSegment()) {
-        await this.execution.cancel("Agent stream consumer closed the stream.");
-      }
-      this.consuming = false;
-      this.completed = true;
-    }
-  }
-};
-async function cancelAgentApproval(pending, reason) {
-  const continuation = approvalContinuations.get(pending);
-  if (continuation === void 0) {
-    return;
-  }
-  approvalContinuations.delete(pending);
-  await continuation.execution.cancel(reason);
-}
-var AgentSession = class {
-  constructor(agent, context) {
-    this.agent = agent;
-    this.context = context;
-  }
-  agent;
-  context;
-  generate(input, options = {}) {
-    if (Array.isArray(input)) {
-      throw new TypeError("AgentSession.generate does not accept Message[] transcripts.");
-    }
-    const run = AgentRun.fromAgent(this.agent, input, {
-      ...options,
-      memoryContext: this.context
-    });
-    return createGenerateExecution(this.agent, run).next();
-  }
-  stream(input, options = {}) {
-    if (Array.isArray(input)) {
-      throw new TypeError("AgentSession.stream does not accept Message[] transcripts.");
-    }
-    return createStreamExecution(
-      this.agent,
-      AgentRun.fromAgent(this.agent, input, { ...options, memoryContext: this.context }),
-      options.includeToolCallDeltas !== false
-    );
-  }
-  async messages() {
-    const memory = this.agent.memory;
-    if (memory === void 0) {
-      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
-    }
-    return memory.store.load(this.context);
-  }
-  async contextUsage() {
-    const messages = await this.messages();
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-      const message = messages[index];
-      if (message === void 0) {
-        continue;
-      }
-      const generation = getAssistantGenerationMetadata(message);
-      if (generation !== void 0) {
-        return generation.contextUsage;
-      }
-    }
-    return void 0;
-  }
-  async clear() {
-    const memory = this.agent.memory;
-    if (memory === void 0) {
-      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
-    }
-    await memory.store.clear(this.context);
-  }
-};
-function snapshotContextInput(input) {
-  if (!isContextIndex(input)) {
-    return Object.freeze({
-      id: input.id,
-      text: input.text,
-      ...input.additionalProps === void 0 ? {} : { additionalProps: cloneFrozenPlainData(input.additionalProps) }
-    });
-  }
-  const format = input.format;
-  return Object.freeze({
-    kind: "context-index",
-    index: input.index,
-    topK: input.topK,
-    ...input.threshold === void 0 ? {} : { threshold: input.threshold },
-    ...input.filter === void 0 ? {} : { filter: cloneFrozenPlainData(input.filter) },
-    ...format === void 0 ? {} : { format: (result) => format.call(input, result) }
-  });
-}
-function snapshotProviderTool(tool) {
-  return Object.freeze({
-    ...tool,
-    ...tool.configuration === void 0 ? {} : { configuration: cloneFrozenPlainData(tool.configuration) }
-  });
-}
-function snapshotToolIndex(index) {
-  const inspect = index.inspect;
-  return Object.freeze({
-    kind: "tool-index",
-    tools: Object.freeze([...index.tools]),
-    topK: index.topK,
-    ...index.threshold === void 0 ? {} : { threshold: index.threshold },
-    ...index.filter === void 0 ? {} : { filter: cloneFrozenPlainData(index.filter) },
-    search: (request) => index.search(request),
-    searchIds: (request) => index.searchIds(request),
-    asTool: (options) => index.asTool(options),
-    ...inspect === void 0 ? {} : { inspect: (request) => inspect.call(index, request) }
-  });
-}
-function snapshotGuardrailPolicy(policy) {
-  return Object.freeze({
-    ...policy,
-    input: Object.freeze([...policy.input]),
-    output: Object.freeze([...policy.output])
-  });
-}
-function snapshotMemoryRegistration(memory) {
-  if (memory === void 0) {
-    return void 0;
-  }
-  const compaction = memory.options.compaction === void 0 ? void 0 : Object.freeze({ ...memory.options.compaction });
-  return Object.freeze({
-    store: memory.store,
-    options: Object.freeze({
-      ...memory.options,
-      ...compaction === void 0 ? {} : { compaction }
-    })
-  });
-}
-function cloneFrozenPlainData(value) {
-  if (Array.isArray(value)) {
-    return Object.freeze(value.map(cloneFrozenPlainData));
-  }
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    return value;
-  }
-  const clone = Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [key, cloneFrozenPlainData(item)])
-  );
-  return Object.freeze(clone);
-}
-function dedupeTools(tools) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const tool of tools) {
-    byName.set(tool.name, tool);
-  }
-  return [...byName.values()];
-}
-
-export {
-  MaxTurnsError,
-  AgentRunCancelledError,
-  getAgentToolState,
-  createHook,
-  getAgentApprovalRequestDetails,
-  createContextIndex,
-  isContextIndex,
-  withInternalAgentRunOptions,
-  Agent,
-  createResolvedAgent,
-  getResolvedAgentOptions,
-  cancelAgentApproval
-};
-//# sourceMappingURL=chunk-IL3ZSNJI.js.map