@paean-ai/adk 0.2.19 → 0.2.21

package/dist/esm/sessions/in_memory_session_service.js

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { deepClone } from "../utils/deep_clone.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+import { BaseSessionService } from "./base_session_service.js";
+import { createSession } from "./session.js";
+import { State } from "./state.js";
+class InMemorySessionService extends BaseSessionService {
+  constructor() {
+    super(...arguments);
+    /**
+     * A map from app name to a map from user ID to a map from session ID to
+     * session.
+     */
+    this.sessions = {};
+    /**
+     * A map from app name to a map from user ID to a map from key to the value.
+     */
+    this.userState = {};
+    /**
+     * A map from app name to a map from key to the value.
+     */
+    this.appState = {};
+  }
+  createSession({ appName, userId, state, sessionId }) {
+    const session = createSession({
+      id: sessionId || randomUUID(),
+      appName,
+      userId,
+      state,
+      events: [],
+      lastUpdateTime: Date.now()
+    });
+    if (!this.sessions[appName]) {
+      this.sessions[appName] = {};
+    }
+    if (!this.sessions[appName][userId]) {
+      this.sessions[appName][userId] = {};
+    }
+    this.sessions[appName][userId][session.id] = session;
+    return Promise.resolve(
+      this.mergeState(appName, userId, deepClone(session))
+    );
+  }
+  getSession({ appName, userId, sessionId, config }) {
+    if (!this.sessions[appName] || !this.sessions[appName][userId] || !this.sessions[appName][userId][sessionId]) {
+      return Promise.resolve(void 0);
+    }
+    const session = this.sessions[appName][userId][sessionId];
+    const copiedSession = deepClone(session);
+    if (config) {
+      if (config.numRecentEvents) {
+        copiedSession.events = copiedSession.events.slice(-config.numRecentEvents);
+      }
+      if (config.afterTimestamp) {
+        let i = copiedSession.events.length - 1;
+        while (i >= 0) {
+          if (copiedSession.events[i].timestamp < config.afterTimestamp) {
+            break;
+          }
+          i--;
+        }
+        if (i >= 0) {
+          copiedSession.events = copiedSession.events.slice(i + 1);
+        }
+      }
+    }
+    return Promise.resolve(this.mergeState(appName, userId, copiedSession));
+  }
+  listSessions({ appName, userId }) {
+    if (!this.sessions[appName] || !this.sessions[appName][userId]) {
+      return Promise.resolve({ sessions: [] });
+    }
+    const sessionsWithoutEvents = [];
+    for (const session of Object.values(this.sessions[appName][userId])) {
+      sessionsWithoutEvents.push(createSession({
+        id: session.id,
+        appName: session.appName,
+        userId: session.userId,
+        state: {},
+        events: [],
+        lastUpdateTime: session.lastUpdateTime
+      }));
+    }
+    return Promise.resolve({ sessions: sessionsWithoutEvents });
+  }
+  async deleteSession({ appName, userId, sessionId }) {
+    const session = await this.getSession({ appName, userId, sessionId });
+    if (!session) {
+      return;
+    }
+    delete this.sessions[appName][userId][sessionId];
+  }
+  async appendEvent({ session, event }) {
+    await super.appendEvent({ session, event });
+    session.lastUpdateTime = event.timestamp;
+    const appName = session.appName;
+    const userId = session.userId;
+    const sessionId = session.id;
+    const warning = (message) => {
+      logger.warn(`Failed to append event to session ${sessionId}: ${message}`);
+    };
+    if (!this.sessions[appName]) {
+      warning(`appName ${appName} not in sessions`);
+      return event;
+    }
+    if (!this.sessions[appName][userId]) {
+      warning(`userId ${userId} not in sessions[appName]`);
+      return event;
+    }
+    if (!this.sessions[appName][userId][sessionId]) {
+      warning(`sessionId ${sessionId} not in sessions[appName][userId]`);
+      return event;
+    }
+    if (event.actions && event.actions.stateDelta) {
+      for (const key of Object.keys(event.actions.stateDelta)) {
+        if (key.startsWith(State.APP_PREFIX)) {
+          this.appState[appName] = this.appState[appName] || {};
+          this.appState[appName][key.replace(State.APP_PREFIX, "")] = event.actions.stateDelta[key];
+        }
+        if (key.startsWith(State.USER_PREFIX)) {
+          this.userState[appName] = this.userState[appName] || {};
+          this.userState[appName][userId] = this.userState[appName][userId] || {};
+          this.userState[appName][userId][key.replace(State.USER_PREFIX, "")] = event.actions.stateDelta[key];
+        }
+      }
+    }
+    const storageSession = this.sessions[appName][userId][sessionId];
+    await super.appendEvent({ session: storageSession, event });
+    storageSession.lastUpdateTime = event.timestamp;
+    return event;
+  }
+  mergeState(appName, userId, copiedSession) {
+    if (this.appState[appName]) {
+      for (const key of Object.keys(this.appState[appName])) {
+        copiedSession.state[State.APP_PREFIX + key] = this.appState[appName][key];
+      }
+    }
+    if (!this.userState[appName] || !this.userState[appName][userId]) {
+      return copiedSession;
+    }
+    for (const key of Object.keys(this.userState[appName][userId])) {
+      copiedSession.state[State.USER_PREFIX + key] = this.userState[appName][userId][key];
+    }
+    return copiedSession;
+  }
+}
+export {
+  InMemorySessionService
+};

