@anvia/core 1.0.0-rc.9 → 1.0.0

package/dist/{chunk-PISJAAMX.js → chunk-3ZLM6OAZ.js}

@@ -1,6 +1,3 @@
-import {
-  isSkillTool
-} from "./chunk-YK4WAAS4.js";
 import {
   assertAgentInteractionResponse,
   parseAgentContinuation,
@@ -9,7 +6,20 @@ import {
 } from "./chunk-OJBFDBLG.js";
 import {
   isMcpTool
-} from "./chunk-76JLMBVT.js";
+} from "./chunk-J6LVLV6P.js";
+import {
+  MemoryCompactionConflictError,
+  MemoryCompactionError,
+  createMemoryCompactionSummary,
+  cumulativeCompactedMessageCount,
+  resolveMemoryOptions
+} from "./chunk-YA7BMX7D.js";
+import {
+  startAgentRunObservers
+} from "./chunk-6BBOCFHV.js";
+import {
+  isSkillTool
+} from "./chunk-YK4WAAS4.js";
 import {
   isQuestionTool,
   isToolIndex
@@ -29,16 +39,6 @@ import {
   toolMayRequireApproval,
   toolResultContentToText
 } from "./chunk-EMZKPRE6.js";
-import {
-  MemoryCompactionConflictError,
-  MemoryCompactionError,
-  assertPositiveInteger,
-  createMemoryCompactionSummary,
-  cumulativeCompactedMessageCount
-} from "./chunk-TC4FILD3.js";
-import {
-  startAgentRunObservers
-} from "./chunk-WZVHZZW6.js";
 import {
   AgentRunBlockedError,
   AgentRunCancelledError,
@@ -46,7 +46,7 @@ import {
   AgentStructuredOutputError,
   AgentToolSuspensionError,
   MaxTurnsError
-} from "./chunk-X4LK4ODN.js";
+} from "./chunk-AHLKV6KP.js";
 import {
   mapWithConcurrency
 } from "./chunk-3RM57ZT2.js";
@@ -60,15 +60,15 @@ import {
   isProviderTool,
   isStreamingCompletionModel,
   textFromAssistantContent
-} from "./chunk-WTRGYFCD.js";
+} from "./chunk-7PHMK7W4.js";
+import {
+  assertJsonObject
+} from "./chunk-7JLAIN6E.js";
 import {
   parseMessage,
   parseMessages,
   toProviderJsonSchema
 } from "./chunk-QGX73TSQ.js";
-import {
-  assertJsonObject
-} from "./chunk-7JLAIN6E.js";
 import {
   isJsonValue
 } from "./chunk-3XQGVDU5.js";
