@google/adk 1.6.0 → 2.1.0

package/dist/esm/common.js

@@ -9,11 +9,15 @@ import { ActiveStreamingTool } from "./agents/active_streaming_tool.js";
 import { BaseAgent, isBaseAgent } from "./agents/base_agent.js";
 import { Context } from "./agents/context.js";
 import {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
   findEventByFunctionCallId,
   findMatchingFunctionCall,
-  functionsExportedForTestingOnly
+  functionsExportedForTestingOnly,
+  isToolNotFound
 } from "./agents/functions.js";
-import { InvocationContext } from "./agents/invocation_context.js";
+import { InvocationContext, requireAgent } from "./agents/invocation_context.js";
 import { LiveRequestQueue } from "./agents/live_request_queue.js";
 import { LlmAgent, LlmAgent as LlmAgent2, isLlmAgent } from "./agents/llm_agent.js";
 import { LoopAgent, isLoopAgent } from "./agents/loop_agent.js";
@@ -36,8 +40,15 @@ 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 {
+  getPendingUserInputRequests,
+  getUserInputRequests,
+  requiresUserInput
+} from "./agents/user_input_request.js";
 import { createResumabilityConfig } from "./apps/resumability_config.js";
 import { InMemoryArtifactService } from "./artifacts/in_memory_artifact_service.js";
+import { ScopedArtifactService } from "./artifacts/scoped_artifact_service.js";
+import { isSessionArtifactService } from "./artifacts/session_artifact_service.js";
 import { AuthCredentialTypes } from "./auth/auth_credential.js";
 import { AuthHandler } from "./auth/auth_handler.js";
 import { AUTH_PREPROCESSOR, AuthPreprocessor } from "./auth/auth_preprocessor.js";
@@ -61,6 +72,15 @@ 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 { 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,
@@ -81,20 +101,38 @@ import {
   isBaseExampleProvider
 } from "./examples/base_example_provider.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 {
+  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,
-  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   SecurityPlugin,
   getAskUserConfirmationFunctionCalls
 } from "./plugins/security_plugin.js";
