@softactivate/adk 1.1.0

package/dist/cjs/context/summarizers/llm_summarizer.js

@@ -0,0 +1,93 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var llm_summarizer_exports = {};
+__export(llm_summarizer_exports, {
+  LlmSummarizer: () => LlmSummarizer
+});
+module.exports = __toCommonJS(llm_summarizer_exports);
+var import_compacted_event = require("../../events/compacted_event.js");
+var import_event = require("../../events/event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_PROMPT = "The following is a conversation history between a user and an AI agent. Please summarize the conversation, focusing on key information and decisions made, as well as any unresolved questions or tasks. The summary should be concise and capture the essence of the interaction.";
+class LlmSummarizer {
+  constructor(options) {
+    this.llm = options.llm;
+    this.prompt = options.prompt || DEFAULT_PROMPT;
+  }
+  async summarize(events) {
+    var _a, _b, _c, _d, _e, _f;
+    if (events.length === 0) {
+      throw new Error("Cannot summarize an empty list of events.");
+    }
+    const startTime = events[0].timestamp;
+    const endTime = events[events.length - 1].timestamp;
+    let formattedEvents = "";
+    for (let i = 0; i < events.length; i++) {
+      formattedEvents += `[Event ${i + 1} - Author: ${events[i].author}]
+`;
+      formattedEvents += `${(0, import_event.stringifyContent)(events[i])}
+
+`;
+    }
+    const fullPrompt = `${this.prompt}
+
+${formattedEvents}`;
+    const request = {
+      contents: [{ role: "user", parts: [{ text: fullPrompt }] }],
+      toolsDict: {},
+      liveConnectConfig: {}
+    };
+    const responseGen = this.llm.generateContentAsync(request, false);
+    let compactedContent = "";
+    const firstResponse = await responseGen.next();
+    if (firstResponse.done || !((_c = (_b = (_a = firstResponse.value.content) == null ? void 0 : _a.parts) == null ? void 0 : _b[0]) == null ? void 0 : _c.text)) {
+      throw new Error("LLM failed to return a valid summary.");
+    }
+    compactedContent += firstResponse.value.content.parts[0].text;
+    for await (const chunk of responseGen) {
+      if ((_f = (_e = (_d = chunk.content) == null ? void 0 : _d.parts) == null ? void 0 : _e[0]) == null ? void 0 : _f.text) {
+        compactedContent += chunk.content.parts[0].text;
+      }
+    }
+    return (0, import_compacted_event.createCompactedEvent)({
+      author: "system",
+      content: {
+        role: "model",
+        parts: [{ text: compactedContent }]
+      },
+      startTime,
+      endTime,
+      compactedContent
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LlmSummarizer
+});

package/dist/cjs/context/token_based_context_compactor.js

@@ -0,0 +1,135 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var token_based_context_compactor_exports = {};
+__export(token_based_context_compactor_exports, {
+  TokenBasedContextCompactor: () => TokenBasedContextCompactor
+});
+module.exports = __toCommonJS(token_based_context_compactor_exports);
+var import_compacted_event = require("../events/compacted_event.js");
+var import_event = require("../events/event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class TokenBasedContextCompactor {
+  constructor(options) {
+    this.tokenThreshold = options.tokenThreshold;
+    this.eventRetentionSize = options.eventRetentionSize;
+    this.summarizer = options.summarizer;
+  }
+  getActiveEvents(events) {
+    let latestCompactedEvent = void 0;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const e = events[i];
+      if ((0, import_compacted_event.isCompactedEvent)(e)) {
+        if (!latestCompactedEvent || e.endTime > latestCompactedEvent.endTime) {
+          latestCompactedEvent = e;
+        }
+      }
+    }
+    if (!latestCompactedEvent) {
+      return events;
+    }
+    const activeRawEvents = events.filter(
+      (e) => !(0, import_compacted_event.isCompactedEvent)(e) && e.timestamp > latestCompactedEvent.endTime
+    );
+    return [latestCompactedEvent, ...activeRawEvents];
+  }
+  shouldCompact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const rawEvents = activeEvents.filter((e) => !(0, import_compacted_event.isCompactedEvent)(e));
+    if (rawEvents.length <= this.eventRetentionSize) {
+      return false;
+    }
+    let totalTokens = 0;
+    for (const event of activeEvents) {
+      totalTokens += getEventTokens(event);
+    }
+    return totalTokens > this.tokenThreshold;
+  }
+  async compact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const rawEvents = activeEvents.filter((e) => !(0, import_compacted_event.isCompactedEvent)(e));
+    if (rawEvents.length <= this.eventRetentionSize) {
+      return;
+    }
+    let retainStartIndex = Math.max(
+      0,
+      rawEvents.length - this.eventRetentionSize
+    );
+    while (retainStartIndex > 0) {
+      const eventToRetain = rawEvents[retainStartIndex];
+      const previousEvent = rawEvents[retainStartIndex - 1];
+      if (hasFunctionResponse(eventToRetain) && hasFunctionCall(previousEvent)) {
+        retainStartIndex--;
+      } else {
+        break;
+      }
+    }
+    if (retainStartIndex === 0) {
+      return;
+    }
+    const rawEventsToCompact = rawEvents.slice(0, retainStartIndex);
+    const compactedEventPresent = activeEvents.find(import_compacted_event.isCompactedEvent);
+    const eventsToCompact = compactedEventPresent ? [compactedEventPresent, ...rawEventsToCompact] : rawEventsToCompact;
+    const compactedEvent = await this.summarizer.summarize(eventsToCompact);
+    if (!compactedEvent.actions) {
+      compactedEvent.actions = {
+        stateDelta: {},
+        artifactDelta: {},
+        requestedAuthConfigs: [],
+        requestedToolConfirmations: {}
+      };
+    }
+    invocationContext.session.events.push(compactedEvent);
+  }
+}
+function getEventTokens(event) {
+  var _a;
+  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
+    return event.usageMetadata.promptTokenCount;
+  }
+  const contentStr = (0, import_event.stringifyContent)(event);
+  return Math.ceil(contentStr.length / 4);
+}
+function hasFunctionCall(event) {
+  var _a, _b;
+  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
+    (part) => part.functionCall !== void 0
+  ));
+}
+function hasFunctionResponse(event) {
+  var _a, _b;
+  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
+    (part) => part.functionResponse !== void 0
+  ));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TokenBasedContextCompactor
+});

