@google/adk 1.3.0 → 1.5.0

package/dist/web/common.js

@@ -8,7 +8,11 @@ const require = topLevelCreateRequire(import.meta.url);
 import { ActiveStreamingTool } from "./agents/active_streaming_tool.js";
 import { BaseAgent, isBaseAgent } from "./agents/base_agent.js";
 import { Context } from "./agents/context.js";
-import { functionsExportedForTestingOnly } from "./agents/functions.js";
+import {
+  findEventByFunctionCallId,
+  findMatchingFunctionCall,
+  functionsExportedForTestingOnly
+} from "./agents/functions.js";
 import { InvocationContext } from "./agents/invocation_context.js";
 import { LiveRequestQueue } from "./agents/live_request_queue.js";
 import { LlmAgent, LlmAgent as LlmAgent2, isLlmAgent } from "./agents/llm_agent.js";
@@ -24,10 +28,15 @@ import {
   ContentRequestProcessor
 } from "./agents/processors/content_request_processor.js";
 import { ContextCompactorRequestProcessor } from "./agents/processors/context_compactor_request_processor.js";
+import {
+  INTERACTIONS_REQUEST_PROCESSOR,
+  InteractionsRequestProcessor
+} from "./agents/processors/interactions_request_processor.js";
 import { ReadonlyContext } from "./agents/readonly_context.js";
 import { RoutedAgent, isRoutedAgent } from "./agents/routed_agent.js";
 import { StreamingMode } from "./agents/run_config.js";
 import { SequentialAgent, isSequentialAgent } from "./agents/sequential_agent.js";
+import { createResumabilityConfig } from "./apps/resumability_config.js";
 import { InMemoryArtifactService } from "./artifacts/in_memory_artifact_service.js";
 import { AuthCredentialTypes } from "./auth/auth_credential.js";
 import { AuthHandler } from "./auth/auth_handler.js";
@@ -46,16 +55,23 @@ import {
   CodeExecutionLanguage,
   FileContentEncoding
 } from "./code_executors/code_execution_utils.js";
+import { AgentControlledContextCompactor } from "./context/agent_controlled_context_compactor.js";
+import { AnchoredContextCompactor } from "./context/anchored_context_compactor.js";
 import { LlmSummarizer } from "./context/summarizers/llm_summarizer.js";
 import { TokenBasedContextCompactor } from "./context/token_based_context_compactor.js";
+import { TrajectoryThoughtPruningCompactor } from "./context/trajectory_thought_pruning_compactor.js";
 import { TruncatingContextCompactor } from "./context/truncating_context_compactor.js";
-import { isCompactedEvent } from "./events/compacted_event.js";
+import { isCompactedEvent, isScratchpadEvent } from "./events/compacted_event.js";
 import {
   createEvent,
+  generateClientFunctionCallId,
   getFunctionCalls,
   getFunctionResponses,
+  hasThoughts,
   hasTrailingCodeExecutionResult,
   isFinalResponse,
+  populateClientFunctionCallId,
+  pruneThoughts,
   stringifyContent
 } from "./events/event.js";
 import { createEventActions } from "./events/event_actions.js";
@@ -72,6 +88,7 @@ import { Gemini, geminiInitParams } from "./models/google_llm.js";
 import { LLMRegistry } from "./models/registry.js";
 import { RoutedLlm } from "./models/routed_llm.js";
 import { BasePlugin, ContextCompactionTrigger } from "./plugins/base_plugin.js";
