@google/adk 2.0.0 → 2.2.0

package/dist/esm/common.js

@@ -14,7 +14,8 @@ import {
   REQUEST_INPUT_FUNCTION_CALL_NAME,
   findEventByFunctionCallId,
   findMatchingFunctionCall,
-  functionsExportedForTestingOnly
+  functionsExportedForTestingOnly,
+  isToolNotFound
 } from "./agents/functions.js";
 import { InvocationContext, requireAgent } from "./agents/invocation_context.js";
 import { LiveRequestQueue } from "./agents/live_request_queue.js";
@@ -46,7 +47,9 @@ import {
 } from "./agents/user_input_request.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 { ScopedArtifactService } from "./artifacts/scoped_artifact_service.js";
+import { isSessionArtifactService } from "./artifacts/session_artifact_service.js";
+import { AuthCredentialTypes, isAuthCredential } from "./auth/auth_credential.js";
 import { AuthHandler } from "./auth/auth_handler.js";
 import { AUTH_PREPROCESSOR, AuthPreprocessor } from "./auth/auth_preprocessor.js";
 import { AuthProviderRegistry } from "./auth/auth_provider_registry.js";
@@ -70,6 +73,14 @@ import { TokenBasedContextCompactor } from "./context/token_based_context_compac
 import { TrajectoryThoughtPruningCompactor } from "./context/trajectory_thought_pruning_compactor.js";
 import { TruncatingContextCompactor } from "./context/truncating_context_compactor.js";
 import { BaseEnvironment } from "./environment/base_environment.js";
