agents 0.13.2 → 0.14.0

package/dist/{compaction-helpers-DAe-xiVY.d.ts → compaction-helpers-DpP_XP9J.d.ts}

@@ -8,6 +8,7 @@ import { ToolSet } from "ai";
 interface SessionMessagePart {
   type: string;
   text?: string;
+  reasoning?: string;
   toolCallId?: string;
   toolName?: string;
   input?: unknown;
@@ -15,6 +16,40 @@ interface SessionMessagePart {
   state?: string;
   result?: unknown;
 }
+interface SessionTokenCounterInput {
+  /** Messages returned by `session.getHistory()` for the active branch. */
+  messages: SessionMessage[];
+  /** Frozen system prompt managed by the Session context system. */
+  systemPrompt: string;
+  /** Loaded context blocks that were used to build `systemPrompt`. */
+  contextBlocks: ContextBlock[];
+}
+type SessionTokenCounter = (
+  input: SessionTokenCounterInput
+) => number | Promise<number>;
+interface CompactAfterOptions {
+  /**
+   * Override the token estimate used by auto-compaction and status broadcasts.
+   *
+   * The default is a Workers-safe heuristic over message parts plus the
+   * Session-managed frozen system prompt. Callers that have model-reported
+   * usage or a tokenizer can provide a more precise counter here.
+   */
+  tokenCounter?: SessionTokenCounter;
+}
+/**
+ * Context the Session passes to the registered compaction function. Lets the
+ * same authoritative token accounting drive BOTH the "should we compact?"
+ * (`compactAfter`) and "what should we compact?" (boundary) decisions, so a
+ * consumer that wires a `tokenCounter` once doesn't hit the failure mode where
+ * compaction fires every turn but silently no-ops because the boundary logic
+ * used a different (under-counting) estimate.
+ */
+interface CompactContext {
+  /** The Session's token counter (from `compactAfter`/options), if configured. */
+  tokenCounter?: SessionTokenCounter;
+}
+type CompactionErrorHandler = (error: unknown) => void | Promise<void>;
 /**
  * Minimal message shape used by Session internals.
  * Vercel AI SDK's `UIMessage` is structurally compatible — you can pass
@@ -34,6 +69,10 @@ interface SessionOptions {
   context?: ContextConfig[];
   /** Provider for persisting the frozen system prompt. */
   promptStore?: WritableContextProvider;
+  /** Custom token counter for auto-compaction/status estimates. */
+  tokenCounter?: SessionTokenCounter;
+  /** Called when automatic compaction fails after a threshold trigger. */
+  onCompactionError?: CompactionErrorHandler;
 }
 //#endregion
 //#region src/experimental/memory/session/provider.d.ts
@@ -307,6 +346,9 @@ interface ContextBlock {
 }
 //#endregion
 //#region src/experimental/memory/utils/compaction-helpers.d.ts
+type CompactTokenCounter = (
+  messages: SessionMessage[]
+) => number | Promise<number>;
 /** Prefix for all compaction messages (overlays and summaries) */
 declare const COMPACTION_PREFIX = "compaction_";
 /** Check if a message is a compaction message */
