@google/adk 2.0.0 → 2.2.0

package/dist/web/agents/functions.js

@@ -1,462 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { createUserContent } from "@google/genai";
-import { isEmpty } from "lodash-es";
-import {
-  createEvent,
-  generateClientFunctionCallId,
-  getFunctionCalls,
-  getFunctionResponses
-} from "../events/event.js";
-import { mergeEventActions } from "../events/event_actions.js";
-import { logger } from "../utils/logger.js";
-import { Context } from "./context.js";
-import {
-  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
-  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME
-} from "./framework_function_calls.js";
-import {
-  traceMergedToolCalls,
-  tracer,
-  traceToolCall
-} from "../telemetry/tracing.js";
-function toolEventAuthor(invocationContext) {
-  var _a, _b;
-  return (_b = (_a = invocationContext.agent) == null ? void 0 : _a.name) != null ? _b : "";
-}
-__name(toolEventAuthor, "toolEventAuthor");
-import {
-  AF_FUNCTION_CALL_ID_PREFIX,
-  generateClientFunctionCallId as generateClientFunctionCallId2,
-  populateClientFunctionCallId
-} from "../events/event.js";
-import {
-  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME as REQUEST_CONFIRMATION_FUNCTION_CALL_NAME2,
-  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME as REQUEST_CREDENTIAL_FUNCTION_CALL_NAME2,
-  REQUEST_INPUT_FUNCTION_CALL_NAME,
-  reservedFunctionCallName
-} from "./framework_function_calls.js";
-const functionsExportedForTestingOnly = {
-  handleFunctionCallList,
-  generateAuthEvent,
-  generateRequestConfirmationEvent
-};
-function getLongRunningFunctionCalls(functionCalls, toolsDict) {
-  const longRunningToolIds = /* @__PURE__ */ new Set();
-  for (const functionCall of functionCalls) {
-    if (functionCall.name && functionCall.name in toolsDict && toolsDict[functionCall.name].isLongRunning && functionCall.id) {
-      longRunningToolIds.add(functionCall.id);
-    }
-  }
-  return longRunningToolIds;
-}
-__name(getLongRunningFunctionCalls, "getLongRunningFunctionCalls");
-function generateAuthEvent(invocationContext, functionResponseEvent) {
-  var _a;
-  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedAuthConfigs) || isEmpty(functionResponseEvent.actions.requestedAuthConfigs)) {
-    return void 0;
-  }
-  const parts = [];
-  const longRunningToolIds = /* @__PURE__ */ new Set();
-  for (const [functionCallId, authConfig] of Object.entries(
-    functionResponseEvent.actions.requestedAuthConfigs
-  )) {
-    const requestCredentialFunctionCall = {
-      name: REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
-      args: {
-        "function_call_id": functionCallId,
-        "auth_config": authConfig
-      },
-      id: generateClientFunctionCallId()
-    };
-    longRunningToolIds.add(requestCredentialFunctionCall.id);
-    parts.push({ functionCall: requestCredentialFunctionCall });
-  }
-  return createEvent({
-    invocationId: invocationContext.invocationId,
-    author: toolEventAuthor(invocationContext),
-    branch: invocationContext.branch,
-    content: {
-      parts,
-      role: functionResponseEvent.content.role
-    },
-    longRunningToolIds: Array.from(longRunningToolIds)
-  });
-}
-__name(generateAuthEvent, "generateAuthEvent");
-function generateRequestConfirmationEvent({
-  invocationContext,
-  functionCallEvent,
-  functionResponseEvent
-}) {
-  var _a, _b;
-  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedToolConfirmations) || isEmpty(functionResponseEvent.actions.requestedToolConfirmations)) {
-    return;
-  }
-  const parts = [];
-  const longRunningToolIds = /* @__PURE__ */ new Set();
-  const functionCalls = getFunctionCalls(functionCallEvent);
-  for (const [functionCallId, toolConfirmation] of Object.entries(
-    functionResponseEvent.actions.requestedToolConfirmations
-  )) {
-    const originalFunctionCall = (_b = functionCalls.find((call) => call.id === functionCallId)) != null ? _b : void 0;
-    if (!originalFunctionCall) {
-      continue;
-    }
-    const requestConfirmationFunctionCall = {
-      name: REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
-      args: {
-        "originalFunctionCall": originalFunctionCall,
-        "toolConfirmation": toolConfirmation
-      },
-      id: generateClientFunctionCallId()
-    };
-    longRunningToolIds.add(requestConfirmationFunctionCall.id);
-    parts.push({ functionCall: requestConfirmationFunctionCall });
-  }
-  return createEvent({
-    invocationId: invocationContext.invocationId,
-    author: toolEventAuthor(invocationContext),
-    branch: invocationContext.branch,
-    content: {
-      parts,
-      role: functionResponseEvent.content.role
-    },
-    actions: functionResponseEvent.actions,
-    longRunningToolIds: Array.from(longRunningToolIds)
-  });
-}
-__name(generateRequestConfirmationEvent, "generateRequestConfirmationEvent");
-async function callToolAsync(tool, args, toolContext) {
-  return tracer.startActiveSpan("execute_tool ".concat(tool.name), async (span) => {
-    try {
-      logger.debug("callToolAsync ".concat(tool.name));
-      const result = await tool.runAsync({ args, toolContext });
-      traceToolCall({
-        tool,
-        args,
-        functionResponseEvent: buildResponseEvent(
-          tool,
-          result,
-          toolContext,
-          toolContext.invocationContext
-        )
-      });
-      return result;
-    } finally {
-      span.end();
-    }
-  });
-}
-__name(callToolAsync, "callToolAsync");
-function buildResponseEvent(tool, functionResult, toolContext, invocationContext) {
-  let responseResult;
-  if (typeof functionResult !== "object" || functionResult == null) {
-    responseResult = { result: functionResult };
-  } else if (Array.isArray(functionResult)) {
-    responseResult = { results: functionResult };
-  } else {
-    responseResult = functionResult;
-  }
-  const partFunctionResponse = {
-    functionResponse: {
-      name: tool.name,
-      response: responseResult,
-      id: toolContext.functionCallId
-    }
-  };
-  const content = {
-    role: "user",
-    parts: [partFunctionResponse]
-  };
-  return createEvent({
-    invocationId: invocationContext.invocationId,
-    author: toolEventAuthor(invocationContext),
-    content,
-    actions: toolContext.actions,
-    branch: invocationContext.branch
-  });
-}
-__name(buildResponseEvent, "buildResponseEvent");
-async function handleFunctionCallsAsync({
-  invocationContext,
-  functionCallEvent,
-  toolsDict,
-  beforeToolCallbacks,
-  afterToolCallbacks,
-  filters,
-  toolConfirmationDict
-}) {
-  const functionCalls = getFunctionCalls(functionCallEvent);
-  return await handleFunctionCallList({
-    invocationContext,
-    functionCalls,
-    toolsDict,
-    beforeToolCallbacks,
-    afterToolCallbacks,
-    filters,
-    toolConfirmationDict
-  });
-}
-__name(handleFunctionCallsAsync, "handleFunctionCallsAsync");
-function normalizeCallbackResponse(response) {
-  if (response == null) {
-    return void 0;
-  }
-  if (typeof response !== "object") {
-    return { result: response };
-  }
-  if (Array.isArray(response)) {
-    return { results: response };
-  }
-  return response;
-}
-__name(normalizeCallbackResponse, "normalizeCallbackResponse");
-async function handleFunctionCallList({
-  invocationContext,
-  functionCalls,
-  toolsDict,
-  beforeToolCallbacks,
-  afterToolCallbacks,
-  filters,
-  toolConfirmationDict
-}) {
-  var _a;
-  const functionResponseEvents = [];
-  const filteredFunctionCalls = functionCalls.filter((functionCall) => {
-    return !filters || functionCall.id && filters.has(functionCall.id);
-  });
-  for (const functionCall of filteredFunctionCalls) {
-    let toolConfirmation = void 0;
-    if (toolConfirmationDict && functionCall.id) {
-      toolConfirmation = toolConfirmationDict[functionCall.id];
-    }
-    const { tool, toolContext } = getToolAndContext({
-      invocationContext,
-      functionCall,
-      toolsDict,
-      toolConfirmation
-    });
-    logger.debug("execute_tool ".concat(tool.name));
-    const functionArgs = (_a = functionCall.args) != null ? _a : {};
-    let functionResponse = null;
-    let functionResponseError;
-    functionResponse = await invocationContext.pluginManager.runBeforeToolCallback({
-      tool,
-      toolArgs: functionArgs,
-      toolContext
-    });
-    if (functionResponse == null) {
-      for (const callback of beforeToolCallbacks) {
-        functionResponse = await callback({
-          tool,
-          args: functionArgs,
-          context: toolContext
-        });
-        if (functionResponse) {
-          break;
-        }
-      }
-    }
-    functionResponse = normalizeCallbackResponse(functionResponse);
-    if (functionResponse == null) {
-      try {
-        functionResponse = await callToolAsync(tool, functionArgs, toolContext);
-      } catch (e) {
-        if (e instanceof Error) {
-          const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback({
-            tool,
-            toolArgs: functionArgs,
-            toolContext,
-            error: e
-          });
-          if (onToolErrorResponse != null) {
-            functionResponse = normalizeCallbackResponse(onToolErrorResponse);
-          } else {
-            functionResponseError = e.message;
-          }
-        } else {
-          functionResponseError = e;
-        }
-      }
-    }
-    let alteredFunctionResponse = await invocationContext.pluginManager.runAfterToolCallback({
-      tool,
-      toolArgs: functionArgs,
-      toolContext,
-      result: functionResponse
-    });
-    if (alteredFunctionResponse == null) {
-      for (const callback of afterToolCallbacks) {
-        alteredFunctionResponse = await callback({
-          tool,
-          args: functionArgs,
-          context: toolContext,
-          response: functionResponse
-        });
-        if (alteredFunctionResponse) {
-          break;
-        }
-      }
-    }
-    if (alteredFunctionResponse != null) {
-      functionResponse = normalizeCallbackResponse(alteredFunctionResponse);
-    }
-    if (tool.isLongRunning && functionResponse == null) {
-      continue;
-    }
-    if (functionResponseError) {
-      functionResponse = { error: functionResponseError };
-    } else if (functionResponse == null) {
-      functionResponse = { result: functionResponse };
-    } else {
-      functionResponse = normalizeCallbackResponse(functionResponse);
-    }
-    const functionResponseEvent = createEvent({
-      invocationId: invocationContext.invocationId,
-      author: toolEventAuthor(invocationContext),
-      content: createUserContent({
-        functionResponse: {
-          id: toolContext.functionCallId,
-          name: tool.name,
-          response: functionResponse
-        }
-      }),
-      actions: toolContext.actions,
-      branch: invocationContext.branch
-    });
-    logger.debug("traceToolCall", {
-      tool: tool.name,
-      args: functionArgs,
-      functionResponseEvent: functionResponseEvent.id
-    });
-    functionResponseEvents.push(functionResponseEvent);
-  }
-  if (!functionResponseEvents.length) {
-    return null;
-  }
-  const mergedEvent = mergeParallelFunctionResponseEvents(
-    functionResponseEvents
-  );
-  if (functionResponseEvents.length > 1) {
-    tracer.startActiveSpan("execute_tool (merged)", (span) => {
-      try {
-        logger.debug("execute_tool (merged)");
-        logger.debug("traceMergedToolCalls", {
-          responseEventId: mergedEvent.id,
-          functionResponseEvent: mergedEvent.id
-        });
-        traceMergedToolCalls({
-          responseEventId: mergedEvent.id,
-          functionResponseEvent: mergedEvent
-        });
-      } finally {
-        span.end();
-      }
-    });
-  }
-  return mergedEvent;
-}
-__name(handleFunctionCallList, "handleFunctionCallList");
-function getToolAndContext({
-  invocationContext,
-  functionCall,
-  toolsDict,
-  toolConfirmation
-}) {
-  if (!functionCall.name || !(functionCall.name in toolsDict)) {
-    throw new Error(
-      "Function ".concat(functionCall.name, " is not found in the toolsDict.")
-    );
-  }
-  const toolContext = new Context({
-    invocationContext,
-    functionCallId: functionCall.id || void 0,
-    toolConfirmation
-  });
-  const tool = toolsDict[functionCall.name];
-  return { tool, toolContext };
-}
-__name(getToolAndContext, "getToolAndContext");
-function mergeParallelFunctionResponseEvents(functionResponseEvents) {
-  if (!functionResponseEvents.length) {
-    throw new Error("No function response events provided.");
-  }
-  if (functionResponseEvents.length === 1) {
-    return functionResponseEvents[0];
-  }
-  const mergedParts = [];
-  for (const event of functionResponseEvents) {
-    if (event.content && event.content.parts) {
-      mergedParts.push(...event.content.parts);
-    }
-  }
-  const baseEvent = functionResponseEvents[0];
-  const actionsList = functionResponseEvents.map(
-    (event) => event.actions || {}
-  );
-  const mergedActions = mergeEventActions(actionsList);
-  return createEvent({
-    invocationId: baseEvent.invocationId,
-    author: baseEvent.author,
-    branch: baseEvent.branch,
-    content: { role: "user", parts: mergedParts },
-    actions: mergedActions,
-    timestamp: baseEvent.timestamp
-  });
-}
-__name(mergeParallelFunctionResponseEvents, "mergeParallelFunctionResponseEvents");
-function findEventByFunctionCallId(events, functionCallId, endIndex = events.length) {
-  for (let i = endIndex - 1; i >= 0; i--) {
-    const event = events[i];
-    const functionCalls = getFunctionCalls(event);
-    for (const functionCall of functionCalls) {
-      if (functionCall.id === functionCallId) {
-        return event;
-      }
-    }
-  }
-  return void 0;
-}
-__name(findEventByFunctionCallId, "findEventByFunctionCallId");
-function findMatchingFunctionCall(events) {
-  if (!events.length) {
-    return void 0;
-  }
-  const lastEvent = events[events.length - 1];
-  const functionResponses = getFunctionResponses(lastEvent);
-  if (!functionResponses.length || !functionResponses[0].id) {
-    return void 0;
-  }
-  return findEventByFunctionCallId(
-    events,
-    functionResponses[0].id,
-    events.length - 1
-  );
-}
-__name(findMatchingFunctionCall, "findMatchingFunctionCall");
-export {
-  AF_FUNCTION_CALL_ID_PREFIX,
-  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME2 as REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
-  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME2 as REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
-  REQUEST_INPUT_FUNCTION_CALL_NAME,
-  findEventByFunctionCallId,
-  findMatchingFunctionCall,
-  functionsExportedForTestingOnly,
-  generateAuthEvent,
-  generateClientFunctionCallId2 as generateClientFunctionCallId,
-  generateRequestConfirmationEvent,
-  getLongRunningFunctionCalls,
-  handleFunctionCallList,
-  handleFunctionCallsAsync,
-  mergeParallelFunctionResponseEvents,
-  populateClientFunctionCallId,
-  reservedFunctionCallName
-};

