@google/adk 1.3.0 → 1.5.0

package/dist/esm/models/interactions_utils.js

@@ -0,0 +1,697 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  Outcome
+} from "@google/genai";
+import { logger } from "../utils/logger.js";
+function getInteractionMediaType(mimeType) {
+  switch (mimeType.split("/")[0]) {
+    case "image":
+      return "image";
+    case "audio":
+      return "audio";
+    case "video":
+      return "video";
+    default:
+      return "document";
+  }
+}
+function getLatestUserContents(contents) {
+  if (!contents || contents.length === 0) {
+    return [];
+  }
+  const latestUserContents = [];
+  for (let i = contents.length - 1; i >= 0; i--) {
+    const content = contents[i];
+    if (content.role === "user") {
+      latestUserContents.unshift(content);
+    } else {
+      break;
+    }
+  }
+  let hasFunctionResult = false;
+  for (const content of latestUserContents) {
+    if (content.parts) {
+      for (const part of content.parts) {
+        if (part.functionResponse !== void 0 && part.functionResponse !== null) {
+          hasFunctionResult = true;
+          break;
+        }
+      }
+    }
+    if (hasFunctionResult) {
+      break;
+    }
+  }
+  if (hasFunctionResult && contents.length > latestUserContents.length) {
+    const userStartIdx = contents.length - latestUserContents.length;
+    if (userStartIdx > 0) {
+      const precedingContent = contents[userStartIdx - 1];
+      if (precedingContent.role === "model" && precedingContent.parts) {
+        for (const part of precedingContent.parts) {
+          if (part.functionCall !== void 0 && part.functionCall !== null) {
+            return [precedingContent, ...latestUserContents];
+          }
+        }
+      }
+    }
+  }
+  return latestUserContents;
+}
+function convertPartToMediaContent(part) {
+  if (part.text !== void 0 && part.text !== null) {
+    return { type: "text", text: part.text };
+  }
+  if (part.inlineData !== void 0 && part.inlineData !== null) {
+    const mimeType = part.inlineData.mimeType || "";
+    return {
+      type: getInteractionMediaType(mimeType),
+      data: part.inlineData.data,
+      mime_type: mimeType
+    };
+  }
+  if (part.fileData !== void 0 && part.fileData !== null) {
+    const mimeType = part.fileData.mimeType || "";
+    return {
+      type: getInteractionMediaType(mimeType),
+      uri: part.fileData.fileUri,
+      mime_type: mimeType
+    };
+  }
+  return null;
+}
+function convertContentToSteps(content) {
+  const steps = [];
+  const role = content.role || "user";
+  if (role === "user") {
+    const mediaContents = [];
+    if (content.parts) {
+      for (const part of content.parts) {
+        if (part.functionResponse) {
+          steps.push({
+            type: "function_result",
+            call_id: part.functionResponse.id || "",
+            name: part.functionResponse.name || "",
+            result: part.functionResponse.response
+          });
+        } else if (part.codeExecutionResult) {
+          const isError = part.codeExecutionResult.outcome === Outcome.OUTCOME_FAILED || part.codeExecutionResult.outcome === Outcome.OUTCOME_DEADLINE_EXCEEDED;
+          steps.push({
+            type: "code_execution_result",
+            call_id: "",
+            result: part.codeExecutionResult.output || "",
+            is_error: isError
+          });
+        } else {
+          const mediaContent = convertPartToMediaContent(part);
+          if (mediaContent) {
+            mediaContents.push(mediaContent);
+          }
+        }
+      }
+    }
+    if (mediaContents.length > 0) {
+      steps.push({
+        type: "user_input",
+        content: mediaContents
+      });
+    }
+  } else if (role === "model") {
+    const mediaContents = [];
+    if (content.parts) {
+      for (const part of content.parts) {
+        if (part.functionCall) {
+          const step = {
+            type: "function_call",
+            id: part.functionCall.id || "",
+            name: part.functionCall.name || "",
+            arguments: part.functionCall.args || {}
+          };
+          if (part.thoughtSignature) {
+            step.signature = part.thoughtSignature;
+          }
+          steps.push(step);
+        } else if (part.executableCode) {
+          steps.push({
+            type: "code_execution_call",
+            id: "",
+            arguments: {
+              code: part.executableCode.code || "",
+              language: "python"
+            }
+          });
+        } else if (part.thought) {
+          const step = {
+            type: "thought"
+          };
+          if (part.thoughtSignature) {
+            step.signature = part.thoughtSignature;
+          }
+          steps.push(step);
+        } else {
+          const mediaContent = convertPartToMediaContent(part);
+          if (mediaContent) {
+            mediaContents.push(mediaContent);
+          }
+        }
+      }
+    }
+    if (mediaContents.length > 0) {
+      steps.push({
+        type: "model_output",
+        content: mediaContents
+      });
+    }
+  }
+  return steps;
+}
+function convertMediaContentToPart(content) {
+  if (content.type === "text") {
+    return { text: content.text || "" };
+  }
+  if (content.type === "image" || content.type === "audio" || content.type === "video" || content.type === "document") {
+    const media = content;
+    if (media.data) {
+      return {
+        inlineData: {
+          data: media.data,
+          mimeType: media.mime_type || ""
+        }
+      };
+    } else if (media.uri) {
+      return {
+        fileData: {
+          fileUri: media.uri,
+          mimeType: media.mime_type || ""
+        }
+      };
+    }
+  }
+  return null;
+}
+function convertStepToParts(step) {
+  if (!step || !step.type) {
+    return [];
+  }
+  switch (step.type) {
+    case "model_output": {
+      const modelOutputStep = step;
+      const parts = [];
+      if (modelOutputStep.content) {
+        for (const content of modelOutputStep.content) {
+          const part = convertMediaContentToPart(content);
+          if (part) {
+            parts.push(part);
+          }
+        }
+      }
+      return parts;
+    }
+    case "user_input": {
+      const userInputStep = step;
+      const parts = [];
+      if (userInputStep.content) {
+        for (const content of userInputStep.content) {
+          const part = convertMediaContentToPart(content);
+          if (part) {
+            parts.push(part);
+          }
+        }
+      }
+      return parts;
+    }
+    case "function_call": {
+      const functionCallStep = step;
+      const part = {
+        functionCall: {
+          id: functionCallStep.id,
+          name: functionCallStep.name,
+          args: functionCallStep.arguments || {}
+        }
+      };
+      if (functionCallStep.signature) {
+        part.thoughtSignature = functionCallStep.signature;
+      }
+      return [part];
+    }
+    case "function_result": {
+      const functionResultStep = step;
+      const result = functionResultStep.result;
+      return [
+        {
+          functionResponse: {
+            id: functionResultStep.call_id,
+            name: functionResultStep.name || "",
+            response: typeof result === "object" && result !== null ? result : { output: result }
+          }
+        }
+      ];
+    }
+    case "code_execution_call": {
+      const codeExecutionCallStep = step;
+      const args = codeExecutionCallStep.arguments || {};
+      return [
+        {
+          executableCode: {
+            code: args.code || "",
+            language: (args.language || "PYTHON").toUpperCase()
+          }
+        }
+      ];
+    }
+    case "code_execution_result": {
+      const codeExecutionResultStep = step;
+      return [
+        {
+          codeExecutionResult: {
+            output: codeExecutionResultStep.result || "",
+            outcome: codeExecutionResultStep.is_error ? Outcome.OUTCOME_FAILED : Outcome.OUTCOME_OK
+          }
+        }
+      ];
+    }
+    case "thought": {
+      const thoughtStep = step;
+      const part = {
+        thought: true
+      };
+      if (thoughtStep.signature) {
+        part.thoughtSignature = thoughtStep.signature;
+      }
+      return [part];
+    }
+    default:
+      return [];
+  }
+}
+function convertToolsConfigToInteractionsFormat(config) {
+  if (!config.tools) {
+    return [];
+  }
+  const interactionTools = [];
+  for (const tool of config.tools) {
+    const t = tool;
+    if (t.functionDeclarations) {
+      for (const funcDecl of t.functionDeclarations) {
+        const funcTool = {
+          type: "function",
+          name: funcDecl.name
+        };
+        if (funcDecl.description) {
+          funcTool.description = funcDecl.description;
+        }
+        if (funcDecl.parameters) {
+          if (funcDecl.parameters.properties) {
+            const props = {};
+            for (const [k, v] of Object.entries(
+              funcDecl.parameters.properties
+            )) {
+              props[k] = JSON.parse(JSON.stringify(v));
+            }
+            funcTool.parameters = {
+              type: "object",
+              properties: props,
+              required: funcDecl.parameters.required ? [...funcDecl.parameters.required] : void 0
+            };
+          }
+        } else if (funcDecl.parametersJsonSchema) {
+          funcTool.parameters = funcDecl.parametersJsonSchema;
+        }
+        interactionTools.push(funcTool);
+      }
+    }
+    if (t.googleSearch) {
+      interactionTools.push({ type: "google_search" });
+    }
+    if (t.codeExecution) {
+      interactionTools.push({ type: "code_execution" });
+    }
+    if (t.urlContext) {
+      interactionTools.push({ type: "url_context" });
+    }
+  }
+  return interactionTools;
+}
+function findLastPart(parts, predicate) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if (predicate(parts[i])) {
+      return parts[i];
+    }
+  }
+  return void 0;
+}
+function getLatestModelParts(steps) {
+  if (!steps || steps.length === 0) {
+    return [];
+  }
+  const latestParts = [];
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const step = steps[i];
+    if (step.type === "user_input" || step.type === "function_result" || step.type === "code_execution_result") {
+      break;
+    }
+    const parts = convertStepToParts(step);
+    latestParts.unshift(...parts);
+  }
+  return latestParts;
+}
+function convertInteractionToLlmResponse(interaction) {
+  if (interaction.status === "failed") {
+    let errorMsg = "Unknown error";
+    let errorCode = "UNKNOWN_ERROR";
+    if (interaction.error) {
+      errorMsg = interaction.error.message || errorMsg;
+      errorCode = interaction.error.code || errorCode;
+    }
+    return {
+      errorCode,
+      errorMessage: errorMsg,
+      interactionId: interaction.id
+    };
+  }
+  const parts = getLatestModelParts(interaction.steps || []);
+  let content = void 0;
+  if (parts.length > 0) {
+    content = { role: "model", parts };
+  }
+  let usageMetadata = void 0;
+  if (interaction.usage) {
+    const inputTokens = interaction.usage.total_input_tokens || 0;
+    const outputTokens = interaction.usage.total_output_tokens || 0;
+    usageMetadata = {
+      promptTokenCount: inputTokens,
+      candidatesTokenCount: outputTokens,
+      totalTokenCount: inputTokens + outputTokens
+    };
+  }
+  let finishReason = void 0;
+  if (interaction.status === "completed" || interaction.status === "requires_action") {
+    finishReason = "STOP";
+  }
+  return {
+    content,
+    usageMetadata,
+    finishReason,
+    turnComplete: interaction.status === "completed" || interaction.status === "requires_action",
+    interactionId: interaction.id
+  };
+}
+function convertInteractionEventToLlmResponse(event, aggregatedParts, interactionId) {
+  var _a, _b;
+  const eventType = event.event_type || event.eventType;
+  if (eventType === "step.start") {
+    const stepStart = event;
+    const step = stepStart.step;
+    if (step.type === "function_call") {
+      const fcStep = step;
+      const part = {
+        functionCall: {
+          id: fcStep.id,
+          name: fcStep.name,
+          args: {}
+        },
+        partMetadata: {
+          accumulatedArgs: "",
+          isComplete: false
+        }
+      };
+      if (fcStep.signature) {
+        part.thoughtSignature = fcStep.signature;
+      }
+      aggregatedParts.push(part);
+      return null;
+    }
+    if (step.type === "thought") {
+      const part = {
+        thought: true,
+        partMetadata: {
+          isComplete: false
+        }
+      };
+      if (step.signature) {
+        part.thoughtSignature = step.signature;
+      }
+      aggregatedParts.push(part);
+      return null;
+    }
+  } else if (eventType === "step.delta") {
+    const stepDelta = event;
+    const delta = stepDelta.delta;
+    if (!delta) {
+      return null;
+    }
+    if (delta.type === "text") {
+      const text = delta.text || "";
+      if (text) {
+        const part = { text };
+        aggregatedParts.push(part);
+        return {
+          content: { role: "model", parts: [part] },
+          partial: true,
+          turnComplete: false,
+          interactionId
+        };
+      }
+    } else if (delta.type === "arguments_delta") {
+      const activePart = findLastPart(
+        aggregatedParts,
+        (p) => !!(p.functionCall && p.partMetadata && !p.partMetadata.isComplete)
+      );
+      if (activePart && activePart.partMetadata && delta.arguments) {
+        activePart.partMetadata.accumulatedArgs = activePart.partMetadata.accumulatedArgs + delta.arguments;
+      }
+      return null;
+    } else if (delta.type === "thought_signature") {
+      const activePart = findLastPart(
+        aggregatedParts,
+        (p) => !!((p.thought || p.functionCall) && p.partMetadata && !p.partMetadata.isComplete)
+      );
+      if (activePart && delta.signature) {
+        activePart.thoughtSignature = delta.signature;
+      }
+      return null;
+    } else if (delta.type === "image" || delta.type === "audio" || delta.type === "video" || delta.type === "document") {
+      const part = convertMediaContentToPart(delta);
+      if (part) {
+        aggregatedParts.push(part);
+        return {
+          content: { role: "model", parts: [part] },
+          partial: false,
+          turnComplete: false,
+          interactionId
+        };
+      }
+    }
+  } else if (eventType === "step.stop") {
+    const activePart = findLastPart(
+      aggregatedParts,
+      (p) => !!(p.partMetadata && !p.partMetadata.isComplete)
+    );
+    if (activePart && activePart.partMetadata) {
+      activePart.partMetadata.isComplete = true;
+      if (activePart.functionCall) {
+        const accumulatedArgs = activePart.partMetadata.accumulatedArgs;
+        try {
+          activePart.functionCall.args = accumulatedArgs ? JSON.parse(accumulatedArgs) : {};
+        } catch (e) {
+          logger.error(
+            `Failed to parse accumulated arguments: ${accumulatedArgs}`,
+            e
+          );
+          activePart.functionCall.args = {};
+        }
+        delete activePart.partMetadata;
+        return {
+          content: { role: "model", parts: [activePart] },
+          partial: false,
+          turnComplete: false,
+          interactionId
+        };
+      }
+      if (activePart.thought) {
+        delete activePart.partMetadata;
+        return null;
+      }
+    }
+  } else if (eventType === "interaction.completed") {
+    return {
+      content: aggregatedParts.length > 0 ? { role: "model", parts: [...aggregatedParts] } : void 0,
+      partial: false,
+      turnComplete: true,
+      finishReason: "STOP",
+      interactionId
+    };
+  } else if (eventType === "interaction.status_update") {
+    const statusUpdate = event;
+    const status = statusUpdate.status;
+    if (status === "completed" || status === "requires_action") {
+      return {
+        content: aggregatedParts.length > 0 ? { role: "model", parts: [...aggregatedParts] } : void 0,
+        partial: false,
+        turnComplete: true,
+        finishReason: "STOP",
+        interactionId
+      };
+    } else if (status === "failed") {
+      const error = statusUpdate.error;
+      return {
+        errorCode: error ? error.code : "UNKNOWN_ERROR",
+        errorMessage: error ? error.message : "Unknown error",
+        turnComplete: true,
+        interactionId
+      };
+    }
+  } else if (eventType === "error") {
+    return {
+      errorCode: ((_a = event.error) == null ? void 0 : _a.code) || event.code || "UNKNOWN_ERROR",
+      errorMessage: ((_b = event.error) == null ? void 0 : _b.message) || event.message || "Unknown error",
+      turnComplete: true,
+      interactionId
+    };
+  }
+  return null;
+}
+function buildGenerationConfig(config) {
+  const generationConfig = {};
+  if (config.temperature !== void 0 && config.temperature !== null) {
+    generationConfig["temperature"] = config.temperature;
+  }
+  if (config.topP !== void 0 && config.topP !== null) {
+    generationConfig["top_p"] = config.topP;
+  }
+  if (config.topK !== void 0 && config.topK !== null) {
+    generationConfig["top_k"] = config.topK;
+  }
+  if (config.maxOutputTokens !== void 0 && config.maxOutputTokens !== null) {
+    generationConfig["max_output_tokens"] = config.maxOutputTokens;
+  }
+  if (config.stopSequences) {
+    generationConfig["stop_sequences"] = config.stopSequences;
+  }
+  if (config.presencePenalty !== void 0 && config.presencePenalty !== null) {
+    generationConfig["presence_penalty"] = config.presencePenalty;
+  }
+  if (config.frequencyPenalty !== void 0 && config.frequencyPenalty !== null) {
+    generationConfig["frequency_penalty"] = config.frequencyPenalty;
+  }
+  return generationConfig;
+}
+function extractSystemInstruction(config) {
+  const systemInstruction = config.systemInstruction;
+  if (!systemInstruction) {
+    return void 0;
+  }
+  if (typeof systemInstruction === "string") {
+    return systemInstruction;
+  }
+  if (typeof systemInstruction === "object" && "parts" in systemInstruction && Array.isArray(systemInstruction.parts)) {
+    const texts = [];
+    for (const part of systemInstruction.parts) {
+      const p = part;
+      if (p.text) {
+        texts.push(p.text);
+      }
+    }
+    return texts.length > 0 ? texts.join("\n") : void 0;
+  }
+  return void 0;
+}
+function extractStreamInteractionId(event) {
+  if (event.interaction_id || event.interactionId) {
+    return event.interaction_id || event.interactionId;
+  }
+  if (event.interaction && event.interaction.id) {
+    return event.interaction.id;
+  }
+  if (event.event_type === "interaction" || event.eventType === "interaction") {
+    return event.id;
+  }
+  return void 0;
+}
+async function* generateContentViaInteractions(apiClient, llmRequest, stream) {
+  let contents = llmRequest.contents;
+  if (llmRequest.previousInteractionId && contents) {
+    contents = getLatestUserContents(contents);
+  }
+  const inputSteps = [];
+  if (contents) {
+    for (const content of contents) {
+      inputSteps.push(...convertContentToSteps(content));
+    }
+  }
+  const interactionTools = convertToolsConfigToInteractionsFormat(
+    llmRequest.config || {}
+  );
+  const systemInstruction = extractSystemInstruction(llmRequest.config || {});
+  const generationConfig = buildGenerationConfig(llmRequest.config || {});
+  const previousInteractionId = llmRequest.previousInteractionId;
+  logger.info(
+    `Sending request via interactions API, model: ${llmRequest.model}, stream: ${stream}, previous_interaction_id: ${previousInteractionId}`
+  );
+  let currentInteractionId = previousInteractionId;
+  if (stream) {
+    const responses = await apiClient.interactions.create({
+      model: llmRequest.model || "gemini-2.5-flash",
+      input: inputSteps,
+      stream: true,
+      system_instruction: systemInstruction,
+      tools: interactionTools.length > 0 ? interactionTools : void 0,
+      generation_config: Object.keys(generationConfig).length > 0 ? generationConfig : void 0,
+      previous_interaction_id: previousInteractionId
+    });
+    const aggregatedParts = [];
+    for await (const event of responses) {
+      const sseEvent = event;
+      const interactionId = extractStreamInteractionId(sseEvent);
+      if (interactionId) {
+        currentInteractionId = interactionId;
+      }
+      const llmResponse = convertInteractionEventToLlmResponse(
+        sseEvent,
+        aggregatedParts,
+        currentInteractionId
+      );
+      if (llmResponse) {
+        yield llmResponse;
+      }
+    }
+    if (aggregatedParts.length > 0) {
+      yield {
+        content: { role: "model", parts: aggregatedParts },
+        partial: false,
+        turnComplete: true,
+        finishReason: "STOP",
+        interactionId: currentInteractionId
+      };
+    }
+  } else {
+    const interaction = await apiClient.interactions.create({
+      model: llmRequest.model || "gemini-2.5-flash",
+      input: inputSteps,
+      stream: false,
+      system_instruction: systemInstruction,
+      tools: interactionTools.length > 0 ? interactionTools : void 0,
+      generation_config: Object.keys(generationConfig).length > 0 ? generationConfig : void 0,
+      previous_interaction_id: previousInteractionId
+    });
+    logger.info("Interaction response received from the model.");
+    yield convertInteractionToLlmResponse(interaction);
+  }
+}
+export {
+  buildGenerationConfig,
+  convertContentToSteps,
+  convertInteractionEventToLlmResponse,
+  convertInteractionToLlmResponse,
+  convertStepToParts,
+  convertToolsConfigToInteractionsFormat,
+  extractSystemInstruction,
+  generateContentViaInteractions,
+  getLatestModelParts,
+  getLatestUserContents
+};

package/dist/esm/plugins/base_plugin.js

@@ -19,6 +19,7 @@ import { experimental } from "../utils/experimental.js";
 var ContextCompactionTrigger = /* @__PURE__ */ ((ContextCompactionTrigger2) => {
   ContextCompactionTrigger2["Manual"] = "Manual";
   ContextCompactionTrigger2["Auto"] = "Auto";
+  ContextCompactionTrigger2["AgentControlled"] = "AgentControlled";
   return ContextCompactionTrigger2;
 })(ContextCompactionTrigger || {});
 class BasePlugin {