@@ -401,6 +443,12 @@ interface CompactOptions {
   tailTokenBudget?: number;
   /** Minimum tail messages to protect (default: 2) */
   minTailMessages?: number;
+  /**
+   * Optional counter for tail-budget decisions. Use this when a tokenizer or
+   * model-reported accounting is available; otherwise the Workers-safe
+   * heuristic is used.
+   */
+  tokenCounter?: CompactTokenCounter;
 }
 /**
  * Reference compaction implementation.
@@ -429,38 +477,47 @@ interface CompactOptions {
  */
 declare function createCompactFunction(
   opts: CompactOptions
-): (messages: SessionMessage[]) => Promise<CompactResult | null>;
+): (
+  messages: SessionMessage[],
+  context?: CompactContext
+) => Promise<CompactResult | null>;
 //#endregion
 export {
-  SessionOptions as A,
-  AgentSessionProvider as C,
-  StoredCompaction as D,
-  SessionProvider as E,
-  SessionMessage as O,
-  isSearchProvider as S,
-  SearchResult as T,
-  R2SkillProvider as _,
-  alignBoundaryForward as a,
-  AgentSearchProvider as b,
-  createCompactFunction as c,
-  sanitizeToolPairs as d,
-  ContextBlock as f,
-  isWritableProvider as g,
-  WritableContextProvider as h,
-  alignBoundaryBackward as i,
-  SessionMessagePart as k,
-  findTailCutByTokens as l,
-  ContextProvider as m,
+  CompactContext as A,
+  isSearchProvider as C,
+  SessionProvider as D,
+  SearchResult as E,
+  SessionTokenCounter as F,
+  SessionTokenCounterInput as I,
+  SessionMessage as M,
+  SessionMessagePart as N,
+  StoredCompaction as O,
+  SessionOptions as P,
+  SearchProvider as S,
+  SqlProvider as T,
+  isWritableProvider as _,
+  alignBoundaryBackward as a,
+  isSkillProvider as b,
+  computeSummaryBudget as c,
+  isCompactionMessage as d,
+  sanitizeToolPairs as f,
+  WritableContextProvider as g,
+  ContextProvider as h,
+  CompactTokenCounter as i,
+  CompactionErrorHandler as j,
+  CompactAfterOptions as k,
+  createCompactFunction as l,
+  ContextConfig as m,
   CompactOptions as n,
-  buildSummaryPrompt as o,
-  ContextConfig as p,
+  alignBoundaryForward as o,
+  ContextBlock as p,
   CompactResult as r,
-  computeSummaryBudget as s,
+  buildSummaryPrompt as s,
   COMPACTION_PREFIX as t,
-  isCompactionMessage as u,
-  SkillProvider as v,
-  SqlProvider as w,
-  SearchProvider as x,
-  isSkillProvider as y
+  findTailCutByTokens as u,
+  R2SkillProvider as v,
+  AgentSessionProvider as w,
+  AgentSearchProvider as x,
+  SkillProvider as y
 };
-//# sourceMappingURL=compaction-helpers-DAe-xiVY.d.ts.map
+//# sourceMappingURL=compaction-helpers-DpP_XP9J.d.ts.map

package/dist/{do-oauth-client-provider-4OKQU9rT.d.ts → do-oauth-client-provider-CPm9rK5I.d.ts}

@@ -75,4 +75,4 @@ export {
   DurableObjectOAuthClientProvider as r,
   AgentMcpOAuthProvider as t
 };
-//# sourceMappingURL=do-oauth-client-provider-4OKQU9rT.d.ts.map
+//# sourceMappingURL=do-oauth-client-provider-CPm9rK5I.d.ts.map

package/dist/{email-J0GGS3sa.d.ts → email-1fTSJwPm.d.ts}

@@ -154,4 +154,4 @@ export {
   DEFAULT_MAX_AGE_SECONDS as t,
   createSecureReplyEmailResolver as u
 };
-//# sourceMappingURL=email-J0GGS3sa.d.ts.map
+//# sourceMappingURL=email-1fTSJwPm.d.ts.map

package/dist/email.d.ts

@@ -1,4 +1,4 @@
-import { n as AgentEmail } from "./internal_context-BZrMS0B5.js";
+import { n as AgentEmail } from "./internal_context-CcZy2Em7.js";
 import {
   a as SecureReplyResolverOptions,
   c as createCatchAllEmailResolver,
@@ -12,7 +12,7 @@ import {
   s as createAddressBasedEmailResolver,
   t as DEFAULT_MAX_AGE_SECONDS,
   u as createSecureReplyEmailResolver
-} from "./email-J0GGS3sa.js";
+} from "./email-1fTSJwPm.js";
 export {
   type AgentEmail,
   DEFAULT_MAX_AGE_SECONDS,

package/dist/experimental/memory/session/index.d.ts

@@ -1,25 +1,30 @@
 import {
-  A as SessionOptions,
-  C as AgentSessionProvider,
-  D as StoredCompaction,
-  E as SessionProvider,
-  O as SessionMessage,
-  S as isSearchProvider,
-  T as SearchResult,
-  _ as R2SkillProvider,
-  b as AgentSearchProvider,
-  f as ContextBlock,
-  g as isWritableProvider,
-  h as WritableContextProvider,
-  k as SessionMessagePart,
-  m as ContextProvider,
-  p as ContextConfig,
+  A as CompactContext,
+  C as isSearchProvider,
+  D as SessionProvider,
+  E as SearchResult,
+  F as SessionTokenCounter,
+  I as SessionTokenCounterInput,
+  M as SessionMessage,
+  N as SessionMessagePart,
+  O as StoredCompaction,
+  P as SessionOptions,
+  S as SearchProvider,
+  T as SqlProvider,
+  _ as isWritableProvider,
+  b as isSkillProvider,
+  g as WritableContextProvider,
+  h as ContextProvider,
+  j as CompactionErrorHandler,
+  k as CompactAfterOptions,
+  m as ContextConfig,
+  p as ContextBlock,
   r as CompactResult,
-  v as SkillProvider,
-  w as SqlProvider,
-  x as SearchProvider,
-  y as isSkillProvider
-} from "../../../compaction-helpers-DAe-xiVY.js";
+  v as R2SkillProvider,
+  w as AgentSessionProvider,
+  x as AgentSearchProvider,
+  y as SkillProvider
+} from "../../../compaction-helpers-DpP_XP9J.js";
 import { ToolSet } from "ai";
 
 //#region src/experimental/memory/session/session.d.ts
