@google/adk 1.6.0 → 2.1.0

package/dist/web/models/interactions_utils.js

@@ -1,728 +0,0 @@
-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 __await = function(promise, isYieldStar) {
-  this[0] = promise;
-  this[1] = isYieldStar;
-};
-var __asyncGenerator = (__this, __arguments, generator) => {
-  var resume = (k, v, yes, no) => {
-    try {
-      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
-      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
-    } catch (e) {
-      no(e);
-    }
-  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
-  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
-};
-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 {
-  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: ".concat(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;
-}
-function generateContentViaInteractions(apiClient, llmRequest, stream) {
-  return __asyncGenerator(this, null, function* () {
-    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: ".concat(llmRequest.model, ", stream: ").concat(stream, ", previous_interaction_id: ").concat(previousInteractionId)
-    );
-    let currentInteractionId = previousInteractionId;
-    if (stream) {
-      const responses = yield new __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 = [];
-      try {
-        for (var iter = __forAwait(responses), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const event = temp.value;
-          const sseEvent = event;
-          const interactionId = extractStreamInteractionId(sseEvent);
-          if (interactionId) {
-            currentInteractionId = interactionId;
-          }
-          const llmResponse = convertInteractionEventToLlmResponse(
-            sseEvent,
-            aggregatedParts,
-            currentInteractionId
-          );
-          if (llmResponse) {
-            yield llmResponse;
-          }
-        }
-      } catch (temp) {
-        error = [temp];
-      } finally {
-        try {
-          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-        } finally {
-          if (error)
-            throw error[0];
-        }
-      }
-      if (aggregatedParts.length > 0) {
-        yield {
-          content: { role: "model", parts: aggregatedParts },
-          partial: false,
-          turnComplete: true,
-          finishReason: "STOP",
-          interactionId: currentInteractionId
-        };
-      }
-    } else {
-      const interaction = yield new __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
-};