+import { GlobalInstructionPlugin } from "./plugins/global_instruction_plugin.js";
 import { LoggingPlugin } from "./plugins/logging_plugin.js";
 import { PluginManager } from "./plugins/plugin_manager.js";
 import {
@@ -82,7 +99,13 @@ import {
   getAskUserConfirmationFunctionCalls
 } from "./plugins/security_plugin.js";
 import { InMemoryRunner } from "./runner/in_memory_runner.js";
-import { Runner, isRunner } from "./runner/runner.js";
+import {
+  Runner,
+  determineAgentForResumption,
+  findEventByLastFunctionResponseId,
+  isRoutableLlmAgent,
+  isRunner
+} from "./runner/runner.js";
 import { BaseSessionService } from "./sessions/base_session_service.js";
 import { InMemorySessionService } from "./sessions/in_memory_session_service.js";
 import { createSession } from "./sessions/session.js";
@@ -90,6 +113,12 @@ import { State } from "./sessions/state.js";
 import { AgentTool, isAgentTool } from "./tools/agent_tool.js";
 import { BaseTool, isBaseTool } from "./tools/base_tool.js";
 import { BaseToolset, isBaseToolset } from "./tools/base_toolset.js";
+import { ConsolidateContextTool } from "./tools/consolidate_context_tool.js";
+import {
+  ENTERPRISE_WEB_SEARCH,
+  EnterpriseWebSearchTool
+} from "./tools/enterprise_web_search_tool.js";
+import { ExampleTool } from "./tools/example_tool.js";
 import { EXIT_LOOP, ExitLoopTool } from "./tools/exit_loop_tool.js";
 import { FunctionTool, isFunctionTool } from "./tools/function_tool.js";
 import {
@@ -102,6 +131,7 @@ import {
   LoadArtifactsTool
 } from "./tools/load_artifacts_tool.js";
 import { LOAD_MEMORY, LoadMemoryTool } from "./tools/load_memory_tool.js";
+import { LOAD_WEB_PAGE, loadWebPage } from "./tools/load_web_page.js";
 import { LongRunningFunctionTool } from "./tools/long_running_tool.js";
 import {
   PRELOAD_MEMORY,
@@ -111,9 +141,11 @@ import { ToolConfirmation } from "./tools/tool_confirmation.js";
 import { URL_CONTEXT, UrlContextTool } from "./tools/url_context_tool.js";
 import { VertexAiSearchTool } from "./tools/vertex_ai_search_tool.js";
 import { VertexRagRetrievalTool } from "./tools/vertex_rag_retrieval_tool.js";
+import { getClientLabels, runWithClientLabel } from "./utils/client_labels.js";
 import { LogLevel, getLogger, setLogLevel, setLogger } from "./utils/logger.js";
 import { isGemini2OrAbove, isGemini3xFlashLive } from "./utils/model_name.js";
 import { zodObjectToSchema } from "./utils/simple_zod_to_json.js";
+import { Task } from "./utils/task.js";
 import { GoogleLLMVariant } from "./utils/variant_utils.js";
 import { version } from "./version.js";
 import { GCPSkillRegistry } from "./skills/gcp_skill_registry.js";
@@ -128,6 +160,11 @@ import { LoadSkillResourceTool } from "./tools/skill/load_skill_resource_tool.js
 import { LoadSkillTool } from "./tools/skill/load_skill_tool.js";
 import { SearchSkillsTool } from "./tools/skill/search_skills_tool.js";
 import { SkillToolset } from "./tools/skill/skill_toolset.js";
+export * from "./artifacts/base_artifact_service.js";
+export * from "./features/feature_registry.js";
+export * from "./memory/base_memory_service.js";
+export * from "./sessions/base_session_service.js";
+export * from "./tools/base_tool.js";
 import { OpenApiSpecParser } from "./tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js";
 import { OperationParser } from "./tools/openapi_tool/openapi_spec_parser/operation_parser.js";
 import { ToolAuthHandler } from "./tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js";
@@ -136,6 +173,7 @@ import {
   RestApiTool,
   createRestApiTool
 } from "./tools/openapi_tool/rest_api_tool.js";
+export * from "./apps/app.js";
 export * from "./artifacts/base_artifact_service.js";
 export * from "./features/feature_registry.js";
 export * from "./memory/base_memory_service.js";
@@ -145,8 +183,10 @@ export {
   AUTH_PREPROCESSOR,
   ActiveStreamingTool,
   LlmAgent as Agent,
+  AgentControlledContextCompactor,
   AgentTool,
   AgentTransferLlmRequestProcessor,
+  AnchoredContextCompactor,
   ApigeeLlm,
   AuthCredentialTypes,
   AuthHandler,
@@ -165,14 +205,18 @@ export {
   BuiltInCodeExecutor,
   CONTENT_REQUEST_PROCESSOR,
   CodeExecutionLanguage,
+  ConsolidateContextTool,
   ContentRequestProcessor,
   Context,
   ContextCompactionTrigger,
   ContextCompactorRequestProcessor,
   CredentialExchangeError,
   CredentialRefresherRegistry,
+  ENTERPRISE_WEB_SEARCH,
   EXIT_LOOP,
+  EnterpriseWebSearchTool,
   EventType,
+  ExampleTool,
   ExitLoopTool,
   FileContentEncoding,
   FunctionTool,
@@ -180,19 +224,23 @@ export {
   GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
+  GlobalInstructionPlugin,
   GoogleLLMVariant,
   GoogleMapsGroundingTool,
   GoogleSearchTool,
+  INTERACTIONS_REQUEST_PROCESSOR,
   InMemoryArtifactService,
   InMemoryCredentialService,
   InMemoryMemoryService,
   InMemoryPolicyEngine,
   InMemoryRunner,
   InMemorySessionService,
+  InteractionsRequestProcessor,
   InvocationContext,
   LLMRegistry,
   LOAD_ARTIFACTS,
   LOAD_MEMORY,
+  LOAD_WEB_PAGE,
   ListSkillsTool,
   LiveRequestQueue,
   LlmAgent2 as LlmAgent,
@@ -229,9 +277,11 @@ export {
   SkillToolset,
   State,
   StreamingMode,
+  Task,
   TokenBasedContextCompactor,
   ToolAuthHandler,
   ToolConfirmation,
+  TrajectoryThoughtPruningCompactor,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
@@ -241,13 +291,21 @@ export {
   createEvent,
   createEventActions,
   createRestApiTool,
+  createResumabilityConfig,
   createSession,
+  determineAgentForResumption,
+  findEventByFunctionCallId,
+  findEventByLastFunctionResponseId,
+  findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   geminiInitParams,
+  generateClientFunctionCallId,
   getAskUserConfirmationFunctionCalls,
+  getClientLabels,
   getFunctionCalls,
   getFunctionResponses,
   getLogger,
+  hasThoughts,
   hasTrailingCodeExecutionResult,
   isAgentTool,
   isBaseAgent,
@@ -263,12 +321,18 @@ export {
   isLlmAgent,
   isLoopAgent,
   isParallelAgent,
+  isRoutableLlmAgent,
   isRoutedAgent,
   isRunner,
+  isScratchpadEvent,
   isSequentialAgent,
   loadAllSkillsInDir,
   loadSkillFromDir,
   loadSkillFromZipBuffer,
+  loadWebPage,
+  populateClientFunctionCallId,
+  pruneThoughts,
+  runWithClientLabel,
   setLogLevel,
   setLogger,
   stringifyContent,

package/dist/web/context/agent_controlled_context_compactor.js

@@ -0,0 +1,81 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isCompactedEvent } from "../events/compacted_event.js";
+import { createEvent } from "../events/event.js";
+import { ContextCompactionTrigger } from "../plugins/base_plugin.js";
+class AgentControlledContextCompactor {
+  constructor(options) {
+    this.trigger = ContextCompactionTrigger.AgentControlled;
+    this.summarizer = options.summarizer;
+  }
+  shouldCompact(invocationContext) {
+    return invocationContext.session.state["temp:consolidate_context"] === true;
+  }
+  async compact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const consolidateToolCallIndex = activeEvents.reduce(
+      (acc, e, idx) => {
+        var _a, _b;
+        return ((_b = (_a = e.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
+          (p) => {
+            var _a2;
+            return ((_a2 = p.functionCall) == null ? void 0 : _a2.name) === "consolidate_context";
+          }
+        )) ? idx : acc;
+      },
+      -1
+    );
+    if (consolidateToolCallIndex <= 0) {
+      this.clearFlags(invocationContext);
+      return;
+    }
+    const eventsToCompact = activeEvents.slice(0, consolidateToolCallIndex);
+    const detail = invocationContext.session.state["temp:consolidate_context_detail"];
+    if (detail) {
+      eventsToCompact.push(
+        createEvent({
+          author: "system",
+          timestamp: eventsToCompact[eventsToCompact.length - 1].timestamp,
+          content: {
+            role: "user",
+            parts: [
+              {
+                text: "CRITICAL INSTRUCTION FOR SUMMARY: Please summarize the history. Focus especially on: ".concat(detail)
+              }
+            ]
+          }
+        })
+      );
+    }
+    try {
+      const compactedEvent = await this.summarizer.summarize(eventsToCompact);
+      invocationContext.session.events.push(compactedEvent);
+    } catch (error) {
+      console.error("Compaction failed:", error);
+    } finally {
+      this.clearFlags(invocationContext);
+    }
+  }
+  clearFlags(invocationContext) {
+    delete invocationContext.session.state["temp:consolidate_context"];
+    delete invocationContext.session.state["temp:consolidate_context_detail"];
+  }
+  getActiveEvents(events) {
+    const latest = events.filter(isCompactedEvent).pop();
+    return latest ? [
+      latest,
+      ...events.filter(
+        (e) => !isCompactedEvent(e) && e.timestamp > latest.endTime
+      )
+    ] : events;
+  }
+}
+export {
+  AgentControlledContextCompactor
+};

package/dist/web/context/anchored_context_compactor.js

@@ -0,0 +1,117 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isScratchpadEvent } from "../events/compacted_event.js";
+import { getEventTokens } from "../events/event.js";
+import { calculateRetainStartIndex } from "./compaction_utils.js";
+class AnchoredContextCompactor {
+  constructor(options) {
+    this.tokenThreshold = options.tokenThreshold;
+    this.eventRetentionSize = options.eventRetentionSize;
+    this.summarizer = options.summarizer;
+  }
+  getActiveEvents(events) {
+    let latestScratchpad = void 0;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const e = events[i];
+      if (isScratchpadEvent(e)) {
+        latestScratchpad = e;
+        break;
+      }
+    }
+    if (!latestScratchpad) {
+      return events;
+    }
+    const activeRawEvents = events.filter(
+      (e) => e.timestamp > latestScratchpad.endTime && !isScratchpadEvent(e)
+    );
+    return [latestScratchpad, ...activeRawEvents];
+  }
+  shouldCompact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const hasScratchpad = activeEvents.length > 0 && isScratchpadEvent(activeEvents[0]);
+    const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
+    if (rawEvents.length <= this.eventRetentionSize) {
+      return false;
+    }
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return false;
+    }
+    const totalTokens = activeEvents.reduce(
+      (sum, event) => sum + getEventTokens(event),
+      0
+    );
+    return totalTokens > this.tokenThreshold;
+  }
+  async compact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const hasScratchpad = activeEvents.length > 0 && isScratchpadEvent(activeEvents[0]);
+    const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
+    if (rawEvents.length <= this.eventRetentionSize) {
+      return;
+    }
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return;
+    }
+    const rawEventsToCompact = rawEvents.slice(0, retainStartIndex);
+    let scratchpadEvent;
+    if (hasScratchpad) {
+      const existingScratchpad = activeEvents[0];
+      scratchpadEvent = await this.summarizer.summarize([
+        existingScratchpad,
+        ...rawEventsToCompact
+      ]);
+    } else {
+      scratchpadEvent = await this.summarizer.summarize(rawEventsToCompact);
+    }
+    const updatedScratchpad = __spreadProps(__spreadValues({}, scratchpadEvent), {
+      isScratchpad: true,
+      author: "system"
+    });
+    const inactiveEvents = events.slice(0, events.indexOf(activeEvents[0]));
+    const retainedRawEvents = rawEvents.slice(retainStartIndex);
+    const newEventsList = [
+      ...inactiveEvents,
+      updatedScratchpad,
+      ...retainedRawEvents
+    ];
+    events.length = 0;
+    events.push(...newEventsList);
+  }
+}
+export {
+  AnchoredContextCompactor
+};

package/dist/web/context/compaction_utils.js

@@ -0,0 +1,27 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
+function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
+  let retainStartIndex = Math.max(0, rawEvents.length - eventRetentionSize);
+  while (retainStartIndex > 0) {
+    const eventToRetain = rawEvents[retainStartIndex];
+    const previousEvent = rawEvents[retainStartIndex - 1];
+    if (getFunctionResponses(eventToRetain).length > 0 && getFunctionCalls(previousEvent).length > 0) {
+      retainStartIndex--;
+    } else {
+      break;
+    }
+  }
+  return retainStartIndex;
+}
+export {
+  calculateRetainStartIndex
+};

package/dist/web/context/token_based_context_compactor.js

@@ -5,8 +5,10 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { getContents } from "../agents/processors/content_processor_utils.js";
 import { isCompactedEvent } from "../events/compacted_event.js";
-import { stringifyContent } from "../events/event.js";
+import { calculateRetainStartIndex } from "./compaction_utils.js";
+const CHARS_PER_TOKEN = 4;
 class TokenBasedContextCompactor {
   constructor(options) {
     this.tokenThreshold = options.tokenThreshold;
@@ -38,11 +40,21 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
     }
-    let totalTokens = 0;
-    for (const event of activeEvents) {
-      totalTokens += getEventTokens(event);
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return false;
     }
-    return totalTokens > this.tokenThreshold;
+    const promptTokenCount = latestPromptTokenCount(
+      activeEvents,
+      invocationContext
+    );
+    if (promptTokenCount === void 0) {
+      return false;
+    }
+    return promptTokenCount > this.tokenThreshold;
   }
   async compact(invocationContext) {
     const events = invocationContext.session.events;
@@ -51,19 +63,10 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return;
     }
-    let retainStartIndex = Math.max(
-      0,
-      rawEvents.length - this.eventRetentionSize
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
     );
-    while (retainStartIndex > 0) {
-      const eventToRetain = rawEvents[retainStartIndex];
-      const previousEvent = rawEvents[retainStartIndex - 1];
-      if (hasFunctionResponse(eventToRetain) && hasFunctionCall(previousEvent)) {
-        retainStartIndex--;
-      } else {
-        break;
-      }
-    }
     if (retainStartIndex === 0) {
       return;
     }
@@ -82,25 +85,41 @@ class TokenBasedContextCompactor {
     invocationContext.session.events.push(compactedEvent);
   }
 }