package/dist/web/agents/instructions.js

@@ -1,188 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { State } from "../sessions/state.js";
-const ARTIFACT_PREFIX = "artifact.";
-const WORKFLOW_FIELD_KEY = /^[A-Za-z_]\w*\.[A-Za-z_]\w*$/;
-const SOURCE_NODE_PLACEHOLDER = /<\s*[A-Za-z_]\w*\.([A-Za-z_]\w*)\s+from\s+([A-Za-z_]\w*)\s*>/g;
-function resolveSourceNode(raw, field, nodeName, scope) {
-  var _a;
-  const out = (_a = scope.outputsByNode) == null ? void 0 : _a[nodeName];
-  if (out && typeof out === "object" && field in out) {
-    return formatValue(out[field], false);
-  }
-  return raw;
-}
-__name(resolveSourceNode, "resolveSourceNode");
-async function resolveKey(key, isOptional, rawMatch, readonlyContext) {
-  const invocationContext = readonlyContext.invocationContext;
-  if (key.startsWith(ARTIFACT_PREFIX)) {
-    const fileName = key.substring(ARTIFACT_PREFIX.length);
-    if (invocationContext.artifactService === void 0) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    const artifact = await invocationContext.artifactService.loadArtifact({
-      filename: fileName
-    });
-    if (!artifact) {
-      if (isOptional) {
-        return "";
-      }
-      throw new Error("Artifact ".concat(fileName, " not found."));
-    }
-    return formatValue(artifact, true);
-  }
-  if (isValidStateName(key)) {
-    if (key in invocationContext.session.state) {
-      return formatValue(invocationContext.session.state[key], false);
-    }
-    if (isOptional) {
-      return "";
-    }
-    throw new Error("Context variable not found: `".concat(key, "`."));
-  }
-  const scope = invocationContext.workflowInstructionScope;
-  if (scope && WORKFLOW_FIELD_KEY.test(key)) {
-    const field = key.slice(key.indexOf(".") + 1);
-    const input = scope.input;
-    if (input && typeof input === "object" && field in input) {
-      return formatValue(input[field], false);
-    }
-    if (isOptional) {
-      return "";
-    }
-  }
-  return rawMatch;
-}
-__name(resolveKey, "resolveKey");
-function formatValue(value, isArtifact = false) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "object" && value !== null) {
-    if (isArtifact && "text" in value && typeof value.text === "string") {
-      return value.text;
-    }
-    try {
-      const json = JSON.stringify(value);
-      if (json !== void 0) {
-        return json;
-      }
-    } catch (e) {
-      throw new Error(
-        "Failed to serialize value for instruction template: ".concat(e instanceof Error ? e.message : String(e))
-      );
-    }
-  }
-  return String(value);
-}
-__name(formatValue, "formatValue");
-async function injectSessionState(template, readonlyContext) {
-  const scope = readonlyContext.invocationContext.workflowInstructionScope;
-  const sourceMatches = scope ? Array.from(template.matchAll(SOURCE_NODE_PLACEHOLDER)).map((match) => ({
-    raw: match[0],
-    index: match.index,
-    resolved: resolveSourceNode(match[0], match[1], match[2], scope)
-  })) : [];
-  const pattern = /\{+[^{}]*}+/g;
-  const matches = Array.from(template.matchAll(pattern));
-  if (matches.length === 0 && sourceMatches.length === 0) {
-    return template;
-  }
-  const parsedMatches = matches.map((match) => {
-    const raw = match[0];
-    let key = raw.replace(/^\{+/, "").replace(/\}+$/, "").trim();
-    const isOptional = key.endsWith("?");
-    if (isOptional) {
-      key = key.slice(0, -1);
-    }
-    const isValid = key.startsWith(ARTIFACT_PREFIX) || isValidStateName(key) || !!scope && WORKFLOW_FIELD_KEY.test(key);
-    return {
-      raw,
-      key,
-      isOptional,
-      isValid,
-      index: match.index
-    };
-  });
-  const uniqueKeys = /* @__PURE__ */ new Map();
-  for (const pm of parsedMatches) {
-    if (!pm.isValid) {
-      continue;
-    }
-    const existing = uniqueKeys.get(pm.key);
-    if (existing) {
-      if (existing.isOptional && !pm.isOptional) {
-        existing.isOptional = false;
-      }
-    } else {
-      uniqueKeys.set(pm.key, {
-        key: pm.key,
-        isOptional: pm.isOptional,
-        raw: pm.raw
-      });
-    }
-  }
-  const resolutions = /* @__PURE__ */ new Map();
-  for (const info of uniqueKeys.values()) {
-    resolutions.set(
-      info.key,
-      resolveKey(info.key, info.isOptional, info.raw, readonlyContext)
-    );
-  }
-  await Promise.all(resolutions.values());
-  const allMatches = [...parsedMatches, ...sourceMatches].sort(
-    (a, b) => a.index - b.index
-  );
-  const result = [];
-  let lastEnd = 0;
-  for (const pm of allMatches) {
-    result.push(template.slice(lastEnd, pm.index));
-    if ("resolved" in pm) {
-      result.push(pm.resolved);
-    } else if (pm.isValid) {
-      const replacement = await resolutions.get(pm.key);
-      result.push(replacement);
-    } else {
-      result.push(pm.raw);
-    }
-    lastEnd = pm.index + pm.raw.length;
-  }
-  result.push(template.slice(lastEnd));
-  return result.join("");
-}
-__name(injectSessionState, "injectSessionState");
-const isIdentifierPattern = /* @__PURE__ */ (() => {
-  return /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-})();
-function isIdentifier(s) {
-  if (s === "" || s === void 0) {
-    return false;
-  }
-  return isIdentifierPattern.test(s);
-}
-__name(isIdentifier, "isIdentifier");
-const VALID_PREFIXES = [State.APP_PREFIX, State.USER_PREFIX, State.TEMP_PREFIX];
-function isValidStateName(variableName) {
-  const parts = variableName.split(":");
-  if (parts.length === 0 || parts.length > 2) {
-    return false;
-  }
-  if (parts.length === 1) {
-    return isIdentifier(variableName);
-  }
-  if (VALID_PREFIXES.includes(parts[0] + ":")) {
-    return isIdentifier(parts[1]);
-  }
-  return false;
-}
-__name(isValidStateName, "isValidStateName");
-export {
-  injectSessionState
-};