@@ -55,7 +60,10 @@ declare class Session {
   private _pending?;
   private _cachedPrompt?;
   private _compactionFn?;
+  private _warnedCompactionNoOp;
   private _tokenThreshold?;
+  private _tokenCounter?;
+  private _compactionErrorHandler?;
   private _ready;
   private _restorePromise?;
   private _messageChangeListener?;
@@ -99,13 +107,27 @@ declare class Session {
    * message history into a summary overlay.
    */
   onCompaction(
-    fn: (messages: SessionMessage[]) => Promise<CompactResult | null>
+    fn: (
+      messages: SessionMessage[],
+      context?: CompactContext
+    ) => Promise<CompactResult | null>
   ): this;
   /**
    * Auto-compact when estimated token count exceeds the threshold.
    * Checked after each `appendMessage`. Requires `onCompaction()`.
+   *
+   * By default this uses a Workers-safe heuristic over stored messages plus
+   * the Session-managed frozen system prompt. Provide `tokenCounter` when you
+   * have model-reported usage or a tokenizer and need a stricter budget.
    */
-  compactAfter(tokenThreshold: number): this;
+  compactAfter(tokenThreshold: number, options?: CompactAfterOptions): this;
+  /**
+   * Handle failures from the automatic `compactAfter()` trigger.
+   *
+   * Manual `compact()` still reports errors through the existing session error
+   * broadcast path.
+   */
+  onCompactionError(handler: CompactionErrorHandler): this;
   /**
    * @internal
    * Framework hook for cache-owning callers that need to mirror message
@@ -153,6 +175,9 @@ declare class Session {
   getBranches(messageId: string): Promise<SessionMessage[]>;
   getPathLength(leafId?: string | null): Promise<number>;
   private _broadcast;
+  private _shouldEstimateTokens;
+  private _estimateTokenCount;
+  private _handleAutoCompactionError;
   private _emitStatus;
   private _emitError;
   appendMessage(
@@ -263,6 +288,8 @@ declare class SessionManager {
   private _cachedPrompt?;
   private _compactionFn?;
   private _tokenThreshold?;
+  private _tokenCounter?;
+  private _compactionErrorHandler?;
   private _sessions;
   private _historyLabel?;
   private _tableReady;
@@ -299,7 +326,11 @@ declare class SessionManager {
    * Auto-compact when estimated token count exceeds the threshold.
    * Propagated to all sessions. Requires `onCompaction()`.
    */
-  compactAfter(tokenThreshold: number): this;
+  compactAfter(tokenThreshold: number, options?: CompactAfterOptions): this;
+  /**
+   * Handle failures from automatic compaction in managed sessions.
+   */
+  onCompactionError(handler: CompactionErrorHandler): this;
   /**
    * Add a searchable context block that searches conversation history
    * across all sessions managed by this manager.
@@ -540,6 +571,8 @@ export {
   AgentContextProvider,
   AgentSearchProvider,
   AgentSessionProvider,
+  type CompactAfterOptions,
+  type CompactionErrorHandler,
   type ContextBlock,
   type ContextConfig,
   type ContextProvider,
@@ -561,6 +594,8 @@ export {
   type SessionMessagePart,
   type SessionOptions,
   type SessionProvider,
+  type SessionTokenCounter,
+  type SessionTokenCounterInput,
   type SkillProvider,
   type SqlProvider,
   type StoredCompaction,

package/dist/experimental/memory/session/index.js

@@ -1,5 +1,5 @@
 import "../../../types.js";
-import { m as estimateStringTokens, p as estimateMessageTokens, t as COMPACTION_PREFIX } from "../../../compaction-helpers-DvcZnvQ1.js";
+import { m as estimateStringTokens, p as estimateMessageTokens, t as COMPACTION_PREFIX } from "../../../compaction-helpers-BjT2NKRZ.js";
 import { z } from "zod";
 //#region src/experimental/memory/session/search.ts
 /**
@@ -446,7 +446,7 @@ var ContextBlocks = class {
 	refreshSnapshot() {
 		return this.captureSnapshot();
 	}
-	captureSnapshot() {
+	renderPrompt() {
 		const parts = [];
 		const sep = "═".repeat(46);
 		for (const block of this.blocks.values()) {
@@ -463,7 +463,10 @@ var ContextBlocks = class {
 			else header += " [writable]";
 			parts.push(`${sep}\n${header}\n${sep}\n${block.content}`);
 		}
-		this.snapshot = parts.join("\n\n");
+		return parts.join("\n\n");
+	}
+	captureSnapshot() {
+		this.snapshot = this.renderPrompt();
 		return this.snapshot;
 	}
 	/**
@@ -512,6 +515,23 @@ var ContextBlocks = class {
 		return prompt;
 	}
 	/**
+	* Return the prompt text used for token estimation without persisting a new
+	* frozen prompt to the prompt store.
+	*
+	* This still reads an existing cached prompt when present, so estimates match
+	* the prompt that inference would reuse. If no cached prompt exists, it loads
+	* providers and renders the current blocks without freezing the snapshot.
+	*/
+	async getSystemPromptForEstimate() {
+		if (this.snapshot !== null) return this.snapshot;
+		if (this.promptStore) {
+			const stored = await this.promptStore.get();
+			if (stored !== null) return stored;
+		}
+		if (!this.loaded) await this.load();
+		return this.renderPrompt();
+	}
+	/**
 	* Force reload blocks from providers, re-render the system prompt,
 	* and persist to the store. Use this after block content has changed
 	* or to invalidate the cached prompt.
@@ -1001,9 +1021,12 @@ function isSqlProvider(arg) {
 }
 var Session = class Session {
 	constructor(storage, options) {
+		this._warnedCompactionNoOp = false;
 		this._ready = false;
 		this.storage = storage;
 		this.context = new ContextBlocks(options?.context ?? [], options?.promptStore);
+		this._tokenCounter = options?.tokenCounter;
+		this._compactionErrorHandler = options?.onCompactionError;
 		this._ready = true;
 	}
 	/**
@@ -1072,9 +1095,24 @@ var Session = class Session {
 	/**
 	* Auto-compact when estimated token count exceeds the threshold.
 	* Checked after each `appendMessage`. Requires `onCompaction()`.
+	*
+	* By default this uses a Workers-safe heuristic over stored messages plus
+	* the Session-managed frozen system prompt. Provide `tokenCounter` when you
+	* have model-reported usage or a tokenizer and need a stricter budget.
 	*/
-	compactAfter(tokenThreshold) {
+	compactAfter(tokenThreshold, options) {
 		this._tokenThreshold = tokenThreshold;
+		if (options?.tokenCounter) this._tokenCounter = options.tokenCounter;
+		return this;
+	}
+	/**
+	* Handle failures from the automatic `compactAfter()` trigger.
+	*
+	* Manual `compact()` still reports errors through the existing session error
+	* broadcast path.
+	*/
+	onCompactionError(handler) {
+		this._compactionErrorHandler = handler;
 		return this;
 	}
 	/**
@@ -1223,8 +1261,42 @@ var Session = class Session {
 			...data
 		}));
 	}
+	_shouldEstimateTokens() {
+		return Boolean(this._broadcaster || this._tokenThreshold != null && this._compactionFn);
+	}
+	async _estimateTokenCount() {
+		const messages = await this.getHistory();
+		const systemPrompt = await this.context.getSystemPromptForEstimate();
+		if (this._tokenCounter) {
+			if (!this.context.isLoaded()) await this.context.load();
+			const contextBlocks = this.context.getBlocks();
+			const estimate = await this._tokenCounter({
+				messages,
+				systemPrompt,
+				contextBlocks
+			});
+			return Number.isFinite(estimate) ? Math.max(0, Math.ceil(estimate)) : 0;
+		}
+		return estimateMessageTokens(messages) + estimateStringTokens(systemPrompt);
+	}
+	async _handleAutoCompactionError(error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (this._compactionErrorHandler) try {
+			await this._compactionErrorHandler(error);
+		} catch (handlerError) {
+			const handlerMessage = handlerError instanceof Error ? handlerError.message : String(handlerError);
+			console.warn(`Session auto-compaction error handler failed: ${handlerMessage}`);
+		}
+		else console.warn(`Session auto-compaction failed: ${message}`);
+		this._emitError(message);
+	}
 	async _emitStatus(phase, extra) {
-		const tokenEstimate = estimateMessageTokens(await this.getHistory());
+		let tokenEstimate = 0;
+		if (this._shouldEstimateTokens()) try {
+			tokenEstimate = await this._estimateTokenCount();
+		} catch (err) {
+			await this._handleAutoCompactionError(err);
+		}
 		this._broadcast("cf_agent_session", {
 			phase,
 			tokenEstimate,
@@ -1256,7 +1328,13 @@ var Session = class Session {
 		let compacted = false;
 		if (this._tokenThreshold != null && this._compactionFn && tokenEstimate > this._tokenThreshold) try {
 			compacted = Boolean(await this.compact());
-		} catch {}
+			if (!compacted && !this._warnedCompactionNoOp) {
+				this._warnedCompactionNoOp = true;
+				console.warn(`[Session] Auto-compaction fired (~${tokenEstimate} tokens > ${this._tokenThreshold}) but the compaction function returned null, so history was not shortened. ` + (this._tokenCounter ? `A tokenCounter is configured and now flows to the boundary logic, but it is invoked per-message there — a whole-prompt/usage counter (e.g. returning a fixed usage.inputTokens regardless of which messages are passed) degrades the tail budget to minTailMessages and can still no-op. Pass a per-message CompactOptions.tokenCounter for precise tail budgeting.` : `If your history is tool-heavy, configure a tokenCounter on compactAfter() — it flows to createCompactFunction's boundary logic automatically.`));
+			} else if (compacted) this._warnedCompactionNoOp = false;
+		} catch (err) {
+			await this._handleAutoCompactionError(err);
+		}
 		if (!compacted) await this._notifyMessagesChanged({
 			type: "append",
 			message,
@@ -1308,7 +1386,7 @@ var Session = class Session {
 		const tokensBefore = await this._emitStatus("compacting");
 		let result;
 		try {
-			result = await this._compactionFn(await this.getHistory());
+			result = await this._compactionFn(await this.getHistory(), { tokenCounter: this._tokenCounter });
 		} catch (err) {
 			this._emitError(err instanceof Error ? err.message : String(err));
 			return null;
@@ -1468,6 +1546,8 @@ var SessionManager = class SessionManager {
 		mgr._pending = [];
 		mgr._compactionFn = null;
 		mgr._tokenThreshold = void 0;
+		mgr._tokenCounter = void 0;
+		mgr._compactionErrorHandler = void 0;
 		mgr._sessions = /* @__PURE__ */ new Map();
 		mgr._tableReady = false;
 		mgr._ready = false;
@@ -1496,8 +1576,16 @@ var SessionManager = class SessionManager {
 	* Auto-compact when estimated token count exceeds the threshold.
 	* Propagated to all sessions. Requires `onCompaction()`.
 	*/
-	compactAfter(tokenThreshold) {
+	compactAfter(tokenThreshold, options) {
 		this._tokenThreshold = tokenThreshold;
+		if (options?.tokenCounter) this._tokenCounter = options.tokenCounter;
+		return this;
+	}
+	/**
+	* Handle failures from automatic compaction in managed sessions.
+	*/
+	onCompactionError(handler) {
+		this._compactionErrorHandler = handler;
 		return this;
 	}
 	/**
@@ -1576,7 +1664,8 @@ var SessionManager = class SessionManager {
 				provider: this._createHistoryProvider()
 			});
 			if (this._compactionFn) s.onCompaction(this._compactionFn);
-			if (this._tokenThreshold != null) s.compactAfter(this._tokenThreshold);
+			if (this._tokenThreshold != null) s.compactAfter(this._tokenThreshold, { tokenCounter: this._tokenCounter });
+			if (this._compactionErrorHandler) s.onCompactionError(this._compactionErrorHandler);
 			session = s;
 			this._sessions.set(sessionId, session);
 		}