package/dist/esm/sessions/session.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createSession(params) {
+  return {
+    id: params.id,
+    appName: params.appName,
+    userId: params.userId || "",
+    state: params.state || {},
+    events: params.events || [],
+    lastUpdateTime: params.lastUpdateTime || 0
+  };
+}
+export {
+  createSession
+};

package/dist/esm/sessions/state.js

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class State {
+  constructor(value = {}, delta = {}) {
+    this.value = value;
+    this.delta = delta;
+  }
+  /**
+   * Returns the value of the state dict for the given key.
+   *
+   * @param key The key to get the value for.
+   * @param defaultValue The default value to return if the key is not found.
+   * @return The value of the state for the given key, or the default value if
+   *     not found.
+   */
+  get(key, defaultValue) {
+    if (key in this.delta) {
+      return this.delta[key];
+    }
+    if (key in this.value) {
+      return this.value[key];
+    }
+    return defaultValue;
+  }
+  /**
+   * Sets the value of the state dict for the given key.
+   *
+   * @param key The key to set the value for.
+   * @param value The value to set.
+   */
+  set(key, value) {
+    this.value[key] = value;
+    this.delta[key] = value;
+  }
+  /**
+   * Whether the state has pending delta.
+   */
+  has(key) {
+    return key in this.value || key in this.delta;
+  }
+  /**
+   * Whether the state has pending delta.
+   */
+  hasDelta() {
+    return Object.keys(this.delta).length > 0;
+  }
+  /**
+   * Updates the state dict with the given delta.
+   *
+   * @param delta The delta to update the state with.
+   */
+  update(delta) {
+    this.delta = { ...this.delta, ...delta };
+    this.value = { ...this.value, ...delta };
+  }
+  /**
+   * Returns the state as a plain JSON object.
+   */
+  toRecord() {
+    return { ...this.value, ...this.delta };
+  }
+}
+State.APP_PREFIX = "app:";
+State.USER_PREFIX = "user:";
+State.TEMP_PREFIX = "temp:";
+export {
+  State
+};