package/dist/cjs/context/truncating_context_compactor.js

@@ -0,0 +1,58 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var truncating_context_compactor_exports = {};
+__export(truncating_context_compactor_exports, {
+  TruncatingContextCompactor: () => TruncatingContextCompactor
+});
+module.exports = __toCommonJS(truncating_context_compactor_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class TruncatingContextCompactor {
+  constructor(options) {
+    var _a;
+    this.threshold = options.threshold;
+    this.preserveLeadingEvents = (_a = options.preserveLeadingEvents) != null ? _a : 0;
+  }
+  shouldCompact(invocationContext) {
+    const eventsLength = invocationContext.session.events.length;
+    return eventsLength > this.threshold + Math.max(0, this.preserveLeadingEvents);
+  }
+  compact(invocationContext) {
+    const events = invocationContext.session.events;
+    const excess = events.length - this.threshold - Math.max(0, this.preserveLeadingEvents);
+    if (excess <= 0) {
+      return;
+    }
+    const startIndexToRemove = Math.max(0, this.preserveLeadingEvents);
+    events.splice(startIndexToRemove, excess);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TruncatingContextCompactor
+});

package/dist/cjs/events/compacted_event.js

@@ -0,0 +1,53 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compacted_event_exports = {};
+__export(compacted_event_exports, {
+  createCompactedEvent: () => createCompactedEvent,
+  isCompactedEvent: () => isCompactedEvent
+});
+module.exports = __toCommonJS(compacted_event_exports);
+var import_event = require("./event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isCompactedEvent(event) {
+  return "isCompacted" in event && event.isCompacted === true;
+}
+function createCompactedEvent(params = {}) {
+  return {
+    ...(0, import_event.createEvent)(params),
+    isCompacted: params.isCompacted || true,
+    startTime: params.startTime,
+    endTime: params.endTime,
+    compactedContent: params.compactedContent
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCompactedEvent,
+  isCompactedEvent
+});

package/dist/cjs/events/event.js

@@ -0,0 +1,146 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_exports = {};
+__export(event_exports, {
+  createEvent: () => createEvent,
+  createNewEventId: () => createNewEventId,
+  getFunctionCalls: () => getFunctionCalls,
+  getFunctionResponses: () => getFunctionResponses,
+  hasTrailingCodeExecutionResult: () => hasTrailingCodeExecutionResult,
+  isFinalResponse: () => isFinalResponse,
+  stringifyContent: () => stringifyContent,
+  transformToCamelCaseEvent: () => transformToCamelCaseEvent,
+  transformToSnakeCaseEvent: () => transformToSnakeCaseEvent
+});
+module.exports = __toCommonJS(event_exports);
+var import_object_notation_utils = require("../utils/object_notation_utils.js");
+var import_event_actions = require("./event_actions.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createEvent(params = {}) {
+  return {
+    ...params,
+    id: params.id || createNewEventId(),
+    invocationId: params.invocationId || "",
+    author: params.author,
+    actions: params.actions || (0, import_event_actions.createEventActions)(),
+    longRunningToolIds: params.longRunningToolIds || [],
+    branch: params.branch,
+    timestamp: params.timestamp || Date.now()
+  };
+}
+function isFinalResponse(event) {
+  if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0) {
+    return true;
+  }
+  return getFunctionCalls(event).length === 0 && getFunctionResponses(event).length === 0 && !event.partial && !hasTrailingCodeExecutionResult(event);
+}
+function getFunctionCalls(event) {
+  const funcCalls = [];
+  if (event.content && event.content.parts) {
+    for (const part of event.content.parts) {
+      if (part.functionCall) {
+        funcCalls.push(part.functionCall);
+      }
+    }
+  }
+  return funcCalls;
+}
+function getFunctionResponses(event) {
+  const funcResponses = [];
+  if (event.content && event.content.parts) {
+    for (const part of event.content.parts) {
+      if (part.functionResponse) {
+        funcResponses.push(part.functionResponse);
+      }
+    }
+  }
+  return funcResponses;
+}
+function hasTrailingCodeExecutionResult(event) {
+  var _a;
+  if (event.content && ((_a = event.content.parts) == null ? void 0 : _a.length)) {
+    const lastPart = event.content.parts[event.content.parts.length - 1];
+    return lastPart.codeExecutionResult !== void 0;
+  }
+  return false;
+}
+function stringifyContent(event) {
+  var _a;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return "";
+  }
+  return event.content.parts.filter((part) => !part.thought).map((part) => {
+    var _a2;
+    return (_a2 = part.text) != null ? _a2 : "";
+  }).join("");
+}
+const ASCII_LETTERS_AND_NUMBERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function createNewEventId() {
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += ASCII_LETTERS_AND_NUMBERS[Math.floor(Math.random() * ASCII_LETTERS_AND_NUMBERS.length)];
+  }
+  return id;
+}
+const PRESERVE_KEYS_CAMEL_CASE = [
+  "actions.stateDelta",
+  "actions.artifactDelta",
+  "actions.requestedAuthConfigs",
+  "actions.requestedToolConfirmations",
+  "actions.customMetadata",
+  "content.parts.functionCall.args",
+  "content.parts.functionResponse.response"
+];
+const PRESERVE_KEYS_SNAKE_CASE = [
+  "actions.state_delta",
+  "actions.artifact_delta",
+  "actions.requested_auth_configs",
+  "actions.requested_tool_confirmations",
+  "actions.custom_metadata",
+  "content.parts.function_call.args",
+  "content.parts.function_response.response"
+];
+function transformToCamelCaseEvent(event) {
+  return (0, import_object_notation_utils.toCamelCase)(event, PRESERVE_KEYS_SNAKE_CASE);
+}
+function transformToSnakeCaseEvent(event) {
+  return (0, import_object_notation_utils.toSnakeCase)(event, PRESERVE_KEYS_CAMEL_CASE);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEvent,
+  createNewEventId,
+  getFunctionCalls,
+  getFunctionResponses,
+  hasTrailingCodeExecutionResult,
+  isFinalResponse,
+  stringifyContent,
+  transformToCamelCaseEvent,
+  transformToSnakeCaseEvent
+});