@@ -109,10 +147,11 @@ import {
 import { BaseSessionService } from "./sessions/base_session_service.js";
 import { InMemorySessionService } from "./sessions/in_memory_session_service.js";
 import { createSession } from "./sessions/session.js";
-import { State } from "./sessions/state.js";
+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,
@@ -120,6 +159,12 @@ import {
 } 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 {
+  FINISH_TASK_SUCCESS_RESULT,
+  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 {
@@ -132,80 +177,123 @@ 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 { ToolConfirmation } from "./tools/tool_confirmation.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 { 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 { AsyncQueue } from "./utils/async_queue.js";
 import { getClientLabels, runWithClientLabel } from "./utils/client_labels.js";
-import { LogLevel, getLogger, setLogLevel, setLogger } from "./utils/logger.js";
+import {
+  LogLevel,
+  getLogger,
+  resetLogger,
+  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";
-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";
-export * from "./apps/app.js";
+  BaseNode,
+  BranchPath,
+  DEFAULT_ROUTE,
+  Edge,
+  FunctionNode,
+  Graph,
+  JoinNode,
+  NodeContext,
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeStatus,
+  NodeTimeoutError,
+  NodeTool,
+  ParallelWorker,
+  RequestInput,
+  START,
+  ToolNode,
+  Workflow,
+  WorkflowNode,
+  asRunnableRoot,
+  commonPrefixOf,
+  createNodeErrorEvent,
+  createNodeState,
+  createSubBranch,
+  isNodeErrorEvent,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeState,
+  isNodeTimeoutError,
+  isRequestInput,
+  isRunnableRoot,
+  isWorkflow,
+  node,
+  normalizeRetryExceptions,
+  prepareRetryConfig
+} from "./workflow/index.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,
   AuthPreprocessor,
   AuthProviderRegistry,
   BaseAgent,
   BaseCodeExecutor,
+  BaseEnvironment,
   BaseExampleProvider,
   BaseLlm,
   BaseLlmRequestProcessor,
   BaseLlmResponseProcessor,
+  BaseNode,
   BasePlugin,
+  BaseRetrievalTool,
   BaseSessionService,
   BaseTool,
   BaseToolset,
+  BranchPath,
   BuiltInCodeExecutor,
+  BuiltInTool,
   CONTENT_REQUEST_PROCESSOR,
+  ChromeBuiltInLlm,
+  ChromeModelUnavailableError,
   CodeExecutionLanguage,
   ConsolidateContextTool,
   ContentRequestProcessor,
@@ -214,15 +302,22 @@ export {
   ContextCompactorRequestProcessor,
   CredentialExchangeError,
   CredentialRefresherRegistry,
+  DEFAULT_ROUTE,
   ENTERPRISE_WEB_SEARCH,
   EXIT_LOOP,
+  Edge,
   EnterpriseWebSearchTool,
   EventType,
   ExampleTool,
   ExitLoopTool,
+  FINISH_TASK_SUCCESS_RESULT,
+  FINISH_TASK_TOOL_NAME,
   FileContentEncoding,
+  FinishTaskTool,
+  ForwardingArtifactService,
+  FunctionNode,
   FunctionTool,
-  GCPSkillRegistry,
+  GLOBAL_SCOPE_KEY,
   GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
@@ -230,6 +325,7 @@ export {
   GoogleLLMVariant,
   GoogleMapsGroundingTool,
   GoogleSearchTool,
+  Graph,
   INTERACTIONS_REQUEST_PROCESSOR,
   InMemoryArtifactService,
   InMemoryCredentialService,
@@ -237,64 +333,89 @@ export {
   InMemoryPolicyEngine,
   InMemoryRunner,
   InMemorySessionService,
+  InputValidationError,
+  IntentMismatchError,
   InteractionsRequestProcessor,
   InvocationContext,
+  JoinNode,
   LLMRegistry,
   LOAD_ARTIFACTS,
   LOAD_MEMORY,
-  LOAD_WEB_PAGE,
   ListSkillsTool,
   LiveRequestQueue,
+  LlamaIndexRetrieval,
   LlmAgent2 as LlmAgent,
   LlmSummarizer,
   LoadArtifactsTool,
   LoadMemoryTool,
-  LoadSkillResourceTool,
   LoadSkillTool,
   LogLevel,
   LoggingPlugin,
   LongRunningFunctionTool,
   LoopAgent,
+  NodeContext,
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeStatus,
+  NodeTimeoutError,
+  NodeTool,
+  NotFoundError,
   OAuth2CredentialExchanger,
   OAuth2DiscoveryManager,
   OAuthGrantType,
-  OpenAPIToolset,
-  OpenApiSpecParser,
-  OperationParser,
   PRELOAD_MEMORY,
   ParallelAgent,
+  ParallelWorker,
   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,
-  RestApiTool,
+  ReflectAndRetryModelPlugin,
+  ReflectAndRetryToolPlugin,
+  RequestInput,
   RoutedAgent,
   RoutedLlm,
   Runner,
+  START,
+  ScopedArtifactService,
+  ScopedFailureTracker,
   SearchSkillsTool,
   SecurityPlugin,
   SequentialAgent,
+  SessionNotFoundError,
   SessionStateCredentialService,
-  SkillToolset,
   State,
+  StateSchemaError,
   StreamingMode,
   Task,
   TokenBasedContextCompactor,
-  ToolAuthHandler,
   ToolConfirmation,
+  ToolErrorType,
+  ToolExecutionError,
+  ToolNode,
+  TrackingScope,
   TrajectoryThoughtPruningCompactor,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
-  VertexAiMemoryBankService,
   VertexAiSearchTool,
   VertexRagRetrievalTool,
+  Workflow,
+  WorkflowNode,
+  asRunnableRoot,
+  commonPrefixOf,
   createEvent,
   createEventActions,
-  createRestApiTool,
+  createNodeErrorEvent,
+  createNodeState,
   createResumabilityConfig,
   createSession,
+  createSubBranch,
   determineAgentForResumption,
   findEventByFunctionCallId,
   findEventByLastFunctionResponseId,
@@ -307,10 +428,13 @@ export {
   getFunctionCalls,
   getFunctionResponses,
   getLogger,
+  getPendingUserInputRequests,
   getUserChoiceTool,
+  getUserInputRequests,
   hasThoughts,
   hasTrailingCodeExecutionResult,
   isAgentTool,
+  isApp,
   isBaseAgent,
   isBaseExampleProvider,
   isBaseLlm,
@@ -321,27 +445,43 @@ export {
   isFunctionTool,
   isGemini2OrAbove,
   isGemini3xFlashLive,
+  isIntentMismatchError,
   isLlmAgent,
   isLoopAgent,
+  isNodeErrorEvent,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeState,
+  isNodeTimeoutError,
   isParallelAgent,
+  isRequestInput,
   isRoutableLlmAgent,
   isRoutedAgent,
+  isRunnableRoot,
   isRunner,
   isScratchpadEvent,
   isSequentialAgent,
-  loadAllSkillsInDir,
-  loadSkillFromDir,
-  loadSkillFromZipBuffer,
-  loadWebPage,
+  isSessionArtifactService,
+  isStateSchemaError,
+  isToolNotFound,
+  isWorkflow,
+  node,
+  normalizeRetryExceptions,
   populateClientFunctionCallId,
+  prepareRetryConfig,
   pruneThoughts,
   requestInputTool,
+  requireAgent,
+  requiresUserInput,
+  resetLogger,
+  resolveScopeKey,
   runWithClientLabel,
   setLogLevel,
   setLogger,
   stringifyContent,
+  stripAdkIdentityPreamble,
   toStructuredEvents,
-  validateSkillDir,
+  validateAppName,
   version,
   zodObjectToSchema
 };

package/dist/esm/context/agent_controlled_context_compactor.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -8,7 +10,7 @@ const require = topLevelCreateRequire(import.meta.url);
 import { createEvent } from "../events/event.js";
 import { ContextCompactionTrigger } from "../plugins/base_plugin.js";
 import { getActiveEvents } from "./compaction_utils.js";
-class AgentControlledContextCompactor {
+const _AgentControlledContextCompactor = class _AgentControlledContextCompactor {
   constructor(options) {
     this.trigger = ContextCompactionTrigger.AgentControlled;
     this.summarizer = options.summarizer;
@@ -17,15 +19,19 @@ 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;
       },
@@ -55,6 +61,7 @@ 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);
@@ -66,7 +73,9 @@ class AgentControlledContextCompactor {
     delete invocationContext.session.state["temp:consolidate_context"];
     delete invocationContext.session.state["temp:consolidate_context_detail"];
   }
-}
+};
+__name(_AgentControlledContextCompactor, "AgentControlledContextCompactor");
+let AgentControlledContextCompactor = _AgentControlledContextCompactor;
 export {
   AgentControlledContextCompactor
 };

package/dist/esm/context/anchored_context_compactor.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -7,33 +9,42 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { isScratchpadEvent } from "../events/compacted_event.js";
 import { getEventTokens } from "../events/event.js";
-import { calculateRetainStartIndex } from "./compaction_utils.js";
-class AnchoredContextCompactor {
+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) {
@@ -54,7 +65,10 @@ 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) {
@@ -69,10 +83,11 @@ 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 {
@@ -81,19 +96,34 @@ 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);
   }
-}
+};
+__name(_AnchoredContextCompactor, "AnchoredContextCompactor");
+let AnchoredContextCompactor = _AnchoredContextCompactor;
 export {
   AnchoredContextCompactor
 };

package/dist/esm/context/compaction_utils.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -10,15 +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) {
@@ -32,7 +42,9 @@ function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
   }
   return retainStartIndex;
 }
+__name(calculateRetainStartIndex, "calculateRetainStartIndex");
 export {
   calculateRetainStartIndex,
-  getActiveEvents
+  getActiveEvents,
+  isEventVisibleInIsolationScope
 };