@softactivate/adk 1.1.0

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

@@ -0,0 +1,76 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createCompactedEvent
+} from "../../events/compacted_event.js";
+import { stringifyContent } from "../../events/event.js";
+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 ".concat(i + 1, " - Author: ").concat(events[i].author, "]\n");
+      formattedEvents += "".concat(stringifyContent(events[i]), "\n\n");
+    }
+    const fullPrompt = "".concat(this.prompt, "\n\n").concat(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;
+    try {
+      for (var iter = __forAwait(responseGen), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const chunk = temp.value;
+        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;
+        }
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    return createCompactedEvent({
+      author: "system",
+      content: {
+        role: "model",
+        parts: [{ text: compactedContent }]
+      },
+      startTime,
+      endTime,
+      compactedContent
+    });
+  }
+}
+export {
+  LlmSummarizer
+};

package/dist/web/context/token_based_context_compactor.js

@@ -0,0 +1,107 @@
+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 { stringifyContent } from "../events/event.js";
+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 (isCompactedEvent(e)) {
+        if (!latestCompactedEvent || e.endTime > latestCompactedEvent.endTime) {
+          latestCompactedEvent = e;
+        }
+      }
+    }
+    if (!latestCompactedEvent) {
+      return events;
+    }
+    const activeRawEvents = events.filter(
+      (e) => !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) => !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) => !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(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 = 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
+  ));
+}
+export {
+  TokenBasedContextCompactor
+};

package/dist/web/context/truncating_context_compactor.js

@@ -0,0 +1,30 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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);
+  }
+}
+export {
+  TruncatingContextCompactor
+};

package/dist/web/events/compacted_event.js

@@ -0,0 +1,42 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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 { createEvent } from "./event.js";
+function isCompactedEvent(event) {
+  return "isCompacted" in event && event.isCompacted === true;
+}
+function createCompactedEvent(params = {}) {
+  return __spreadProps(__spreadValues({}, createEvent(params)), {
+    isCompacted: params.isCompacted || true,
+    startTime: params.startTime,
+    endTime: params.endTime,
+    compactedContent: params.compactedContent
+  });
+}
+export {
+  createCompactedEvent,
+  isCompactedEvent
+};

package/dist/web/events/event.js