package/dist/esm/telemetry/google_cloud.js

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleAuth } from "google-auth-library";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { detectResources } from "@opentelemetry/resources";
+import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import { TraceExporter } from "@google-cloud/opentelemetry-cloud-trace-exporter";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { MetricExporter } from "@google-cloud/opentelemetry-cloud-monitoring-exporter";
+import { logger } from "../utils/logger.js";
+const GCP_PROJECT_ERROR_MESSAGE = "Cannot determine GCP Project. OTel GCP Exporters cannot be set up. Please make sure to log into correct GCP Project.";
+async function getGcpProjectId() {
+  try {
+    const auth = new GoogleAuth();
+    const projectId = await auth.getProjectId();
+    return projectId || void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+async function getGcpExporters(config = {}) {
+  const {
+    enableTracing = false,
+    enableMetrics = false
+    // enableCloudLogging = false,
+  } = config;
+  const projectId = await getGcpProjectId();
+  if (!projectId) {
+    logger.warn(GCP_PROJECT_ERROR_MESSAGE);
+    return {};
+  }
+  return {
+    spanProcessors: enableTracing ? [
+      new BatchSpanProcessor(new TraceExporter({ projectId }))
+    ] : [],
+    metricReaders: enableMetrics ? [
+      new PeriodicExportingMetricReader({
+        exporter: new MetricExporter({ projectId }),
+        exportIntervalMillis: 5e3
+      })
+    ] : [],
+    logRecordProcessors: []
+  };
+}
+function getGcpResource() {
+  return detectResources({ detectors: [gcpDetector] });
+}
+export {
+  getGcpExporters,
+  getGcpResource
+};

package/dist/esm/telemetry/setup.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { trace, metrics } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { LoggerProvider, BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { detectResources } from "@opentelemetry/resources";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
+  const resource = otelResource || getOtelResource();
+  const allHooks = [...otelHooksToSetup, getOtelExporters()];
+  const spanProcessors = allHooks.flatMap((hooks) => hooks.spanProcessors || []);
+  const metricReaders = allHooks.flatMap((hooks) => hooks.metricReaders || []);
+  const logRecordProcessors = allHooks.flatMap((hooks) => hooks.logRecordProcessors || []);
+  if (spanProcessors.length > 0) {
+    const tracerProvider = new NodeTracerProvider({
+      resource,
+      spanProcessors
+    });
+    tracerProvider.register();
+    trace.setGlobalTracerProvider(tracerProvider);
+  }
+  if (metricReaders.length > 0) {
+    const meterProvider = new MeterProvider({
+      readers: metricReaders,
+      resource
+    });
+    metrics.setGlobalMeterProvider(meterProvider);
+  }
+  if (logRecordProcessors.length > 0) {
+    const loggerProvider = new LoggerProvider({
+      resource,
+      processors: logRecordProcessors
+    });
+    logs.setGlobalLoggerProvider(loggerProvider);
+  }
+}
+function getOtelResource() {
+  return detectResources({
+    detectors: []
+  });
+}
+function getOtelExportersConfig() {
+  return {
+    enableTracing: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT),
+    enableMetrics: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT),
+    enableLogging: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
+  };
+}
+function getOtelExporters(config = getOtelExportersConfig()) {
+  const { enableTracing, enableMetrics, enableLogging } = config;
+  return {
+    spanProcessors: enableTracing ? [new BatchSpanProcessor(new OTLPTraceExporter())] : [],
+    metricReaders: enableMetrics ? [new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter() })] : [],
+    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor(new OTLPLogExporter())] : []
+  };
+}
+export {
+  maybeSetOtelProviders
+};

package/dist/esm/telemetry/tracing.js

