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

package/dist/{chunk-IL3ZSNJI.js → chunk-DBSCKTUL.js}

@@ -2,58 +2,65 @@ import {
   isSkillTool
 } from "./chunk-YK4WAAS4.js";
 import {
-  assertFiniteSearchThreshold,
-  assertPositiveSearchLimit,
+  isMcpTool
+} from "./chunk-EINTGEGY.js";
+import {
   isToolIndex
-} from "./chunk-6WGGTJE6.js";
+} from "./chunk-D37WMSP6.js";
 import {
   ToolNotFoundError,
+  assertFiniteMinScore,
+  assertPositiveSearchLimit,
   assertToolApprovalRequirement,
   createTool,
   parseToolArgs,
   prepareToolCall,
+  retrieveDocuments,
   toolMayRequireApproval,
   toolResultContentToText
-} from "./chunk-R2LJSQUW.js";
+} from "./chunk-77AIYARB.js";
 import {
   MemoryCompactionConflictError,
   MemoryCompactionError,
+  assertPositiveInteger,
   createMemoryCompactionSummary,
-  cumulativeCompactedMessageCount,
-  resolveMemoryOptions
-} from "./chunk-5XKDW36Z.js";
+  cumulativeCompactedMessageCount
+} from "./chunk-OJH6HWHX.js";
 import {
-  mapWithConcurrency
-} from "./chunk-DZ3CKYTH.js";
+  startAgentRunObservers
+} from "./chunk-CWM7B2OO.js";
 import {
-  createCompletionRequest,
-  isStreamingCompletionModel
-} from "./chunk-M3IOWB4Y.js";
-import {
-  toProviderJsonSchema
-} from "./chunk-RFDVKCIE.js";
+  mapWithConcurrency
+} from "./chunk-FMHLROPQ.js";
 import {
-  AssistantContent,
-  Message,
-  ToolContent,
   Usage,
   assertCompletionRequestSupported,
+  createCompletionRequest,
   getAssistantGenerationMetadata,
   isProviderTool,
+  isStreamingCompletionModel,
   textFromAssistantContent
-} from "./chunk-ADH7NNCS.js";
+} from "./chunk-KR3RCCHJ.js";
 import {
-  resolveRetryOptions,
-  retryDelayMs,
-  retryErrorAttributes,
-  waitForRetry
-} from "./chunk-A3UBYTJT.js";
+  parseMessage,
+  parseMessages,
+  toProviderJsonSchema
+} from "./chunk-TIZYTPJO.js";
 import {
   appendGuardrailPolicies,
   hasEnforcedOutputGuardrails,
   runInputGuardrails,
   runOutputGuardrails
-} from "./chunk-FNQB2JEH.js";
+} 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 {
@@ -69,8 +76,8 @@ var MaxTurnsError = class extends Error {
   prompt;
 };
 var AgentRunCancelledError = class extends Error {
-  constructor(chatHistory, reason) {
-    super(`Agent run cancelled: ${reason}`);
+  constructor(chatHistory, reason, options) {
+    super(`Agent run cancelled: ${reason}`, options);
     this.chatHistory = chatHistory;
     this.reason = reason;
     this.name = "AgentRunCancelledError";
@@ -78,6 +85,14 @@ var AgentRunCancelledError = class extends Error {
   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();
@@ -152,27 +167,24 @@ function getAgentApprovalRequestDetails(approval) {
   return approvalDetails.get(approval);
 }
 
-// src/agent/context-index.ts
-function createContextIndex(index, options) {
+// src/agent/vector-context.ts
+function createVectorContext(options) {
   const topK = assertPositiveSearchLimit(options.topK);
-  const threshold = assertFiniteSearchThreshold(options.threshold);
+  const minScore = assertFiniteMinScore(options.minScore);
   return Object.freeze({
     ...options,
     topK,
-    ...threshold === void 0 ? {} : { threshold },
-    kind: "context-index",
-    index
+    ...minScore === void 0 ? {} : { minScore },
+    kind: "vector-context"
   });
 }
-function isContextIndex(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
+function isVectorContext(value) {
+  if (typeof value !== "object" || value === null) return false;
   const candidate = value;
-  if (candidate.kind !== "context-index" || typeof candidate.index !== "object") {
+  if (candidate.kind !== "vector-context" || typeof candidate.store?.search !== "function") {
     return false;
   }
-  return candidate.index !== null && typeof candidate.index.search === "function";
+  return candidate.model !== void 0 || candidate.models?.dense !== void 0 && candidate.models.sparse !== void 0;
 }
 
 // src/internal/agent-runtime/run-options.ts
@@ -253,280 +265,6 @@ function cloneLifecycleFallback(value, seen) {
   return clone;
 }
 
-// src/observability/snapshot.ts
-function observerSnapshot(value) {
-  if (containsError(value, /* @__PURE__ */ new WeakSet())) {
-    return cloneObserverFallback(value, /* @__PURE__ */ new WeakMap());
-  }
-  try {
-    return globalThis.structuredClone(value);
-  } catch {
-    return cloneObserverFallback(value, /* @__PURE__ */ new WeakMap());
-  }
-}
-function cloneObserverFallback(value, seen) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const existing = seen.get(value);
-  if (existing !== void 0) {
-    return existing;
-  }
-  if (Array.isArray(value)) {
-    const clone2 = [];
-    seen.set(value, clone2);
-    clone2.push(...value.map((item) => cloneObserverFallback(item, seen)));
-    return clone2;
-  }
-  if (value instanceof Date) {
-    return new Date(value.getTime());
-  }
-  if (value instanceof Error) {
-    const clone2 = Object.create(Object.getPrototypeOf(value));
-    seen.set(value, clone2);
-    Object.defineProperties(clone2, {
-      name: { configurable: true, writable: true, value: value.name },
-      message: { configurable: true, writable: true, value: value.message }
-    });
-    if (value.stack !== void 0) {
-      Object.defineProperty(clone2, "stack", {
-        configurable: true,
-        writable: true,
-        value: value.stack
-      });
-    }
-    if (value.cause !== void 0) {
-      Object.defineProperty(clone2, "cause", {
-        configurable: true,
-        writable: true,
-        value: cloneObserverFallback(value.cause, seen)
-      });
-    }
-    for (const key of Object.getOwnPropertyNames(value)) {
-      if (key === "name" || key === "message" || key === "stack" || key === "cause") continue;
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (descriptor === void 0) continue;
-      if ("value" in descriptor) {
-        descriptor.value = cloneObserverFallback(descriptor.value, seen);
-      }
-      Object.defineProperty(clone2, key, descriptor);
-    }
-    return clone2;
-  }
-  if (Object.getPrototypeOf(value) !== Object.prototype) {
-    return value;
-  }
-  const clone = {};
-  seen.set(value, clone);
-  for (const [key, item] of Object.entries(value)) {
-    clone[key] = cloneObserverFallback(item, seen);
-  }
-  return clone;
-}
-function containsError(value, seen) {
-  if (typeof value !== "object" || value === null) return false;
-  if (value instanceof Error) return true;
-  if (seen.has(value)) return false;
-  seen.add(value);
-  if (Array.isArray(value)) {
-    return value.some((item) => containsError(item, seen));
-  }
-  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
-  return Object.values(value).some((item) => containsError(item, seen));
-}
-
-// src/observability/group.ts
-async function startAgentRunObservers(registrations, args, failOnObserverError) {
-  const runObservers = [];
-  for (const registration of registrations) {
-    try {
-      const runObserver = await registration.observer.startRun(observerSnapshot(args));
-      if (runObserver !== void 0) {
-        runObservers.push(runObserver);
-      }
-    } catch (error) {
-      if (failOnObserverError || registration.failOnObserverError === true) {
-        throw error;
-      }
-    }
-  }
-  return new ActiveAgentRunObservers(runObservers, failOnObserverError);
-}
-var ActiveAgentRunObservers = class {
-  constructor(runObservers, failOnObserverError) {
-    this.runObservers = runObservers;
-    this.failOnObserverError = failOnObserverError;
-    this.trace = runObservers.find((observer) => observer.trace !== void 0)?.trace;
-  }
-  runObservers;
-  failOnObserverError;
-  trace;
-  async startGeneration(args) {
-    const generationObservers = [];
-    for (const runObserver of this.runObservers) {
-      if (runObserver.startGeneration === void 0) {
-        continue;
-      }
-      try {
-        const generationObserver = await runObserver.startGeneration(observerSnapshot(args));
-        if (generationObserver !== void 0) {
-          generationObservers.push(generationObserver);
-        }
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-    return new ActiveGenerationObservers(generationObservers, this.failOnObserverError);
-  }
-  async startTool(args) {
-    const toolObservers = [];
-    for (const runObserver of this.runObservers) {
-      if (runObserver.startTool === void 0) {
-        continue;
-      }
-      try {
-        const toolObserver = await runObserver.startTool(observerSnapshot(args));
-        if (toolObserver !== void 0) {
-          toolObservers.push(toolObserver);
-        }
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-    return new ActiveToolObservers(toolObservers, this.failOnObserverError);
-  }
-  async end(args) {
-    for (const runObserver of this.runObservers) {
-      try {
-        await runObserver.end(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async error(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.error === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.error(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async event(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.event === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.event(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
-  }
-};
-var ActiveGenerationObservers = class {
-  constructor(generationObservers, failOnObserverError) {
-    this.generationObservers = generationObservers;
-    this.failOnObserverError = failOnObserverError;
-  }
-  generationObservers;
-  failOnObserverError;
-  async end(args) {
-    for (const observer of this.generationObservers) {
-      try {
-        await observer.end(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async error(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.error === void 0) {
-        continue;
-      }
-      try {
-        await observer.error(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async update(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.update === void 0) {
-        continue;
-      }
-      try {
-        await observer.update(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
-  }
-};
-var ActiveToolObservers = class {
-  constructor(toolObservers, failOnObserverError) {
-    this.toolObservers = toolObservers;
-    this.failOnObserverError = failOnObserverError;
-  }
-  toolObservers;
-  failOnObserverError;
-  async streamEvent(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.streamEvent === void 0) {
-        continue;
-      }
-      try {
-        await observer.streamEvent(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async end(args) {
-    for (const observer of this.toolObservers) {
-      try {
-        await observer.end(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  async error(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.error === void 0) {
-        continue;
-      }
-      try {
-        await observer.error(observerSnapshot(args));
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
-  }
-};
-
 // src/internal/async-queue.ts
 function createAsyncQueue() {
   const values = [];
@@ -598,39 +336,56 @@ function createAsyncQueue() {
 // 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) => item.content.flatMap((part) => part.type === "text" ? [part.text] : [])).join("\n");
+    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, memoryContext, initialHistory) {
+  constructor(agent, memoryScope, initialHistory) {
     this.agent = agent;
-    this.memoryContext = memoryContext;
+    this.memoryScope = memoryScope;
     this.initialHistory = initialHistory;
   }
   agent;
-  memoryContext;
+  memoryScope;
   initialHistory;
   memoryPolicy() {
-    return this.memory()?.options.savePolicy;
+    return this.memory()?.savePolicy;
   }
   pendingTurnMessages(newMessages) {
     return this.memoryPolicy() === "turn" ? [...newMessages] : [];
   }
-  async prepareHistory(runId, incomingMessageCount) {
+  async prepareHistory(runId, incomingMessageCount, abortSignal) {
     const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
+    if (memory === void 0 || this.memoryScope === void 0) {
       return {
         history: this.initialHistory,
         usage: Usage.empty()
       };
     }
-    const preparation = await this.prepareStoredHistory(memory, runId, incomingMessageCount);
+    const preparation = await this.prepareStoredHistory(
+      memory,
+      runId,
+      incomingMessageCount,
+      abortSignal
+    );
     const memoryHistory = preparation.history;
     const chatHistory = [...memoryHistory, ...this.initialHistory];
     return {
@@ -640,11 +395,11 @@ var AgentRunMemory = class {
   }
   async commitAcceptedInput(runId, messages) {
     const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "message" || messages.length === 0) {
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "message" || messages.length === 0) {
       return;
     }
     await memory.store.append({
-      context: this.memoryContext,
+      scope: this.memoryScope,
       runId,
       turn: 1,
       messages
@@ -652,27 +407,27 @@ var AgentRunMemory = class {
   }
   async commitMessages(runId, turn, messages, pendingTurnMessages) {
     const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
+    if (memory === void 0 || this.memoryScope === void 0 || messages.length === 0) {
       return;
     }
-    if (memory.options.savePolicy === "message") {
+    if (memory.savePolicy === "message") {
       await memory.store.append({
-        context: this.memoryContext,
+        scope: this.memoryScope,
         runId,
         turn,
         messages
       });
-    } else if (memory.options.savePolicy === "turn") {
+    } else if (memory.savePolicy === "turn") {
       pendingTurnMessages.push(...messages);
     }
   }
   async commitCompletedTurn(runId, turn, pendingTurnMessages) {
     const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
       return;
     }
     await memory.store.append({
-      context: this.memoryContext,
+      scope: this.memoryScope,
       runId,
       turn,
       messages: [...pendingTurnMessages]
@@ -682,11 +437,11 @@ var AgentRunMemory = class {
   async commitCompletedRun(runId, turn, newMessages, pendingTurnMessages) {
     await this.commitCompletedTurn(runId, turn, pendingTurnMessages);
     const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "run") {
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "run") {
       return;
     }
     await memory.store.append({
-      context: this.memoryContext,
+      scope: this.memoryScope,
       runId,
       turn,
       messages: [...newMessages]
@@ -694,41 +449,43 @@ var AgentRunMemory = class {
   }
   async recordError(runId, error, newMessages) {
     const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
+    if (memory === void 0 || this.memoryScope === void 0) {
       return;
     }
     await memory.store.recordError?.({
-      context: this.memoryContext,
+      scope: this.memoryScope,
       runId,
       error,
       messages: [...newMessages]
     });
   }
   memory() {
-    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
+    return this.memoryScope === void 0 ? void 0 : this.agent.memory;
   }
-  async prepareStoredHistory(memory, runId, incomingMessageCount) {
-    const context = this.memoryContext;
-    if (context === void 0) {
+  async prepareStoredHistory(memory, runId, incomingMessageCount, abortSignal) {
+    const scope = this.memoryScope;
+    if (scope === void 0) {
       return { history: [], usage: Usage.empty() };
     }
-    const options = memory.options.compaction;
+    const options = memory.compaction;
     const capability = memory.store.compaction;
     if (options === void 0 || capability === void 0) {
       return {
-        history: await memory.store.load(context),
+        history: await memory.store.load({ scope }),
         usage: Usage.empty()
       };
     }
     let usage = Usage.empty();
-    let conflictRetries = 0;
-    for (let attempt = 0; attempt <= options.conflictRetries; attempt += 1) {
-      const snapshot = await capability.load(context);
+    const 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.maxMessages,
-        options.keepRecentUserTurns
+        options.trigger.afterMessages,
+        options.retention.recentUserTurns
       );
       if (compactedMessageCount === 0) {
         return { history: snapshot.messages, usage };
@@ -737,8 +494,9 @@ var AgentRunMemory = class {
       let result;
       try {
         result = await options.compactor({
-          context,
-          messages: prefix
+          scope,
+          messages: prefix,
+          abortSignal
         });
       } catch (error) {
         throw remappedCompactorError(error, usage);
@@ -756,22 +514,23 @@ var AgentRunMemory = class {
         summaryText,
         cumulativeCompactedMessageCount(prefix)
       );
-      let commit;
+      throwIfAborted(abortSignal);
+      let replacement;
       try {
-        commit = await capability.commit({
-          context,
+        replacement = await capability.replacePrefix({
+          scope,
           revision: snapshot.revision,
-          compactedMessageCount,
-          summary,
-          runId: `memory-compaction:${runId}:${attempt + 1}`
+          messageCount: compactedMessageCount,
+          replacement: summary,
+          runId: `memory-compaction:${runId}:${attempt}`
         });
       } catch (error) {
-        throw new MemoryCompactionError("Memory compaction store commit failed.", {
+        throw new MemoryCompactionError("Memory compaction prefix replacement failed.", {
           cause: error,
           usage
         });
       }
-      if (commit === "committed") {
+      if (replacement.status === "committed") {
         const retained = snapshot.messages.slice(compactedMessageCount);
         return {
           history: [summary, ...retained],
@@ -780,26 +539,27 @@ var AgentRunMemory = class {
             originalMessageCount: snapshot.messages.length,
             compactedMessageCount,
             retainedMessageCount: retained.length,
-            conflictRetries
+            attempts: attempt,
+            usage
           }
         };
       }
-      conflictRetries += 1;
+      throwIfAborted(abortSignal);
     }
-    throw new MemoryCompactionConflictError(options.conflictRetries + 1, usage);
+    throw new MemoryCompactionConflictError(maxAttempts, usage);
   }
 };
-function compactedPrefixLength(messages, incomingMessageCount, maxMessages, keepRecentUserTurns) {
-  if (messages.length + incomingMessageCount <= maxMessages) {
+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 <= keepRecentUserTurns) {
+  if (userMessageIndexes.length <= recentUserTurns) {
     return 0;
   }
-  return userMessageIndexes[userMessageIndexes.length - keepRecentUserTurns] ?? 0;
+  return userMessageIndexes[userMessageIndexes.length - recentUserTurns] ?? 0;
 }
 function remappedCompactorError(error, usage) {
   if (error instanceof MemoryCompactionError) {
@@ -822,42 +582,46 @@ function isEmptyUsage(usage) {
 }
 
 // src/internal/agent-runtime/retrieval.ts
-async function fetchContextDocuments(agent, ragText) {
+async function fetchContextDocuments(agent, ragText, abortSignal) {
   const documents = [];
   for (const input of agent.context) {
-    if (!isContextIndex(input)) {
+    if (!isVectorContext(input)) {
       documents.push(input);
       continue;
     }
-    if (ragText === void 0 || ragText.length === 0) {
-      continue;
-    }
-    const results = await input.index.search({
+    if (ragText === void 0 || ragText.length === 0) continue;
+    const request = {
       query: ragText,
       topK: input.topK,
-      threshold: input.threshold,
-      filter: input.filter
-    });
+      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);
-      } else {
-        const metadata = formatMetadata(result.metadata);
-        const document = {
-          id: result.id,
-          text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2)
-        };
-        if (metadata !== void 0) {
-          document.additionalProps = metadata;
-        }
-        documents.push(document);
+        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) {
+async function fetchToolDefinitions(agent, ragText, abortSignal) {
   const state = getAgentToolState(agent);
   const staticDefinitions = await Promise.all(
     state.staticTools.map((tool) => tool.definition(ragText ?? ""))
@@ -868,21 +632,12 @@ async function fetchToolDefinitions(agent, ragText) {
   const definitions = [...staticDefinitions];
   const names = new Set(staticDefinitions.map((definition) => definition.name));
   for (const index of state.toolIndexes) {
-    const results = await index.search({
-      query: ragText,
-      topK: index.topK,
-      threshold: index.threshold,
-      filter: index.filter
-    });
+    const results = await index.search({ query: ragText, abortSignal });
     for (const result of results) {
       const toolName = result.document.toolName;
-      if (names.has(toolName)) {
-        continue;
-      }
+      if (names.has(toolName)) continue;
       const tool = index.tools.find((candidate) => candidate.name === toolName);
-      if (tool === void 0) {
-        continue;
-      }
+      if (tool === void 0) continue;
       names.add(toolName);
       definitions.push(await tool.definition(ragText));
     }
@@ -890,9 +645,7 @@ async function fetchToolDefinitions(agent, ragText) {
   return definitions;
 }
 function formatMetadata(metadata) {
-  if (metadata === void 0) {
-    return void 0;
-  }
+  if (metadata === void 0) return void 0;
   return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
 }
 
@@ -1022,13 +775,13 @@ var CompletionStreamAccumulator = class {
     return response;
   }
   upsertToolCall(toolCall) {
-    if (!this.toolCalls.has(toolCall.id)) {
-      this.orderedParts.push({ type: "tool_call", key: toolCall.id });
+    if (!this.toolCalls.has(toolCall.toolCallId)) {
+      this.orderedParts.push({ type: "tool_call", key: toolCall.toolCallId });
     }
     const partial = {
-      id: toolCall.id,
-      name: toolCall.function.name,
-      argumentsText: JSON.stringify(toolCall.function.arguments ?? {})
+      id: toolCall.toolCallId,
+      name: toolCall.toolName,
+      argumentsText: JSON.stringify(toolCall.input ?? {})
     };
     if (toolCall.callId !== void 0) {
       partial.callId = toolCall.callId;
@@ -1036,10 +789,7 @@ var CompletionStreamAccumulator = class {
     if (toolCall.signature !== void 0) {
       partial.signature = toolCall.signature;
     }
-    if (toolCall.additionalParams !== void 0) {
-      partial.additionalParams = toolCall.additionalParams;
-    }
-    this.toolCalls.set(toolCall.id, partial);
+    this.toolCalls.set(toolCall.toolCallId, partial);
   }
   mergeFinalResponse(accumulatedResponse, finalResponse) {
     if (finalResponse.choice.length === 0) {
@@ -1056,20 +806,20 @@ var CompletionStreamAccumulator = class {
     const finalById = /* @__PURE__ */ new Map();
     const finalByCallId = /* @__PURE__ */ new Map();
     for (const content of finalResponse.choice) {
-      if (content.type !== "tool_call") {
+      if (content.type !== "tool-call") {
         continue;
       }
-      finalById.set(content.id, content);
+      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") {
+      if (content.type !== "tool-call") {
         return content;
       }
-      const finalToolCall = finalById.get(content.id) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
+      const finalToolCall = finalById.get(content.toolCallId) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
       if (finalToolCall === void 0) {
         return content;
       }
@@ -1077,7 +827,7 @@ var CompletionStreamAccumulator = class {
       return mergeFinalToolCall(content, finalToolCall);
     });
     for (const content of finalResponse.choice) {
-      if (content.type !== "tool_call") {
+      if (content.type !== "tool-call") {
         continue;
       }
       if (!matchedFinalToolCalls.has(content)) {
@@ -1172,16 +922,17 @@ var CompletionStreamAccumulator = class {
     if (event.contentType === void 0 && event.signature === void 0) {
       return;
     }
-    reasoning.content ??= [];
-    const last = reasoning.content.at(-1);
+    reasoning.details ??= [];
+    const last = reasoning.details.at(-1);
     if (contentType === "text") {
       if (last?.type === "text") {
-        last.text += event.delta;
-        if (event.signature !== void 0) {
-          last.signature = event.signature;
-        }
+        reasoning.details[reasoning.details.length - 1] = {
+          ...last,
+          text: `${last.text}${event.delta}`,
+          ...event.signature === void 0 ? {} : { signature: event.signature }
+        };
       } else {
-        reasoning.content.push(
+        reasoning.details.push(
           event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
         );
       }
@@ -1189,17 +940,20 @@ var CompletionStreamAccumulator = class {
     }
     if (contentType === "summary") {
       if (last?.type === "summary") {
-        last.text += event.delta;
+        reasoning.details[reasoning.details.length - 1] = {
+          ...last,
+          text: `${last.text}${event.delta}`
+        };
       } else {
-        reasoning.content.push({ type: "summary", text: event.delta });
+        reasoning.details.push({ type: "summary", text: event.delta });
       }
       return;
     }
     if (contentType === "encrypted") {
-      reasoning.content.push({ type: "encrypted", data: event.delta });
+      reasoning.details.push({ type: "encrypted", data: event.delta });
       return;
     }
-    reasoning.content.push({ type: "redacted", data: event.delta });
+    reasoning.details.push({ type: "redacted", data: event.delta });
   }
 };
 function sourceKey(source) {
@@ -1220,51 +974,37 @@ function mergeProviderToolCalls(accumulated, final) {
   return [...toolCalls.values()];
 }
 function reasoningContent(reasoning) {
-  const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
+  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.function.arguments) ? finalToolCall.function.arguments : parseToolArguments(toolCall.id, toolCall.argumentsText);
-  const content = {
-    type: "tool_call",
-    id: toolCall.id,
-    function: {
-      name: toolCall.name,
-      arguments: argumentsValue
-    }
+  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 }
   };
-  if (toolCall.callId !== void 0) {
-    content.callId = toolCall.callId;
-  }
-  if (toolCall.signature !== void 0) {
-    content.signature = toolCall.signature;
-  }
-  if (toolCall.additionalParams !== void 0) {
-    content.additionalParams = toolCall.additionalParams;
-  }
-  return content;
 }
 function matchingFinalToolCall(accumulated, finalChoice) {
   const byId = finalChoice?.find(
-    (content) => content.type === "tool_call" && content.id === accumulated.id
+    (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
+    (content) => content.type === "tool-call" && content.callId === accumulated.callId
   );
 }
 function mergeFinalToolCall(accumulated, finalToolCall) {
-  const argumentsValue = isEmptyToolArguments(finalToolCall.function.arguments) ? accumulated.function.arguments : finalToolCall.function.arguments;
+  const input = isEmptyToolArguments(finalToolCall.input) ? accumulated.input : finalToolCall.input;
   return {
     ...accumulated,
     ...finalToolCall,
-    function: {
-      ...accumulated.function,
-      ...finalToolCall.function,
-      arguments: argumentsValue
-    }
+    input
   };
 }
 function reasoningDeltaEvent(event) {
@@ -1340,9 +1080,8 @@ function isGenerationDeltaEvent(type) {
 }
 
 // src/internal/agent-runtime/tool-execution.ts
-var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
 var ToolCallExecutor = class {
-  constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, includeToolCallDeltas, cancel) {
+  constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, abortSignal, cancel) {
     this.agent = agent;
     this.activeHook = activeHook;
     this.approvalHandler = approvalHandler;
@@ -1350,7 +1089,7 @@ var ToolCallExecutor = class {
     this.runContext = runContext;
     this.concurrency = concurrency;
     this.requestMiddlewares = requestMiddlewares;
-    this.includeToolCallDeltas = includeToolCallDeltas;
+    this.abortSignal = abortSignal;
     this.cancel = cancel;
   }
   agent;
@@ -1360,36 +1099,37 @@ var ToolCallExecutor = class {
   runContext;
   concurrency;
   requestMiddlewares;
-  includeToolCallDeltas;
+  abortSignal;
   cancel;
   async execute(toolCalls, onResult, onStreamEvent, observation) {
     for (const toolCall of toolCalls) {
-      if (toolCall.function.name.length === 0) {
+      if (toolCall.toolName.length === 0) {
         throw new Error(
-          `Completion returned tool call "${toolCall.id}" with an empty function name; this indicates invalid provider output or provider mapping.`
+          `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) => {
-      const args = JSON.stringify(toolCall.function.arguments ?? {});
+      throwIfAborted(this.abortSignal);
+      const args = JSON.stringify(toolCall.input);
       const internalCallId = globalThis.crypto.randomUUID();
       const hookArgs = {
-        toolName: toolCall.function.name,
+        toolName: toolCall.toolName,
         internalCallId,
         args
       };
       if (toolCall.callId !== void 0) {
         hookArgs.toolCallId = toolCall.callId;
       }
-      const tool = this.agent.getTool(toolCall.function.name);
+      const tool = this.agent.getTool(toolCall.toolName);
       const toolDefinition = observation?.toolDefinitions?.find(
-        (definition) => definition.name === toolCall.function.name
+        (definition) => definition.name === toolCall.toolName
       );
       const toolMetadata = toolTraceMetadata(tool);
       const toolStartArgs = {
         turn: observation?.turn ?? 0,
         toolCall,
-        toolName: toolCall.function.name,
+        toolName: toolCall.toolName,
         internalCallId,
         args,
         ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
@@ -1411,7 +1151,7 @@ var ToolCallExecutor = class {
           throw this.cancel(callAction.reason);
         }
         if (callAction?.type === "skip") {
-          output = callAction.reason;
+          output = { type: "text", value: callAction.reason };
           skipped = true;
         } else {
           try {
@@ -1423,7 +1163,7 @@ var ToolCallExecutor = class {
             hookArgs.args = effectiveArgs;
             let prepared;
             try {
-              prepared = this.prepareToolCall(tool, toolCall.function.name, effectiveArgs);
+              prepared = this.prepareToolCall(tool, toolCall.toolName, effectiveArgs);
             } catch (error) {
               const outcome = await this.handleToolError(
                 toolCall,
@@ -1447,14 +1187,14 @@ var ToolCallExecutor = class {
                 approved: true
               };
               if (!approvalDecision.approved) {
-                output = approvalDecision.result;
+                output = { type: "execution-denied", reason: approvalDecision.result };
                 skipped = true;
               } else {
                 const step = observation?.turn ?? 0;
                 const lifecycleEvent = {
                   runId: this.runContext.runId,
                   step,
-                  toolName: toolCall.function.name,
+                  toolName: toolCall.toolName,
                   input: lifecycleSnapshot(prepared.input),
                   ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
                 };
@@ -1495,7 +1235,7 @@ var ToolCallExecutor = class {
           }
         }
         if (output === void 0) {
-          throw new Error(`Tool "${toolCall.function.name}" did not produce an execution result.`);
+          throw new Error(`Tool "${toolCall.toolName}" did not produce an execution result.`);
         }
         let result = toolOutputToText(output);
         let structuredResult = toolOutputToStructuredResult(output);
@@ -1526,7 +1266,7 @@ var ToolCallExecutor = class {
           await toolObservation.end({
             turn: observation?.turn ?? 0,
             toolCall,
-            toolName: toolCall.function.name,
+            toolName: toolCall.toolName,
             internalCallId,
             args: effectiveArgs,
             result,
@@ -1540,20 +1280,23 @@ var ToolCallExecutor = class {
         }
         const resultPayload = {
           type: "tool_result",
-          toolName: toolCall.function.name,
+          toolName: toolCall.toolName,
+          toolCallId: toolCall.toolCallId,
           internalCallId,
           args: effectiveArgs,
+          output,
           result,
-          structuredResult
+          structuredResult,
+          ...toolCall.callId === void 0 ? {} : { callId: toolCall.callId }
         };
-        if (toolCall.callId !== void 0) {
-          resultPayload.toolCallId = toolCall.callId;
-        }
         onResult?.(resultPayload);
-        return ToolContent.toolResult(toolCall.id, output, {
-          callId: toolCall.callId,
-          toolName: toolCall.function.name
-        });
+        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)
@@ -1565,11 +1308,12 @@ var ToolCallExecutor = class {
   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.function.name,
+            toolName: toolCall.toolName,
             internalCallId: hookArgs.internalCallId,
             args: effectiveArgs,
             event,
@@ -1582,7 +1326,6 @@ var ToolCallExecutor = class {
           }
         }
       };
-      toolContext.includeToolCallDeltas = this.includeToolCallDeltas;
       return {
         output: await prepared.call(toolContext),
         failed: false
@@ -1622,7 +1365,10 @@ var ToolCallExecutor = class {
       throw this.cancel(errorAction.reason);
     }
     return {
-      output: error instanceof Error ? error.toString() : String(error),
+      output: {
+        type: "error-text",
+        value: error instanceof Error ? error.toString() : String(error)
+      },
       failed: true,
       error
     };
@@ -1650,7 +1396,7 @@ var ToolCallExecutor = class {
         replaced = true;
       }
     }
-    return replaced ? structuredResult ?? result : void 0;
+    return replaced ? structuredResult === void 0 ? { type: "text", value: result } : { type: "content", value: structuredResult } : void 0;
   }
   async runToolInputMiddlewares(args) {
     let current = args.args;
@@ -1766,13 +1512,12 @@ function toolTraceMetadata(tool) {
   if (tool === void 0) {
     return void 0;
   }
-  const metadata = tool[MCP_TOOL_METADATA_KEY];
-  const mcpMetadata = typeof metadata === "object" && metadata !== null ? metadata : void 0;
   const result = {
     approvalRequired: toolMayRequireApproval(tool.requiresApproval)
   };
-  if (typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0) {
-    result.mcpServerName = mcpMetadata.serverName;
+  if (isMcpTool(tool)) {
+    result.mcpServerName = tool.mcp.serverName;
+    result.mcpRemoteName = tool.mcp.remoteName;
   }
   return result;
 }
@@ -1780,7 +1525,7 @@ function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
   const observerArgs = {
     turn,
     toolCall,
-    toolName: toolCall.function.name,
+    toolName: toolCall.toolName,
     internalCallId,
     args,
     error,
@@ -1809,10 +1554,21 @@ var ToolObserverScope = class {
   }
 };
 function toolOutputToText(output) {
-  return typeof output === "string" ? output : toolResultContentToText(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 typeof output === "string" ? void 0 : output;
+  return output.type === "content" ? output.value : void 0;
 }
 function agentToolEventPayload(toolCall, internalCallId, event) {
   if (typeof event.agentId !== "string" || event.agentId.length === 0) {
@@ -1820,7 +1576,7 @@ function agentToolEventPayload(toolCall, internalCallId, event) {
   }
   const payload = {
     type: "agent_tool_event",
-    toolName: toolCall.function.name,
+    toolName: toolCall.toolName,
     internalCallId,
     agentId: event.agentId,
     event: event.event
@@ -1862,6 +1618,8 @@ var AgentRun = class _AgentRun {
     );
     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);
@@ -1871,10 +1629,12 @@ var AgentRun = class _AgentRun {
     );
     this.concurrency = this.activeHook !== void 0 || agent.tools.some((tool) => toolMayRequireApproval(tool.requiresApproval)) ? 1 : configuredConcurrency;
     this.traceOptions = options.trace;
-    this.completionRetryOptions = options.retries === void 0 ? void 0 : resolveRetryOptions(options.retries);
+    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.memoryContext = options.memoryContext;
-    this.memoryRecorder = new AgentRunMemory(agent, options.memoryContext, initialHistory);
+    this.memoryScope = options.memoryScope;
+    this.memoryRecorder = new AgentRunMemory(agent, options.memoryScope, initialHistory);
+    this.linkExternalAbortSignal(options.abortSignal);
   }
   agent;
   promptMessage;
@@ -1891,7 +1651,10 @@ var AgentRun = class _AgentRun {
   steeringMessages = [];
   runState = "idle";
   memoryRecorder;
-  memoryContext;
+  memoryScope;
+  onInternalFailure;
+  onInternalMemoryCompaction;
+  memoryCompaction;
   pendingApproval;
   approvalSignal = deferredSignal();
   activeRunId;
@@ -1900,9 +1663,17 @@ var AgentRun = class _AgentRun {
   currentMessages = [];
   cancellationError;
   activeGeneration;
-  static fromAgent(agent, input, options = {}) {
-    const normalized = normalizeAgentInput(input);
-    return new _AgentRun(agent, normalized.prompt, normalized.history, options);
+  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) {
@@ -1937,7 +1708,11 @@ var AgentRun = class _AgentRun {
     }
     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;
@@ -1955,11 +1730,19 @@ var AgentRun = class _AgentRun {
     let newMessages = [this.promptMessage];
     let runObservers;
     try {
-      const memoryPreparation = await this.memoryRecorder.prepareHistory(runId, newMessages.length);
+      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),
@@ -1977,19 +1760,22 @@ var AgentRun = class _AgentRun {
       }
       this.promptMessage = inputResult.prompt;
       if (inputResult.blocked) {
-        const output = inputResult.message ?? "The request was blocked by a guardrail.";
+        const text = inputResult.message ?? "The request was blocked by a guardrail.";
         const result = {
-          status: "completed",
+          status: "blocked",
+          stage: "input",
           runId,
-          output,
+          text,
           usage,
-          messages: [this.promptMessage, Message.assistant(output)],
+          messages: [this.promptMessage, { role: "assistant", content: text }],
           trace: runObservers.trace,
-          guardrails: [...this.guardrailDecisions]
+          guardrails: [...this.guardrailDecisions],
+          ...this.memoryCompactionResult()
         };
         await this.runLifecycleFinish(result);
         await runObservers.end(result);
         this.runState = "completed";
+        this.disposeAbortLink();
         return result;
       }
       newMessages = [this.promptMessage];
@@ -2028,7 +1814,7 @@ var AgentRun = class _AgentRun {
           usage: lifecycleSnapshot(usage)
         });
         const toolCalls = response.choice.filter(
-          (item) => item.type === "tool_call"
+          (item) => item.type === "tool-call"
         );
         const assistantMessage = this.generatedAssistantMessage(response, request);
         newMessages.push(assistantMessage);
@@ -2061,17 +1847,17 @@ var AgentRun = class _AgentRun {
             [finalAssistantMessage],
             pendingTurnMessages
           );
-          const result = {
-            status: "completed",
+          const result = this.createTerminalResult(
             runId,
-            output: guardedOutput.output,
+            guardedOutput.text,
+            guardedOutput.blocked,
             usage,
-            messages: [...newMessages],
-            trace: runObservers.trace,
-            guardrails: [...this.guardrailDecisions],
-            ...generationArtifacts(newMessages)
-          };
-          await this.runRunEndHook(result, newMessages);
+            newMessages,
+            runObservers
+          );
+          if (result.status === "completed") {
+            await this.runRunEndHook(result, newMessages);
+          }
           await this.memoryRecorder.commitCompletedRun(
             runId,
             currentTurns,
@@ -2081,6 +1867,7 @@ var AgentRun = class _AgentRun {
           await this.runLifecycleFinish(result);
           await runObservers.end(result);
           this.runState = "completed";
+          this.disposeAbortLink();
           return result;
         }
         this.updateApprovalProgress(runId, usage, newMessages);
@@ -2096,7 +1883,7 @@ var AgentRun = class _AgentRun {
             toolDefinitions: request.tools
           }
         );
-        const toolMessage = Message.tool(toolResults);
+        const toolMessage = { role: "tool", content: toolResults };
         newMessages.push(toolMessage);
         await this.memoryRecorder.commitMessages(
           runId,
@@ -2112,21 +1899,20 @@ var AgentRun = class _AgentRun {
       if (error instanceof MemoryCompactionError && error.usage !== void 0) {
         usage = Usage.add(usage, error.usage);
       }
+      const runError = this.normalizeRunError(error);
       const reportedError = await this.reportRunFailure(
-        error,
+        runError,
         runId,
         usage,
         newMessages,
         runObservers
       );
       this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
+      this.disposeAbortLink();
       throw reportedError;
     }
   }
-  async *events(includeToolCallDeltas = true) {
-    if (!this.agent.model.capabilities.streaming || !isStreamingCompletionModel(this.agent.model)) {
-      throw new Error("This completion model does not support streaming");
-    }
+  async *events() {
     this.startRun();
     const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
     this.activeRunId = runId;
@@ -2137,11 +1923,22 @@ var AgentRun = class _AgentRun {
     const bufferOutputDeltas = hasEnforcedOutputGuardrails(this.guardrailPolicies);
     let runObservers;
     try {
-      const memoryPreparation = await this.memoryRecorder.prepareHistory(runId, newMessages.length);
+      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),
@@ -2160,28 +1957,23 @@ var AgentRun = class _AgentRun {
       }
       this.promptMessage = inputResult.prompt;
       if (inputResult.blocked) {
-        const output = inputResult.message ?? "The request was blocked by a guardrail.";
+        const text = inputResult.message ?? "The request was blocked by a guardrail.";
         const result = {
-          status: "completed",
+          status: "blocked",
+          stage: "input",
           runId,
-          output,
+          text,
           usage,
-          messages: [this.promptMessage, Message.assistant(output)],
+          messages: [this.promptMessage, { role: "assistant", content: text }],
           trace: runObservers.trace,
-          guardrails: [...this.guardrailDecisions]
+          guardrails: [...this.guardrailDecisions],
+          ...this.memoryCompactionResult()
         };
         await this.runLifecycleFinish(result);
         await runObservers.end(result);
         this.runState = "completed";
-        yield {
-          type: "final",
-          runId,
-          output: result.output,
-          usage: result.usage,
-          messages: result.messages,
-          trace: result.trace,
-          guardrails: result.guardrails
-        };
+        this.disposeAbortLink();
+        yield { type: "final", result };
         return;
       }
       newMessages = [this.promptMessage];
@@ -2234,7 +2026,6 @@ var AgentRun = class _AgentRun {
             for await (const event of this.streamCompletion({
               request,
               turn: currentTurns,
-              includeToolCallDeltas,
               bufferResponseEvents,
               bufferOutputDeltas,
               generationStartedAt,
@@ -2278,7 +2069,7 @@ var AgentRun = class _AgentRun {
           usage: lifecycleSnapshot(usage)
         });
         const toolCalls = response.choice.filter(
-          (item) => item.type === "tool_call"
+          (item) => item.type === "tool-call"
         );
         const assistantMessage = this.generatedAssistantMessage(response, request);
         newMessages.push(assistantMessage);
@@ -2334,7 +2125,7 @@ var AgentRun = class _AgentRun {
           }
         } else {
           for (const toolCall of toolCalls) {
-            if (!emittedToolCallIds.has(toolCall.id)) {
+            if (!emittedToolCallIds.has(toolCall.toolCallId)) {
               yield { type: "tool_call", turn: currentTurns, toolCall };
             }
           }
@@ -2349,14 +2140,13 @@ var AgentRun = class _AgentRun {
         const toolExecution = this.executeStreamingToolCalls(runId, toolCalls, newMessages, {
           turn: currentTurns,
           runObservers,
-          toolDefinitions: request.tools,
-          includeToolCallDeltas
+          toolDefinitions: request.tools
         });
         for await (const result of toolExecution.events) {
           yield { turn: currentTurns, ...result };
         }
         const toolResults = await toolExecution.results;
-        const toolMessage = Message.tool(toolResults);
+        const toolMessage = { role: "tool", content: toolResults };
         newMessages.push(toolMessage);
         await this.memoryRecorder.commitMessages(
           runId,
@@ -2372,8 +2162,9 @@ var AgentRun = class _AgentRun {
       if (error instanceof MemoryCompactionError && error.usage !== void 0) {
         usage = Usage.add(usage, error.usage);
       }
+      const runError = this.normalizeRunError(error);
       const reportedError = await this.reportRunFailure(
-        error,
+        runError,
         runId,
         usage,
         newMessages,
@@ -2382,7 +2173,8 @@ var AgentRun = class _AgentRun {
       this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
       const finalUsage = usage;
       yield { type: "error", error: reportedError, usage: finalUsage };
-      throw reportedError;
+      this.disposeAbortLink();
+      return;
     } finally {
       if (this.runState === "running") {
         const cancellation = this.cancellationError ?? new AgentRunCancelledError([...this.chatHistory, ...newMessages], "Agent stream closed.");
@@ -2390,6 +2182,7 @@ var AgentRun = class _AgentRun {
         await settleFailureCleanup([() => this.closeActiveGeneration(cancellation)]);
         await this.reportRunFailure(cancellation, runId, usage, newMessages, runObservers);
         this.runState = "cancelled";
+        this.disposeAbortLink();
       }
     }
   }
@@ -2403,7 +2196,8 @@ var AgentRun = class _AgentRun {
       for (let attempt = 1; ; attempt += 1) {
         let response;
         try {
-          response = await this.agent.model.completion(request);
+          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) {
@@ -2429,20 +2223,20 @@ var AgentRun = class _AgentRun {
   }
   async createTurnRequest(prompt, history, turn) {
     const ragText = extractRagText(prompt);
-    const documents = await fetchContextDocuments(this.agent, ragText);
-    const toolDefinitions = await fetchToolDefinitions(this.agent, ragText);
+    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], {
-      model: this.agent.model,
       instructions: this.agent.instructions,
       documents,
       tools: [...toolDefinitions, ...getAgentToolState(this.agent).providerTools],
       temperature: this.agent.temperature,
       maxTokens: this.agent.maxTokens,
-      additionalParams: this.agent.additionalParams,
+      providerOptions: this.agent.providerOptions,
       toolChoice: this.agent.toolChoice,
-      outputSchema: this.agent.outputSchema
+      outputSchema: getAgentProviderOutputSchema(this.agent)
     });
-    return await this.runCompletionRequestMiddlewares(request, turn);
+    return this.runCompletionRequestMiddlewares(request, turn);
   }
   async *streamCompletion(args) {
     const model = this.agent.model;
@@ -2453,7 +2247,8 @@ var AgentRun = class _AgentRun {
     for (let attempt = 1; ; attempt += 1) {
       let hasProviderProgress = false;
       try {
-        for await (const event of model.streamCompletion(args.request)) {
+        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);
@@ -2465,13 +2260,13 @@ var AgentRun = class _AgentRun {
             args.state.firstDeltaMs = Date.now() - args.generationStartedAt;
           }
           const mapped = accumulator.accept(event);
-          if (args.includeToolCallDeltas && event.type === "tool_call_delta") {
+          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.id);
+              args.state.emittedToolCallIds.add(mapped.toolCall.toolCallId);
             }
             const shouldBuffer = args.bufferResponseEvents || args.bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
             if (!shouldBuffer) {
@@ -2530,17 +2325,17 @@ var AgentRun = class _AgentRun {
         firstDeltaMs: args.firstDeltaMs
       };
     }
-    const result = {
-      status: "completed",
-      runId: args.runId,
-      output: guardedOutput.output,
-      usage: args.usage,
-      messages: [...args.newMessages],
-      trace: args.runObservers.trace,
-      guardrails: [...this.guardrailDecisions],
-      ...generationArtifacts(args.newMessages)
-    };
-    await this.runRunEndHook(result, args.newMessages);
+    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,
@@ -2550,25 +2345,15 @@ var AgentRun = class _AgentRun {
     await this.runLifecycleFinish(result);
     await args.runObservers.end(result);
     this.runState = "completed";
-    yield {
-      type: "final",
-      runId: args.runId,
-      output: result.output,
-      usage: result.usage,
-      contextUsage: result.contextUsage,
-      messages: result.messages,
-      trace: result.trace,
-      guardrails: result.guardrails,
-      sources: result.sources,
-      providerToolCalls: result.providerToolCalls
-    };
+    this.disposeAbortLink();
+    yield { type: "final", result };
   }
-  generatedAssistantMessage(response, request) {
+  generatedAssistantMessage(response, _request) {
     const metadata = {
       anvia: {
         generation: {
           provider: this.agent.model.provider,
-          model: request.model ?? this.agent.model.defaultModel,
+          modelId: this.agent.model.modelId,
           usage: { ...response.usage },
           ...response.contextUsage === void 0 ? {} : { contextUsage: response.contextUsage },
           ...response.sources === void 0 ? {} : { sources: response.sources },
@@ -2576,10 +2361,12 @@ var AgentRun = class _AgentRun {
         }
       }
     };
-    return Message.assistant(response.choice, {
+    return {
+      role: "assistant",
+      content: response.choice,
       ...response.messageId === void 0 ? {} : { id: response.messageId },
       metadata
-    });
+    };
   }
   providerTraceRequest(request, options = {}) {
     try {
@@ -2596,25 +2383,20 @@ var AgentRun = class _AgentRun {
       request,
       modelInfo: {
         provider: this.agent.model.provider,
-        defaultModel: this.agent.model.defaultModel,
+        modelId: this.agent.model.modelId,
         capabilities: this.agent.model.capabilities
       },
       ...providerRequest === void 0 ? {} : { providerRequest }
     };
   }
   retryOptionsForFailure(error, attempt, turn, streaming) {
-    const options = this.completionRetryOptions;
-    if (options === void 0 || attempt >= options.maxAttempts) {
-      return void 0;
-    }
-    const shouldRetry = options.shouldRetry({
+    if (this.abortController.signal.aborted) return void 0;
+    return retryOptionsForFailure(this.completionRetryOptions, {
       error,
       attempt,
-      maxAttempts: options.maxAttempts,
       turn,
       streaming
     });
-    return shouldRetry ? options : void 0;
   }
   async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers) {
     const delayMs = retryDelayMs(options, attempt);
@@ -2631,7 +2413,7 @@ var AgentRun = class _AgentRun {
         ...retryErrorAttributes(error)
       }
     });
-    await waitForRetry(delayMs);
+    await waitForRetry(delayMs, this.abortController.signal);
   }
   async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
     const executor = new ToolCallExecutor(
@@ -2641,12 +2423,12 @@ var AgentRun = class _AgentRun {
       this.activeLifecycle,
       {
         runId,
-        sessionId: this.memoryContext?.sessionId,
-        metadata: this.memoryContext?.metadata
+        sessionId: this.memoryScope?.sessionId,
+        metadata: this.memoryScope?.metadata
       },
       this.concurrency,
       this.requestMiddlewares,
-      observation?.includeToolCallDeltas ?? false,
+      this.abortController.signal,
       (reason) => this.cancelled(newMessages, reason)
     );
     return executor.execute(toolCalls, onResult, onStreamEvent, observation);
@@ -2705,7 +2487,8 @@ var AgentRun = class _AgentRun {
       runId,
       approval,
       usage: lifecycleSnapshot(this.currentUsage),
-      messages: lifecycleSnapshot(this.currentMessages)
+      messages: lifecycleSnapshot(this.currentMessages),
+      ...this.memoryCompactionResult()
     };
   }
   updateApprovalProgress(runId, usage, messages) {
@@ -2714,12 +2497,23 @@ var AgentRun = class _AgentRun {
     this.currentMessages = [...messages];
   }
   async runLifecycleFinish(result) {
-    await this.activeLifecycle?.onFinish?.({
+    const common = {
       runId: result.runId,
-      output: result.output,
+      text: result.text,
       usage: lifecycleSnapshot(result.usage),
-      messages: lifecycleSnapshot(result.messages)
-    });
+      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 {
@@ -2737,6 +2531,10 @@ var AgentRun = class _AgentRun {
   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,
@@ -2765,19 +2563,54 @@ var AgentRun = class _AgentRun {
     for (const decision of result.decisions) {
       await this.recordGuardrailDecision(decision, runObservers);
     }
-    const output = result.blocked ? result.message ?? "The response was blocked by a guardrail." : result.outputText;
-    if (output === originalOutput) {
-      return { output, response, decisions: result.decisions };
+    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 {
-      output,
+      text,
+      blocked: result.blocked,
       response: {
         ...response,
-        choice: [AssistantContent.text(output)]
+        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({
@@ -2797,30 +2630,36 @@ var AgentRun = class _AgentRun {
         originalMessageCount: compaction.originalMessageCount,
         compactedMessageCount: compaction.compactedMessageCount,
         retainedMessageCount: compaction.retainedMessageCount,
-        conflictRetries: compaction.conflictRetries,
-        inputTokens: preparation.usage.inputTokens,
-        outputTokens: preparation.usage.outputTokens,
-        totalTokens: preparation.usage.totalTokens
+        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.memoryContext !== void 0) {
-      context.sessionId = this.memoryContext.sessionId;
-      if (this.memoryContext.metadata !== void 0) {
-        context.metadata = this.memoryContext.metadata;
+    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 failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
+    const observability = this.agent.observability;
     return startAgentRunObservers(
-      this.agent.observers,
+      observability?.observers ?? {},
       {
         runId,
         agentName: this.agent.name,
@@ -2832,7 +2671,10 @@ var AgentRun = class _AgentRun {
         history: this.chatHistory,
         maxTurns: this.maxTurnCount
       },
-      failOnObserverError
+      {
+        primaryTrace: observability?.primaryTrace,
+        errorPolicy: observability?.errorPolicy ?? "ignore"
+      }
     );
   }
   async runCompletionCallHook(prompt, history, newMessages) {
@@ -2858,7 +2700,9 @@ var AgentRun = class _AgentRun {
   }
   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
@@ -2977,33 +2821,139 @@ var AgentRun = class _AgentRun {
     return this.runState === "completed" || this.runState === "errored" || this.runState === "cancelled";
   }
   cancelled(newMessages, reason) {
-    return new AgentRunCancelledError([...this.chatHistory, ...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 normalizeAgentInput(prompt) {
-  if (typeof prompt === "string") {
-    return { prompt: Message.user(prompt), history: [] };
+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 (!Array.isArray(prompt)) {
-    return { prompt, history: [] };
+  if (input.session !== void 0) {
+    throw new TypeError("Agent messages cannot be combined with a persisted session.");
   }
-  if (prompt.length === 0) {
+  const messages = input.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
     throw new TypeError("Agent input transcript must contain at least one message.");
   }
-  const activePrompt = prompt.at(-1);
+  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: prompt.slice(0, -1)
+    history: parsedMessages.slice(0, -1)
   };
 }
 function normalizeSteeringInput(input) {
-  if (typeof input === "string") {
-    return [Message.user(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.");
   }
-  return Array.isArray(input) ? [...input] : [input];
+  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) {
@@ -3024,13 +2974,13 @@ function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
       continue;
     }
     if (item.type === "reasoning") {
-      if (item.content === void 0) {
+      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.content) {
+      for (const content of item.details) {
         const delta = content.type === "encrypted" || content.type === "redacted" ? content.data : content.text;
         events.push(
           reasoningDeltaEvent2(turn, delta, {
@@ -3042,7 +2992,7 @@ function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
       }
       continue;
     }
-    if (item.type === "tool_call") {
+    if (item.type === "tool-call") {
       events.push({ type: "tool_call", turn, toolCall: item });
     }
   }
@@ -3100,12 +3050,15 @@ 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 === "document" && content.source.type === "text") {
-      return [content.source.text];
+    if (content.type === "file" && content.data.type === "text") {
+      return [content.data.text];
     }
     return [];
   }).join("\n");
@@ -3129,6 +3082,39 @@ function guardrailDecisionAttributes(decision) {
   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") {
@@ -3143,6 +3129,7 @@ function normalizeAgentId(id) {
 
 // src/agent/agent.ts
 var DEFAULT_MAX_TURNS = 20;
+var providerOutputSchemas = /* @__PURE__ */ new WeakMap();
 var Agent = class {
   id;
   name;
@@ -3152,13 +3139,15 @@ var Agent = class {
   context;
   temperature;
   maxTokens;
-  additionalParams;
+  providerOptions;
+  retries;
+  mcpServers;
   tools;
   toolChoice;
   defaultMaxTurns;
   lifecycle;
   outputSchema;
-  observers;
+  observability;
   guardrails;
   middlewares;
   memory;
@@ -3170,26 +3159,34 @@ var Agent = class {
     this.model = resolved.model;
     this.instructions = resolved.instructions;
     const context = (resolved.context ?? []).map(snapshotContextInput);
-    assertValidContextIndexes(context);
+    assertValidVectorContexts(context);
     this.context = Object.freeze(context);
     this.temperature = resolved.temperature;
     this.maxTokens = resolved.maxTokens;
-    this.additionalParams = cloneFrozenPlainData(resolved.additionalParams);
-    const staticTools = dedupeTools(resolved.tools ?? []);
+    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);
-    assertUniqueIndexedToolNames(toolIndexes);
+    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) {
-        if (!toolsByName.has(tool.name)) {
-          toolsByName.set(tool.name, tool);
-        }
+        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((resolved.providerTools ?? []).map(snapshotProviderTool)),
+      providerTools: Object.freeze(providerTools),
       toolIndexes: Object.freeze(toolIndexes)
     });
     registerAgentToolState(this, publicToolState, toolsByName);
@@ -3199,23 +3196,24 @@ var Agent = class {
       "maxTurns"
     );
     this.lifecycle = resolved.lifecycle;
-    this.outputSchema = cloneFrozenPlainData(resolved.outputSchema);
-    this.observers = Object.freeze(
-      (resolved.observers ?? []).map((registration) => Object.freeze({ ...registration }))
-    );
+    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 = snapshotMemoryRegistration(resolved.memory);
+    this.memory = snapshotAgentMemory(resolved.memory);
   }
-  generate(input, options = {}) {
-    return createGenerateExecution(this, AgentRun.fromAgent(this, input, options)).next();
+  generate(options) {
+    return createGenerateExecution(this, AgentRun.fromAgent(this, options)).next();
   }
-  stream(input, options = {}) {
-    return createStreamExecution(
-      this,
-      AgentRun.fromAgent(this, input, options),
-      options.includeToolCallDeltas !== false
-    );
+  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);
@@ -3224,27 +3222,8 @@ var Agent = class {
       throw new TypeError("Approval continuation does not belong to this agent.");
     }
     approvalContinuations.delete(pending);
-    continuation.run.resolveApproval(decision);
-    return continuation.mode === "generate" ? continuation.execution.next() : continuation.execution.segment();
-  }
-  session(sessionId, options = {}) {
-    if (this.memory === void 0) {
-      throw new Error(`Agent "${this.id}" has no memory store configured.`);
-    }
-    const normalized = sessionId.trim();
-    if (normalized.length === 0) {
-      throw new TypeError("Session id must be a non-empty string.");
-    }
-    const context = {
-      sessionId: normalized
-    };
-    if (options.userId !== void 0) {
-      context.userId = options.userId;
-    }
-    if (options.metadata !== void 0) {
-      context.metadata = cloneFrozenPlainData(options.metadata);
-    }
-    return new AgentSession(this, context);
+    continuation.resolve(decision);
+    return continuation.mode === "generate" ? continuation.resume() : continuation.resume();
   }
   asTool(options) {
     const description = options.description ?? this.description ?? `Prompt the ${options.name} agent.`;
@@ -3254,13 +3233,14 @@ var Agent = class {
       inputSchema: z.object({
         prompt: z.string().describe("The prompt to send to the agent.")
       }),
-      outputSchema: z.string(),
       execute: async ({ prompt }, context) => {
         if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
-          let output = "";
-          const childStream = this.stream(prompt, {
+          let completed = false;
+          let output;
+          const childStream = this.stream({
+            prompt,
             maxTurns: options.maxTurns,
-            includeToolCallDeltas: context.includeToolCallDeltas !== false
+            abortSignal: context.abortSignal
           });
           for await (const event of childStream) {
             if (event.type === "approval_required") {
@@ -3280,13 +3260,27 @@ var Agent = class {
               streamEvent.agentName = this.name;
             }
             await context.emitStreamEvent(streamEvent);
+            if (event.type === "error") {
+              throw event.error;
+            }
             if (event.type === "final") {
-              output = event.output;
+              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 });
+        const response = await this.generate({
+          prompt,
+          maxTurns: options.maxTurns,
+          abortSignal: context.abortSignal
+        });
         if (response.status === "approval_required") {
           await cancelAgentApproval(
             response,
@@ -3296,6 +3290,9 @@ var Agent = class {
             `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;
       }
     });
@@ -3329,20 +3326,25 @@ function getResolvedAgentOptions(agent) {
     context: [...agent.context],
     temperature: agent.temperature,
     maxTokens: agent.maxTokens,
-    additionalParams: agent.additionalParams,
-    tools: [...toolState.staticTools],
+    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,
-    observers: [...agent.observers],
+    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;
@@ -3356,21 +3358,23 @@ function resolveAgentOptions(options) {
     } 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(
-        "Invalid tool index: search, searchIds, asTool, tools, and a numeric topK are required."
+        `MCP tool "${tool.name}" must be registered through Agent.mcpServers, not Agent.tools.`
       );
     } else {
-      toolsByName.set(tool.name, tool);
-    }
-  }
-  for (const server of options.mcpServers ?? []) {
-    for (const tool of server.tools) {
-      toolsByName.set(tool.name, tool);
+      addUniqueTool(toolsByName, tool, "local tool");
     }
   }
   if (options.skills !== void 0) {
     for (const tool of options.skills.tools) {
-      toolsByName.set(tool.name, tool);
+      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);
@@ -3384,54 +3388,94 @@ function resolveAgentOptions(options) {
     context: [...options.context ?? []],
     temperature: options.temperature,
     maxTokens: options.maxTokens,
-    additionalParams: options.additionalParams,
+    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 === void 0 ? void 0 : toProviderJsonSchema(options.outputSchema),
-    observers: (options.observers ?? []).map(
-      (input) => "observer" in input ? { observer: input.observer, failOnObserverError: input.failOnObserverError } : { observer: input }
-    ),
+    outputSchema: options.outputSchema,
+    observability: options.observability,
     guardrails: options.guardrails === void 0 ? [] : appendGuardrailPolicies([], options.guardrails),
     middlewares: [...options.middlewares ?? []],
     memory
   };
 }
-function assertUniqueIndexedToolNames(indexes) {
+function assertUniqueAgentToolNames(options) {
   const owners = /* @__PURE__ */ new Map();
-  for (const [indexPosition, index] of indexes.entries()) {
+  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, searchIds, asTool, tools, and a numeric topK are required."
-      );
+      throw new TypeError("Invalid tool index: search, tools, and a numeric topK are required.");
     }
     assertPositiveSearchLimit(index.topK);
-    assertFiniteSearchThreshold(index.threshold);
+    assertFiniteMinScore(index.minScore);
     for (const tool of index.tools) {
-      const existingPosition = owners.get(tool.name);
-      if (existingPosition !== void 0) {
-        if (existingPosition === indexPosition) {
-          throw new TypeError(
-            `Tool "${tool.name}" is registered more than once by tool index ${indexPosition + 1}. Tool names must be unique within each index.`
-          );
-        }
+      if (isMcpTool(tool)) {
         throw new TypeError(
-          `Tool "${tool.name}" is registered by multiple tool indexes (${existingPosition + 1} and ${indexPosition + 1}). Tool names must be unique across indexes.`
+          `MCP tool "${tool.name}" must be registered through Agent.mcpServers, not a tool index.`
         );
       }
-      owners.set(tool.name, indexPosition);
+      registerToolOwner(owners, tool.name, `tool index ${indexPosition + 1}`);
     }
   }
 }
-function assertValidContextIndexes(inputs) {
+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 (!isContextIndex(input)) continue;
+    if (!isVectorContext(input)) continue;
     assertPositiveSearchLimit(input.topK);
-    assertFiniteSearchThreshold(input.threshold);
+    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;
@@ -3447,7 +3491,7 @@ function resolveAgentMemory(options) {
       "Memory compaction requires a store with the optional compaction capability."
     );
   }
-  return { store, options: resolvedOptions };
+  return { store, ...resolvedOptions };
 }
 var approvalContinuations = /* @__PURE__ */ new WeakMap();
 function assertAgentApprovalDecision(decision) {
@@ -3470,7 +3514,13 @@ function createGenerateExecution(agent, run) {
         return outcome.result;
       }
       const pending = run.approvalResult();
-      approvalContinuations.set(pending, { agent, run, mode: "generate", execution });
+      approvalContinuations.set(pending, {
+        agent,
+        mode: "generate",
+        resolve: (decision) => run.resolveApproval(decision),
+        resume: () => execution.next(),
+        cancel: (reason) => execution.cancel(reason)
+      });
       return pending;
     },
     async cancel(reason) {
@@ -3481,10 +3531,10 @@ function createGenerateExecution(agent, run) {
   return execution;
 }
 var StreamExecution = class {
-  constructor(agent, run, includeToolCallDeltas) {
+  constructor(agent, run) {
     this.agent = agent;
     this.run = run;
-    this.iterator = run.events(includeToolCallDeltas)[Symbol.asyncIterator]();
+    this.iterator = run.events()[Symbol.asyncIterator]();
   }
   agent;
   run;
@@ -3518,9 +3568,10 @@ var StreamExecution = class {
         const pending = this.run.approvalEvent();
         approvalContinuations.set(pending, {
           agent: this.agent,
-          run: this.run,
           mode: "stream",
-          execution: this
+          resolve: (decision) => this.run.resolveApproval(decision),
+          resume: () => this.segment(),
+          cancel: (reason) => this.cancel(reason)
         });
         yield pending;
         return;
@@ -3548,8 +3599,8 @@ var StreamExecution = class {
     }
   }
 };
-function createStreamExecution(agent, run, includeToolCallDeltas) {
-  return new StreamExecution(agent, run, includeToolCallDeltas).segment();
+function createStreamExecution(agent, run) {
+  return new StreamExecution(agent, run).segment();
 }
 var DefaultAgentStream = class {
   constructor(execution) {
@@ -3591,66 +3642,10 @@ async function cancelAgentApproval(pending, reason) {
     return;
   }
   approvalContinuations.delete(pending);
-  await continuation.execution.cancel(reason);
+  await continuation.cancel(reason);
 }
-var AgentSession = class {
-  constructor(agent, context) {
-    this.agent = agent;
-    this.context = context;
-  }
-  agent;
-  context;
-  generate(input, options = {}) {
-    if (Array.isArray(input)) {
-      throw new TypeError("AgentSession.generate does not accept Message[] transcripts.");
-    }
-    const run = AgentRun.fromAgent(this.agent, input, {
-      ...options,
-      memoryContext: this.context
-    });
-    return createGenerateExecution(this.agent, run).next();
-  }
-  stream(input, options = {}) {
-    if (Array.isArray(input)) {
-      throw new TypeError("AgentSession.stream does not accept Message[] transcripts.");
-    }
-    return createStreamExecution(
-      this.agent,
-      AgentRun.fromAgent(this.agent, input, { ...options, memoryContext: this.context }),
-      options.includeToolCallDeltas !== false
-    );
-  }
-  async messages() {
-    const memory = this.agent.memory;
-    if (memory === void 0) {
-      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
-    }
-    return memory.store.load(this.context);
-  }
-  async contextUsage() {
-    const messages = await this.messages();
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-      const message = messages[index];
-      if (message === void 0) {
-        continue;
-      }
-      const generation = getAssistantGenerationMetadata(message);
-      if (generation !== void 0) {
-        return generation.contextUsage;
-      }
-    }
-    return void 0;
-  }
-  async clear() {
-    const memory = this.agent.memory;
-    if (memory === void 0) {
-      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
-    }
-    await memory.store.clear(this.context);
-  }
-};
 function snapshotContextInput(input) {
-  if (!isContextIndex(input)) {
+  if (!isVectorContext(input)) {
     return Object.freeze({
       id: input.id,
       text: input.text,
@@ -3658,14 +3653,23 @@ function snapshotContextInput(input) {
     });
   }
   const format = input.format;
-  return Object.freeze({
-    kind: "context-index",
-    index: input.index,
+  const shared = {
+    kind: "vector-context",
+    store: input.store,
     topK: input.topK,
-    ...input.threshold === void 0 ? {} : { threshold: input.threshold },
+    ...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({
@@ -3673,17 +3677,61 @@ function snapshotProviderTool(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.threshold === void 0 ? {} : { threshold: index.threshold },
+    ...index.minScore === void 0 ? {} : { minScore: index.minScore },
     ...index.filter === void 0 ? {} : { filter: cloneFrozenPlainData(index.filter) },
-    search: (request) => index.search(request),
-    searchIds: (request) => index.searchIds(request),
-    asTool: (options) => index.asTool(options),
+    search: (options) => index.search(options),
     ...inspect === void 0 ? {} : { inspect: (request) => inspect.call(index, request) }
   });
 }
@@ -3694,17 +3742,20 @@ function snapshotGuardrailPolicy(policy) {
     output: Object.freeze([...policy.output])
   });
 }
-function snapshotMemoryRegistration(memory) {
+function snapshotAgentMemory(memory) {
   if (memory === void 0) {
     return void 0;
   }
-  const compaction = memory.options.compaction === void 0 ? void 0 : Object.freeze({ ...memory.options.compaction });
+  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,
-    options: Object.freeze({
-      ...memory.options,
-      ...compaction === void 0 ? {} : { compaction }
-    })
+    savePolicy: memory.savePolicy,
+    ...compaction === void 0 ? {} : { compaction }
   });
 }
 function cloneFrozenPlainData(value) {
@@ -3723,26 +3774,20 @@ function cloneFrozenPlainData(value) {
   );
   return Object.freeze(clone);
 }
-function dedupeTools(tools) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const tool of tools) {
-    byName.set(tool.name, tool);
-  }
-  return [...byName.values()];
-}
 
 export {
   MaxTurnsError,
   AgentRunCancelledError,
+  AgentRunBlockedError,
   getAgentToolState,
   createHook,
   getAgentApprovalRequestDetails,
-  createContextIndex,
-  isContextIndex,
+  createVectorContext,
+  isVectorContext,
   withInternalAgentRunOptions,
   Agent,
   createResolvedAgent,
   getResolvedAgentOptions,
   cancelAgentApproval
 };
-//# sourceMappingURL=chunk-IL3ZSNJI.js.map
+//# sourceMappingURL=chunk-DBSCKTUL.js.map