@@ -0,0 +1,128 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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 { toCamelCase, toSnakeCase } from "../utils/object_notation_utils.js";
+import { createEventActions } from "./event_actions.js";
+function createEvent(params = {}) {
+  return __spreadProps(__spreadValues({}, params), {
+    id: params.id || createNewEventId(),
+    invocationId: params.invocationId || "",
+    author: params.author,
+    actions: params.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 toCamelCase(event, PRESERVE_KEYS_SNAKE_CASE);
+}
+function transformToSnakeCaseEvent(event) {
+  return toSnakeCase(event, PRESERVE_KEYS_CAMEL_CASE);
+}
+export {
+  createEvent,
+  createNewEventId,
+  getFunctionCalls,
+  getFunctionResponses,
+  hasTrailingCodeExecutionResult,
+  isFinalResponse,
+  stringifyContent,
+  transformToCamelCaseEvent,
+  transformToSnakeCaseEvent
+};

package/dist/web/events/event_actions.js

@@ -0,0 +1,69 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createEventActions(state = {}) {
+  return __spreadValues({
+    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;
+}
+export {
+  createEventActions,
+  mergeEventActions
+};

package/dist/web/events/structured_events.js

@@ -0,0 +1,76 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isEmpty } from "lodash-es";
+import { isFinalResponse } from "./event.js";
+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 && !isEmpty(part.functionCall)) {
+      structuredEvents.push({
+        type: "tool_call" /* TOOL_CALL */,
+        call: part.functionCall
+      });
+    } else if (part.functionResponse && !isEmpty(part.functionResponse)) {
+      structuredEvents.push({
+        type: "tool_result" /* TOOL_RESULT */,
+        result: part.functionResponse
+      });
+    } else if (part.executableCode && !isEmpty(part.executableCode)) {
+      structuredEvents.push({
+        type: "call_code" /* CALL_CODE */,
+        code: part.executableCode
+      });
+    } else if (part.codeExecutionResult && !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 && !isEmpty(event.actions.requestedToolConfirmations)) {
+    structuredEvents.push({
+      type: "tool_confirmation" /* TOOL_CONFIRMATION */,
+      confirmations: event.actions.requestedToolConfirmations
+    });
+  }
+  if (isFinalResponse(event)) {
+    structuredEvents.push({ type: "finished" /* FINISHED */, output: void 0 });
+  }
+  return structuredEvents;
+}
+export {
+  EventType,
+  toStructuredEvents
+};

package/dist/web/examples/base_example_provider.js

@@ -0,0 +1,27 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL = Symbol.for(
+  "google.adk.baseExampleProvider"
+);
+function isBaseExampleProvider(obj) {
+  return typeof obj === "object" && obj !== null && BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL in obj && obj[BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL;
+class BaseExampleProvider {
+  constructor() {
+    /**
+     * A unique symbol to identify ADK example provider classes.
+     */
+    this[_a] = true;
+  }
+}
+export {
+  BaseExampleProvider,
+  isBaseExampleProvider
+};

package/dist/web/examples/example.js

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

package/dist/web/examples/example_util.js

@@ -0,0 +1,79 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  isBaseExampleProvider
+} from "./base_example_provider.js";
+const EXAMPLES_INTRO = "<EXAMPLES>\nBegin few-shot\nThe following are examples of user queries and model responses using the available tools.\n\n";
+const EXAMPLES_END = "End few-shot\n<EXAMPLES>";
+const EXAMPLE_START = "EXAMPLE {}:\nBegin example\n";
+const EXAMPLE_END = "End example\n\n";
+const USER_PREFIX = "[user]\n";
+const MODEL_PREFIX = "[model]\n";
+const FUNCTION_PREFIX = "```\n";
+const FUNCTION_CALL_PREFIX = "```tool_code\n";
+const FUNCTION_CALL_SUFFIX = "\n```\n";
+const FUNCTION_RESPONSE_PREFIX = "```tool_outputs\n";
+const FUNCTION_RESPONSE_SUFFIX = "\n```\n";
+function convertExamplesToText(examples, model) {
+  var _a;
+  let examplesStr = "";
+  for (const [exampleNum, example] of examples.entries()) {
+    let output = "".concat(EXAMPLE_START.replace("{}", String(exampleNum + 1))).concat(USER_PREFIX);
+    if ((_a = example.input) == null ? void 0 : _a.parts) {
+      output += example.input.parts.filter((part) => part.text).map((part) => part.text).join("\n") + "\n";
+    }
+    const gemini2 = !model || model.includes("gemini-2");
+    let previousRole;
+    for (const content of example.output) {
+      const role = content.role === "model" ? MODEL_PREFIX : USER_PREFIX;
+      if (role !== previousRole) {
+        output += role;
+      }
+      previousRole = role;
+      for (const part of content.parts || []) {
+        if (part.functionCall) {
+          const prefix = gemini2 ? FUNCTION_PREFIX : FUNCTION_CALL_PREFIX;
+          const functionCall = part.functionCall;
+          const args = [];
+          if (functionCall.args) {
+            for (const [k, v] of Object.entries(functionCall.args)) {
+              if (typeof v === "string") {
+                args.push("".concat(k, "='").concat(v, "'"));
+              } else {
+                args.push("".concat(k, "=").concat(v));
+              }
+            }
+          }
+          const functionCallString = "".concat(functionCall.name, "(").concat(args.join(", "), ")");
+          output += "".concat(prefix).concat(functionCallString).concat(FUNCTION_CALL_SUFFIX);
+        } else if (part.functionResponse) {
+          const prefix = gemini2 ? FUNCTION_PREFIX : FUNCTION_RESPONSE_PREFIX;
+          output += "".concat(prefix).concat(JSON.stringify(part.functionResponse)).concat(FUNCTION_RESPONSE_SUFFIX);
+        } else if (part.text) {
+          output += "".concat(part.text, "\n");
+        }
+      }
+    }
+    output += EXAMPLE_END;
+    examplesStr += output;
+  }
+  return "".concat(EXAMPLES_INTRO).concat(examplesStr).concat(EXAMPLES_END);
+}
+function buildExampleSi(examples, query, model) {
+  if (Array.isArray(examples)) {
+    return convertExamplesToText(examples, model);
+  }
+  if (isBaseExampleProvider(examples)) {
+    return convertExamplesToText(examples.getExamples(query), model);
+  }
+  throw new Error("Invalid example configuration");
+}
+export {
+  buildExampleSi,
+  convertExamplesToText
+};