@@ -0,0 +1,195 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { trace, context } from "@opentelemetry/api";
+import { version } from "../version.js";
+const GEN_AI_AGENT_DESCRIPTION = "gen_ai.agent.description";
+const GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+const GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+const GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+const GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+const GEN_AI_TOOL_DESCRIPTION = "gen_ai.tool.description";
+const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+const GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+const tracer = trace.getTracer(
+  "gcp.vertex.agent",
+  version
+);
+function safeJsonSerialize(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch (error) {
+    return "<not serializable>";
+  }
+}
+function traceAgentInvocation({
+  agent,
+  invocationContext
+}) {
+  const span = trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    [GEN_AI_OPERATION_NAME]: "invoke_agent",
+    // Conditionally Required
+    [GEN_AI_AGENT_DESCRIPTION]: agent.description,
+    [GEN_AI_AGENT_NAME]: agent.name,
+    [GEN_AI_CONVERSATION_ID]: invocationContext.session.id
+  });
+}
+function traceToolCall({
+  tool,
+  args,
+  functionResponseEvent
+}) {
+  var _a, _b;
+  const span = trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    [GEN_AI_OPERATION_NAME]: "execute_tool",
+    [GEN_AI_TOOL_DESCRIPTION]: tool.description || "",
+    [GEN_AI_TOOL_NAME]: tool.name,
+    // e.g. FunctionTool
+    [GEN_AI_TOOL_TYPE]: tool.constructor.name,
+    // Setting empty llm request and response (as UI expect these) while not
+    // applicable for tool_response.
+    "gcp.vertex.agent.llm_request": "{}",
+    "gcp.vertex.agent.llm_response": "{}",
+    "gcp.vertex.agent.tool_call_args": shouldAddRequestResponseToSpans() ? safeJsonSerialize(args) : "{}"
+  });
+  let toolCallId = "<not specified>";
+  let toolResponse = "<not specified>";
+  if ((_a = functionResponseEvent.content) == null ? void 0 : _a.parts) {
+    const responseParts = functionResponseEvent.content.parts;
+    const functionResponse = (_b = responseParts[0]) == null ? void 0 : _b.functionResponse;
+    if (functionResponse == null ? void 0 : functionResponse.id) {
+      toolCallId = functionResponse.id;
+    }
+    if (functionResponse == null ? void 0 : functionResponse.response) {
+      toolResponse = functionResponse.response;
+    }
+  }
+  if (typeof toolResponse !== "object" || toolResponse === null) {
+    toolResponse = { result: toolResponse };
+  }
+  span.setAttributes({
+    [GEN_AI_TOOL_CALL_ID]: toolCallId,
+    "gcp.vertex.agent.event_id": functionResponseEvent.id,
+    "gcp.vertex.agent.tool_response": shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
+  });
+}
+function traceMergedToolCalls({
+  responseEventId,
+  functionResponseEvent
+}) {
+  const span = trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    [GEN_AI_OPERATION_NAME]: "execute_tool",
+    [GEN_AI_TOOL_NAME]: "(merged tools)",
+    [GEN_AI_TOOL_DESCRIPTION]: "(merged tools)",
+    [GEN_AI_TOOL_CALL_ID]: responseEventId,
+    "gcp.vertex.agent.tool_call_args": "N/A",
+    "gcp.vertex.agent.event_id": responseEventId,
+    // Setting empty llm request and response (as UI expect these) while not
+    // applicable for tool_response.
+    "gcp.vertex.agent.llm_request": "{}",
+    "gcp.vertex.agent.llm_response": "{}"
+  });
+  span.setAttribute("gcp.vertex.agent.tool_response", shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}");
+}
+function traceCallLlm({
+  invocationContext,
+  eventId,
+  llmRequest,
+  llmResponse
+}) {
+  var _a, _b, _c;
+  const span = trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    "gen_ai.system": "gcp.vertex.agent",
+    "gen_ai.request.model": llmRequest.model,
+    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
+    "gcp.vertex.agent.session_id": invocationContext.session.id,
+    "gcp.vertex.agent.event_id": eventId,
+    // Consider removing once GenAI SDK provides a way to record this info.
+    "gcp.vertex.agent.llm_request": shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
+  });
+  if ((_a = llmRequest.config) == null ? void 0 : _a.topP) {
+    span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
+  }
+  if (((_b = llmRequest.config) == null ? void 0 : _b.maxOutputTokens) !== void 0) {
+    span.setAttribute("gen_ai.request.max_tokens", llmRequest.config.maxOutputTokens);
+  }
+  span.setAttribute("gcp.vertex.agent.llm_response", shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}");
+  if (llmResponse.usageMetadata) {
+    span.setAttribute("gen_ai.usage.input_tokens", llmResponse.usageMetadata.promptTokenCount || 0);
+  }
+  if ((_c = llmResponse.usageMetadata) == null ? void 0 : _c.candidatesTokenCount) {
+    span.setAttribute("gen_ai.usage.output_tokens", llmResponse.usageMetadata.candidatesTokenCount);
+  }
+  if (llmResponse.finishReason) {
+    const finishReasonValue = typeof llmResponse.finishReason === "string" ? llmResponse.finishReason.toLowerCase() : String(llmResponse.finishReason).toLowerCase();
+    span.setAttribute("gen_ai.response.finish_reasons", [finishReasonValue]);
+  }
+}
+function traceSendData({
+  invocationContext,
+  eventId,
+  data
+}) {
+  const span = trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
+    "gcp.vertex.agent.event_id": eventId
+  });
+  span.setAttribute("gcp.vertex.agent.data", shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}");
+}
+function buildLlmRequestForTrace(llmRequest) {
+  const result = {
+    model: llmRequest.model,
+    contents: []
+  };
+  if (llmRequest.config) {
+    const { responseSchema, ...cleanConfig } = llmRequest.config;
+    result.config = cleanConfig;
+  }
+  result.contents = llmRequest.contents.map((content) => {
+    var _a;
+    return {
+      role: content.role,
+      parts: ((_a = content.parts) == null ? void 0 : _a.filter((part) => !part.inlineData)) || []
+    };
+  });
+  return result;
+}
+function bindAsyncGenerator(ctx, generator) {
+  return {
+    // Bind the next() method to execute within the provided context
+    next: context.bind(ctx, generator.next.bind(generator)),
+    // Bind the return() method to execute within the provided context
+    return: context.bind(ctx, generator.return.bind(generator)),
+    // Bind the throw() method to execute within the provided context
+    throw: context.bind(ctx, generator.throw.bind(generator)),
+    // Ensure the async iterator symbol also returns a context-bound generator
+    [Symbol.asyncIterator]() {
+      return bindAsyncGenerator(ctx, generator[Symbol.asyncIterator]());
+    }
+  };
+}
+function shouldAddRequestResponseToSpans() {
+  const envValue = process.env.ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS || "true";
+  return envValue === "true" || envValue === "1";
+}
+export {
+  bindAsyncGenerator,
+  traceAgentInvocation,
+  traceCallLlm,
+  traceMergedToolCalls,
+  traceSendData,
+  traceToolCall,
+  tracer
+};

