@cap-js/agents 0.9.4 → 0.9.6

package/srv/handlers/graph-executor.js

@@ -9,7 +9,14 @@ import { convertUsageData } from "../../lib/telemetry/chat-tracing.js"
 import { triggerCleanup } from "../../lib/protocol/persistence/cleanup.js"
 import { COLLECT_RESULT } from "./chat.js"
 import { linkTraceToPrompt } from "../../lib/telemetry/mlflow/tracing.js"
-import { handleHitlInterrupt, requiresHitl, resumeHitl } from "./graph-executor/hitl.js"
+import {
+  handleHitlInterrupt,
+  isTimeoutHitl,
+  publishTimeoutHitl,
+  requiresHitl,
+  resumeHitl,
+  resumeTimeoutHitl,
+} from "./graph-executor/hitl.js"
 
 const LOG = cds.log("agents")
 
@@ -145,7 +152,7 @@ class GraphExecutor {
   abort(taskId) {
     const controller = this._abortControllers.get(taskId)
     if (controller && !controller.signal.aborted) {
-      LOG.info("aborting", { task: short(taskId), service: this._srv.name })
+      LOG.info(this._srv.name, "aborting", { task: short(taskId) })
       controller.abort()
     }
   }
@@ -163,7 +170,7 @@ class GraphExecutor {
       const { CdsCheckpointSaver } =
         await import("../../lib/protocol/persistence/checkpoint-saver.js")
       resolved.checkpointer = new CdsCheckpointSaver()
-      LOG.debug("Auto-injected CdsCheckpointSaver", { service: this._srv.name })
+      LOG.debug(this._srv.name, "- auto-injected CdsCheckpointSaver")
     }
     this._graph = resolved
     return this._graph
@@ -174,12 +181,10 @@ class GraphExecutor {
    * per-token artifact-update SSE events as LLM tokens arrive.
    */
   async _streamWithPublish(graph, input, config, eventBus, taskId, contextId, signal) {
-    const maxExecution = ms4(cds.env.agents?.pool?.maxExecutionTimePerTask || "5min")
-    const grace = this._getGrace()
-    const softTimeout = Math.max(maxExecution - grace, 1000)
+    const maxExecution = ms4(cds.env.agents?.quotas?.maxExecutionTimePerTask || "5min")
 
     const controller = new AbortController()
-    const timeoutHandle = setTimeout(() => controller.abort(), softTimeout)
+    const timeoutHandle = setTimeout(() => controller.abort(), maxExecution)
     const combinedSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal
 
     let tokenCount = 0
@@ -271,8 +276,8 @@ class GraphExecutor {
         if (signal?.aborted) {
           throw new AbortError("Task execution aborted")
         }
-        throw new TimeoutError(`Graph execution timed out after ${softTimeout / 1000}s`, {
-          timeout: softTimeout,
+        throw new TimeoutError(`Graph execution timed out after ${maxExecution / 1000}s`, {
+          timeout: maxExecution,
         })
       }
       throw err
@@ -312,23 +317,13 @@ class GraphExecutor {
 
     return { state: finalState, tokenCount }
   }
-  /**
-   * Parse configured timeout grace period.
-   */
-  _getGrace() {
-    return ms4(cds.env.agents?.pool?.timeoutGrace ?? "15s")
-  }
-
   async _invokeWithTimeout(graph, input, config, signal) {
-    const maxExecution = ms4(cds.env.agents?.pool?.maxExecutionTimePerTask || "5min")
-    const grace = this._getGrace()
-    // Soft timeout fires early to allow graceful summarization
-    const softTimeout = Math.max(maxExecution - grace, 1000)
+    const maxExecution = ms4(cds.env.agents?.quotas?.maxExecutionTimePerTask || "5min")
 
     // Use explicit AbortController + setTimeout (reffed timer keeps event loop alive)
     // instead of AbortSignal.timeout() which uses an unreffed timer
     const timeoutController = new AbortController()
-    const timer = setTimeout(() => timeoutController.abort(), softTimeout)
+    const timer = setTimeout(() => timeoutController.abort(), maxExecution)
 
     // Combine caller-provided abort signal with timeout
     const combinedSignal = signal
@@ -344,8 +339,8 @@ class GraphExecutor {
         if (signal?.aborted) {
           throw new AbortError("Task execution aborted")
         }
-        throw new TimeoutError(`Graph execution timed out after ${softTimeout / 1000}s`, {
-          timeout: softTimeout,
+        throw new TimeoutError(`Graph execution timed out after ${maxExecution / 1000}s`, {
+          timeout: maxExecution,
         })
       }
       throw err
@@ -359,7 +354,6 @@ class GraphExecutor {
    */
   async _summarizePartialWork(taskId, contextId, serviceName, reason) {
     const { summarizePartialWork } = await import("../../lib/agents/summarize-on-timeout.js")
-    const grace = this._getGrace()
     return summarizePartialWork({
       taskId,
       contextId,
@@ -367,7 +361,8 @@ class GraphExecutor {
       reason,
       checkpointer: this._graph?.checkpointer,
       getModel: () => this._srv.send("buildModel"),
-      timeout: Math.max(grace - 2000, grace * 0.8, 500),
+      // Summary runs after graph abort, so no execution-time grace is needed.
+      timeout: 10_000,
     })
   }
 
@@ -447,9 +442,8 @@ class GraphExecutor {
                 cds.env.agents?.fileIO,
               )
               if (rejection) {
-                LOG.warn("input file rejected", {
+                LOG.warn(serviceName, "-", "input file rejected", {
                   conversation: short(contextId),
-                  service: serviceName,
                   name: safeName,
                   mimeType: safeMime,
                   reason: rejection,
@@ -458,9 +452,8 @@ class GraphExecutor {
               }
               const buf = Buffer.from(file.bytes, "base64")
               await fileStore.saveInputFile(taskId, safeName, safeMime, buf)
-              LOG.info("file uploaded", {
+              LOG.info(serviceName, "-", "file uploaded", {
                 conversation: short(contextId),
-                service: serviceName,
                 name: safeName,
                 mimeType: safeMime,
                 size: buf.length,
@@ -564,7 +557,8 @@ class GraphExecutor {
         const t0 = Date.now()
 
         if (isResume) {
-          result = await resumeHitl({
+          const resume = isTimeoutHitl(requestContext.task) ? resumeTimeoutHitl : resumeHitl
+          result = await resume({
             requestContext,
             graph,
             config,
@@ -619,7 +613,7 @@ class GraphExecutor {
         const outputMapper = this._outputMapper || defaultOutputMapper
         const output = outputMapper(result) || "I could not generate a response."
 
-        LOG.info("completed", { conversation: short(contextId), service: serviceName, duration })
+        LOG.info(serviceName, "completed", { conversation: short(contextId), duration })
 
         if (wfSpan) {
           wfSpan.setAttribute("agent.outcome", "completed")
@@ -750,9 +744,8 @@ class GraphExecutor {
                   ? Buffer.byteLength(artifact.file.bytes, "base64")
                   : 0
               if (declaredBytes > maxFileBytes) {
-                LOG.warn("emit_file_part artifact exceeds cap; skipping", {
+                LOG.warn(serviceName, "-", "emit_file_part artifact exceeds cap; skipping", {
                   conversation: short(contextId),
-                  service: serviceName,
                   name: artifact.file?.name,
                   size: declaredBytes,
                   cap: maxFileBytes,
@@ -777,9 +770,8 @@ class GraphExecutor {
           const outputMeta = await fileStore.listOutputFilesMeta(taskId)
           for (const meta of outputMeta) {
             if (meta.size > maxFileBytes) {
-              LOG.warn("output file exceeds cap; skipping", {
+              LOG.warn(serviceName, "-", "output file exceeds cap; skipping", {
                 conversation: short(contextId),
-                service: serviceName,
                 name: meta.name,
                 size: meta.size,
                 cap: maxFileBytes,
@@ -798,7 +790,7 @@ class GraphExecutor {
           // Exclude emit_file_part outputs — those are this agent's own artifacts, not
           // downstream files, and re-persisting them would create spurious /uploads/ entries.
           // Enforce the same size + MIME guard as inbound uploads so a malicious
-          // sub-agent cannot bypass the cap by echoing an oversized FilePart.
+          // subagent cannot bypass the cap by echoing an oversized FilePart.
           await Promise.all(
             fileArtifacts
               .slice(0, source1Count)
@@ -806,9 +798,8 @@ class GraphExecutor {
                 if (!fa.file?.bytes || !fa.file?.name || fa._fromEmitFilePart) return false
                 const rejection = checkInputFile(fa.file, cds.env.agents?.fileIO)
                 if (rejection) {
-                  LOG.warn("downstream file re-persist rejected", {
+                  LOG.warn(serviceName, "-", "downstream file re-persist rejected", {
                     conversation: short(contextId),
-                    service: serviceName,
                     name: fa.file.name,
                     reason: rejection,
                   })
@@ -828,9 +819,8 @@ class GraphExecutor {
         // Capture source classification for the log line below.
         for (const filePart of fileArtifacts) {
           if (!filePart.file?.name) {
-            LOG.warn("skipping malformed file artifact", {
+            LOG.warn(serviceName, "-", "skipping malformed file artifact", {
               conversation: short(contextId),
-              service: serviceName,
             })
             continue
           }
@@ -841,9 +831,8 @@ class GraphExecutor {
             typeof filePart.file?.bytes === "string"
               ? Buffer.byteLength(filePart.file.bytes, "base64")
               : 0
-          LOG.info("file emitted", {
+          LOG.info(serviceName, "-", "file emitted", {
             conversation: short(contextId),
-            service: serviceName,
             name: safeName,
             mimeType: filePart.file?.mimeType,
             bytes: decodedSize,
@@ -863,13 +852,12 @@ class GraphExecutor {
 
         dataArtifacts.forEach((artifact, i) => {
           if (artifact.data == null || typeof artifact.data !== "object") {
-            LOG.warn("skipping malformed data artifact", {
+            LOG.warn(serviceName, "-", "skipping malformed data artifact", {
               conversation: short(contextId),
-              service: serviceName,
             })
             return
           }
-          LOG.info("data emitted", { conversation: short(contextId), service: serviceName })
+          LOG.info(serviceName, "-", "data emitted", { conversation: short(contextId) })
           eventBus.publish({
             kind: "artifact-update",
             taskId,
@@ -902,7 +890,7 @@ class GraphExecutor {
         // Aborted (client disconnect or tasks/cancel) — publish canceled, not failed
         // Use name check (not instanceof) to also catch native DOMException AbortError from LangGraph
         if (err.name === "AbortError") {
-          LOG.info("canceled", { conversation: short(contextId), service: serviceName })
+          LOG.info(serviceName, "-", "canceled", { conversation: short(contextId) })
           if (wfSpan) wfSpan.setAttribute("agent.outcome", "canceled")
 
           audit("AgentTaskCanceled", {
@@ -923,62 +911,34 @@ class GraphExecutor {
           return
         }
 
-        // Timeout — attempt graceful summary of work-in-progress before reporting
+        // Timeout — pause at checkpoint. User decides whether to resume graph.
         if (err.name === "TimeoutError") {
-          LOG.warn("timeout", { conversation: short(contextId), service: serviceName })
+          LOG.warn(serviceName, "-", "timeout", { conversation: short(contextId) })
 
-          if (wfSpan) wfSpan.setAttribute("agent.outcome", "timeout")
-          metrics.errorsTotal.add(1, { ...mAttrs, "agent.error.code": "timeout" })
+          if (wfSpan) wfSpan.setAttribute("agent.outcome", "input-required")
 
           const summary = await this._summarizePartialWork(
             taskId,
             contextId,
             serviceName,
-            "timed out",
+            "timeOut",
           )
 
-          audit("AgentTaskFailed", {
-            data: {
-              taskId,
-              contextId,
-              service: serviceName,
-              error: err.message,
-              errorCode: "timeout",
-              task: requestContext.task,
-            },
-          })
-
-          eventBus.publish({
-            kind: "status-update",
-            taskId,
-            contextId,
-            status: {
-              state: "canceled",
-              message: agentMessage(summary),
-              timestamp: new Date().toISOString(),
-            },
-            final: true,
-          })
+          publishTimeoutHitl({ requestContext, eventBus, description: summary, serviceName })
           return
         }
 
         // Quota exceeded — summarize partial work instead of raw error
         if (err.quotaExceeded) {
-          LOG.warn("quota exceeded", {
+          LOG.warn(serviceName, "-", "quota exceeded", {
             conversation: short(contextId),
-            service: serviceName,
             error: err.message,
           })
 
           if (wfSpan) wfSpan.setAttribute("agent.outcome", "quota_exceeded")
           metrics.errorsTotal.add(1, { ...mAttrs, "agent.error.code": "quota_exceeded" })
 
-          const summary = await this._summarizePartialWork(
-            taskId,
-            contextId,
-            serviceName,
-            "quota exceeded",
-          )
+          const summary = await this._summarizePartialWork(taskId, contextId, serviceName, "quota")
 
           audit("AgentTaskFailed", {
             data: {
@@ -1005,16 +965,11 @@ class GraphExecutor {
           return
         }
 
-        LOG.error("failed", {
-          conversation: short(contextId),
-          service: serviceName,
-          error: err.message,
-        })
-        LOG.debug("failed stack", {
-          conversation: short(contextId),
-          service: serviceName,
-          stack: err.stack,
-        })
+        LOG.error(
+          Object.assign(err, {
+            conversation: short(contextId),
+          }),
+        )
 
         if (wfSpan) {
           wfSpan.setAttribute("agent.outcome", "failed")

package/srv/handlers/index.js

@@ -67,7 +67,7 @@ export default function registerDefaultAgentHandlers(srv) {
     }
 
     const { buildMcpTools } = await import("./mcp-tools.js")
-    const { buildSubAgentTool } = await import("./sub-agent-tools.js")
+    const { buildSubAgentTool } = await import("./subagent-tools.js")
 
     const results = await Promise.allSettled([
       ...mcpEntries.map((e) => buildMcpTools(e.service ?? e)),
@@ -76,7 +76,7 @@ export default function registerDefaultAgentHandlers(srv) {
 
     const extraTools = []
     for (const r of results) {
-      // MCP connections yield an array of tools; sub-agent connections yield a
+      // MCP connections yield an array of tools; subagent connections yield a
       // single tool. Normalize both so instrumentTools sees a flat tool list.
       if (r.status === "fulfilled") {
         if (Array.isArray(r.value)) extraTools.push(...r.value.filter(Boolean))

package/srv/handlers/mcp-tools.js

@@ -101,7 +101,7 @@ export async function buildMcpToolsFromConnection(serviceName) {
 
   const path = typeof credentials === "object" ? credentials?.path : null
   const mcpUrl = url.replace(/\/$/, "") + (path ? `/${path.replace(/^\//, "")}` : "")
-  LOG.info(`Connecting to MCP server at ${mcpUrl}`)
+  LOG.info(`Connecting to MCP service ${serviceName}`, { at: mcpUrl })
 
   const resolveHeaders = async () => {
     if (destinationName) {
@@ -113,7 +113,8 @@ export async function buildMcpToolsFromConnection(serviceName) {
     return token ? { Authorization: `Bearer ${token}` } : {}
   }
 
-  return { _mcpDynamic: true, mcpUrl, serviceName, resolveHeaders }
+  const toolFilter = cds.requires[serviceName]?.mcp?.tools
+  return { _mcpDynamic: true, mcpUrl, serviceName, resolveHeaders, toolFilter }
 }
 
 export async function buildMcpTools(serviceName) {

package/srv/handlers/{sub-agent-tools.js → subagent-tools.js}

@@ -1,10 +1,14 @@
 import cds from "@sap/cds"
 import { tool } from "@langchain/core/tools"
 import { z } from "zod"
+import { getTracer } from "../../lib/telemetry/metrics.js"
 import { LangGraphExecutor } from "../langgraph-executor-srv.js"
 import { short, toolName } from "../../lib/utils/utils.js"
 
-const LOG = cds.log("agents:sub-agents|agents|sub-agents")
+const LOG = cds.log("agents:a2a|agents|subagents|a2a")
+
+const TRUNCATE = cds.env.agents?.truncate || 111
+const truncated = (msg) => (msg?.length > TRUNCATE ? msg.slice(0, TRUNCATE) + "..." : msg)
 
 import { inspect } from "util"
 /**
@@ -93,10 +97,14 @@ function createA2ATool(client, agentCard) {
           LOG.trace(`Raw results from ${subagent}`, inspect(result, { depth: null, colors: true }))
         let response = formatToolResult(extractResult(result))
         if (response)
-          LOG.info(`Got response from ${subagent}`, { messageId }, "\n\n" + response + "\n")
+          LOG.info(
+            `Got response from ${subagent}`,
+            { messageId },
+            "\n\n" + truncated(response) + "\n",
+          )
         return response
       } catch (err) {
-        LOG.warn("Sub agent tool error", { subagent, error: err.message })
+        LOG.warn("Subagent tool error", { subagent, error: err.message })
         return `Error communicating with ${subagent}: ${err.message}`
       }
     },
@@ -112,13 +120,13 @@ function createA2ATool(client, agentCard) {
 
 export async function buildSubAgentToolLocally(serviceName) {
   const srv = cds.services[serviceName]
-  if (!srv) throw new Error(`[sub-agents] No local service "${serviceName}" found.`)
+  if (!srv) throw new Error(`[subagents] No local service "${serviceName}" found.`)
 
   const executor = LangGraphExecutor.for(srv)
 
   const { generateAgentCard } = await import("../../lib/protocol/agent-card.js")
   const agentCard = generateAgentCard(srv)
-  LOG.info(`Connecting to sub agent ${serviceName}`, "(local)")
+  LOG.info(`Connecting to subagent ${serviceName}`, "(local)")
 
   const { RequestContext, DefaultExecutionEventBus } = await import("@a2a-js/sdk/server")
 
@@ -147,7 +155,7 @@ export async function buildSubAgentToolLocally(serviceName) {
             .map((p) => p.text)
             .join("\n")
           if (text) statusText = text
-          if (state === "failed") failed = text || "Sub-agent execution failed."
+          if (state === "failed") failed = text || "Subagent execution failed."
         } else if (event.kind === "artifact-update") {
           const parts = event.artifact?.parts || []
           if (event.artifact?.artifactId === "response") {
@@ -176,19 +184,17 @@ export async function buildSubAgentToolLocally(serviceName) {
         taskId,
         contextId,
       )
-      const truncated = message?.length > 80 ? message.slice(0, 80) + "..." : message
 
       try {
-        // Run the sub-agent detached from the calling agent, in its own root
+        // Run the subagent detached from the calling agent, in its own root
         // context and transaction (cds.spawn creates + commits a fresh tx). A
         // shared transaction breaks the stream.
         await new Promise((resolve, reject) => {
           cds
             .spawn({ user: cds.context?.user, tenant: cds.context?.tenant }, async () => {
-              LOG.info("request", {
+              LOG.info(srv.name, "-", "request", {
                 conversation: short(contextId),
-                service: srv.name,
-                text: truncated,
+                text: truncated(message),
               })
 
               await executor.execute(requestContext, eventBus)
@@ -198,7 +204,7 @@ export async function buildSubAgentToolLocally(serviceName) {
             .on("failed", reject)
         })
       } catch (err) {
-        LOG.warn("Local sub-agent tool error", { agent: agentCard.name, error: err.message })
+        LOG.warn("Local subagent tool error", { agent: agentCard.name, error: err.message })
         return `Error running ${agentCard.name}: ${err.message}`
       }
 
@@ -238,7 +244,7 @@ export async function buildSubAgentToolFromConnection(serviceName) {
 
   if (!localUrl && !destinationName) {
     throw new Error(
-      `[sub-agents] Could not resolve URL or destination name for service "${serviceName}". Check cds.requires config.`,
+      `[subagents] Could not resolve URL or destination name for service "${serviceName}". Check cds.requires config.`,
     )
   }
 
@@ -286,13 +292,13 @@ export async function buildSubAgentToolFromConnection(serviceName) {
 
   if (!agentBaseUrl) {
     throw new Error(
-      `[sub-agents] Could not resolve URL for service "${serviceName}" after destination lookup.`,
+      `[subagents] Could not resolve URL for service "${serviceName}" after destination lookup.`,
     )
   }
 
   const path = typeof credentials === "object" ? credentials?.path : null
   const base = agentBaseUrl.replace(/\/$/, "") + (path ? `/${path.replace(/^\//, "")}` : "")
-  LOG.info(`Connecting to sub agent ${serviceName}`, { at: base })
+  LOG.info(`Connecting to subagent ${serviceName}`, { at: base })
 
   // revisit: a2a agents may be tenant specific, card per tenant?
   const initialHeaders = await resolveHeaders()
@@ -302,7 +308,7 @@ export async function buildSubAgentToolFromConnection(serviceName) {
   })
   if (!cardRes.ok) {
     throw new Error(
-      `[sub-agents] Agent card fetch failed for "${serviceName}" at ${cardUrl}: HTTP ${cardRes.status}`,
+      `[subagents] Agent card fetch failed for "${serviceName}" at ${cardUrl}: HTTP ${cardRes.status}`,
     )
   }
   const agentCard = await cardRes.json()
@@ -312,6 +318,10 @@ export async function buildSubAgentToolFromConnection(serviceName) {
 
   const customFetch = async (url, init = {}) => {
     const headers = await resolveHeaders()
+    if (getTracer()) {
+      const { context, propagation } = await import("@opentelemetry/api")
+      propagation.inject(context.active(), headers)
+    }
     return fetch(url, { ...init, headers: { ...headers, ...(init.headers || {}) } })
   }
   const factory = new ClientFactory(

package/srv/handlers/tools.js

@@ -11,7 +11,8 @@ import {
   executeCallActionTool,
   executePerActionTool,
 } from "@cap-js/mcp/lib/tools.js"
-import { getFilteredEntities, getFilteredActions, getAgentLogger } from "../../lib/utils/utils.js"
+
+import { getFilteredEntities, getFilteredActions } from "@cap-js/mcp/lib/utils/tools-shared.js"
 import { isTextMime } from "../../lib/agents/markdown/backends/mime-utils.js"
 import { checkAuthorization } from "@cap-js/mcp/lib/auth.js"
 
@@ -31,7 +32,6 @@ function cachedAuth(srv) {
 
 class GenericReadTool extends DynamicStructuredTool {
   constructor(srv, entities) {
-    const log = getAgentLogger(srv)
     const def = createGenericReadToolDefinition(Object.keys(entities), srv.name, "")
     super({
       name: def.name,
@@ -39,7 +39,7 @@ class GenericReadTool extends DynamicStructuredTool {
       schema: def.inputSchema,
       responseFormat: "content_and_artifact",
       func: async (args) => {
-        return unwrap(await executeGenericReadTool(srv, entities, args, { log }))
+        return unwrap(await executeGenericReadTool(srv, entities, args))
       },
     })
     this.srv = srv
@@ -68,7 +68,6 @@ class GenericReadTool extends DynamicStructuredTool {
 
 class DescribeTool extends DynamicStructuredTool {
   constructor(srv, entities, actions) {
-    const log = getAgentLogger(srv)
     const def = createDescribeToolDefinition(
       Object.keys(entities),
       Object.keys(actions),
@@ -80,8 +79,8 @@ class DescribeTool extends DynamicStructuredTool {
       description: def.description,
       schema: def.inputSchema,
       responseFormat: "content_and_artifact",
-      func: async (args) => {
-        return unwrap(await executeDescribe(srv, entities, actions, args, { log }))
+      func: (args) => {
+        return unwrap(executeDescribe(srv, entities, actions, args))
       },
     })
     this.srv = srv
@@ -121,7 +120,6 @@ class DescribeTool extends DynamicStructuredTool {
 
 class PerActionTool extends DynamicStructuredTool {
   constructor(srv, actionName, action) {
-    const log = getAgentLogger(srv)
     const def = createPerActionToolDefinition(actionName, action, srv.name, srv.model, "")
     super({
       name: def.name,
@@ -129,7 +127,7 @@ class PerActionTool extends DynamicStructuredTool {
       schema: def.inputSchema,
       responseFormat: "content_and_artifact",
       func: async (args) => {
-        return unwrap(await executePerActionTool(srv, actionName, action, args, { log }))
+        return unwrap(await executePerActionTool(srv, actionName, action, args))
       },
     })
     this.srv = srv
@@ -145,7 +143,6 @@ class PerActionTool extends DynamicStructuredTool {
 
 class CallActionTool extends DynamicStructuredTool {
   constructor(srv, actions) {
-    const log = getAgentLogger(srv)
     const def = createCallActionToolDefinition(Object.keys(actions), srv.name, "")
     super({
       name: def.name,
@@ -153,7 +150,7 @@ class CallActionTool extends DynamicStructuredTool {
       schema: def.inputSchema,
       responseFormat: "content_and_artifact",
       func: async (args) => {
-        return unwrap(await executeCallActionTool(srv, actions, args, { log }))
+        return unwrap(await executeCallActionTool(srv, actions, args))
       },
     })
     this.srv = srv