-function getEventTokens(event) {
+function latestPromptTokenCount(activeEvents, invocationContext) {
   var _a;
-  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
-    return event.usageMetadata.promptTokenCount;
+  for (let i = activeEvents.length - 1; i >= 0; i--) {
+    const count = (_a = activeEvents[i].usageMetadata) == null ? void 0 : _a.promptTokenCount;
+    if (count !== void 0) {
+      return count;
+    }
   }
-  const contentStr = stringifyContent(event);
-  return Math.ceil(contentStr.length / 4);
+  return estimatePromptTokenCount(activeEvents, invocationContext);
 }
-function hasFunctionCall(event) {
-  var _a, _b;
-  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
-    (part) => part.functionCall !== void 0
-  ));
-}
-function hasFunctionResponse(event) {
-  var _a, _b;
-  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
-    (part) => part.functionResponse !== void 0
-  ));
+function estimatePromptTokenCount(activeEvents, invocationContext) {
+  var _a;
+  const contents = getContents(
+    activeEvents,
+    invocationContext.agent.name,
+    invocationContext.branch
+  );
+  let totalChars = 0;
+  for (const content of contents) {
+    for (const part of (_a = content.parts) != null ? _a : []) {
+      if (part.text) {
+        totalChars += part.text.length;
+      }
+      if (part.functionCall) {
+        totalChars += JSON.stringify(part.functionCall).length;
+      }
+      if (part.functionResponse) {
+        totalChars += JSON.stringify(part.functionResponse).length;
+      }
+    }
+  }
+  if (totalChars <= 0) {
+    return void 0;
+  }
+  return Math.ceil(totalChars / CHARS_PER_TOKEN);
 }
 export {
   TokenBasedContextCompactor

package/dist/web/context/trajectory_thought_pruning_compactor.js

@@ -0,0 +1,43 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { hasThoughts, pruneThoughts } from "../events/event.js";
+class TrajectoryThoughtPruningCompactor {
+  constructor(options) {
+    if (options.eventRetentionSize < 0) {
+      throw new Error("eventRetentionSize must be a non-negative integer.");
+    }
+    this.eventRetentionSize = options.eventRetentionSize;
+  }
+  shouldCompact(invocationContext) {
+    const events = invocationContext.session.events;
+    if (events.length <= this.eventRetentionSize) {
+      return false;
+    }
+    const olderEvents = events.slice(
+      0,
+      events.length - this.eventRetentionSize
+    );
+    return olderEvents.some((event) => hasThoughts(event));
+  }
+  compact(invocationContext) {
+    const events = invocationContext.session.events;
+    if (events.length <= this.eventRetentionSize) {
+      return;
+    }
+    const pruneLimit = events.length - this.eventRetentionSize;
+    for (let i = 0; i < pruneLimit; i++) {
+      const event = events[i];
+      if (hasThoughts(event)) {
+        events[i] = pruneThoughts(event);
+      }
+    }
+  }
+}
+export {
+  TrajectoryThoughtPruningCompactor
+};

package/dist/web/events/compacted_event.js

@@ -28,15 +28,20 @@ import { createEvent } from "./event.js";
 function isCompactedEvent(event) {
   return "isCompacted" in event && event.isCompacted === true;
 }
+function isScratchpadEvent(event) {
+  return isCompactedEvent(event) && event.isScratchpad === true;
+}
 function createCompactedEvent(params = {}) {
   return __spreadProps(__spreadValues({}, createEvent(params)), {
     isCompacted: params.isCompacted || true,
     startTime: params.startTime,
     endTime: params.endTime,
-    compactedContent: params.compactedContent
+    compactedContent: params.compactedContent,
+    isScratchpad: params.isScratchpad
   });
 }
 export {
   createCompactedEvent,
-  isCompactedEvent
+  isCompactedEvent,
+  isScratchpadEvent
 };