@softactivate/adk 1.1.0

package/dist/cjs/agents/processors/content_processor_utils.js

@@ -0,0 +1,338 @@
+/**
+  * @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 content_processor_utils_exports = {};
+__export(content_processor_utils_exports, {
+  getContents: () => getContents,
+  getCurrentTurnContents: () => getCurrentTurnContents
+});
+module.exports = __toCommonJS(content_processor_utils_exports);
+var import_genai = require("@google/genai");
+var import_lodash_es = require("lodash-es");
+var import_compacted_event = require("../../events/compacted_event.js");
+var import_event = require("../../events/event.js");
+var import_functions = require("../functions.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getContents(events, agentName, currentBranch) {
+  var _a, _b, _c;
+  const filteredEvents = [];
+  for (const event of events) {
+    if ((0, import_compacted_event.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;
+    }
+    if (currentBranch && event.branch && !currentBranch.startsWith(event.branch)) {
+      continue;
+    }
+    if (isAuthEvent(event)) {
+      continue;
+    }
+    if (isToolConfirmationEvent(event)) {
+      continue;
+    }
+    filteredEvents.push(
+      isEventFromAnotherAgent(agentName, event) ? convertForeignEvent(event) : event
+    );
+  }
+  let resultEvents = rearrangeEventsForLatestFunctionResponse(filteredEvents);
+  resultEvents = rearrangeEventsForAsyncFunctionResponsesInHistory(resultEvents);
+  const contents = [];
+  for (const event of resultEvents) {
+    const content = (0, import_lodash_es.cloneDeep)(event.content);
+    (0, import_functions.removeClientFunctionCallId)(content);
+    contents.push(content);
+  }
+  return contents;
+}
+function getCurrentTurnContents(events, agentName, currentBranch) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author === "user" || isEventFromAnotherAgent(agentName, event)) {
+      return getContents(events.slice(i), agentName, currentBranch);
+    }
+  }
+  return [];
+}
+function isAuthEvent(event) {
+  var _a, _b, _c;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return false;
+  }
+  for (const part of event.content.parts) {
+    if (((_b = part.functionCall) == null ? void 0 : _b.name) === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
+      return true;
+    }
+  }
+  return false;
+}
+function isToolConfirmationEvent(event) {
+  var _a, _b, _c;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return false;
+  }
+  for (const part of event.content.parts) {
+    if (((_b = part.functionCall) == null ? void 0 : _b.name) === import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME || ((_c = part.functionResponse) == null ? void 0 : _c.name) === import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+      return true;
+    }
+  }
+  return false;
+}
+function isEventFromAnotherAgent(agentName, event) {
+  return !!agentName && event.author !== agentName && event.author !== "user";
+}
+function convertForeignEvent(event) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+    return event;
+  }
+  const content = {
+    role: "user",
+    parts: [
+      {
+        text: "For context:"
+      }
+    ]
+  };
+  for (const part of event.content.parts) {
+    if (part.text && !part.thought) {
+      (_c = content.parts) == null ? void 0 : _c.push({
+        text: `[${event.author}] said: ${part.text}`
+      });
+    } else if (part.functionCall) {
+      const argsText = safeStringify(part.functionCall.args);
+      (_d = content.parts) == null ? void 0 : _d.push({
+        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${argsText}`
+      });
+    } else if (part.functionResponse) {
+      const responseText = safeStringify(part.functionResponse.response);
+      (_e = content.parts) == null ? void 0 : _e.push({
+        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${responseText}`
+      });
+    } else {
+      (_f = content.parts) == null ? void 0 : _f.push(part);
+    }
+  }
+  return (0, import_event.createEvent)({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
+function mergeFunctionResponseEvents(events) {
+  var _a;
+  if (events.length === 0) {
+    throw new Error("Cannot merge an empty list of events.");
+  }
+  const mergedEvent = (0, import_event.createEvent)(events[0]);
+  const partsInMergedEvent = ((_a = mergedEvent.content) == null ? void 0 : _a.parts) || [];
+  if (partsInMergedEvent.length === 0) {
+    throw new Error("There should be at least one function_response part.");
+  }
+  const partIndicesInMergedEvent = {};
+  for (let i = 0; i < partsInMergedEvent.length; i++) {
+    const part = partsInMergedEvent[i];
+    if (part.functionResponse && part.functionResponse.id) {
+      partIndicesInMergedEvent[part.functionResponse.id] = i;
+    }
+  }
+  for (const event of events.slice(1)) {
+    if (!event.content || !event.content.parts) {
+      throw new Error("There should be at least one function_response part.");
+    }
+    for (const part of event.content.parts) {
+      if (part.functionResponse && part.functionResponse.id) {
+        const functionCallId = part.functionResponse.id;
+        if (functionCallId in partIndicesInMergedEvent) {
+          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
+        } else {
+          partsInMergedEvent.push(part);
+          partIndicesInMergedEvent[functionCallId] = partsInMergedEvent.length - 1;
+        }
+      } else {
+        partsInMergedEvent.push(part);
+      }
+    }
+  }
+  return mergedEvent;
+}
+function rearrangeEventsForLatestFunctionResponse(events) {
+  if (events.length === 0) {
+    return events;
+  }
+  const latestEvent = events[events.length - 1];
+  const functionResponses = (0, import_event.getFunctionResponses)(latestEvent);
+  if (!(functionResponses == null ? void 0 : functionResponses.length)) {
+    return events;
+  }
+  let functionResponsesIds = new Set(
+    functionResponses.filter((response) => !!response.id).map((response) => response.id)
+  );
+  const secondLatestEvent = events.at(-2);
+  if (secondLatestEvent) {
+    const functionCallsFromSecondLatest = (0, import_event.getFunctionCalls)(secondLatestEvent);
+    if (functionCallsFromSecondLatest) {
+      for (const functionCall of functionCallsFromSecondLatest) {
+        if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
+          return events;
+        }
+      }
+    }
+  }
+  let functionCallEventIdx = -1;
+  for (let idx = events.length - 2; idx >= 0; idx--) {
+    const event = events[idx];
+    const functionCalls = (0, import_event.getFunctionCalls)(event);
+    if (!(functionCalls == null ? void 0 : functionCalls.length)) {
+      continue;
+    }
+    for (const functionCall of functionCalls) {
+      if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
+        functionCallEventIdx = idx;
+        const functionCallIds = new Set(
+          functionCalls.map((fc) => fc.id).filter((id) => !!id)
+        );
+        const isSubset = Array.from(functionResponsesIds).every(
+          (id) => functionCallIds.has(id)
+        );
+        if (!isSubset) {
+          throw new Error(
+            `Last response event should only contain the responses for the function calls in the same function call event. Function call ids found : ${Array.from(functionCallIds).join(
+              ", "
+            )}, function response ids provided: ${Array.from(functionResponsesIds).join(", ")}`
+          );
+        }
+        functionResponsesIds = functionCallIds;
+        break;
+      }
+    }
+  }
+  if (functionCallEventIdx === -1) {
+    throw new Error(
+      `No function call event found for function responses ids: ${Array.from(
+        functionResponsesIds
+      ).join(", ")}`
+    );
+  }
+  const functionResponseEvents = [];
+  for (let idx = functionCallEventIdx + 1; idx < events.length - 1; idx++) {
+    const event = events[idx];
+    const responses = (0, import_event.getFunctionResponses)(event);
+    if (responses && responses.some(
+      (response) => response.id && functionResponsesIds.has(response.id)
+    )) {
+      functionResponseEvents.push(event);
+    }
+  }
+  functionResponseEvents.push(events[events.length - 1]);
+  const resultEvents = events.slice(0, functionCallEventIdx + 1);
+  resultEvents.push(mergeFunctionResponseEvents(functionResponseEvents));
+  return resultEvents;
+}
+function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
+  const functionCallIdToResponseEventIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    const functionResponses = (0, import_event.getFunctionResponses)(event);
+    if (functionResponses == null ? void 0 : functionResponses.length) {
+      for (const functionResponse of functionResponses) {
+        if (!functionResponse.id) {
+          continue;
+        }
+        functionCallIdToResponseEventIndex.set(functionResponse.id, i);
+      }
+    }
+  }
+  const resultEvents = [];
+  for (const event of events) {
+    if ((0, import_event.getFunctionResponses)(event).length > 0) {
+      continue;
+    }
+    const functionCalls = (0, import_event.getFunctionCalls)(event);
+    if (functionCalls == null ? void 0 : functionCalls.length) {
+      const functionResponseEventsIndices = /* @__PURE__ */ new Set();
+      for (const functionCall of functionCalls) {
+        const functionCallId = functionCall.id;
+        if (functionCallId && functionCallIdToResponseEventIndex.has(functionCallId)) {
+          functionResponseEventsIndices.add(
+            functionCallIdToResponseEventIndex.get(functionCallId)
+          );
+        }
+      }
+      resultEvents.push(event);
+      if (functionResponseEventsIndices.size === 0) {
+        continue;
+      }
+      if (functionResponseEventsIndices.size === 1) {
+        const [responseIndex] = [...functionResponseEventsIndices];
+        resultEvents.push(events[responseIndex]);
+      } else {
+        const indicesArray = Array.from(functionResponseEventsIndices).sort(
+          (a, b) => a - b
+        );
+        const eventsToMerge = indicesArray.map((index) => events[index]);
+        resultEvents.push(mergeFunctionResponseEvents(eventsToMerge));
+      }
+    } else {
+      resultEvents.push(event);
+    }
+  }
+  return resultEvents;
+}
+function safeStringify(obj) {
+  if (typeof obj === "string") {
+    return obj;
+  }
+  try {
+    return JSON.stringify(obj);
+  } catch (_e) {
+    return String(obj);
+  }
+}
+function convertCompactedEvent(event) {
+  const content = (0, import_genai.createUserContent)(
+    `[Previous Context Summary]:
+${event.compactedContent}`
+  );
+  return (0, import_event.createEvent)({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContents,
+  getCurrentTurnContents
+});

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

@@ -0,0 +1,87 @@
+/**
+  * @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 content_request_processor_exports = {};
+__export(content_request_processor_exports, {
+  CONTENT_REQUEST_PROCESSOR: () => CONTENT_REQUEST_PROCESSOR,
+  ContentRequestProcessor: () => ContentRequestProcessor
+});
+module.exports = __toCommonJS(content_request_processor_exports);
+var import_compacted_event = require("../../events/compacted_event.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_content_processor_utils = require("./content_processor_utils.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ContentRequestProcessor {
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!agent || !(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    let events = invocationContext.session.events;
+    const compactedEvents = events.filter(import_compacted_event.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 ((0, import_compacted_event.isCompactedEvent)(event)) {
+          return false;
+        }
+        if (event.timestamp <= latestCompactedEvent.endTime) {
+          return false;
+        }
+        return true;
+      });
+      events = [latestCompactedEvent, ...remainingEvents];
+    }
+    if (agent.includeContents === "default") {
+      llmRequest.contents = (0, import_content_processor_utils.getContents)(
+        events,
+        agent.name,
+        invocationContext.branch
+      );
+    } else {
+      llmRequest.contents = (0, import_content_processor_utils.getCurrentTurnContents)(
+        events,
+        agent.name,
+        invocationContext.branch
+      );
+    }
+    return;
+  }
+}
+const CONTENT_REQUEST_PROCESSOR = new ContentRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTENT_REQUEST_PROCESSOR,
+  ContentRequestProcessor
+});

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

@@ -0,0 +1,70 @@
+/**
+  * @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 context_compactor_request_processor_exports = {};
+__export(context_compactor_request_processor_exports, {
+  ContextCompactorRequestProcessor: () => ContextCompactorRequestProcessor
+});
+module.exports = __toCommonJS(context_compactor_request_processor_exports);
+var import_base_plugin = require("../../plugins/base_plugin.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ContextCompactorRequestProcessor {
+  constructor(compactors) {
+    this.compactors = compactors;
+  }
+  async *runAsync(invocationContext, _llmRequest) {
+    for (const compactor of this.compactors) {
+      const shouldCompact = await Promise.resolve(
+        compactor.shouldCompact(invocationContext)
+      );
+      if (shouldCompact) {
+        await invocationContext.pluginManager.runBeforeContextCompaction({
+          invocationContext,
+          trigger: import_base_plugin.ContextCompactionTrigger.Auto
+        });
+        const oldEvents = new Set(invocationContext.session.events);
+        await Promise.resolve(compactor.compact(invocationContext));
+        await invocationContext.pluginManager.runAfterContextCompaction({
+          invocationContext,
+          trigger: import_base_plugin.ContextCompactionTrigger.Auto
+        });
+        const newEvents = invocationContext.session.events.filter(
+          (e) => !oldEvents.has(e)
+        );
+        for (const e of newEvents) {
+          yield e;
+        }
+        return;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextCompactorRequestProcessor
+});

package/dist/cjs/agents/processors/identity_llm_request_processor.js

@@ -0,0 +1,54 @@
+/**
+  * @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 identity_llm_request_processor_exports = {};
+__export(identity_llm_request_processor_exports, {
+  IDENTITY_LLM_REQUEST_PROCESSOR: () => IDENTITY_LLM_REQUEST_PROCESSOR,
+  IdentityLlmRequestProcessor: () => IdentityLlmRequestProcessor
+});
+module.exports = __toCommonJS(identity_llm_request_processor_exports);
+var import_llm_request = require("../../models/llm_request.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class IdentityLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    const si = [`You are an agent. Your internal name is "${agent.name}".`];
+    if (agent.description) {
+      si.push(`The description about you is "${agent.description}"`);
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, si);
+  }
+}
+const IDENTITY_LLM_REQUEST_PROCESSOR = new IdentityLlmRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IDENTITY_LLM_REQUEST_PROCESSOR,
+  IdentityLlmRequestProcessor
+});

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

@@ -0,0 +1,85 @@
+/**
+  * @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 instructions_llm_request_processor_exports = {};
+__export(instructions_llm_request_processor_exports, {
+  INSTRUCTIONS_LLM_REQUEST_PROCESSOR: () => INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
+  InstructionsLlmRequestProcessor: () => InstructionsLlmRequestProcessor
+});
+module.exports = __toCommonJS(instructions_llm_request_processor_exports);
+var import_llm_request = require("../../models/llm_request.js");
+var import_instructions = require("../instructions.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_readonly_context = require("../readonly_context.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /**
+   * Handles instructions and global instructions for LLM flow.
+   */
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    const rootAgent = agent.rootAgent;
+    if ((0, import_llm_agent.isLlmAgent)(rootAgent) && rootAgent.globalInstruction) {
+      const { instruction, requireStateInjection } = await rootAgent.canonicalGlobalInstruction(
+        new import_readonly_context.ReadonlyContext(invocationContext)
+      );
+      let instructionWithState = instruction;
+      if (requireStateInjection) {
+        instructionWithState = await (0, import_instructions.injectSessionState)(
+          instruction,
+          new import_readonly_context.ReadonlyContext(invocationContext)
+        );
+      }
+      (0, import_llm_request.appendInstructions)(llmRequest, [instructionWithState]);
+    }
+    if (agent.instruction) {
+      const { instruction, requireStateInjection } = await agent.canonicalInstruction(
+        new import_readonly_context.ReadonlyContext(invocationContext)
+      );
+      let instructionWithState = instruction;
+      if (requireStateInjection) {
+        instructionWithState = await (0, import_instructions.injectSessionState)(
+          instruction,
+          new import_readonly_context.ReadonlyContext(invocationContext)
+        );
+      }
+      (0, import_llm_request.appendInstructions)(llmRequest, [instructionWithState]);
+    }
+  }
+}
+const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
+  InstructionsLlmRequestProcessor
+});