@google/adk 0.5.0 → 0.6.1

package/dist/web/a2a/agent_to_a2a.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AGENT_CARD_PATH } from "@a2a-js/sdk";
+import { DefaultRequestHandler, InMemoryTaskStore } from "@a2a-js/sdk/server";
+import {
+  agentCardHandler,
+  jsonRpcHandler,
+  restHandler,
+  UserBuilder
+} from "@a2a-js/sdk/server/express";
+import express from "express";
+import { StreamingMode } from "../agents/run_config.js";
+import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
+import { getA2AAgentCard, resolveAgentCard } from "./agent_card.js";
+import { A2AAgentExecutor } from "./agent_executor.js";
+async function toA2a(agent, options = {}) {
+  var _a, _b, _c, _d;
+  const host = (_a = options.host) != null ? _a : "localhost";
+  const port = (_b = options.port) != null ? _b : 8e3;
+  const protocol = (_c = options.protocol) != null ? _c : "http";
+  const basePath = options.basePath || "";
+  const rpcUrl = "".concat(protocol, "://").concat(host, ":").concat(port).concat(basePath);
+  const agentCard = options.agentCard ? await resolveAgentCard(options.agentCard) : await getA2AAgentCard(agent, [
+    {
+      url: "".concat(rpcUrl, "/jsonrpc"),
+      transport: "JSONRPC"
+    },
+    {
+      url: "".concat(rpcUrl, "/rest"),
+      transport: "HTTP+JSON"
+    }
+  ]);
+  const agentExecutor = new A2AAgentExecutor({
+    runner: options.runner || {
+      agent,
+      appName: agent.name,
+      sessionService: options.sessionService || new InMemorySessionService(),
+      memoryService: options.memoryService,
+      artifactService: options.artifactService
+    },
+    runConfig: {
+      streamingMode: StreamingMode.SSE
+    }
+  });
+  const requestHandler = new DefaultRequestHandler(
+    agentCard,
+    new InMemoryTaskStore(),
+    agentExecutor
+  );
+  const app = (_d = options.app) != null ? _d : express();
+  if (!options.app) {
+    app.use(express.urlencoded({ limit: "50mb", extended: true }));
+    app.use(express.json({ limit: "50mb" }));
+  }
+  app.use(
+    "".concat(basePath, "/").concat(AGENT_CARD_PATH),
+    agentCardHandler({ agentCardProvider: requestHandler })
+  );
+  app.use(
+    "".concat(basePath, "/rest"),
+    restHandler({
+      requestHandler,
+      userBuilder: UserBuilder.noAuthentication
+    })
+  );
+  app.use(
+    "".concat(basePath, "/jsonrpc"),
+    jsonRpcHandler({
+      requestHandler,
+      userBuilder: UserBuilder.noAuthentication
+    })
+  );
+  return app;
+}
+export {
+  toA2a
+};

package/dist/web/a2a/event_processor_utils.js

