@anvia/core 0.26.0 → 1.0.0-rc.2

package/dist/chunk-DBSCKTUL.js

@@ -0,0 +1,3793 @@
+import {
+  isSkillTool
+} from "./chunk-YK4WAAS4.js";
+import {
+  isMcpTool
+} from "./chunk-EINTGEGY.js";
+import {
+  isToolIndex
+} from "./chunk-D37WMSP6.js";
+import {
+  ToolNotFoundError,
+  assertFiniteMinScore,
+  assertPositiveSearchLimit,
+  assertToolApprovalRequirement,
+  createTool,
+  parseToolArgs,
+  prepareToolCall,
+  retrieveDocuments,
+  toolMayRequireApproval,
+  toolResultContentToText
+} from "./chunk-77AIYARB.js";
+import {
+  MemoryCompactionConflictError,
+  MemoryCompactionError,
+  assertPositiveInteger,
+  createMemoryCompactionSummary,
+  cumulativeCompactedMessageCount
+} from "./chunk-OJH6HWHX.js";
+import {
+  startAgentRunObservers
+} from "./chunk-CWM7B2OO.js";
+import {
+  mapWithConcurrency
+} from "./chunk-FMHLROPQ.js";
+import {
+  Usage,
+  assertCompletionRequestSupported,
+  createCompletionRequest,
+  getAssistantGenerationMetadata,
+  isProviderTool,
+  isStreamingCompletionModel,
+  textFromAssistantContent
+} from "./chunk-KR3RCCHJ.js";
+import {
+  parseMessage,
+  parseMessages,
+  toProviderJsonSchema
+} from "./chunk-TIZYTPJO.js";
+import {
+  appendGuardrailPolicies,
+  hasEnforcedOutputGuardrails,
+  runInputGuardrails,
+  runOutputGuardrails
+} from "./chunk-KIDGIJM7.js";
+import {
+  abortError,
+  resolveRetryOptions,
+  retryDelayMs,
+  retryErrorAttributes,
+  retryOptionsForFailure,
+  throwIfAborted,
+  waitForRetry
+} from "./chunk-FN7HLLAZ.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, options) {
+    super(`Agent run cancelled: ${reason}`, options);
+    this.chatHistory = chatHistory;
+    this.reason = reason;
+    this.name = "AgentRunCancelledError";
+  }
+  chatHistory;
+  reason;
+};
+var AgentRunBlockedError = class extends Error {
+  constructor(result) {
+    super(`Agent run was blocked by an ${result.stage} guardrail.`);
+    this.result = result;
+    this.name = "AgentRunBlockedError";
+  }
+  result;
+};
+
+// 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/vector-context.ts
+function createVectorContext(options) {
+  const topK = assertPositiveSearchLimit(options.topK);
+  const minScore = assertFiniteMinScore(options.minScore);
+  return Object.freeze({
+    ...options,
+    topK,
+    ...minScore === void 0 ? {} : { minScore },
+    kind: "vector-context"
+  });
+}
+function isVectorContext(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (candidate.kind !== "vector-context" || typeof candidate.store?.search !== "function") {
+    return false;
+  }
+  return candidate.model !== void 0 || candidate.models?.dense !== void 0 && candidate.models.sparse !== void 0;
+}
+
+// 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/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") {
+    if (typeof message.content === "string") {
+      return message.content;
+    }
+    return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
+  }
+  if (message.role === "tool") {
+    return message.content.flatMap((item) => {
+      const output = item.output;
+      if (output.type === "text" || output.type === "error-text") {
+        return [output.value];
+      }
+      if (output.type === "content") {
+        return output.value.flatMap((part) => part.type === "text" ? [part.text] : []);
+      }
+      return [];
+    }).join("\n");
+  }
+  return void 0;
+}
+
+// src/internal/agent-runtime/memory.ts
+var AgentRunMemory = class {
+  constructor(agent, memoryScope, initialHistory) {
+    this.agent = agent;
+    this.memoryScope = memoryScope;
+    this.initialHistory = initialHistory;
+  }
+  agent;
+  memoryScope;
+  initialHistory;
+  memoryPolicy() {
+    return this.memory()?.savePolicy;
+  }
+  pendingTurnMessages(newMessages) {
+    return this.memoryPolicy() === "turn" ? [...newMessages] : [];
+  }
+  async prepareHistory(runId, incomingMessageCount, abortSignal) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0) {
+      return {
+        history: this.initialHistory,
+        usage: Usage.empty()
+      };
+    }
+    const preparation = await this.prepareStoredHistory(
+      memory,
+      runId,
+      incomingMessageCount,
+      abortSignal
+    );
+    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.memoryScope === void 0 || memory.savePolicy !== "message" || messages.length === 0) {
+      return;
+    }
+    await memory.store.append({
+      scope: this.memoryScope,
+      runId,
+      turn: 1,
+      messages
+    });
+  }
+  async commitMessages(runId, turn, messages, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0 || messages.length === 0) {
+      return;
+    }
+    if (memory.savePolicy === "message") {
+      await memory.store.append({
+        scope: this.memoryScope,
+        runId,
+        turn,
+        messages
+      });
+    } else if (memory.savePolicy === "turn") {
+      pendingTurnMessages.push(...messages);
+    }
+  }
+  async commitCompletedTurn(runId, turn, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
+      return;
+    }
+    await memory.store.append({
+      scope: this.memoryScope,
+      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.memoryScope === void 0 || memory.savePolicy !== "run") {
+      return;
+    }
+    await memory.store.append({
+      scope: this.memoryScope,
+      runId,
+      turn,
+      messages: [...newMessages]
+    });
+  }
+  async recordError(runId, error, newMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0) {
+      return;
+    }
+    await memory.store.recordError?.({
+      scope: this.memoryScope,
+      runId,
+      error,
+      messages: [...newMessages]
+    });
+  }
+  memory() {
+    return this.memoryScope === void 0 ? void 0 : this.agent.memory;
+  }
+  async prepareStoredHistory(memory, runId, incomingMessageCount, abortSignal) {
+    const scope = this.memoryScope;
+    if (scope === void 0) {
+      return { history: [], usage: Usage.empty() };
+    }
+    const options = memory.compaction;
+    const capability = memory.store.compaction;
+    if (options === void 0 || capability === void 0) {
+      return {
+        history: await memory.store.load({ scope }),
+        usage: Usage.empty()
+      };
+    }
+    let usage = Usage.empty();
+    const maxAttempts = options.conflictRetries === false ? 1 : options.conflictRetries.maxAttempts;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      throwIfAborted(abortSignal);
+      const snapshot = await capability.snapshot({ scope });
+      throwIfAborted(abortSignal);
+      const compactedMessageCount = compactedPrefixLength(
+        snapshot.messages,
+        incomingMessageCount,
+        options.trigger.afterMessages,
+        options.retention.recentUserTurns
+      );
+      if (compactedMessageCount === 0) {
+        return { history: snapshot.messages, usage };
+      }
+      const prefix = snapshot.messages.slice(0, compactedMessageCount);
+      let result;
+      try {
+        result = await options.compactor({
+          scope,
+          messages: prefix,
+          abortSignal
+        });
+      } 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)
+      );
+      throwIfAborted(abortSignal);
+      let replacement;
+      try {
+        replacement = await capability.replacePrefix({
+          scope,
+          revision: snapshot.revision,
+          messageCount: compactedMessageCount,
+          replacement: summary,
+          runId: `memory-compaction:${runId}:${attempt}`
+        });
+      } catch (error) {
+        throw new MemoryCompactionError("Memory compaction prefix replacement failed.", {
+          cause: error,
+          usage
+        });
+      }
+      if (replacement.status === "committed") {
+        const retained = snapshot.messages.slice(compactedMessageCount);
+        return {
+          history: [summary, ...retained],
+          usage,
+          compaction: {
+            originalMessageCount: snapshot.messages.length,
+            compactedMessageCount,
+            retainedMessageCount: retained.length,
+            attempts: attempt,
+            usage
+          }
+        };
+      }
+      throwIfAborted(abortSignal);
+    }
+    throw new MemoryCompactionConflictError(maxAttempts, usage);
+  }
+};
+function compactedPrefixLength(messages, incomingMessageCount, afterMessages, recentUserTurns) {
+  if (messages.length + incomingMessageCount <= afterMessages) {
+    return 0;
+  }
+  const userMessageIndexes = messages.flatMap(
+    (message, index) => message.role === "user" ? [index] : []
+  );
+  if (userMessageIndexes.length <= recentUserTurns) {
+    return 0;
+  }
+  return userMessageIndexes[userMessageIndexes.length - recentUserTurns] ?? 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, abortSignal) {
+  const documents = [];
+  for (const input of agent.context) {
+    if (!isVectorContext(input)) {
+      documents.push(input);
+      continue;
+    }
+    if (ragText === void 0 || ragText.length === 0) continue;
+    const request = {
+      query: ragText,
+      topK: input.topK,
+      minScore: input.minScore,
+      filter: input.filter,
+      retries: input.retries,
+      abortSignal
+    };
+    const results = "models" in input && input.models !== void 0 ? await retrieveDocuments({
+      ...request,
+      store: input.store,
+      models: input.models,
+      fusion: input.fusion
+    }) : await retrieveDocuments({ ...request, store: input.store, model: input.model });
+    for (const result of results) {
+      const formatted = input.format?.(result);
+      if (formatted !== void 0) {
+        documents.push(formatted);
+        continue;
+      }
+      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, abortSignal) {
+  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, abortSignal });
+    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.toolCallId)) {
+      this.orderedParts.push({ type: "tool_call", key: toolCall.toolCallId });
+    }
+    const partial = {
+      id: toolCall.toolCallId,
+      name: toolCall.toolName,
+      argumentsText: JSON.stringify(toolCall.input ?? {})
+    };
+    if (toolCall.callId !== void 0) {
+      partial.callId = toolCall.callId;
+    }
+    if (toolCall.signature !== void 0) {
+      partial.signature = toolCall.signature;
+    }
+    this.toolCalls.set(toolCall.toolCallId, 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.toolCallId, 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.toolCallId) ?? (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.details ??= [];
+    const last = reasoning.details.at(-1);
+    if (contentType === "text") {
+      if (last?.type === "text") {
+        reasoning.details[reasoning.details.length - 1] = {
+          ...last,
+          text: `${last.text}${event.delta}`,
+          ...event.signature === void 0 ? {} : { signature: event.signature }
+        };
+      } else {
+        reasoning.details.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") {
+        reasoning.details[reasoning.details.length - 1] = {
+          ...last,
+          text: `${last.text}${event.delta}`
+        };
+      } else {
+        reasoning.details.push({ type: "summary", text: event.delta });
+      }
+      return;
+    }
+    if (contentType === "encrypted") {
+      reasoning.details.push({ type: "encrypted", data: event.delta });
+      return;
+    }
+    reasoning.details.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.details === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, details: reasoning.details };
+  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
+}
+function toolCallContent(toolCall, finalToolCall) {
+  const argumentsValue = finalToolCall !== void 0 && !isEmptyToolArguments(finalToolCall.input) ? finalToolCall.input : parseToolArguments(toolCall.id, toolCall.argumentsText);
+  return {
+    type: "tool-call",
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    input: argumentsValue,
+    ...toolCall.callId === void 0 ? {} : { callId: toolCall.callId },
+    ...toolCall.signature === void 0 ? {} : { signature: toolCall.signature }
+  };
+}
+function matchingFinalToolCall(accumulated, finalChoice) {
+  const byId = finalChoice?.find(
+    (content) => content.type === "tool-call" && content.toolCallId === 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 input = isEmptyToolArguments(finalToolCall.input) ? accumulated.input : finalToolCall.input;
+  return {
+    ...accumulated,
+    ...finalToolCall,
+    input
+  };
+}
+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 ToolCallExecutor = class {
+  constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, abortSignal, cancel) {
+    this.agent = agent;
+    this.activeHook = activeHook;
+    this.approvalHandler = approvalHandler;
+    this.lifecycle = lifecycle;
+    this.runContext = runContext;
+    this.concurrency = concurrency;
+    this.requestMiddlewares = requestMiddlewares;
+    this.abortSignal = abortSignal;
+    this.cancel = cancel;
+  }
+  agent;
+  activeHook;
+  approvalHandler;
+  lifecycle;
+  runContext;
+  concurrency;
+  requestMiddlewares;
+  abortSignal;
+  cancel;
+  async execute(toolCalls, onResult, onStreamEvent, observation) {
+    for (const toolCall of toolCalls) {
+      if (toolCall.toolName.length === 0) {
+        throw new Error(
+          `Completion returned tool call "${toolCall.toolCallId}" with an empty tool name; this indicates invalid provider output or provider mapping.`
+        );
+      }
+    }
+    return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
+      throwIfAborted(this.abortSignal);
+      const args = JSON.stringify(toolCall.input);
+      const internalCallId = globalThis.crypto.randomUUID();
+      const hookArgs = {
+        toolName: toolCall.toolName,
+        internalCallId,
+        args
+      };
+      if (toolCall.callId !== void 0) {
+        hookArgs.toolCallId = toolCall.callId;
+      }
+      const tool = this.agent.getTool(toolCall.toolName);
+      const toolDefinition = observation?.toolDefinitions?.find(
+        (definition) => definition.name === toolCall.toolName
+      );
+      const toolMetadata = toolTraceMetadata(tool);
+      const toolStartArgs = {
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.toolName,
+        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 = { type: "text", value: 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.toolName, 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 = { type: "execution-denied", reason: approvalDecision.result };
+                skipped = true;
+              } else {
+                const step = observation?.turn ?? 0;
+                const lifecycleEvent = {
+                  runId: this.runContext.runId,
+                  step,
+                  toolName: toolCall.toolName,
+                  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.toolName}" 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.toolName,
+            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.toolName,
+          toolCallId: toolCall.toolCallId,
+          internalCallId,
+          args: effectiveArgs,
+          output,
+          result,
+          structuredResult,
+          ...toolCall.callId === void 0 ? {} : { callId: toolCall.callId }
+        };
+        onResult?.(resultPayload);
+        return {
+          type: "tool-result",
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          output,
+          ...toolCall.callId === void 0 ? {} : { callId: toolCall.callId }
+        };
+      } 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 = {
+        abortSignal: this.abortSignal,
+        emitStreamEvent: async (event) => {
+          const streamEventArgs = {
+            turn: observation?.turn ?? 0,
+            toolCall,
+            toolName: toolCall.toolName,
+            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);
+          }
+        }
+      };
+      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: {
+        type: "error-text",
+        value: 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 === void 0 ? { type: "text", value: result } : { type: "content", value: structuredResult } : 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 result = {
+    approvalRequired: toolMayRequireApproval(tool.requiresApproval)
+  };
+  if (isMcpTool(tool)) {
+    result.mcpServerName = tool.mcp.serverName;
+    result.mcpRemoteName = tool.mcp.remoteName;
+  }
+  return result;
+}
+function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
+  const observerArgs = {
+    turn,
+    toolCall,
+    toolName: toolCall.toolName,
+    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) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "content":
+      return toolResultContentToText(output.value);
+    case "execution-denied":
+      return output.reason ?? "Tool execution was denied.";
+  }
+}
+function toolOutputToStructuredResult(output) {
+  return output.type === "content" ? output.value : void 0;
+}
+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.toolName,
+    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.onInternalFailure = internalOptions?.onFailure;
+    this.onInternalMemoryCompaction = internalOptions?.onMemoryCompaction;
+    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;
+    const retrySetting = options.retries === void 0 ? agent.retries : options.retries;
+    this.completionRetryOptions = retrySetting === void 0 || retrySetting === false ? void 0 : resolveRetryOptions(retrySetting);
+    this.requestMiddlewares = [...options.middlewares ?? []];
+    this.memoryScope = options.memoryScope;
+    this.memoryRecorder = new AgentRunMemory(agent, options.memoryScope, initialHistory);
+    this.linkExternalAbortSignal(options.abortSignal);
+  }
+  agent;
+  promptMessage;
+  chatHistory;
+  maxTurnCount;
+  activeHook;
+  activeLifecycle;
+  guardrailPolicies;
+  guardrailDecisions = [];
+  concurrency;
+  traceOptions;
+  completionRetryOptions;
+  requestMiddlewares;
+  steeringMessages = [];
+  runState = "idle";
+  memoryRecorder;
+  memoryScope;
+  onInternalFailure;
+  onInternalMemoryCompaction;
+  memoryCompaction;
+  pendingApproval;
+  approvalSignal = deferredSignal();
+  activeRunId;
+  requestedRunId;
+  currentUsage = Usage.empty();
+  currentMessages = [];
+  cancellationError;
+  activeGeneration;
+  abortController = new AbortController();
+  removeExternalAbortListener;
+  static fromAgent(agent, options) {
+    const normalized = normalizeAgentInput(options);
+    if (normalized.scope !== void 0 && agent.memory === void 0) {
+      throw new TypeError(`Agent "${agent.id}" cannot use a session without a memory store.`);
+    }
+    return new _AgentRun(agent, normalized.prompt, normalized.history, {
+      ...options,
+      memoryScope: normalized.scope
+    });
+  }
+  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.setCancellationError(error);
+  }
+  setCancellationError(error) {
+    this.cancellationError = error;
+    if (!this.abortController.signal.aborted) this.abortController.abort(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 {
+      this.throwIfCancelled();
+      const memoryPreparation = await this.memoryRecorder.prepareHistory(
+        runId,
+        newMessages.length,
+        this.abortController.signal
+      );
+      this.chatHistory = memoryPreparation.history;
+      usage = Usage.add(usage, memoryPreparation.usage);
+      this.memoryCompaction = memoryPreparation.compaction;
+      await this.notifyInternalMemoryCompaction(memoryPreparation.compaction);
+      runObservers = await this.startRunObservers(runId);
+      await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      this.throwIfCancelled();
+      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 text = inputResult.message ?? "The request was blocked by a guardrail.";
+        const result = {
+          status: "blocked",
+          stage: "input",
+          runId,
+          text,
+          usage,
+          messages: [this.promptMessage, { role: "assistant", content: text }],
+          trace: runObservers.trace,
+          guardrails: [...this.guardrailDecisions],
+          ...this.memoryCompactionResult()
+        };
+        await this.runLifecycleFinish(result);
+        await runObservers.end(result);
+        this.runState = "completed";
+        this.disposeAbortLink();
+        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 = this.createTerminalResult(
+            runId,
+            guardedOutput.text,
+            guardedOutput.blocked,
+            usage,
+            newMessages,
+            runObservers
+          );
+          if (result.status === "completed") {
+            await this.runRunEndHook(result, newMessages);
+          }
+          await this.memoryRecorder.commitCompletedRun(
+            runId,
+            currentTurns,
+            newMessages,
+            pendingTurnMessages
+          );
+          await this.runLifecycleFinish(result);
+          await runObservers.end(result);
+          this.runState = "completed";
+          this.disposeAbortLink();
+          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 = { role: "tool", content: 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 runError = this.normalizeRunError(error);
+      const reportedError = await this.reportRunFailure(
+        runError,
+        runId,
+        usage,
+        newMessages,
+        runObservers
+      );
+      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
+      this.disposeAbortLink();
+      throw reportedError;
+    }
+  }
+  async *events() {
+    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 {
+      this.throwIfCancelled();
+      const memoryPreparation = await this.memoryRecorder.prepareHistory(
+        runId,
+        newMessages.length,
+        this.abortController.signal
+      );
+      this.chatHistory = memoryPreparation.history;
+      usage = Usage.add(usage, memoryPreparation.usage);
+      this.memoryCompaction = memoryPreparation.compaction;
+      await this.notifyInternalMemoryCompaction(memoryPreparation.compaction);
+      runObservers = await this.startRunObservers(runId);
+      await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      if (memoryPreparation.compaction !== void 0) {
+        yield { type: "memory_compaction", ...memoryPreparation.compaction };
+      }
+      this.throwIfCancelled();
+      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 text = inputResult.message ?? "The request was blocked by a guardrail.";
+        const result = {
+          status: "blocked",
+          stage: "input",
+          runId,
+          text,
+          usage,
+          messages: [this.promptMessage, { role: "assistant", content: text }],
+          trace: runObservers.trace,
+          guardrails: [...this.guardrailDecisions],
+          ...this.memoryCompactionResult()
+        };
+        await this.runLifecycleFinish(result);
+        await runObservers.end(result);
+        this.runState = "completed";
+        this.disposeAbortLink();
+        yield { type: "final", result };
+        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,
+              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.toolCallId)) {
+              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
+        });
+        for await (const result of toolExecution.events) {
+          yield { turn: currentTurns, ...result };
+        }
+        const toolResults = await toolExecution.results;
+        const toolMessage = { role: "tool", content: 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 runError = this.normalizeRunError(error);
+      const reportedError = await this.reportRunFailure(
+        runError,
+        runId,
+        usage,
+        newMessages,
+        runObservers
+      );
+      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
+      const finalUsage = usage;
+      yield { type: "error", error: reportedError, usage: finalUsage };
+      this.disposeAbortLink();
+      return;
+    } 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";
+        this.disposeAbortLink();
+      }
+    }
+  }
+  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 {
+          this.throwIfCancelled();
+          response = await this.agent.model.completion(request, this.modelCallOptions());
+        } 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 abortSignal = this.abortController.signal;
+    const documents = await fetchContextDocuments(this.agent, ragText, abortSignal);
+    const toolDefinitions = await fetchToolDefinitions(this.agent, ragText, abortSignal);
+    const request = createCompletionRequest([...history, prompt], {
+      instructions: this.agent.instructions,
+      documents,
+      tools: [...toolDefinitions, ...getAgentToolState(this.agent).providerTools],
+      temperature: this.agent.temperature,
+      maxTokens: this.agent.maxTokens,
+      providerOptions: this.agent.providerOptions,
+      toolChoice: this.agent.toolChoice,
+      outputSchema: getAgentProviderOutputSchema(this.agent)
+    });
+    return 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 {
+        this.throwIfCancelled();
+        for await (const event of model.streamCompletion(args.request, this.modelCallOptions())) {
+          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 (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.toolCallId);
+            }
+            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 = this.createTerminalResult(
+      args.runId,
+      guardedOutput.text,
+      guardedOutput.blocked,
+      args.usage,
+      args.newMessages,
+      args.runObservers
+    );
+    if (result.status === "completed") {
+      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";
+    this.disposeAbortLink();
+    yield { type: "final", result };
+  }
+  generatedAssistantMessage(response, _request) {
+    const metadata = {
+      anvia: {
+        generation: {
+          provider: this.agent.model.provider,
+          modelId: this.agent.model.modelId,
+          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 {
+      role: "assistant",
+      content: 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,
+        modelId: this.agent.model.modelId,
+        capabilities: this.agent.model.capabilities
+      },
+      ...providerRequest === void 0 ? {} : { providerRequest }
+    };
+  }
+  retryOptionsForFailure(error, attempt, turn, streaming) {
+    if (this.abortController.signal.aborted) return void 0;
+    return retryOptionsForFailure(this.completionRetryOptions, {
+      error,
+      attempt,
+      turn,
+      streaming
+    });
+  }
+  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, this.abortController.signal);
+  }
+  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.memoryScope?.sessionId,
+        metadata: this.memoryScope?.metadata
+      },
+      this.concurrency,
+      this.requestMiddlewares,
+      this.abortController.signal,
+      (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),
+      ...this.memoryCompactionResult()
+    };
+  }
+  updateApprovalProgress(runId, usage, messages) {
+    this.activeRunId = runId;
+    this.currentUsage = usage;
+    this.currentMessages = [...messages];
+  }
+  async runLifecycleFinish(result) {
+    const common = {
+      runId: result.runId,
+      text: result.text,
+      usage: lifecycleSnapshot(result.usage),
+      messages: lifecycleSnapshot(result.messages),
+      ...result.memoryCompaction === void 0 ? {} : { memoryCompaction: lifecycleSnapshot(result.memoryCompaction) }
+    };
+    const event = result.status === "completed" ? {
+      ...common,
+      status: "completed",
+      output: lifecycleSnapshot(result.output)
+    } : {
+      ...common,
+      status: "blocked",
+      stage: result.stage
+    };
+    await this.activeLifecycle?.onFinish?.(event);
+  }
+  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([
+      () => this.onInternalFailure?.({
+        error: reportedError,
+        messages: lifecycleSnapshot(messages)
+      }),
+      () => 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 text = result.blocked ? result.message ?? "The response was blocked by a guardrail." : result.outputText;
+    if (text === originalOutput) {
+      return { text, blocked: result.blocked, response, decisions: result.decisions };
+    }
+    return {
+      text,
+      blocked: result.blocked,
+      response: {
+        ...response,
+        choice: [{ type: "text", text }]
+      },
+      decisions: result.decisions
+    };
+  }
+  createTerminalResult(runId, text, blocked, usage, messages, runObservers) {
+    const common = {
+      runId,
+      text,
+      usage,
+      messages: [...messages],
+      trace: runObservers.trace,
+      guardrails: [...this.guardrailDecisions],
+      ...generationArtifacts(messages),
+      ...this.memoryCompactionResult()
+    };
+    if (blocked) {
+      return { ...common, status: "blocked", stage: "output" };
+    }
+    return {
+      ...common,
+      status: "completed",
+      output: this.parseOutput(text)
+    };
+  }
+  parseOutput(text) {
+    const schema = this.agent.outputSchema;
+    if (schema === void 0) return text;
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (error) {
+      throw new Error("Agent expected the model response to be valid JSON.", { cause: error });
+    }
+    return schema.parse(json);
+  }
+  memoryCompactionResult() {
+    return this.memoryCompaction === void 0 ? {} : { memoryCompaction: lifecycleSnapshot(this.memoryCompaction) };
+  }
+  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,
+        attempts: compaction.attempts,
+        inputTokens: compaction.usage.inputTokens,
+        outputTokens: compaction.usage.outputTokens,
+        totalTokens: compaction.usage.totalTokens
+      }
+    });
+  }
+  async notifyInternalMemoryCompaction(compaction) {
+    if (compaction === void 0) {
+      return;
+    }
+    await this.onInternalMemoryCompaction?.(lifecycleSnapshot(compaction));
+  }
+  guardrailRunContext(runId) {
+    const context = {
+      agentId: this.agent.id,
+      runId
+    };
+    if (this.memoryScope !== void 0) {
+      context.sessionId = this.memoryScope.sessionId;
+      if (this.memoryScope.metadata !== void 0) {
+        context.metadata = this.memoryScope.metadata;
+      }
+    }
+    return context;
+  }
+  async startRunObservers(runId) {
+    const observability = this.agent.observability;
+    return startAgentRunObservers(
+      observability?.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
+      },
+      {
+        primaryTrace: observability?.primaryTrace,
+        errorPolicy: observability?.errorPolicy ?? "ignore"
+      }
+    );
+  }
+  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?.({
+      status: "completed",
+      output: result.output,
+      text: result.text,
+      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) {
+    if (this.cancellationError !== void 0) return this.cancellationError;
+    const error = new AgentRunCancelledError([...this.chatHistory, ...newMessages], reason);
+    this.setCancellationError(error);
+    return error;
+  }
+  linkExternalAbortSignal(signal) {
+    if (signal === void 0) return;
+    const cancelFromSignal = () => {
+      if (this.cancellationError !== void 0 || this.isTerminal()) return;
+      const cause = abortError(signal.reason);
+      const reason = abortReason(signal.reason);
+      const messages = this.currentMessages.length === 0 ? [this.promptMessage] : [...this.currentMessages];
+      this.setCancellationError(
+        new AgentRunCancelledError([...this.chatHistory, ...messages], reason, { cause })
+      );
+    };
+    if (signal.aborted) {
+      cancelFromSignal();
+      return;
+    }
+    signal.addEventListener("abort", cancelFromSignal, { once: true });
+    this.removeExternalAbortListener = () => signal.removeEventListener("abort", cancelFromSignal);
+  }
+  throwIfCancelled() {
+    if (this.cancellationError !== void 0) throw this.cancellationError;
+    throwIfAborted(this.abortController.signal);
+  }
+  normalizeRunError(error) {
+    return this.abortController.signal.aborted && this.cancellationError !== void 0 ? this.cancellationError : error;
+  }
+  modelCallOptions() {
+    return { abortSignal: this.abortController.signal };
+  }
+  disposeAbortLink() {
+    this.removeExternalAbortListener?.();
+    this.removeExternalAbortListener = void 0;
+  }
+};
+function abortReason(reason) {
+  if (typeof reason === "string" && reason.trim().length > 0) return reason;
+  if (reason instanceof Error && reason.message.trim().length > 0) return reason.message;
+  return "External abort signal.";
+}
+function normalizeAgentInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new TypeError("Agent runs require one options object with prompt or messages.");
+  }
+  const hasPrompt = "prompt" in input && input.prompt !== void 0;
+  const hasMessages = "messages" in input && input.messages !== void 0;
+  if (hasPrompt === hasMessages) {
+    throw new TypeError("Agent runs require exactly one of prompt or messages.");
+  }
+  if (hasPrompt) {
+    const prompt = input.prompt;
+    if (typeof prompt !== "string" && (typeof prompt !== "object" || prompt === null || prompt.role !== "user")) {
+      throw new TypeError("Agent prompt must be text or a user message.");
+    }
+    const parsedPrompt = parseMessage(
+      typeof prompt === "string" ? { role: "user", content: prompt } : prompt
+    );
+    if (parsedPrompt.role !== "user") {
+      throw new TypeError("Agent prompt must be text or a user message.");
+    }
+    return {
+      prompt: parsedPrompt,
+      history: [],
+      ...input.session === void 0 ? {} : { scope: normalizeMemoryScope(input.session) }
+    };
+  }
+  if (input.session !== void 0) {
+    throw new TypeError("Agent messages cannot be combined with a persisted session.");
+  }
+  const messages = input.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new TypeError("Agent input transcript must contain at least one message.");
+  }
+  const parsedMessages = parseMessages(messages);
+  const activePrompt = parsedMessages.at(-1);
+  if (activePrompt === void 0) {
+    throw new TypeError("Agent input transcript must contain at least one message.");
+  }
+  if (activePrompt.role !== "user") {
+    throw new TypeError("Agent input transcript must end with a user message.");
+  }
+  return {
+    prompt: activePrompt,
+    history: parsedMessages.slice(0, -1)
+  };
+}
+function normalizeSteeringInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new TypeError("Agent steering requires one options object with prompt or messages.");
+  }
+  const hasPrompt = "prompt" in input && input.prompt !== void 0;
+  const hasMessages = "messages" in input && input.messages !== void 0;
+  if (hasPrompt === hasMessages) {
+    throw new TypeError("Agent steering requires exactly one of prompt or messages.");
+  }
+  if (hasPrompt) {
+    const prompt = input.prompt;
+    if (typeof prompt !== "string" && (typeof prompt !== "object" || prompt === null || prompt.role !== "user")) {
+      throw new TypeError("Agent steering prompt must be text or a user message.");
+    }
+    const parsedPrompt = parseMessage(
+      typeof prompt === "string" ? { role: "user", content: prompt } : prompt
+    );
+    if (parsedPrompt.role !== "user") {
+      throw new TypeError("Agent steering prompt must be text or a user message.");
+    }
+    return [parsedPrompt];
+  }
+  const messages = input.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new TypeError("Agent steering messages must contain at least one user message.");
+  }
+  const parsedMessages = parseMessages(messages);
+  if (parsedMessages.some((message) => message.role !== "user")) {
+    throw new TypeError("Agent steering messages must all be user messages.");
+  }
+  return parsedMessages;
+}
+function normalizeMemoryScope(scope) {
+  if (typeof scope !== "object" || scope === null) {
+    throw new TypeError("Agent session must be an object.");
+  }
+  if (typeof scope.sessionId !== "string" || scope.sessionId.trim().length === 0) {
+    throw new TypeError("Agent sessionId must be a non-empty string.");
+  }
+  return lifecycleSnapshot({
+    sessionId: scope.sessionId.trim(),
+    ...scope.userId === void 0 ? {} : { userId: scope.userId },
+    ...scope.metadata === void 0 ? {} : { metadata: scope.metadata }
+  });
+}
+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.details === void 0) {
+        if (item.text.length > 0) {
+          events.push(reasoningDeltaEvent2(turn, item.text, { id: item.id }));
+        }
+        continue;
+      }
+      for (const content of item.details) {
+        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;
+  }
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.flatMap((content) => {
+    if (content.type === "text") {
+      return [content.text];
+    }
+    if (content.type === "file" && content.data.type === "text") {
+      return [content.data.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/memory/options.ts
+function resolveMemoryOptions(options = {}) {
+  const resolved = {
+    savePolicy: options.savePolicy ?? "message"
+  };
+  if (options.compaction !== void 0) {
+    assertPositiveInteger(
+      options.compaction.trigger.afterMessages,
+      "compaction.trigger.afterMessages"
+    );
+    const recentUserTurns = options.compaction.retention?.recentUserTurns ?? 4;
+    assertPositiveInteger(recentUserTurns, "compaction.retention.recentUserTurns");
+    if (typeof options.compaction.compactor !== "function") {
+      throw new TypeError("compaction.compactor must be a function.");
+    }
+    const conflictRetries = options.compaction.conflictRetries ?? false;
+    if (conflictRetries !== false) {
+      assertPositiveInteger(conflictRetries.maxAttempts, "compaction.conflictRetries.maxAttempts");
+    }
+    resolved.compaction = {
+      trigger: {
+        afterMessages: options.compaction.trigger.afterMessages
+      },
+      retention: {
+        recentUserTurns
+      },
+      compactor: options.compaction.compactor,
+      conflictRetries
+    };
+  }
+  return resolved;
+}
+
+// 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 providerOutputSchemas = /* @__PURE__ */ new WeakMap();
+var Agent = class {
+  id;
+  name;
+  description;
+  model;
+  instructions;
+  context;
+  temperature;
+  maxTokens;
+  providerOptions;
+  retries;
+  mcpServers;
+  tools;
+  toolChoice;
+  defaultMaxTurns;
+  lifecycle;
+  outputSchema;
+  observability;
+  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);
+    assertValidVectorContexts(context);
+    this.context = Object.freeze(context);
+    this.temperature = resolved.temperature;
+    this.maxTokens = resolved.maxTokens;
+    this.providerOptions = cloneFrozenPlainData(resolved.providerOptions);
+    this.retries = cloneFrozenPlainData(resolved.retries);
+    assertUniqueMcpServerNames(resolved.mcpServers ?? []);
+    this.mcpServers = Object.freeze((resolved.mcpServers ?? []).map(snapshotMcpServer));
+    const configuredTools = [...resolved.tools ?? []];
+    const staticTools = [...configuredTools, ...this.mcpServers.flatMap((server) => server.tools)];
+    const toolIndexes = (resolved.toolIndexes ?? []).map(snapshotToolIndex);
+    const providerTools = (resolved.providerTools ?? []).map(snapshotProviderTool);
+    assertUniqueAgentToolNames({
+      staticTools,
+      providerTools,
+      toolIndexes
+    });
+    const toolsByName = new Map(staticTools.map((tool) => [tool.name, tool]));
+    for (const index of toolIndexes) {
+      for (const tool of index.tools) {
+        toolsByName.set(tool.name, tool);
+      }
+    }
+    this.tools = Object.freeze([...toolsByName.values()]);
+    const publicToolState = Object.freeze({
+      configuredTools: Object.freeze(configuredTools),
+      staticTools: Object.freeze(staticTools),
+      providerTools: Object.freeze(providerTools),
+      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 = resolved.outputSchema;
+    if (resolved.outputSchema !== void 0) {
+      providerOutputSchemas.set(this, toProviderJsonSchema(resolved.outputSchema));
+    }
+    this.observability = snapshotAgentObservability(resolved.observability);
+    this.guardrails = Object.freeze((resolved.guardrails ?? []).map(snapshotGuardrailPolicy));
+    this.middlewares = Object.freeze([...resolved.middlewares ?? []]);
+    this.memory = snapshotAgentMemory(resolved.memory);
+  }
+  generate(options) {
+    return createGenerateExecution(this, AgentRun.fromAgent(this, options)).next();
+  }
+  stream(options) {
+    const run = AgentRun.fromAgent(this, options);
+    if (!this.model.capabilities.streaming || !isStreamingCompletionModel(this.model)) {
+      throw new Error("This completion model does not support streaming");
+    }
+    return createStreamExecution(this, run);
+  }
+  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.resolve(decision);
+    return continuation.mode === "generate" ? continuation.resume() : continuation.resume();
+  }
+  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.")
+      }),
+      execute: async ({ prompt }, context) => {
+        if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
+          let completed = false;
+          let output;
+          const childStream = this.stream({
+            prompt,
+            maxTurns: options.maxTurns,
+            abortSignal: context.abortSignal
+          });
+          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 === "error") {
+              throw event.error;
+            }
+            if (event.type === "final") {
+              if (event.result.status === "blocked") {
+                throw new AgentRunBlockedError(event.result);
+              }
+              output = event.result.output;
+              completed = true;
+            }
+          }
+          if (!completed) {
+            throw new Error(`Agent tool "${options.name}" ended without a final result.`);
+          }
+          return output;
+        }
+        const response = await this.generate({
+          prompt,
+          maxTurns: options.maxTurns,
+          abortSignal: context.abortSignal
+        });
+        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.`
+          );
+        }
+        if (response.status === "blocked") {
+          throw new AgentRunBlockedError(response);
+        }
+        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,
+    providerOptions: agent.providerOptions,
+    retries: agent.retries,
+    tools: [...toolState.configuredTools],
+    mcpServers: [...agent.mcpServers],
+    providerTools: [...toolState.providerTools],
+    toolIndexes: [...toolState.toolIndexes],
+    toolChoice: agent.toolChoice,
+    defaultMaxTurns: agent.defaultMaxTurns,
+    lifecycle: agent.lifecycle,
+    outputSchema: agent.outputSchema,
+    observability: agent.observability,
+    guardrails: [...agent.guardrails],
+    middlewares: [...agent.middlewares],
+    memory: agent.memory
+  };
+}
+function getAgentProviderOutputSchema(agent) {
+  return providerOutputSchemas.get(agent);
+}
+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, tools, and a numeric topK are required.");
+    } else if (isMcpTool(tool)) {
+      throw new TypeError(
+        `MCP tool "${tool.name}" must be registered through Agent.mcpServers, not Agent.tools.`
+      );
+    } else {
+      addUniqueTool(toolsByName, tool, "local tool");
+    }
+  }
+  if (options.skills !== void 0) {
+    for (const tool of options.skills.tools) {
+      if (isMcpTool(tool)) {
+        throw new TypeError(
+          `MCP tool "${tool.name}" must be registered through Agent.mcpServers, not Agent.skills.`
+        );
+      }
+      addUniqueTool(toolsByName, tool, "skill 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,
+    providerOptions: options.providerOptions,
+    retries: options.retries,
+    tools: [...toolsByName.values()],
+    mcpServers: [...options.mcpServers ?? []],
+    providerTools,
+    toolIndexes,
+    toolChoice: options.toolChoice,
+    defaultMaxTurns: options.maxTurns,
+    lifecycle: options.lifecycle,
+    outputSchema: options.outputSchema,
+    observability: options.observability,
+    guardrails: options.guardrails === void 0 ? [] : appendGuardrailPolicies([], options.guardrails),
+    middlewares: [...options.middlewares ?? []],
+    memory
+  };
+}
+function assertUniqueAgentToolNames(options) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const tool of options.staticTools) {
+    registerToolOwner(owners, tool.name, isMcpTool(tool) ? "MCP tool" : "local or skill tool");
+  }
+  for (const tool of options.providerTools) {
+    registerToolOwner(owners, tool.name, "provider tool");
+  }
+  for (const [indexPosition, index] of options.toolIndexes.entries()) {
+    if (!isToolIndex(index)) {
+      throw new TypeError("Invalid tool index: search, tools, and a numeric topK are required.");
+    }
+    assertPositiveSearchLimit(index.topK);
+    assertFiniteMinScore(index.minScore);
+    for (const tool of index.tools) {
+      if (isMcpTool(tool)) {
+        throw new TypeError(
+          `MCP tool "${tool.name}" must be registered through Agent.mcpServers, not a tool index.`
+        );
+      }
+      registerToolOwner(owners, tool.name, `tool index ${indexPosition + 1}`);
+    }
+  }
+}
+function registerToolOwner(owners, name, owner) {
+  const existing = owners.get(name);
+  if (existing !== void 0) {
+    throw new TypeError(
+      `Tool name collision for "${name}" between ${existing} and ${owner}. Tool names must be unique across every Agent tool source.`
+    );
+  }
+  owners.set(name, owner);
+}
+function addUniqueTool(tools, tool, source) {
+  if (tools.has(tool.name)) {
+    throw new TypeError(`Duplicate ${source} name "${tool.name}".`);
+  }
+  tools.set(tool.name, tool);
+}
+function assertValidVectorContexts(inputs) {
+  for (const input of inputs) {
+    if (!isVectorContext(input)) continue;
+    assertPositiveSearchLimit(input.topK);
+    assertFiniteMinScore(input.minScore);
+  }
+}
+function snapshotAgentObservability(observability) {
+  if (observability === void 0) return void 0;
+  const observers = {};
+  for (const [name, observer] of Object.entries(observability.observers)) {
+    if (name.trim().length === 0) {
+      throw new TypeError("Agent observer names must not be empty.");
+    }
+    if (typeof observer !== "object" || observer === null || typeof observer.startRun !== "function") {
+      throw new TypeError(`Agent observer "${name}" must implement startRun().`);
+    }
+    observers[name] = observer;
+  }
+  if (observability.primaryTrace !== void 0 && !(observability.primaryTrace in observers)) {
+    throw new TypeError(
+      `Agent primaryTrace "${observability.primaryTrace}" must name a configured observer.`
+    );
+  }
+  const errorPolicy = observability.errorPolicy ?? "ignore";
+  if (errorPolicy !== "ignore" && errorPolicy !== "throw") {
+    throw new TypeError('Agent observability.errorPolicy must be "ignore" or "throw".');
+  }
+  return Object.freeze({
+    observers: Object.freeze(observers),
+    ...observability.primaryTrace === void 0 ? {} : { primaryTrace: observability.primaryTrace },
+    errorPolicy
+  });
+}
+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, ...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,
+        mode: "generate",
+        resolve: (decision) => run.resolveApproval(decision),
+        resume: () => execution.next(),
+        cancel: (reason) => execution.cancel(reason)
+      });
+      return pending;
+    },
+    async cancel(reason) {
+      run.cancel(reason);
+      await completion.catch(() => void 0);
+    }
+  };
+  return execution;
+}
+var StreamExecution = class {
+  constructor(agent, run) {
+    this.agent = agent;
+    this.run = run;
+    this.iterator = run.events()[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,
+          mode: "stream",
+          resolve: (decision) => this.run.resolveApproval(decision),
+          resume: () => this.segment(),
+          cancel: (reason) => this.cancel(reason)
+        });
+        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) {
+  return new StreamExecution(agent, run).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.cancel(reason);
+}
+function snapshotContextInput(input) {
+  if (!isVectorContext(input)) {
+    return Object.freeze({
+      id: input.id,
+      text: input.text,
+      ...input.additionalProps === void 0 ? {} : { additionalProps: cloneFrozenPlainData(input.additionalProps) }
+    });
+  }
+  const format = input.format;
+  const shared = {
+    kind: "vector-context",
+    store: input.store,
+    topK: input.topK,
+    ...input.minScore === void 0 ? {} : { minScore: input.minScore },
+    ...input.filter === void 0 ? {} : { filter: cloneFrozenPlainData(input.filter) },
+    ...input.retries === void 0 ? {} : { retries: cloneFrozenPlainData(input.retries) },
+    ...format === void 0 ? {} : { format: (result) => format.call(input, result) }
+  };
+  return Object.freeze(
+    "models" in input && input.models !== void 0 ? {
+      ...shared,
+      store: input.store,
+      models: input.models,
+      ...input.fusion === void 0 ? {} : { fusion: input.fusion }
+    } : { ...shared, store: input.store, model: input.model }
+  );
+}
+function snapshotProviderTool(tool) {
+  return Object.freeze({
+    ...tool,
+    ...tool.configuration === void 0 ? {} : { configuration: cloneFrozenPlainData(tool.configuration) }
+  });
+}
+function snapshotMcpServer(server) {
+  if (server.name.trim() === "") {
+    throw new TypeError("MCP server name must not be empty.");
+  }
+  for (const tool of server.tools) {
+    if (!isMcpTool(tool)) {
+      throw new TypeError(`MCP server "${server.name}" contains an invalid MCP tool.`);
+    }
+    if (tool.mcp.serverName !== server.name) {
+      throw new TypeError(
+        `MCP tool "${tool.name}" belongs to server "${tool.mcp.serverName}", not "${server.name}".`
+      );
+    }
+  }
+  const tools = server.tools.map(snapshotMcpTool);
+  return Object.freeze({
+    name: server.name,
+    tools: Object.freeze(tools),
+    ...server.serverInfo === void 0 ? {} : { serverInfo: cloneFrozenPlainData(server.serverInfo) },
+    ...server.capabilities === void 0 ? {} : { capabilities: cloneFrozenPlainData(server.capabilities) },
+    ...server.instructions === void 0 ? {} : { instructions: server.instructions }
+  });
+}
+function snapshotMcpTool(tool) {
+  if (Object.isFrozen(tool) && Object.isFrozen(tool.mcp)) {
+    return tool;
+  }
+  const parseInput = tool.parseInput;
+  return Object.freeze({
+    name: tool.name,
+    mcp: Object.freeze({ ...tool.mcp }),
+    ...tool.requiresApproval === void 0 ? {} : { requiresApproval: tool.requiresApproval },
+    definition: (prompt) => tool.definition(prompt),
+    call: (args, context) => tool.call(args, context),
+    ...parseInput === void 0 ? {} : { parseInput: (args) => parseInput.call(tool, args) }
+  });
+}
+function assertUniqueMcpServerNames(servers) {
+  const names = /* @__PURE__ */ new Set();
+  for (const server of servers) {
+    if (names.has(server.name)) {
+      throw new TypeError(`Duplicate MCP server name "${server.name}".`);
+    }
+    names.add(server.name);
+  }
+}
+function snapshotToolIndex(index) {
+  const inspect = index.inspect;
+  return Object.freeze({
+    kind: "tool-index",
+    tools: Object.freeze([...index.tools]),
+    topK: index.topK,
+    ...index.minScore === void 0 ? {} : { minScore: index.minScore },
+    ...index.filter === void 0 ? {} : { filter: cloneFrozenPlainData(index.filter) },
+    search: (options) => index.search(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 snapshotAgentMemory(memory) {
+  if (memory === void 0) {
+    return void 0;
+  }
+  const compaction = memory.compaction === void 0 ? void 0 : Object.freeze({
+    ...memory.compaction,
+    trigger: Object.freeze({ ...memory.compaction.trigger }),
+    retention: Object.freeze({ ...memory.compaction.retention }),
+    conflictRetries: memory.compaction.conflictRetries === false ? false : Object.freeze({ ...memory.compaction.conflictRetries })
+  });
+  return Object.freeze({
+    store: memory.store,
+    savePolicy: memory.savePolicy,
+    ...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);
+}
+
+export {
+  MaxTurnsError,
+  AgentRunCancelledError,
+  AgentRunBlockedError,
+  getAgentToolState,
+  createHook,
+  getAgentApprovalRequestDetails,
+  createVectorContext,
+  isVectorContext,
+  withInternalAgentRunOptions,
+  Agent,
+  createResolvedAgent,
+  getResolvedAgentOptions,
+  cancelAgentApproval
+};
+//# sourceMappingURL=chunk-DBSCKTUL.js.map