package/dist/esm/tools/agent_tool.js

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { LlmAgent } from "../agents/llm_agent.js";
+import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
+import { Runner } from "../runner/runner.js";
+import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
+import { GoogleLLMVariant } from "../utils/variant_utils.js";
+import { BaseTool } from "./base_tool.js";
+import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
+class AgentTool extends BaseTool {
+  constructor(config) {
+    super(
+      { name: config.agent.name, description: config.agent.description || "" }
+    );
+    this.agent = config.agent;
+    this.skipSummarization = config.skipSummarization || false;
+  }
+  _getDeclaration() {
+    let declaration;
+    if (this.agent instanceof LlmAgent && this.agent.inputSchema) {
+      declaration = {
+        name: this.name,
+        description: this.description,
+        // TODO(b/425992518): We should not use the agent's input schema as is.
+        // It should be validated and possibly transformed. Consider similar
+        // logic to one we have in Python ADK.
+        parameters: this.agent.inputSchema
+      };
+    } else {
+      declaration = {
+        name: this.name,
+        description: this.description,
+        parameters: {
+          type: Type.OBJECT,
+          properties: {
+            "request": {
+              type: Type.STRING
+            }
+          },
+          required: ["request"]
+        }
+      };
+    }
+    if (this.apiVariant !== GoogleLLMVariant.GEMINI_API) {
+      const hasOutputSchema = this.agent instanceof LlmAgent && this.agent.outputSchema;
+      declaration.response = hasOutputSchema ? { type: Type.OBJECT } : { type: Type.STRING };
+    }
+    return declaration;
+  }
+  async runAsync({ args, toolContext }) {
+    var _a, _b;
+    if (this.skipSummarization) {
+      toolContext.actions.skipSummarization = true;
+    }
+    const hasInputSchema = this.agent instanceof LlmAgent && this.agent.inputSchema;
+    const content = {
+      role: "user",
+      parts: [
+        {
+          // TODO(b/425992518): Should be validated. Consider similar
+          // logic to one we have in Python ADK.
+          text: hasInputSchema ? JSON.stringify(args) : args["request"]
+        }
+      ]
+    };
+    const runner = new Runner({
+      appName: this.agent.name,
+      agent: this.agent,
+      artifactService: new ForwardingArtifactService(toolContext),
+      sessionService: new InMemorySessionService(),
+      memoryService: new InMemoryMemoryService(),
+      credentialService: toolContext.invocationContext.credentialService
+    });
+    const session = await runner.sessionService.createSession({
+      appName: this.agent.name,
+      userId: "tmp_user",
+      state: toolContext.state.toRecord()
+    });
+    let lastEvent;
+    for await (const event of runner.runAsync({
+      userId: session.userId,
+      sessionId: session.id,
+      newMessage: content
+    })) {
+      if (event.actions.stateDelta) {
+        toolContext.state.update(event.actions.stateDelta);
+      }
+      lastEvent = event;
+    }
+    if (!((_b = (_a = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+      return "";
+    }
+    const hasOutputSchema = this.agent instanceof LlmAgent && this.agent.outputSchema;
+    const mergetText = lastEvent.content.parts.map((part) => part.text).filter((text) => text).join("\n");
+    return hasOutputSchema ? JSON.parse(mergetText) : mergetText;
+  }
+}
+export {
+  AgentTool
+};