@google/adk 1.3.0 → 1.4.0

package/dist/esm/artifacts/gcs_artifact_service.js

@@ -8,12 +8,16 @@ const require = topLevelCreateRequire(import.meta.url);
 import { Storage } from "@google-cloud/storage";
 import { createPartFromBase64, createPartFromText } from "@google/genai";
 import { logger } from "../utils/logger.js";
+const GCS_FILE_URI_METADATA_KEY = "adkFileUri";
+const GCS_FILE_MIME_TYPE_METADATA_KEY = "adkFileMimeType";
+const GCS_DISPLAY_NAME_METADATA_KEY = "adkDisplayName";
+const GCS_IS_TEXT_METADATA_KEY = "adkIsText";
 class GcsArtifactService {
-  constructor(bucket) {
-    this.bucket = new Storage().bucket(bucket);
+  constructor(bucket, options) {
+    this.bucket = new Storage(options).bucket(bucket);
   }
   async saveArtifact(request) {
-    if (!request.artifact.inlineData && !request.artifact.text) {
+    if (!request.artifact.inlineData && !request.artifact.text && !request.artifact.fileData) {
       throw new Error("Artifact must have either inlineData or text content.");
     }
     const versions = await this.listVersions(request);
@@ -24,24 +28,48 @@ class GcsArtifactService {
         version
       })
     );
-    const metadata = request.customMetadata || {};
+    const customMetadata = {
+      ...request.customMetadata
+    };
     if (request.artifact.inlineData) {
+      if (request.artifact.inlineData.displayName) {
+        customMetadata[GCS_DISPLAY_NAME_METADATA_KEY] = request.artifact.inlineData.displayName;
+      }
       await file.save(
         Buffer.from(request.artifact.inlineData.data || "", "base64"),
         {
           contentType: request.artifact.inlineData.mimeType,
-          metadata
+          metadata: { metadata: customMetadata }
         }
       );
       return version;
+    } else if (request.artifact.text !== void 0) {
+      await file.save(request.artifact.text, {
+        contentType: "text/plain",
+        metadata: {
+          metadata: { ...customMetadata, [GCS_IS_TEXT_METADATA_KEY]: "true" }
+        }
+      });
+      return version;
+    } else {
+      const fileData = request.artifact.fileData;
+      const fileUri = fileData == null ? void 0 : fileData.fileUri;
+      if (!fileUri) {
+        throw new Error("Artifact fileData must have a fileUri.");
+      }
+      customMetadata[GCS_FILE_URI_METADATA_KEY] = fileUri;
+      if (fileData.mimeType) {
+        customMetadata[GCS_FILE_MIME_TYPE_METADATA_KEY] = fileData.mimeType;
+      }
+      await file.save("", {
+        contentType: fileData.mimeType || void 0,
+        metadata: { metadata: customMetadata }
+      });
+      return version;
     }
-    await file.save(request.artifact.text, {
-      contentType: "text/plain",
-      metadata
-    });
-    return version;
   }
   async loadArtifact(request) {
+    var _a, _b, _c;
     try {
       let version = request.version;
       if (version === void 0) {
@@ -57,11 +85,25 @@ class GcsArtifactService {
           version
         })
       );
-      const [[metadata], [rawDataBuffer]] = await Promise.all([
-        file.getMetadata(),
-        file.download()
-      ]);
-      if (metadata.contentType === "text/plain") {
+      const [metadata] = await file.getMetadata();
+      const customMeta = (_a = metadata.metadata) != null ? _a : {};
+      const fileUri = customMeta[GCS_FILE_URI_METADATA_KEY];
+      if (fileUri) {
+        const mimeType = (_c = (_b = customMeta[GCS_FILE_MIME_TYPE_METADATA_KEY]) != null ? _b : metadata.contentType) != null ? _c : void 0;
+        return { fileData: { fileUri, mimeType } };
+      }
+      const [rawDataBuffer] = await file.download();
+      const displayName = customMeta[GCS_DISPLAY_NAME_METADATA_KEY];
+      if (displayName) {
+        return {
+          inlineData: {
+            data: rawDataBuffer.toString("base64"),
+            mimeType: metadata.contentType,
+            displayName
+          }
+        };
+      }
+      if (customMeta[GCS_IS_TEXT_METADATA_KEY] === "true" || metadata.contentType === "text/plain") {
         return createPartFromText(rawDataBuffer.toString("utf-8"));
       }
       return createPartFromBase64(

package/dist/esm/artifacts/in_memory_artifact_service.js

@@ -20,7 +20,7 @@ class InMemoryArtifactService {
     artifact,
     customMetadata
   }) {
-    if (!artifact.inlineData && !artifact.text) {
+    if (!artifact.inlineData && !artifact.text && !artifact.fileData) {
       return Promise.reject(
         new Error("Artifact must have either inlineData or text content.")
       );
@@ -34,6 +34,10 @@ class InMemoryArtifactService {
       version,
       customMetadata
     };
+    if (!artifact.inlineData && artifact.text === void 0) {
+      const fileData = artifact.fileData;
+      metadata.mimeType = fileData.mimeType;
+    }
     this.artifacts[path].push({ part: artifact, metadata });
     return Promise.resolve(version);
   }

package/dist/esm/artifacts/scoped_artifact_service.js

@@ -0,0 +1,73 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ScopedArtifactService {
+  constructor(delegate, appName, userId, sessionId) {
+    this.delegate = delegate;
+    this.appName = appName;
+    this.userId = userId;
+    this.sessionId = sessionId;
+  }
+  async saveArtifact(request) {
+    return this.delegate.saveArtifact({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      ...request
+    });
+  }
+  async loadArtifact(request) {
+    return this.delegate.loadArtifact({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      ...request
+    });
+  }
+  async listArtifactKeys() {
+    return this.delegate.listArtifactKeys({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId
+    });
+  }
+  async deleteArtifact(filename) {
+    return this.delegate.deleteArtifact({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      filename
+    });
+  }
+  async listVersions(filename) {
+    return this.delegate.listVersions({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      filename
+    });
+  }
+  async listArtifactVersions(filename) {
+    return this.delegate.listArtifactVersions({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      filename
+    });
+  }
+  async getArtifactVersion(request) {
+    return this.delegate.getArtifactVersion({
+      appName: this.appName,
+      userId: this.userId,
+      sessionId: this.sessionId,
+      ...request
+    });
+  }
+}
+export {
+  ScopedArtifactService
+};

package/dist/esm/artifacts/session_artifact_service.js

@@ -0,0 +1,7 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/esm/auth/oauth2/oauth2_discovery.js

@@ -55,7 +55,11 @@ class OAuth2DiscoveryManager {
           method: "GET",
           headers: {
             Accept: "application/json"
-          }
+          },
+          // Never follow redirects: validateDiscoveryUrl only checks the
+          // initial URL, so following a 3xx would let a validated host
+          // redirect discovery to a private/cloud-metadata address (CWE-918).
+          redirect: "error"
         });
         if (!response.ok) {
           continue;
@@ -103,7 +107,11 @@ class OAuth2DiscoveryManager {
         method: "GET",
         headers: {
           Accept: "application/json"
-        }
+        },
+        // Never follow redirects: validateDiscoveryUrl only checks the
+        // initial URL, so following a 3xx would let a validated host
+        // redirect discovery to a private/cloud-metadata address (CWE-918).
+        redirect: "error"
       });
       if (!response.ok) {
         return void 0;
@@ -143,7 +151,7 @@ function validateDiscoveryUrl(urlStr) {
       return false;
     }
     const host = normaliseHostname(url.hostname.toLowerCase());
-    if (host === "localhost" || host === "metadata.google.internal" || host === "metadata.goog" || host.startsWith("127.") || host === "[::1]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
+    if (host === "localhost" || host === "metadata.google.internal" || host === "metadata.goog" || host.startsWith("127.") || host === "[::1]" || host === "[::]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
       logger.warn(`Unsafe host for discovery URL: ${host}`);
       return false;
     }
@@ -176,5 +184,7 @@ function validateDiscoveryUrl(urlStr) {
 export {
   AuthorizationServerMetadataSchema,
   OAuth2DiscoveryManager,
-  ProtectedResourceMetadataSchema
+  ProtectedResourceMetadataSchema,
+  normaliseHostname,
+  validateDiscoveryUrl
 };

package/dist/esm/auth/oauth2/oauth2_utils.js

@@ -6,6 +6,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * SPDX-License-Identifier: Apache-2.0
  */
 import { logger } from "../../utils/logger.js";
+import { validateDiscoveryUrl } from "./oauth2_discovery.js";
 function getTokenEndpoint(authScheme) {
   if (authScheme.type === "openIdConnect" && authScheme.tokenEndpoint) {
     return authScheme.tokenEndpoint;
@@ -20,13 +21,23 @@ function getTokenEndpoint(authScheme) {
   return void 0;
 }
 async function fetchOAuth2Tokens(endpoint, body) {
+  if (!validateDiscoveryUrl(endpoint)) {
+    throw new Error(
+      `SSRF protection: OAuth2 token endpoint '${endpoint}' is not allowed. Must use HTTPS and must not target private/loopback/cloud-metadata addresses.`
+    );
+  }
   try {
     const response = await fetch(endpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: body.toString()
+      body: body.toString(),
+      // Never follow redirects: the SSRF blocklist only validates `endpoint`,
+      // so a validated host that responds with a 3xx could otherwise redirect
+      // this credential-bearing POST (client_secret/refresh_token) to a
+      // private/cloud-metadata address (CWE-918).
+      redirect: "error"
     });
     if (!response.ok) {
       throw new Error(`Token request failed with status ${response.status}`);

package/dist/esm/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,8 +55,10 @@ import {
   CodeExecutionLanguage,
   FileContentEncoding
 } from "./code_executors/code_execution_utils.js";
+import { AgentControlledContextCompactor } from "./context/agent_controlled_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 {
@@ -82,7 +93,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 +107,7 @@ 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 { EXIT_LOOP, ExitLoopTool } from "./tools/exit_loop_tool.js";
 import { FunctionTool, isFunctionTool } from "./tools/function_tool.js";
 import {
@@ -111,9 +129,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 +148,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 +161,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,6 +171,7 @@ export {
   AUTH_PREPROCESSOR,
   ActiveStreamingTool,
   LlmAgent as Agent,
+  AgentControlledContextCompactor,
   AgentTool,
   AgentTransferLlmRequestProcessor,
   ApigeeLlm,
@@ -165,6 +192,7 @@ export {
   BuiltInCodeExecutor,
   CONTENT_REQUEST_PROCESSOR,
   CodeExecutionLanguage,
+  ConsolidateContextTool,
   ContentRequestProcessor,
   Context,
   ContextCompactionTrigger,
@@ -183,12 +211,14 @@ export {
   GoogleLLMVariant,
   GoogleMapsGroundingTool,
   GoogleSearchTool,
+  INTERACTIONS_REQUEST_PROCESSOR,
   InMemoryArtifactService,
   InMemoryCredentialService,
   InMemoryMemoryService,
   InMemoryPolicyEngine,
   InMemoryRunner,
   InMemorySessionService,
+  InteractionsRequestProcessor,
   InvocationContext,
   LLMRegistry,
   LOAD_ARTIFACTS,
@@ -229,9 +259,11 @@ export {
   SkillToolset,
   State,
   StreamingMode,
+  Task,
   TokenBasedContextCompactor,
   ToolAuthHandler,
   ToolConfirmation,
+  TrajectoryThoughtPruningCompactor,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
@@ -241,10 +273,16 @@ export {
   createEvent,
   createEventActions,
   createRestApiTool,
+  createResumabilityConfig,
   createSession,
+  determineAgentForResumption,
+  findEventByFunctionCallId,
+  findEventByLastFunctionResponseId,
+  findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   geminiInitParams,
   getAskUserConfirmationFunctionCalls,
+  getClientLabels,
   getFunctionCalls,
   getFunctionResponses,
   getLogger,
@@ -263,12 +301,14 @@ export {
   isLlmAgent,
   isLoopAgent,
   isParallelAgent,
+  isRoutableLlmAgent,
   isRoutedAgent,
   isRunner,
   isSequentialAgent,
   loadAllSkillsInDir,
   loadSkillFromDir,
   loadSkillFromZipBuffer,
+  runWithClientLabel,
   setLogLevel,
   setLogger,
   stringifyContent,

package/dist/esm/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: ${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/esm/context/token_based_context_compactor.js

@@ -5,8 +5,9 @@ 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";
+const CHARS_PER_TOKEN = 4;
 class TokenBasedContextCompactor {
   constructor(options) {
     this.tokenThreshold = options.tokenThreshold;
@@ -38,11 +39,14 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
     }
-    let totalTokens = 0;
-    for (const event of activeEvents) {
-      totalTokens += getEventTokens(event);
+    const promptTokenCount = latestPromptTokenCount(
+      activeEvents,
+      invocationContext
+    );
+    if (promptTokenCount === void 0) {
+      return false;
     }
-    return totalTokens > this.tokenThreshold;
+    return promptTokenCount > this.tokenThreshold;
   }
   async compact(invocationContext) {
     const events = invocationContext.session.events;
@@ -82,13 +86,41 @@ class TokenBasedContextCompactor {
     invocationContext.session.events.push(compactedEvent);
   }
 }
-function getEventTokens(event) {
+function latestPromptTokenCount(activeEvents, invocationContext) {
+  var _a;
+  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;
+    }
+  }
+  return estimatePromptTokenCount(activeEvents, invocationContext);
+}
+function estimatePromptTokenCount(activeEvents, invocationContext) {
   var _a;
-  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
-    return event.usageMetadata.promptTokenCount;
+  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;
   }
-  const contentStr = stringifyContent(event);
-  return Math.ceil(contentStr.length / 4);
+  return Math.ceil(totalChars / CHARS_PER_TOKEN);
 }
 function hasFunctionCall(event) {
   var _a, _b;

package/dist/esm/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
+};