package/dist/cjs/events/event_actions.js

@@ -0,0 +1,83 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_actions_exports = {};
+__export(event_actions_exports, {
+  createEventActions: () => createEventActions,
+  mergeEventActions: () => mergeEventActions
+});
+module.exports = __toCommonJS(event_actions_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createEventActions(state = {}) {
+  return {
+    stateDelta: {},
+    artifactDelta: {},
+    requestedAuthConfigs: {},
+    requestedToolConfirmations: {},
+    ...state
+  };
+}
+function mergeEventActions(sources, target) {
+  const result = createEventActions();
+  if (target) {
+    Object.assign(result, target);
+  }
+  for (const source of sources) {
+    if (!source) continue;
+    if (source.stateDelta) {
+      Object.assign(result.stateDelta, source.stateDelta);
+    }
+    if (source.artifactDelta) {
+      Object.assign(result.artifactDelta, source.artifactDelta);
+    }
+    if (source.requestedAuthConfigs) {
+      Object.assign(result.requestedAuthConfigs, source.requestedAuthConfigs);
+    }
+    if (source.requestedToolConfirmations) {
+      Object.assign(
+        result.requestedToolConfirmations,
+        source.requestedToolConfirmations
+      );
+    }
+    if (source.skipSummarization !== void 0) {
+      result.skipSummarization = source.skipSummarization;
+    }
+    if (source.transferToAgent !== void 0) {
+      result.transferToAgent = source.transferToAgent;
+    }
+    if (source.escalate !== void 0) {
+      result.escalate = source.escalate;
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEventActions,
+  mergeEventActions
+});

package/dist/cjs/events/structured_events.js

@@ -0,0 +1,105 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var structured_events_exports = {};
+__export(structured_events_exports, {
+  EventType: () => EventType,
+  toStructuredEvents: () => toStructuredEvents
+});
+module.exports = __toCommonJS(structured_events_exports);
+var import_lodash_es = require("lodash-es");
+var import_event = require("./event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["THOUGHT"] = "thought";
+  EventType2["CONTENT"] = "content";
+  EventType2["TOOL_CALL"] = "tool_call";
+  EventType2["TOOL_RESULT"] = "tool_result";
+  EventType2["CALL_CODE"] = "call_code";
+  EventType2["CODE_RESULT"] = "code_result";
+  EventType2["ERROR"] = "error";
+  EventType2["ACTIVITY"] = "activity";
+  EventType2["TOOL_CONFIRMATION"] = "tool_confirmation";
+  EventType2["FINISHED"] = "finished";
+  return EventType2;
+})(EventType || {});
+function toStructuredEvents(event) {
+  var _a, _b;
+  const structuredEvents = [];
+  if (event.errorCode) {
+    structuredEvents.push({
+      type: "error" /* ERROR */,
+      error: new Error(event.errorMessage || event.errorCode)
+    });
+    return structuredEvents;
+  }
+  for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+    if (part.functionCall && !(0, import_lodash_es.isEmpty)(part.functionCall)) {
+      structuredEvents.push({
+        type: "tool_call" /* TOOL_CALL */,
+        call: part.functionCall
+      });
+    } else if (part.functionResponse && !(0, import_lodash_es.isEmpty)(part.functionResponse)) {
+      structuredEvents.push({
+        type: "tool_result" /* TOOL_RESULT */,
+        result: part.functionResponse
+      });
+    } else if (part.executableCode && !(0, import_lodash_es.isEmpty)(part.executableCode)) {
+      structuredEvents.push({
+        type: "call_code" /* CALL_CODE */,
+        code: part.executableCode
+      });
+    } else if (part.codeExecutionResult && !(0, import_lodash_es.isEmpty)(part.codeExecutionResult)) {
+      structuredEvents.push({
+        type: "code_result" /* CODE_RESULT */,
+        result: part.codeExecutionResult
+      });
+    } else if (part.text) {
+      if (part.thought) {
+        structuredEvents.push({ type: "thought" /* THOUGHT */, content: part.text });
+      } else {
+        structuredEvents.push({ type: "content" /* CONTENT */, content: part.text });
+      }
+    }
+  }
+  if (event.actions.requestedToolConfirmations && !(0, import_lodash_es.isEmpty)(event.actions.requestedToolConfirmations)) {
+    structuredEvents.push({
+      type: "tool_confirmation" /* TOOL_CONFIRMATION */,
+      confirmations: event.actions.requestedToolConfirmations
+    });
+  }
+  if ((0, import_event.isFinalResponse)(event)) {
+    structuredEvents.push({ type: "finished" /* FINISHED */, output: void 0 });
+  }
+  return structuredEvents;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventType,
+  toStructuredEvents
+});