@@ -0,0 +1,168 @@
+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 { createEventActions } from "../events/event_actions.js";
+import {
+  createInputMissingErrorEvent,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  isInputRequiredTaskStatusUpdateEvent
+} from "./a2a_event.js";
+import {
+  getA2AEventMetadata,
+  getA2AEventMetadataFromActions,
+  getA2ASessionMetadata
+} from "./metadata_converter_utils.js";
+import { toA2AParts, toGenAIParts } from "./part_converter_utils.js";
+function getFinalTaskStatusUpdate(adkEvents, context) {
+  var _a, _b;
+  const finalEventActions = createEventActions();
+  for (const adkEvent of adkEvents) {
+    if (adkEvent.errorCode || adkEvent.errorMessage) {
+      return createTaskFailedEvent({
+        taskId: context.requestContext.taskId,
+        contextId: context.requestContext.contextId,
+        error: new Error(adkEvent.errorMessage || adkEvent.errorCode),
+        metadata: __spreadValues(__spreadValues({}, getA2AEventMetadata(adkEvent, context)), getA2AEventMetadataFromActions(finalEventActions))
+      });
+    }
+    finalEventActions.escalate = finalEventActions.escalate || ((_a = adkEvent.actions) == null ? void 0 : _a.escalate);
+    if ((_b = adkEvent.actions) == null ? void 0 : _b.transferToAgent) {
+      finalEventActions.transferToAgent = adkEvent.actions.transferToAgent;
+    }
+  }
+  const inputRequiredEvent = scanForInputRequiredEvents(adkEvents, context);
+  if (inputRequiredEvent) {
+    return __spreadProps(__spreadValues({}, inputRequiredEvent), {
+      metadata: __spreadValues(__spreadValues({}, inputRequiredEvent.metadata), getA2AEventMetadataFromActions(finalEventActions))
+    });
+  }
+  return createTaskCompletedEvent({
+    taskId: context.requestContext.taskId,
+    contextId: context.requestContext.contextId,
+    metadata: __spreadValues(__spreadValues({}, getA2ASessionMetadata(context)), getA2AEventMetadataFromActions(finalEventActions))
+  });
+}
+function scanForInputRequiredEvents(adkEvents, context) {
+  var _a, _b;
+  const inputRequiredParts = [];
+  const inputRequiredFunctionCallIds = /* @__PURE__ */ new Set();
+  for (const adkEvent of adkEvents) {
+    if (!((_b = (_a = adkEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+      continue;
+    }
+    for (const genAIPart of adkEvent.content.parts) {
+      const longRunningFunctionCallId = getLongRunnningFunctionCallId(
+        genAIPart,
+        adkEvent.longRunningToolIds,
+        inputRequiredParts
+      );
+      if (!longRunningFunctionCallId) {
+        continue;
+      }
+      const isAlreadyAdded = inputRequiredFunctionCallIds.has(
+        longRunningFunctionCallId
+      );
+      if (isAlreadyAdded) {
+        continue;
+      }
+      inputRequiredParts.push(genAIPart);
+      inputRequiredFunctionCallIds.add(longRunningFunctionCallId);
+    }
+  }
+  if (inputRequiredParts.length > 0) {
+    return createTaskInputRequiredEvent({
+      taskId: context.requestContext.taskId,
+      contextId: context.requestContext.contextId,
+      parts: toA2AParts(inputRequiredParts, [...inputRequiredFunctionCallIds]),
+      metadata: getA2ASessionMetadata(context)
+    });
+  }
+  return void 0;
+}
+function getLongRunnningFunctionCallId(genAIPart, longRunningToolIds = [], inputRequiredParts = []) {
+  var _a, _b, _c;
+  const functionCallId = (_a = genAIPart.functionCall) == null ? void 0 : _a.id;
+  const functionResponseId = (_b = genAIPart.functionResponse) == null ? void 0 : _b.id;
+  if (!functionCallId && !functionResponseId) {
+    return;
+  }
+  if (functionCallId && longRunningToolIds.includes(functionCallId)) {
+    return functionCallId;
+  }
+  if (functionResponseId && longRunningToolIds.includes(functionResponseId)) {
+    return functionResponseId;
+  }
+  for (const part of inputRequiredParts) {
+    if (((_c = part.functionCall) == null ? void 0 : _c.id) === functionResponseId) {
+      return functionResponseId;
+    }
+  }
+  return;
+}
+function getTaskInputRequiredEvent(task, genAIContent) {
+  var _a;
+  if (!task || !isInputRequiredTaskStatusUpdateEvent(task) || !task.status.message) {
+    return void 0;
+  }
+  const statusMsg = task.status.message;
+  const taskParts = toGenAIParts(statusMsg.parts);
+  for (const taskPart of taskParts) {
+    const functionCallId = (_a = taskPart.functionCall) == null ? void 0 : _a.id;
+    if (!functionCallId) {
+      continue;
+    }
+    const hasMatchingResponse = ((genAIContent == null ? void 0 : genAIContent.parts) || []).some(
+      (p) => {
+        var _a2;
+        return ((_a2 = p.functionResponse) == null ? void 0 : _a2.id) === functionCallId;
+      }
+    );
+    if (!hasMatchingResponse) {
+      return createInputMissingErrorEvent({
+        taskId: task.id,
+        contextId: task.contextId,
+        parts: [
+          ...statusMsg.parts.filter((p) => {
+            var _a2;
+            return !((_a2 = p.metadata) == null ? void 0 : _a2.validation_error);
+          }),
+          {
+            kind: "text",
+            text: "No input provided for function call id ".concat(functionCallId),
+            metadata: {
+              validation_error: true
+            }
+          }
+        ]
+      });
+    }
+  }
+  return void 0;
+}
+export {
+  getFinalTaskStatusUpdate,
+  getTaskInputRequiredEvent
+};

package/dist/web/a2a/executor_context.js

@@ -11,7 +11,7 @@ function createExecutorContext({
   return {
     userId: session.userId,
     sessionId: session.id,
-    agentName: session.appName,
+    appName: session.appName,
     readonlyState: session.state,
     events: session.events,
     userContent,

package/dist/web/a2a/metadata_converter_utils.js

@@ -44,6 +44,7 @@ var A2AMetadataKeys = ((A2AMetadataKeys2) => {
   A2AMetadataKeys2[A2AMetadataKeys2["GROUNDING_METADATA"] = "".concat(ADK_METADATA_KEY_PREFIX, "grounding_metadata")] = "GROUNDING_METADATA";
   A2AMetadataKeys2[A2AMetadataKeys2["USAGE_METADATA"] = "".concat(ADK_METADATA_KEY_PREFIX, "usage_metadata")] = "USAGE_METADATA";
   A2AMetadataKeys2[A2AMetadataKeys2["CUSTOM_METADATA"] = "".concat(ADK_METADATA_KEY_PREFIX, "custom_metadata")] = "CUSTOM_METADATA";
+  A2AMetadataKeys2[A2AMetadataKeys2["VIDEO_METADATA"] = "".concat(ADK_METADATA_KEY_PREFIX, "video_metadata")] = "VIDEO_METADATA";
   return A2AMetadataKeys2;
 })(A2AMetadataKeys || {});
 var AdkMetadataKeys = ((AdkMetadataKeys2) => {

package/dist/web/a2a/part_converter_utils.js

@@ -37,6 +37,10 @@ function toA2ATextPart(part) {
   return a2aPart;
 }
 function toA2AFilePart(part) {
+  const metadata = {};
+  if (part.videoMetadata) {
+    metadata[A2AMetadataKeys.VIDEO_METADATA] = part.videoMetadata;
+  }
   if (part.fileData) {
     return {
       kind: "file",
@@ -44,7 +48,7 @@ function toA2AFilePart(part) {
         uri: part.fileData.fileUri || "",
         mimeType: part.fileData.mimeType
       },
-      metadata: {}
+      metadata
     };
   }
   if (part.inlineData) {
@@ -54,7 +58,7 @@ function toA2AFilePart(part) {
         bytes: part.inlineData.data || "",
         mimeType: part.inlineData.mimeType
       },
-      metadata: {}
+      metadata
     };
   }
   throw new Error("Not a file part: ".concat(JSON.stringify(part)));
@@ -75,7 +79,11 @@ function toA2ADataPart(part, longRunningToolIDs = []) {
     dataPartType = "code_execution_result" /* CODE_EXEC_RESULT */;
     data = part.codeExecutionResult;
   } else {
-    throw new Error("Unknown part type: ".concat(JSON.stringify(part)));
+    return {
+      kind: "data",
+      data: {},
+      metadata: {}
+    };
   }
   const metadata = {
     [A2AMetadataKeys.DATA_PART_TYPE]: dataPartType
@@ -119,21 +127,24 @@ function toGenAIPartText(a2aPart) {
   };
 }
 function toGenAIPartFile(a2aPart) {
+  var _a;
+  const part = {};
+  if ((_a = a2aPart.metadata) == null ? void 0 : _a[A2AMetadataKeys.VIDEO_METADATA]) {
+    part.videoMetadata = a2aPart.metadata[A2AMetadataKeys.VIDEO_METADATA];
+  }
   if ("bytes" in a2aPart.file) {
-    return {
-      inlineData: {
-        data: a2aPart.file.bytes,
-        mimeType: a2aPart.file.mimeType || ""
-      }
+    part.inlineData = {
+      data: a2aPart.file.bytes,
+      mimeType: a2aPart.file.mimeType || ""
     };
+    return part;
   }
   if ("uri" in a2aPart.file) {
-    return {
-      fileData: {
-        fileUri: a2aPart.file.uri,
-        mimeType: a2aPart.file.mimeType || ""
-      }
+    part.fileData = {
+      fileUri: a2aPart.file.uri,
+      mimeType: a2aPart.file.mimeType || ""
     };
+    return part;
   }
   throw new Error("Not a file part: ".concat(JSON.stringify(a2aPart)));
 }

package/dist/web/agents/llm_agent.js

@@ -98,6 +98,7 @@ import { AGENT_TRANSFER_LLM_REQUEST_PROCESSOR } from "./processors/agent_transfe
 import { BASIC_LLM_REQUEST_PROCESSOR } from "./processors/basic_llm_request_processor.js";
 import { CODE_EXECUTION_REQUEST_PROCESSOR } from "./processors/code_execution_request_processor.js";
 import { CONTENT_REQUEST_PROCESSOR } from "./processors/content_request_processor.js";
+import { ContextCompactorRequestProcessor } from "./processors/context_compactor_request_processor.js";
 import { IDENTITY_LLM_REQUEST_PROCESSOR } from "./processors/identity_llm_request_processor.js";
 import { INSTRUCTIONS_LLM_REQUEST_PROCESSOR } from "./processors/instructions_llm_request_processor.js";
 import { REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR } from "./processors/request_confirmation_llm_request_processor.js";
@@ -144,6 +145,22 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       CONTENT_REQUEST_PROCESSOR,
       CODE_EXECUTION_REQUEST_PROCESSOR
     ];
+    if (!config.requestProcessors && config.contextCompactors && config.contextCompactors.length > 0) {
+      const contentIndex = this.requestProcessors.indexOf(
+        CONTENT_REQUEST_PROCESSOR
+      );
+      if (contentIndex !== -1) {
+        this.requestProcessors.splice(
+          contentIndex,
+          0,
+          new ContextCompactorRequestProcessor(config.contextCompactors)
+        );
+      } else {
+        this.requestProcessors.push(
+          new ContextCompactorRequestProcessor(config.contextCompactors)
+        );
+      }
+    }
     this.responseProcessors = (_h = config.responseProcessors) != null ? _h : [];
     const agentTransferDisabled = this.disallowTransferToParent && this.disallowTransferToPeers && !((_i = this.subAgents) == null ? void 0 : _i.length);
     if (!agentTransferDisabled) {

package/dist/web/agents/{content_processor_utils.js → processors/content_processor_utils.js}

@@ -3,21 +3,29 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { createUserContent } from "@google/genai";
 import { cloneDeep } from "lodash-es";
+import {
+  isCompactedEvent
+} from "../../events/compacted_event.js";
 import {
   createEvent,
   getFunctionCalls,
   getFunctionResponses
-} from "../events/event.js";
+} from "../../events/event.js";
 import {
   removeClientFunctionCallId,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   REQUEST_EUC_FUNCTION_CALL_NAME
-} from "./functions.js";
+} from "../functions.js";
 function getContents(events, agentName, currentBranch) {
   var _a, _b, _c;
   const filteredEvents = [];
   for (const event of events) {
+    if (isCompactedEvent(event)) {
+      filteredEvents.push(convertCompactedEvent(event));
+      continue;
+    }
     if (!((_a = event.content) == null ? void 0 : _a.role) || ((_c = (_b = event.content.parts) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) === "") {
       continue;
     }
@@ -290,6 +298,18 @@ function safeStringify(obj) {
     return String(obj);
   }
 }
+function convertCompactedEvent(event) {
+  const content = createUserContent(
+    "[Previous Context Summary]:\n".concat(event.compactedContent)
+  );
+  return createEvent({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
 export {
   getContents,
   getCurrentTurnContents

package/dist/web/agents/processors/content_request_processor.js

@@ -19,11 +19,12 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { isCompactedEvent } from "../../events/compacted_event.js";
+import { isLlmAgent } from "../llm_agent.js";
 import {
   getContents,
   getCurrentTurnContents
-} from "../content_processor_utils.js";
-import { isLlmAgent } from "../llm_agent.js";
+} from "./content_processor_utils.js";
 class ContentRequestProcessor {
   // eslint-disable-next-line require-yield
   runAsync(invocationContext, llmRequest) {
@@ -32,15 +33,35 @@ class ContentRequestProcessor {
       if (!agent || !isLlmAgent(agent)) {
         return;
       }
+      let events = invocationContext.session.events;
+      const compactedEvents = events.filter(isCompactedEvent);
+      const latestCompactedEvent = compactedEvents.length > 0 ? compactedEvents.reduce(
+        (latest, current) => current.endTime > latest.endTime ? current : latest
+      ) : void 0;
+      if (latestCompactedEvent) {
+        const remainingEvents = events.filter((event) => {
+          if (event === latestCompactedEvent) {
+            return false;
+          }
+          if (isCompactedEvent(event)) {
+            return false;
+          }
+          if (event.timestamp <= latestCompactedEvent.endTime) {
+            return false;
+          }
+          return true;
+        });
+        events = [latestCompactedEvent, ...remainingEvents];
+      }
       if (agent.includeContents === "default") {
         llmRequest.contents = getContents(
-          invocationContext.session.events,
+          events,
           agent.name,
           invocationContext.branch
         );
       } else {
         llmRequest.contents = getCurrentTurnContents(
-          invocationContext.session.events,
+          events,
           agent.name,
           invocationContext.branch
         );

package/dist/web/agents/processors/context_compactor_request_processor.js

@@ -0,0 +1,49 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ContextCompactorRequestProcessor {
+  constructor(compactors) {
+    this.compactors = compactors;
+  }
+  runAsync(invocationContext, _llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      for (const compactor of this.compactors) {
+        const shouldCompact = yield new __await(Promise.resolve(
+          compactor.shouldCompact(invocationContext)
+        ));
+        if (shouldCompact) {
+          const oldEvents = new Set(invocationContext.session.events);
+          yield new __await(Promise.resolve(compactor.compact(invocationContext)));
+          const newEvents = invocationContext.session.events.filter(
+            (e) => !oldEvents.has(e)
+          );
+          for (const e of newEvents) {
+            yield e;
+          }
+          return;
+        }
+      }
+    });
+  }
+}
+export {
+  ContextCompactorRequestProcessor
+};

package/dist/web/agents/processors/instructions_llm_request_processor.js

@@ -32,7 +32,7 @@ class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {
       const agent = invocationContext.agent;
-      if (!isLlmAgent(agent) || !isLlmAgent(agent.rootAgent)) {
+      if (!isLlmAgent(agent)) {
         return;
       }
       const rootAgent = agent.rootAgent;

package/dist/web/artifacts/file_artifact_service.js

@@ -348,8 +348,28 @@ class FileArtifactService {
     }
   }
 }
+const SAFE_SEGMENT_RE = /^[a-zA-Z0-9_@-][a-zA-Z0-9_.@-]{0,255}$/;
+function assertSafeSegment(value, label) {
+  if (!value || !SAFE_SEGMENT_RE.test(value)) {
+    throw new Error(
+      "[FileArtifactService] Invalid ".concat(label, ": value contains disallowed characters.")
+    );
+  }
+}
+function assertInsideRoot(resolvedPath, rootDir, label) {
+  const root = path.resolve(rootDir);
+  const resolved = path.resolve(resolvedPath);
+  if (!resolved.startsWith(root + path.sep) && resolved !== root) {
+    throw new Error(
+      "[FileArtifactService] ".concat(label, " escapes storage root. Resolved: ").concat(resolved, ", Root: ").concat(root)
+    );
+  }
+}
 function getUserRoot(rootDir, userId) {
-  return path.join(rootDir, "users", userId);
+  assertSafeSegment(userId, "userId");
+  const result = path.join(rootDir, "users", userId);
+  assertInsideRoot(result, rootDir, "userRoot");
+  return result;
 }
 function isUserScoped(sessionId, filename) {
   return !sessionId || filename.startsWith(USER_NAMESPACE_PREFIX);
@@ -358,7 +378,10 @@ function getUserArtifactsDir(userRoot) {
   return path.join(userRoot, "artifacts");
 }
 function getSessionArtifactsDir(baseRoot, sessionId) {
-  return path.join(baseRoot, "sessions", sessionId, "artifacts");
+  assertSafeSegment(sessionId, "sessionId");
+  const result = path.join(baseRoot, "sessions", sessionId, "artifacts");
+  assertInsideRoot(result, baseRoot, "sessionArtifactsDir");
+  return result;
 }
 function getVersionsDir(artifactDir) {
   return path.join(artifactDir, "versions");
@@ -502,5 +525,9 @@ function asPosixPath(p) {
   return p.split(path.sep).join("/");
 }
 export {
-  FileArtifactService
+  FileArtifactService,
+  assertInsideRoot,
+  assertSafeSegment,
+  getSessionArtifactsDir,
+  getUserRoot
 };