+import { AlreadyExistsError } from "./errors/already_exists_error.js";
+import { InputValidationError } from "./errors/input_validation_error.js";
+import { NotFoundError } from "./errors/not_found_error.js";
+import { SessionNotFoundError } from "./errors/session_not_found_error.js";
+import {
+  ToolErrorType,
+  ToolExecutionError
+} from "./errors/tool_execution_error.js";
 import { isCompactedEvent, isScratchpadEvent } from "./events/compacted_event.js";
 import {
   createEvent,
@@ -89,17 +100,40 @@ import {
   BaseExampleProvider,
   isBaseExampleProvider
 } from "./examples/base_example_provider.js";
+import { VertexAiExampleStore } from "./examples/example.js";
 import { InMemoryMemoryService } from "./memory/in_memory_memory_service.js";
-import { VertexAiMemoryBankService } from "./memory/vertex_ai_memory_bank_service.js";
 import { ApigeeLlm } from "./models/apigee_llm.js";
 import { BaseLlm, isBaseLlm } from "./models/base_llm.js";
+import {
+  ChromeBuiltInLlm,
+  ChromeModelUnavailableError,
+  stripAdkIdentityPreamble
+} from "./models/chrome_prompt_llm.js";
 import { Gemini, geminiInitParams } from "./models/google_llm.js";
 import { LLMRegistry } from "./models/registry.js";
 import { RoutedLlm } from "./models/routed_llm.js";
+import { BasePlanner, isBasePlanner } from "./planners/base_planner.js";
+import { BuiltInPlanner, isBuiltInPlanner } from "./planners/built_in_planner.js";
+import { PlanReActPlanner } from "./planners/plan_re_act_planner.js";
+import {
+  GLOBAL_SCOPE_KEY,
+  REFLECT_AND_RETRY_RESPONSE_TYPE,
+  ScopedFailureTracker,
+  TrackingScope,
+  resolveScopeKey
+} from "./plugins/_reflect_retry_utils.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 {
+  ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
+  RESERVED_TOOL_CALL_ERROR_TYPE,
+  ReflectAndRetryModelPlugin
+} from "./plugins/reflect_retry_model_plugin.js";
+import {
+  ReflectAndRetryToolPlugin
+} from "./plugins/reflect_retry_tool_plugin.js";
 import {
   InMemoryPolicyEngine,
   PolicyOutcome,
@@ -121,6 +155,7 @@ import { State, StateSchemaError, isStateSchemaError } 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 { BuiltInTool } from "./tools/built_in_tool.js";
 import { ConsolidateContextTool } from "./tools/consolidate_context_tool.js";
 import {
   ENTERPRISE_WEB_SEARCH,
@@ -133,6 +168,7 @@ import {
   FINISH_TASK_TOOL_NAME,
   FinishTaskTool
 } from "./tools/finish_task_tool.js";
+import { ForwardingArtifactService } from "./tools/forwarding_artifact_service.js";
 import { FunctionTool, isFunctionTool } from "./tools/function_tool.js";
 import { getUserChoiceTool } from "./tools/get_user_choice_tool.js";
 import {
@@ -145,54 +181,58 @@ 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,
   PreloadMemoryTool
 } from "./tools/preload_memory_tool.js";
 import { requestInputTool } from "./tools/request_input_tool.js";
+import { BaseRetrievalTool } from "./tools/retrieval/base_retrieval_tool.js";
+import { LlamaIndexRetrieval } from "./tools/retrieval/llama_index_retrieval.js";
 import {
   IntentMismatchError,
   ToolConfirmation,
   isIntentMismatchError
 } from "./tools/tool_confirmation.js";
+import { CallbackContext, ToolContext } from "./tools/tool_context.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 { WebMCPTool } from "./tools/webmcp/webmcp_tool.js";
+import { WebMCPToolset } from "./tools/webmcp/webmcp_toolset.js";
+import {
+  getModelContext,
+  isWebMCPSupported
+} from "./tools/webmcp/webmcp_types.js";
 import { AsyncQueue } from "./utils/async_queue.js";
+import { renameReservedKeywords, toSnakeCaseName } from "./utils/case_utils.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 {
+  LogLevel,
+  getLogger,
+  logger,
+  resetLogger,
+  setLogLevel,
+  setLogger
+} from "./utils/logger.js";
+import {
+  isGemini2OrAbove,
+  isGemini35LiveTranslate,
+  isGemini3xFlashLive,
+  isGemini3xLive
+} 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";
-import {
-  loadAllSkillsInDir,
-  loadSkillFromDir,
-  loadSkillFromZipBuffer,
-  validateSkillDir
-} from "./skills/loader.js";
 import { ListSkillsTool } from "./tools/skill/list_skills_tool.js";
-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";
-import { OpenAPIToolset } from "./tools/openapi_tool/openapi_toolset.js";
-import {
-  RestApiTool,
-  createRestApiTool
-} from "./tools/openapi_tool/rest_api_tool.js";
 import {
   BaseNode,
   BranchPath,
@@ -230,21 +270,24 @@ import {
   normalizeRetryExceptions,
   prepareRetryConfig
 } from "./workflow/index.js";
-export * from "./apps/app.js";
+import { App, isApp, validateAppName } from "./apps/app.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";
 export {
+  ADK_HANDLE_MODEL_ERROR_TOOL_NAME,
   AUTH_PREPROCESSOR,
   ActiveStreamingTool,
   LlmAgent as Agent,
   AgentControlledContextCompactor,
   AgentTool,
   AgentTransferLlmRequestProcessor,
+  AlreadyExistsError,
   AnchoredContextCompactor,
   ApigeeLlm,
+  App,
   AsyncQueue,
   AuthCredentialTypes,
   AuthHandler,
@@ -258,13 +301,20 @@ export {
   BaseLlmRequestProcessor,
   BaseLlmResponseProcessor,
   BaseNode,
+  BasePlanner,
   BasePlugin,
+  BaseRetrievalTool,
   BaseSessionService,
   BaseTool,
   BaseToolset,
   BranchPath,
   BuiltInCodeExecutor,
+  BuiltInPlanner,
+  BuiltInTool,
   CONTENT_REQUEST_PROCESSOR,
+  CallbackContext,
+  ChromeBuiltInLlm,
+  ChromeModelUnavailableError,
   CodeExecutionLanguage,
   ConsolidateContextTool,
   ContentRequestProcessor,
@@ -285,9 +335,10 @@ export {
   FINISH_TASK_TOOL_NAME,
   FileContentEncoding,
   FinishTaskTool,
+  ForwardingArtifactService,
   FunctionNode,
   FunctionTool,
-  GCPSkillRegistry,
+  GLOBAL_SCOPE_KEY,
   GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
@@ -303,6 +354,7 @@ export {
   InMemoryPolicyEngine,
   InMemoryRunner,
   InMemorySessionService,
+  InputValidationError,
   IntentMismatchError,
   InteractionsRequestProcessor,
   InvocationContext,
@@ -310,14 +362,13 @@ export {
   LLMRegistry,
   LOAD_ARTIFACTS,
   LOAD_MEMORY,
-  LOAD_WEB_PAGE,
   ListSkillsTool,
   LiveRequestQueue,
+  LlamaIndexRetrieval,
   LlmAgent2 as LlmAgent,
   LlmSummarizer,
   LoadArtifactsTool,
   LoadMemoryTool,
-  LoadSkillResourceTool,
   LoadSkillTool,
   LogLevel,
   LoggingPlugin,
@@ -329,48 +380,57 @@ export {
   NodeStatus,
   NodeTimeoutError,
   NodeTool,
+  NotFoundError,
   OAuth2CredentialExchanger,
   OAuth2DiscoveryManager,
   OAuthGrantType,
-  OpenAPIToolset,
-  OpenApiSpecParser,
-  OperationParser,
   PRELOAD_MEMORY,
   ParallelAgent,
   ParallelWorker,
+  PlanReActPlanner,
   PluginManager,
   PolicyOutcome,
   PreloadMemoryTool,
+  REFLECT_AND_RETRY_RESPONSE_TYPE,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
   REQUEST_INPUT_FUNCTION_CALL_NAME,
+  RESERVED_TOOL_CALL_ERROR_TYPE,
   ReadonlyContext,
+  ReflectAndRetryModelPlugin,
+  ReflectAndRetryToolPlugin,
   RequestInput,
-  RestApiTool,
   RoutedAgent,
   RoutedLlm,
   Runner,
   START,
+  ScopedArtifactService,
+  ScopedFailureTracker,
   SearchSkillsTool,
   SecurityPlugin,
   SequentialAgent,
+  SessionNotFoundError,
   SessionStateCredentialService,
-  SkillToolset,
   State,
   StateSchemaError,
   StreamingMode,
   Task,
   TokenBasedContextCompactor,
-  ToolAuthHandler,
   ToolConfirmation,
+  ToolContext,
+  ToolErrorType,
+  ToolExecutionError,
   ToolNode,
+  TrackingScope,
   TrajectoryThoughtPruningCompactor,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
-  VertexAiMemoryBankService,
+  VertexAiExampleStore,
   VertexAiSearchTool,
   VertexRagRetrievalTool,
+  WebMCPTool,
+  WebMCPToolset,
   Workflow,
   WorkflowNode,
   asRunnableRoot,
@@ -379,7 +439,6 @@ export {
   createEventActions,
   createNodeErrorEvent,
   createNodeState,
-  createRestApiTool,
   createResumabilityConfig,
   createSession,
   createSubBranch,
@@ -395,22 +454,29 @@ export {
   getFunctionCalls,
   getFunctionResponses,
   getLogger,
+  getModelContext,
   getPendingUserInputRequests,
   getUserChoiceTool,
   getUserInputRequests,
   hasThoughts,
   hasTrailingCodeExecutionResult,
   isAgentTool,
+  isApp,
+  isAuthCredential,
   isBaseAgent,
   isBaseExampleProvider,
   isBaseLlm,
+  isBasePlanner,
   isBaseTool,
   isBaseToolset,
+  isBuiltInPlanner,
   isCompactedEvent,
   isFinalResponse,
   isFunctionTool,
   isGemini2OrAbove,
+  isGemini35LiveTranslate,
   isGemini3xFlashLive,
+  isGemini3xLive,
   isIntentMismatchError,
   isLlmAgent,
   isLoopAgent,
@@ -427,26 +493,31 @@ export {
   isRunner,
   isScratchpadEvent,
   isSequentialAgent,
+  isSessionArtifactService,
   isStateSchemaError,
+  isToolNotFound,
+  isWebMCPSupported,
   isWorkflow,
-  loadAllSkillsInDir,
-  loadSkillFromDir,
-  loadSkillFromZipBuffer,
-  loadWebPage,
+  logger,
   node,
   normalizeRetryExceptions,
   populateClientFunctionCallId,
   prepareRetryConfig,
   pruneThoughts,
+  renameReservedKeywords,
   requestInputTool,
   requireAgent,
   requiresUserInput,
+  resetLogger,
+  resolveScopeKey,
   runWithClientLabel,
   setLogLevel,
   setLogger,
   stringifyContent,
+  stripAdkIdentityPreamble,
+  toSnakeCaseName,
   toStructuredEvents,
-  validateSkillDir,
+  validateAppName,
   version,
   zodObjectToSchema
 };

package/dist/esm/context/agent_controlled_context_compactor.js

@@ -19,15 +19,19 @@ const _AgentControlledContextCompactor = class _AgentControlledContextCompactor
     return invocationContext.session.state["temp:consolidate_context"] === true;
   }
   async compact(invocationContext) {
+    var _a;
     const events = invocationContext.session.events;
-    const activeEvents = getActiveEvents(events);
+    const activeEvents = getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     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(
+        var _a2, _b;
+        return ((_b = (_a2 = e.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b.some(
           (p) => {
-            var _a2;
-            return ((_a2 = p.functionCall) == null ? void 0 : _a2.name) === "consolidate_context";
+            var _a3;
+            return ((_a3 = p.functionCall) == null ? void 0 : _a3.name) === "consolidate_context";
           }
         )) ? idx : acc;
       },
@@ -57,6 +61,7 @@ const _AgentControlledContextCompactor = class _AgentControlledContextCompactor
     }
     try {
       const compactedEvent = await this.summarizer.summarize(eventsToCompact);
+      (_a = compactedEvent.isolationScope) != null ? _a : compactedEvent.isolationScope = invocationContext.isolationScope;
       invocationContext.session.events.push(compactedEvent);
     } catch (error) {
       console.error("Compaction failed:", error);

package/dist/esm/context/anchored_context_compactor.js

@@ -9,33 +9,42 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { isScratchpadEvent } from "../events/compacted_event.js";
 import { getEventTokens } from "../events/event.js";
-import { calculateRetainStartIndex } from "./compaction_utils.js";
+import {
+  calculateRetainStartIndex,
+  isEventVisibleInIsolationScope
+} from "./compaction_utils.js";
 const _AnchoredContextCompactor = class _AnchoredContextCompactor {
   constructor(options) {
     this.tokenThreshold = options.tokenThreshold;
     this.eventRetentionSize = options.eventRetentionSize;
     this.summarizer = options.summarizer;
   }
-  getActiveEvents(events) {
+  getActiveEvents(events, currentIsolationScope) {
+    const visibleEvents = events.filter(
+      (event) => isEventVisibleInIsolationScope(event, currentIsolationScope)
+    );
     let latestScratchpad = void 0;
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i];
+    for (let i = visibleEvents.length - 1; i >= 0; i--) {
+      const e = visibleEvents[i];
       if (isScratchpadEvent(e)) {
         latestScratchpad = e;
         break;
       }
     }
     if (!latestScratchpad) {
-      return events;
+      return visibleEvents;
     }
-    const activeRawEvents = events.filter(
+    const activeRawEvents = visibleEvents.filter(
       (e) => e.timestamp > latestScratchpad.endTime && !isScratchpadEvent(e)
     );
     return [latestScratchpad, ...activeRawEvents];
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = this.getActiveEvents(events);
+    const activeEvents = this.getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const hasScratchpad = activeEvents.length > 0 && isScratchpadEvent(activeEvents[0]);
     const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
     if (rawEvents.length <= this.eventRetentionSize) {
@@ -56,7 +65,10 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
   }
   async compact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = this.getActiveEvents(events);
+    const activeEvents = this.getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const hasScratchpad = activeEvents.length > 0 && isScratchpadEvent(activeEvents[0]);
     const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
     if (rawEvents.length <= this.eventRetentionSize) {
@@ -71,10 +83,11 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
     }
     const rawEventsToCompact = rawEvents.slice(0, retainStartIndex);
     let scratchpadEvent;
-    if (hasScratchpad) {
-      const existingScratchpad = activeEvents[0];
+    const existingScratchpad = hasScratchpad ? activeEvents[0] : void 0;
+    const reusableScratchpad = existingScratchpad && (existingScratchpad.isolationScope === void 0 || existingScratchpad.isolationScope === invocationContext.isolationScope) ? existingScratchpad : void 0;
+    if (reusableScratchpad) {
       scratchpadEvent = await this.summarizer.summarize([
-        existingScratchpad,
+        reusableScratchpad,
         ...rawEventsToCompact
       ]);
     } else {
@@ -83,15 +96,28 @@ const _AnchoredContextCompactor = class _AnchoredContextCompactor {
     const updatedScratchpad = {
       ...scratchpadEvent,
       isScratchpad: true,
-      author: "system"
+      author: "system",
+      ...invocationContext.isolationScope === void 0 ? {} : { isolationScope: invocationContext.isolationScope }
     };
-    const inactiveEvents = events.slice(0, events.indexOf(activeEvents[0]));
-    const retainedRawEvents = rawEvents.slice(retainStartIndex);
-    const newEventsList = [
-      ...inactiveEvents,
-      updatedScratchpad,
-      ...retainedRawEvents
-    ];
+    const shouldReplaceEvent = /* @__PURE__ */ __name((event) => invocationContext.isolationScope === void 0 || event.isolationScope === invocationContext.isolationScope, "shouldReplaceEvent");
+    const replacedEvents = /* @__PURE__ */ new Set([
+      ...reusableScratchpad && shouldReplaceEvent(reusableScratchpad) ? [reusableScratchpad] : [],
+      ...rawEventsToCompact.filter(shouldReplaceEvent)
+    ]);
+    const firstReplacedIndex = events.findIndex(
+      (event) => replacedEvents.has(event)
+    );
+    const newEventsList = [];
+    let insertedScratchpad = false;
+    for (let index = 0; index < events.length; index++) {
+      const event = events[index];
+      if (index === firstReplacedIndex) {
+        newEventsList.push(updatedScratchpad);
+        insertedScratchpad = true;
+      }
+      if (!replacedEvents.has(event)) newEventsList.push(event);
+    }
+    if (!insertedScratchpad) newEventsList.push(updatedScratchpad);
     events.length = 0;
     events.push(...newEventsList);
   }

package/dist/esm/context/compaction_utils.js

@@ -12,16 +12,23 @@ import {
   getFunctionCalls,
   getFunctionResponses
 } from "../events/event.js";
-function getActiveEvents(events) {
-  const latest = events.filter(isCompactedEvent).pop();
+function getActiveEvents(events, currentIsolationScope) {
+  const visibleEvents = events.filter(
+    (event) => isEventVisibleInIsolationScope(event, currentIsolationScope)
+  );
+  const latest = visibleEvents.filter(isCompactedEvent).pop();
   return latest ? [
     latest,
-    ...events.filter(
+    ...visibleEvents.filter(
       (e) => !isCompactedEvent(e) && e.timestamp > latest.endTime
     )
-  ] : events;
+  ] : visibleEvents;
 }
 __name(getActiveEvents, "getActiveEvents");
+function isEventVisibleInIsolationScope(event, currentIsolationScope) {
+  return event.isolationScope === void 0 || event.isolationScope === currentIsolationScope;
+}
+__name(isEventVisibleInIsolationScope, "isEventVisibleInIsolationScope");
 function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
   let retainStartIndex = Math.max(0, rawEvents.length - eventRetentionSize);
   while (retainStartIndex > 0) {
@@ -38,5 +45,6 @@ function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
 __name(calculateRetainStartIndex, "calculateRetainStartIndex");
 export {
   calculateRetainStartIndex,
-  getActiveEvents
+  getActiveEvents,
+  isEventVisibleInIsolationScope
 };

package/dist/esm/context/token_based_context_compactor.js

@@ -23,7 +23,10 @@ const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    const activeEvents = getActiveEvents(events);
+    const activeEvents = getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const rawEvents = activeEvents.filter((e) => !isCompactedEvent(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
@@ -45,8 +48,12 @@ const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
     return promptTokenCount > this.tokenThreshold;
   }
   async compact(invocationContext) {
+    var _a;
     const events = invocationContext.session.events;
-    const activeEvents = getActiveEvents(events);
+    const activeEvents = getActiveEvents(
+      events,
+      invocationContext.isolationScope
+    );
     const rawEvents = activeEvents.filter((e) => !isCompactedEvent(e));
     if (rawEvents.length <= this.eventRetentionSize) {
       return;
@@ -70,6 +77,7 @@ const _TokenBasedContextCompactor = class _TokenBasedContextCompactor {
         requestedToolConfirmations: {}
       };
     }
+    (_a = compactedEvent.isolationScope) != null ? _a : compactedEvent.isolationScope = invocationContext.isolationScope;
     invocationContext.session.events.push(compactedEvent);
   }
 };

package/dist/esm/context/trajectory_thought_pruning_compactor.js

@@ -8,6 +8,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import { hasThoughts, pruneThoughts } from "../events/event.js";
+import { isEventVisibleInIsolationScope } from "./compaction_utils.js";
 const _TrajectoryThoughtPruningCompactor = class _TrajectoryThoughtPruningCompactor {
   constructor(options) {
     if (options.eventRetentionSize < 0) {
@@ -17,25 +18,31 @@ const _TrajectoryThoughtPruningCompactor = class _TrajectoryThoughtPruningCompac
   }
   shouldCompact(invocationContext) {
     const events = invocationContext.session.events;
-    if (events.length <= this.eventRetentionSize) {
+    const visibleIndices = events.flatMap(
+      (event, index) => isEventVisibleInIsolationScope(event, invocationContext.isolationScope) ? [index] : []
+    );
+    if (visibleIndices.length <= this.eventRetentionSize) {
       return false;
     }
-    const olderEvents = events.slice(
-      0,
-      events.length - this.eventRetentionSize
-    );
+    const olderEvents = visibleIndices.slice(0, visibleIndices.length - this.eventRetentionSize).map((index) => events[index]);
     return olderEvents.some((event) => hasThoughts(event));
   }
   compact(invocationContext) {
     const events = invocationContext.session.events;
-    if (events.length <= this.eventRetentionSize) {
+    const visibleIndices = events.flatMap(
+      (event, index) => isEventVisibleInIsolationScope(event, invocationContext.isolationScope) ? [index] : []
+    );
+    if (visibleIndices.length <= this.eventRetentionSize) {
       return;
     }
-    const pruneLimit = events.length - this.eventRetentionSize;
-    for (let i = 0; i < pruneLimit; i++) {
-      const event = events[i];
+    const pruneIndices = visibleIndices.slice(
+      0,
+      visibleIndices.length - this.eventRetentionSize
+    );
+    for (const index of pruneIndices) {
+      const event = events[index];
       if (hasThoughts(event)) {
-        events[i] = pruneThoughts(event);
+        events[index] = pruneThoughts(event);
       }
     }
   }