@@ -545,7 +545,7 @@ var AgentRunMemory = class {
   pendingTurnMessages(newMessages) {
     return this.memoryPolicy() === "turn" ? [...newMessages] : [];
   }
-  async prepareHistory(runId, incomingMessageCount, abortSignal) {
+  async prepareHistory(runId, incomingMessages, abortSignal) {
     const memory = this.memory();
     if (memory === void 0 || this.memoryScope === void 0) {
       return {
@@ -556,7 +556,7 @@ var AgentRunMemory = class {
     const preparation = await this.prepareStoredHistory(
       memory,
       runId,
-      incomingMessageCount,
+      incomingMessages,
       abortSignal
     );
     const memoryHistory = preparation.history;
@@ -566,6 +566,26 @@ var AgentRunMemory = class {
       history: chatHistory
     };
   }
+  async compact(runId, abortSignal) {
+    const memory = this.memory();
+    const scope = this.memoryScope;
+    if (memory === void 0 || scope === void 0) {
+      throw new TypeError("Manual memory compaction requires an Agent with configured memory.");
+    }
+    if (memory.compaction === void 0 || memory.store.compaction === void 0) {
+      throw new TypeError("Manual memory compaction requires a configured compaction policy.");
+    }
+    const preparation = await this.prepareStoredHistory(memory, runId, [], abortSignal, true);
+    if (preparation.compaction !== void 0) {
+      return { type: "compacted", ...preparation.compaction };
+    }
+    return {
+      type: "skipped",
+      reason: "nothing_to_compact",
+      originalMessageCount: preparation.history.length,
+      originalTokenCount: preparation.originalTokenCount ?? await countTokens(memory.compaction.tokenCounter, preparation.history)
+    };
+  }
   async commitAcceptedInput(runId, messages) {
     const memory = this.memory();
     if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "message" || messages.length === 0) {
@@ -635,7 +655,7 @@ var AgentRunMemory = class {
   memory() {
     return this.memoryScope === void 0 ? void 0 : this.agent.memory;
   }
-  async prepareStoredHistory(memory, runId, incomingMessageCount, abortSignal) {
+  async prepareStoredHistory(memory, runId, incomingMessages, abortSignal, force = false) {
     const scope = this.memoryScope;
     if (scope === void 0) {
       return { history: [], usage: Usage.empty() };
@@ -654,14 +674,22 @@ var AgentRunMemory = class {
       throwIfAborted(abortSignal);
       const snapshot = await capability.snapshot({ scope });
       throwIfAborted(abortSignal);
-      const compactedMessageCount = compactedPrefixLength(
+      const selection = await selectCompactionPrefix(
         snapshot.messages,
-        incomingMessageCount,
-        options.trigger.afterMessages,
-        options.retention.recentUserTurns
+        incomingMessages,
+        options.trigger.afterTokens,
+        options.retention.recentTokens,
+        options.tokenCounter,
+        force
       );
+      throwIfAborted(abortSignal);
+      const compactedMessageCount = selection.compactedMessageCount;
       if (compactedMessageCount === 0) {
-        return { history: snapshot.messages, usage };
+        return {
+          history: snapshot.messages,
+          usage,
+          originalTokenCount: selection.originalTokenCount
+        };
       }
       const prefix = snapshot.messages.slice(0, compactedMessageCount);
       let result;
@@ -677,6 +705,11 @@ var AgentRunMemory = class {
       if (result.usage !== void 0) {
         usage = Usage.add(usage, result.usage);
       }
+      if (typeof result?.summary !== "string") {
+        throw new MemoryCompactionError("Memory compactor must return a summary string.", {
+          usage
+        });
+      }
       const summaryText = result.summary.trim();
       if (summaryText.length === 0) {
         throw new MemoryCompactionError("Memory compactor returned an empty summary.", {
@@ -687,6 +720,13 @@ var AgentRunMemory = class {
         summaryText,
         cumulativeCompactedMessageCount(prefix)
       );
+      const retained = snapshot.messages.slice(compactedMessageCount);
+      let resultTokenCount;
+      try {
+        resultTokenCount = await countTokens(options.tokenCounter, [summary, ...retained]);
+      } catch (error) {
+        throw remappedCompactorError(error, usage);
+      }
       throwIfAborted(abortSignal);
       let replacement;
       try {
@@ -704,7 +744,6 @@ var AgentRunMemory = class {
         });
       }
       if (replacement.status === "committed") {
-        const retained = snapshot.messages.slice(compactedMessageCount);
         return {
           history: [summary, ...retained],
           usage,
@@ -712,6 +751,10 @@ var AgentRunMemory = class {
             originalMessageCount: snapshot.messages.length,
             compactedMessageCount,
             retainedMessageCount: retained.length,
+            originalTokenCount: selection.originalTokenCount,
+            compactedTokenCount: selection.compactedTokenCount,
+            retainedTokenCount: selection.retainedTokenCount,
+            resultTokenCount,
             attempts: attempt,
             usage
           }
@@ -722,17 +765,72 @@ var AgentRunMemory = class {
     throw new MemoryCompactionConflictError(maxAttempts, usage);
   }
 };
-function compactedPrefixLength(messages, incomingMessageCount, afterMessages, recentUserTurns) {
-  if (messages.length + incomingMessageCount <= afterMessages) {
-    return 0;
+async function selectCompactionPrefix(messages, incomingMessages, afterTokens, recentTokens, tokenCounter, force) {
+  const originalTokenCount = await countTokens(tokenCounter, messages);
+  const incomingTokenCount = incomingMessages.length === 0 ? 0 : await countTokens(tokenCounter, incomingMessages);
+  const none = {
+    compactedMessageCount: 0,
+    originalTokenCount,
+    compactedTokenCount: 0,
+    retainedTokenCount: originalTokenCount
+  };
+  if (!force && originalTokenCount + incomingTokenCount <= afterTokens) {
+    return none;
   }
   const userMessageIndexes = messages.flatMap(
     (message, index) => message.role === "user" ? [index] : []
   );
-  if (userMessageIndexes.length <= recentUserTurns) {
-    return 0;
+  if (userMessageIndexes.length <= 1) {
+    return none;
+  }
+  const tailTokenCounts = /* @__PURE__ */ new Map();
+  const countTail = async (messageIndex) => {
+    const cached = tailTokenCounts.get(messageIndex);
+    if (cached !== void 0) return cached;
+    const count = await countTokens(tokenCounter, messages.slice(messageIndex));
+    tailTokenCounts.set(messageIndex, count);
+    return count;
+  };
+  let lower = 0;
+  let upper = userMessageIndexes.length - 1;
+  let retainedBoundary = upper;
+  while (lower <= upper) {
+    const middle = Math.floor((lower + upper) / 2);
+    const candidate = userMessageIndexes[middle] ?? 0;
+    if (await countTail(candidate) <= recentTokens) {
+      retainedBoundary = middle;
+      upper = middle - 1;
+    } else {
+      lower = middle + 1;
+    }
+  }
+  const compactedMessageCount = userMessageIndexes[retainedBoundary] ?? 0;
+  if (compactedMessageCount === 0) {
+    return none;
   }
-  return userMessageIndexes[userMessageIndexes.length - recentUserTurns] ?? 0;
+  const compactedTokenCount = await countTokens(
+    tokenCounter,
+    messages.slice(0, compactedMessageCount)
+  );
+  const retainedTokenCount = tailTokenCounts.get(compactedMessageCount) ?? await countTokens(tokenCounter, messages.slice(compactedMessageCount));
+  return {
+    compactedMessageCount,
+    originalTokenCount,
+    compactedTokenCount,
+    retainedTokenCount
+  };
+}
+async function countTokens(tokenCounter, messages) {
+  let count;
+  try {
+    count = await tokenCounter(messages);
+  } catch (error) {
+    throw new MemoryCompactionError("Memory token counter failed.", { cause: error });
+  }
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new MemoryCompactionError("Memory token counter must return a nonnegative safe integer.");
+  }
+  return count;
 }
 function remappedCompactorError(error, usage) {
   if (error instanceof MemoryCompactionError) {
@@ -754,6 +852,22 @@ function isEmptyUsage(usage) {
   return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.totalTokens === 0 && usage.cachedInputTokens === 0 && usage.cacheCreationInputTokens === 0;
 }
 
+// src/internal/agent-runtime/memory-scope.ts
+function normalizeMemoryScope(scope, owner = "Agent") {
+  if (typeof scope !== "object" || scope === null || Array.isArray(scope)) {
+    throw new TypeError(`${owner} session must be an object.`);
+  }
+  if (typeof scope.sessionId !== "string" || scope.sessionId.trim().length === 0) {
+    throw new TypeError(`${owner} sessionId must be a non-empty string.`);
+  }
+  const normalized = {
+    sessionId: scope.sessionId.trim()
+  };
+  if (scope.userId !== void 0) normalized.userId = scope.userId;
+  if (scope.metadata !== void 0) normalized.metadata = scope.metadata;
+  return lifecycleSnapshot(normalized);
+}
+
 // src/internal/agent-runtime/retrieval.ts
 async function fetchContextDocuments(agent, ragText, abortSignal) {
   const documents = [];
@@ -1915,11 +2029,12 @@ var AgentRun = class _AgentRun {
   }
   cancel(reason) {
     if (this.isTerminal() || this.cancellationError !== void 0) {
-      return;
+      return this.cancellationError;
     }
     const messages = this.currentMessages.length === 0 ? [this.promptMessage] : [...this.currentMessages];
     const error = new AgentRunCancelledError([...this.chatHistory, ...messages], reason);
     this.setCancellationError(error);
+    return error;
   }
   setCancellationError(error) {
     this.cancellationError = error;
@@ -1938,7 +2053,7 @@ var AgentRun = class _AgentRun {
       this.throwIfCancelled();
       const memoryPreparation = this.continuationState === void 0 ? await this.memoryRecorder.prepareHistory(
         runId,
-        newMessages.length,
+        newMessages,
         this.abortController.signal
       ) : void 0;
       if (memoryPreparation !== void 0) {
@@ -1972,8 +2087,12 @@ var AgentRun = class _AgentRun {
         if (inputResult.blocked) {
           const text = inputResult.message ?? "The request was blocked by a guardrail.";
           const result = {
-            status: "blocked",
+            type: "blocked",
             stage: "input",
+            ...blockedOutcomeDetails(
+              this.guardrailDecisions,
+              "The request was blocked by a guardrail."
+            ),
             runId,
             text,
             usage,
@@ -1985,7 +2104,7 @@ var AgentRun = class _AgentRun {
           if (this.resumedFrom !== void 0) result.resumedFrom = this.resumedFrom;
           this.runState = "closing";
           await this.runLifecycleFinish(result);
-          await runObservers.end(result);
+          await runObservers.end(observerRunEnd(result));
           this.runState = "completed";
           this.disposeAbortLink();
           return result;
@@ -2135,7 +2254,7 @@ var AgentRun = class _AgentRun {
             newMessages,
             runObservers
           );
-          if (result.status === "completed") {
+          if (result.type === "response") {
             await this.runRunEndHook(result, newMessages);
           }
           await this.memoryRecorder.commitCompletedRun(
@@ -2145,7 +2264,7 @@ var AgentRun = class _AgentRun {
             pendingTurnMessages
           );
           await this.runLifecycleFinish(result);
-          await runObservers.end(result);
+          await runObservers.end(observerRunEnd(result));
           this.runState = "completed";
           this.disposeAbortLink();
           return result;
@@ -2230,7 +2349,7 @@ var AgentRun = class _AgentRun {
       this.throwIfCancelled();
       const memoryPreparation = this.continuationState === void 0 ? await this.memoryRecorder.prepareHistory(
         runId,
-        newMessages.length,
+        newMessages,
         this.abortController.signal
       ) : void 0;
       if (memoryPreparation !== void 0) {
@@ -2268,8 +2387,12 @@ var AgentRun = class _AgentRun {
         if (inputResult.blocked) {
           const text = inputResult.message ?? "The request was blocked by a guardrail.";
           const result = {
-            status: "blocked",
+            type: "blocked",
             stage: "input",
+            ...blockedOutcomeDetails(
+              this.guardrailDecisions,
+              "The request was blocked by a guardrail."
+            ),
             runId,
             text,
             usage,
@@ -2281,10 +2404,10 @@ var AgentRun = class _AgentRun {
           if (this.resumedFrom !== void 0) result.resumedFrom = this.resumedFrom;
           this.runState = "closing";
           await this.runLifecycleFinish(result);
-          await runObservers.end(result);
+          await runObservers.end(observerRunEnd(result));
           this.runState = "completed";
           this.disposeAbortLink();
-          yield { type: "final", result };
+          yield result;
           return;
         }
       }
@@ -2335,7 +2458,7 @@ var AgentRun = class _AgentRun {
               suspension: error,
               uncommittedMessages: []
             });
-            yield { type: "final", result };
+            yield result;
             return;
           }
           throw error;
@@ -2540,7 +2663,7 @@ var AgentRun = class _AgentRun {
               suspension: error,
               uncommittedMessages: [assistantMessage]
             });
-            yield { type: "final", result };
+            yield result;
             return;
           }
           throw error;
@@ -2831,7 +2954,7 @@ var AgentRun = class _AgentRun {
       args.newMessages,
       args.runObservers
     );
-    if (result.status === "completed") {
+    if (result.type === "response") {
       await this.runRunEndHook(result, args.newMessages);
     }
     await this.memoryRecorder.commitCompletedRun(
@@ -2841,10 +2964,10 @@ var AgentRun = class _AgentRun {
       args.pendingTurnMessages
     );
     await this.runLifecycleFinish(result);
-    await args.runObservers.end(result);
+    await args.runObservers.end(observerRunEnd(result));
     this.runState = "completed";
     this.disposeAbortLink();
-    yield { type: "final", result };
+    yield result;
   }
   async finishSuspension(args) {
     const partialToolMessage = args.suspension.completedResults.length === 0 ? void 0 : { role: "tool", content: [...args.suspension.completedResults] };
@@ -2885,7 +3008,7 @@ var AgentRun = class _AgentRun {
       state: serializeContinuationState(continuationState)
     });
     const result = {
-      status: "suspended",
+      type: "interaction",
       runId: args.runId,
       text: latestAssistantText([...this.chatHistory, ...args.newMessages]),
       usage: args.usage,
@@ -2899,7 +3022,7 @@ var AgentRun = class _AgentRun {
     };
     if (this.resumedFrom !== void 0) result.resumedFrom = this.resumedFrom;
     await this.runLifecycleFinish(result);
-    await args.runObservers.end(result);
+    await args.runObservers.end(observerRunEnd(result));
     this.runState = "completed";
     this.currentMessages = [...args.newMessages];
     this.disposeAbortLink();
@@ -3113,11 +3236,11 @@ var AgentRun = class _AgentRun {
     if (result.memoryCompaction !== void 0) {
       Object.assign(common, { memoryCompaction: lifecycleSnapshot(result.memoryCompaction) });
     }
-    const event = result.status === "completed" ? {
+    const event = result.type === "response" ? {
       ...common,
       status: "completed",
       output: lifecycleSnapshot(result.output)
-    } : result.status === "blocked" ? {
+    } : result.type === "blocked" ? {
       ...common,
       status: "blocked",
       stage: result.stage
@@ -3203,11 +3326,19 @@ var AgentRun = class _AgentRun {
     };
     if (this.resumedFrom !== void 0) Object.assign(common, { resumedFrom: this.resumedFrom });
     if (blocked) {
-      return { ...common, status: "blocked", stage: "output" };
+      return {
+        ...common,
+        type: "blocked",
+        stage: "output",
+        ...blockedOutcomeDetails(
+          this.guardrailDecisions,
+          "The response was blocked by a guardrail."
+        )
+      };
     }
     return {
       ...common,
-      status: "completed",
+      type: "response",
       output: this.parseOutput(text)
     };
   }
@@ -3326,6 +3457,10 @@ var AgentRun = class _AgentRun {
         originalMessageCount: compaction.originalMessageCount,
         compactedMessageCount: compaction.compactedMessageCount,
         retainedMessageCount: compaction.retainedMessageCount,
+        originalTokenCount: compaction.originalTokenCount,
+        compactedTokenCount: compaction.compactedTokenCount,
+        retainedTokenCount: compaction.retainedTokenCount,
+        resultTokenCount: compaction.resultTokenCount,
         attempts: compaction.attempts,
         inputTokens: compaction.usage.inputTokens,
         outputTokens: compaction.usage.outputTokens,
@@ -3701,20 +3836,6 @@ function normalizeSteeringInput(input) {
   }
   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.");
-  }
-  const normalized = {
-    sessionId: scope.sessionId.trim()
-  };
-  if (scope.userId !== void 0) normalized.userId = scope.userId;
-  if (scope.metadata !== void 0) normalized.metadata = scope.metadata;
-  return lifecycleSnapshot(normalized);
-}
 function normalizeRequestedRunId(runId) {
   if (runId === void 0) {
     return void 0;
@@ -3952,6 +4073,33 @@ function guardrailDecisionAttributes(decision) {
   }
   return attributes;
 }
+function blockedOutcomeDetails(decisions, fallbackReason) {
+  for (let index = decisions.length - 1; index >= 0; index -= 1) {
+    const decision = decisions[index];
+    if (decision?.applied !== true || decision.action !== "block") continue;
+    return decision.message === void 0 ? { reason: decision.reason ?? fallbackReason } : { reason: decision.reason ?? fallbackReason, message: decision.message };
+  }
+  return { reason: fallbackReason };
+}
+function observerRunEnd(outcome) {
+  const common = {
+    runId: outcome.runId,
+    text: outcome.text,
+    usage: outcome.usage,
+    messages: outcome.messages,
+    sources: outcome.sources,
+    providerToolCalls: outcome.providerToolCalls,
+    resumedFrom: outcome.resumedFrom
+  };
+  switch (outcome.type) {
+    case "response":
+      return { ...common, status: "completed", output: outcome.output };
+    case "blocked":
+      return { ...common, status: "blocked", stage: outcome.stage };
+    case "interaction":
+      return { ...common, status: "suspended", interaction: outcome.interaction };
+  }
+}
 
 // src/agent/agent-stream.ts
 function createAgentStream(run) {
@@ -3960,13 +4108,49 @@ function createAgentStream(run) {
 var DefaultAgentStream = class {
   constructor(run) {
     this.run = run;
+    let resolveResult;
+    let rejectResult;
+    this.resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    this.resolveResult = resolveResult;
+    this.rejectResult = rejectResult;
+    this.textPromise = this.resultPromise.then((result) => result.text);
+    void this.resultPromise.catch(() => void 0);
+    void this.textPromise.catch(() => void 0);
   }
   run;
   consuming = false;
   completed = false;
+  settled = false;
+  drainScheduled = false;
+  resultPromise;
+  textPromise;
+  resolveResult;
+  rejectResult;
+  get events() {
+    return this;
+  }
+  get textStream() {
+    return {
+      [Symbol.asyncIterator]: () => this.consumeText()
+    };
+  }
+  get text() {
+    this.scheduleDrain();
+    return this.textPromise;
+  }
+  get result() {
+    this.scheduleDrain();
+    return this.resultPromise;
+  }
   steer(input) {
     return this.run.steer(input);
   }
+  cancel(reason = "Agent stream cancelled.") {
+    this.run.cancel(reason);
+  }
   [Symbol.asyncIterator]() {
     return this.consume()[Symbol.asyncIterator]();
   }
@@ -3980,17 +4164,56 @@ var DefaultAgentStream = class {
     this.consuming = true;
     try {
       for await (const event of this.run.events()) {
+        if (isAgentOutcome(event)) {
+          this.settled = true;
+          this.resolveResult(event);
+        } else if (event.type === "error") {
+          this.settled = true;
+          this.rejectResult(event.error);
+        }
         yield event;
       }
     } finally {
       if (!this.completed) {
-        this.run.cancel("Agent stream consumer closed the stream.");
+        const cancellation = this.run.cancel("Agent stream consumer closed the stream.");
+        if (!this.settled && cancellation !== void 0) {
+          this.settled = true;
+          this.rejectResult(cancellation);
+        }
       }
       this.consuming = false;
       this.completed = true;
     }
   }
+  async *consumeText() {
+    for await (const event of this.consume()) {
+      if (event.type === "text_delta") yield event.delta;
+    }
+  }
+  scheduleDrain() {
+    if (this.completed || this.consuming || this.drainScheduled) return;
+    this.drainScheduled = true;
+    queueMicrotask(() => {
+      this.drainScheduled = false;
+      if (this.completed || this.consuming) return;
+      void this.drain();
+    });
+  }
+  async drain() {
+    try {
+      for await (const _event of this.consume()) {
+      }
+    } catch (error) {
+      if (!this.settled) {
+        this.settled = true;
+        this.rejectResult(error);
+      }
+    }
+  }
 };
+function isAgentOutcome(event) {
+  return event.type === "response" || event.type === "interaction" || event.type === "blocked";
+}
 
 // src/agent/agent-tool.ts
 import { z } from "zod";
@@ -4026,14 +4249,14 @@ function createAgentTool(agent, options) {
           if (event.type === "error") {
             throw event.error;
           }
-          if (event.type === "final") {
-            if (event.result.status === "suspended") {
-              throw new AgentToolSuspensionError(event.result);
-            }
-            if (event.result.status === "blocked") {
-              throw new AgentRunBlockedError(event.result);
-            }
-            output = event.result.output;
+          if (event.type === "interaction") {
+            throw new AgentToolSuspensionError(event);
+          }
+          if (event.type === "blocked") {
+            throw new AgentRunBlockedError(event);
+          }
+          if (event.type === "response") {
+            output = event.output;
             completed = true;
           }
         }
@@ -4047,10 +4270,10 @@ function createAgentTool(agent, options) {
         maxTurns: options.maxTurns,
         abortSignal: context.abortSignal
       });
-      if (response.status === "suspended") {
+      if (response.type === "interaction") {
         throw new AgentToolSuspensionError(response);
       }
-      if (response.status === "blocked") {
+      if (response.type === "blocked") {
         throw new AgentRunBlockedError(response);
       }
       return response.output;
@@ -4070,39 +4293,6 @@ function normalizeAgentId(id) {
   return normalized;
 }
 
-// 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/resolve-options.ts
 var resolvedAgentOptions = /* @__PURE__ */ Symbol("resolvedAgentOptions");
 function resolveAgentOptions(options) {
@@ -4535,6 +4725,9 @@ var Agent = class {
   generate(options) {
     return AgentRun.fromAgent(this, options).generate();
   }
+  resume(continuation, response, settings = {}) {
+    return this.generate({ continuation, response, ...settings });
+  }
   stream(options) {
     const run = AgentRun.fromAgent(this, options);
     if (!this.model.capabilities.streaming || !isStreamingCompletionModel(this.model)) {
@@ -4542,6 +4735,17 @@ var Agent = class {
     }
     return createAgentStream(run);
   }
+  compactMemory(options) {
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+      throw new TypeError("Manual memory compaction requires an options object.");
+    }
+    const scope = normalizeMemoryScope(options.session, "Manual memory compaction");
+    const memory = new AgentRunMemory(this, scope, []);
+    return memory.compact(
+      `manual-memory-compaction:${globalThis.crypto.randomUUID()}`,
+      options.abortSignal
+    );
+  }
   asTool(options) {
     return createAgentTool(this, options);
   }
@@ -4566,4 +4770,4 @@ export {
   markResolvedAgentOptions,
   Agent
 };
-//# sourceMappingURL=chunk-PISJAAMX.js.map
+//# sourceMappingURL=chunk-3ZLM6OAZ.js.map