@cap-js/agents 0.9.4 → 0.9.5

package/_i18n/messages.properties

@@ -1,14 +1,24 @@
 # Agent status messages (shown during task execution)
+#XMSG Status info message send to the user client when a tool is called. {0} = tool name
 agent_status_calling_tools = Calling {0}
+#XMSG Status info message send to the user client when an entity is being queried. {0} = entity name
 agent_status_querying = Querying {0}
+#XMSG Status info message send to the user client after a tool result returned and the agent is processing it
 agent_status_processing_response = Processing tool response
+#XMSG Status info message send to the user client after multiple tool results returned and the agent is processing it
 agent_status_processing_responses = Processing tool responses
+agent_status_summarizing_progress = Agent interrupted. Summarising progress.
+AGENT_SUMMARY_QUOTA_FALLBACK = The task was stopped as it reached its resource consumption limit. Some work may have been done — please check the results or retry with a simpler request.
+AGENT_SUMMARY_TIMEOUT_FALLBACK = The task was stopped as it reached its time limit. Progress may be incomplete. Continue running or stop?
 
 # Authentication
+#XMSG Error message for HTTP 401 status
 UNAUTHORIZED = Unauthorized
+#XMSG Error message for HTTP 403 status
 FORBIDDEN = Forbidden
 
 # Input validation
+#XMSG Error message send to the users client when their message exceeds the limit. {0} = number of allowed characters
 MESSAGE_TOO_LONG = The message must not exceed {0} characters.
 
 # Quota enforcement
@@ -28,4 +38,11 @@ CONTENT_FILTER_TOOL_BLOCKED = The last tool called yielded a malicious result. P
 PUSH_URL_NOT_ALLOWED = Push notification callback URL ''{0}'' not in allowed domains: {1}
 
 # HITL
+HITL_APPROVE = Approve
+HITL_REJECT = Reject
+HITL_CONTINUE = Continue
+HITL_STOP = Stop
 RESUME_REQUIRES_TEXT = Resume message must contain text (e.g. ''approve'' or ''reject'') or a data part.
+
+# LLM
+LLM_UNAVAILABLE = The agent is temporarily unavailable. Please try again later.

package/cds-plugin.js

@@ -1,37 +1,21 @@
 import cds from "@sap/cds"
 
 const LOG = cds.log("agents")
-import { patchLangChain } from "./lib/telemetry/tracing.js"
-import cds_compile_to_a2a from "./lib/compile.js"
 import registerDefaultAgentHandlers from "./srv/handlers/index.js"
+import { patchLangChain } from "./lib/telemetry/tracing.js"
 import { slugified } from "./lib/utils/utils.js"
-
+import cds_compile_to_a2a from "./lib/compile.js"
 cds.compile.to.a2a = cds_compile_to_a2a
 
-// Detect optional peer plugins (@cap-js/telemetry, @cap-js/audit-logging)
-const hasTelemetry = !!cds.env.requires?.telemetry
-const hasAuditLog = !!cds.env.requires?.["audit-log"]
-const hasMetrics = !!cds.env.requires?.telemetry?.["metrics"]
-const hasTracing = !!cds.env.requires?.telemetry?.["tracing"]
-if (!hasTelemetry && cds.env.profiles?.includes("production"))
-  LOG.warn("@cap-js/telemetry not configured - metrics and tracing disabled")
-if (!hasAuditLog && cds.env.profiles?.includes("production"))
-  LOG.warn("@cap-js/audit-logging not configured - audit events disabled")
-if (hasTelemetry && !hasMetrics && cds.env.profiles?.includes("production"))
-  LOG.warn("@cap-js/telemetry has no metrics configured - metrics disabled")
-if (hasTelemetry && !hasTracing && cds.env.profiles?.includes("production"))
-  LOG.warn("@cap-js/telemetry has no tracing configured - tracing disabled")
-
 // Enable doc comments in CSN for agent card generation
 cds.env.cdsc = { ...cds.env.cdsc, docComment: true }
 
-// Ensure A2A correlation fields are indexed by SAP Cloud Logging
-cds.env.log ??= {}
-const cls_fields = (cds.env.log.cls_custom_fields ??= [])
-if (!cls_fields.includes("agent.task.id")) cls_fields.push("agent.task.id")
-if (!cls_fields.includes("agent.context.id")) cls_fields.push("agent.context.id")
-
 cds.on("bootstrap", (app) => {
+  // Ensure A2A correlation fields are indexed by SAP Cloud Logging
+  const cls_fields = ((cds.env.log ??= {}).cls_custom_fields ??= [])
+  if (!cls_fields.includes("agent.task.id")) cls_fields.push("agent.task.id")
+  if (!cls_fields.includes("agent.context.id")) cls_fields.push("agent.context.id")
+
   const providers = {
     ["llm-mock"]: {},
     anthropic: {
@@ -77,64 +61,97 @@ cds.on("bootstrap", (app) => {
   })
 })
 
-cds.on("serving", (srv) => {
-  if (!(srv instanceof cds.ApplicationService)) return
-  if (!srv.definition?.["@agent"]) return
-  registerDefaultAgentHandlers(srv)
-})
+!(function cds_agents_config_compat() {
+  // Also support legacy `cds.agents.pool` configuration by merging it into `cds.agents.quotas`
+  if (cds.env.agents?.pool)
+    cds.env.agents.quotas = { ...cds.env.agents.quotas, ...cds.env.agents.pool }
+})()
 
-// Schedule active_users metric computation + MLflow exporter
-cds.on("served", async () => {
-  if (hasTelemetry) {
-    const { setupActiveUsersMetric } = await import("./lib/telemetry/active-users.js")
-    setupActiveUsersMetric()
-    // Defer LangChain patching so the CDS model is fully loaded before patches land.
-    // opt-out via cds.env.agents.trace_langchain = false
-    if (cds.env.agents?.trace_langchain !== false) {
-      await patchLangChain()
+!(function cds_requires_llm() {
+  cds.on("served", async () => {
+    if (
+      cds.requires.llm === "anthropic" ||
+      cds.requires.llm?.kind === "anthropic" ||
+      cds.requires.llm === "auto" ||
+      cds.requires.llm?.kind === "auto"
+    ) {
+      const { resolve_config } = await import("./lib/config/local.js")
+      let options = cds.requires.llm
+      if (options === "auto") options = { kind: "auto" }
+      cds.env.requires.llm = resolve_config(options)
     }
-  }
 
-  if (cds.env.agents?.mlflow) {
-    const { setupMlflowExporter } = await import("./lib/telemetry/mlflow/index.js")
-    setupMlflowExporter()
-  }
-})
+    const config = cds.requires.llm,
+      credentials = {}
+    const { url, destination, anthropicApiUrl, apiKey } = config?.credentials || {}
+    if (url) credentials.url = url
+    if (destination) credentials.destination = destination
+    if (anthropicApiUrl) credentials.anthropicApiUrl = anthropicApiUrl
+    if (apiKey) credentials.apiKey = "***"
+    LOG.info(`cds.connect.to 'llm' with:`, { ...config, credentials })
+  })
+})()
+
+!(function add_agent_handlers() {
+  cds.on("serving", (srv) => {
+    if (srv.definition?.protocols?.agent) registerDefaultAgentHandlers(srv)
+  })
+})()
+
+if (cds.env.requires?.telemetry)
+  !(function telemetry() {
+    // Schedule active_users metric computation + MLflow exporter
+    cds.on("served", async () => {
+      const { setupActiveUsersMetric } = await import("./lib/telemetry/active-users.js")
+      setupActiveUsersMetric()
+      // Defer LangChain patching so the CDS model is fully loaded before patches land.
+      // opt-out via cds.env.agents.trace_langchain = false
+      if (cds.env.agents?.trace_langchain !== false) {
+        await patchLangChain()
+      }
+
+      if (cds.env.agents?.mlflow) {
+        const { setupMlflowExporter } = await import("./lib/telemetry/mlflow/index.js")
+        setupMlflowExporter()
+      }
+    })
+  })()
 
 // Bootstrap sidecar mode when the agent-sidecar profile is active
-if (cds.env.profiles?.includes("agent-sidecar")) {
-  // Auto-mark @agent services as external so CDS does not serve them locally.
-  // Auto-mark them as hcql services served externally, they are served from the main app.
-  // This runs after model load but before cds.serve() filters definitions,
-  // so users don't need to add these things manually.
-  cds.on("loaded", (csn) => {
-    const hcql = cds.requires.kinds["hcql"]
-    const agentSidecar = cds.requires.agent || {}
-    const hcqlBase = agentSidecar.url // For local development the base URL is given in the package.json
-    const agentCredentials = agentSidecar.credentials || {}
-    for (const [name, def] of Object.entries(csn.definitions || {})) {
-      if (def.kind !== "service") continue
-      if (!def["@agent"]) continue
-      // Mark as external so CDS does not serve it locally — it will be served via HCQL from the main app.
-      def["@cds.external"] = true
-      // Java main apps use the CDS service name in the HCQL path (/hcql/CatalogService),
-      // Node.js main apps use the slugified path (/hcql/catalog).
-      const isJava = !cds.env.profiles?.includes("node")
-      let n = isJava ? name : slugified(name)
-      if (cds.requires[name]) continue // skip if user provided service-specific config for this service
-      if (cds.requires[n]) continue // skip if user provided service-specific config for possibly the slugified version
-      const newRequiresEntry = { ...hcql, kind: "hcql" }
-      newRequiresEntry.credentials = {
-        ...agentCredentials,
-        ...(hcqlBase && { url: `${hcqlBase}/${n.split(".").pop()}` }),
-        ...(agentCredentials.destination && { path: `/${n.split(".").pop()}` }),
+if (cds.env.profiles?.includes("agent-sidecar"))
+  !(function sidecar() {
+    // Auto-mark @agent services as external so CDS does not serve them locally.
+    // Auto-mark them as hcql services served externally, they are served from the main app.
+    // This runs after model load but before cds.serve() filters definitions,
+    // so users don't need to add these things manually.
+    cds.on("loaded", (csn) => {
+      const hcql = cds.requires.kinds["hcql"]
+      const agentSidecar = cds.requires.agent || {}
+      const hcqlBase = agentSidecar.url // For local development the base URL is given in the package.json
+      const agentCredentials = agentSidecar.credentials || {}
+      for (const [name, def] of Object.entries(csn.definitions || {})) {
+        if (def.kind !== "service") continue
+        if (!def["@agent"]) continue
+        // Mark as external so CDS does not serve it locally — it will be served via HCQL from the main app.
+        def["@cds.external"] = true
+        // Java main apps use the CDS service name in the HCQL path (/hcql/CatalogService),
+        // Node.js main apps use the slugified path (/hcql/catalog).
+        const isJava = !cds.env.profiles?.includes("node")
+        let n = isJava ? name : slugified(name)
+        if (cds.requires[name]) continue // skip if user provided service-specific config for this service
+        if (cds.requires[n]) continue // skip if user provided service-specific config for possibly the slugified version
+        const newRequiresEntry = { ...hcql, kind: "hcql" }
+        newRequiresEntry.credentials = {
+          ...agentCredentials,
+          ...(hcqlBase && { url: `${hcqlBase}/${n.split(".").pop()}` }),
+          ...(agentCredentials.destination && { path: `/${n.split(".").pop()}` }),
+        }
+        cds.requires[n] = newRequiresEntry
       }
-      cds.requires[n] = newRequiresEntry
-    }
-  })
+    })
 
-  cds.on("served", async () => {
-    const { bootstrapSidecar } = await import("./lib/sidecar.js")
-    await bootstrapSidecar()
-  })
-}
+    cds.on("served", async () => {
+      const { bootstrapSidecar } = await import("./lib/sidecar.js")
+      await bootstrapSidecar()
+    })
+  })()

package/lib/agents/markdown/deep-agent.js

@@ -27,7 +27,7 @@ export async function createAutoDeepAgent(srv, agentDir) {
     createSkillsMiddleware,
   } = await import("deepagents")
 
-  LOG.debug("Auto-building deep agent", {
+  LOG.debug("Auto-building deep agent for:", {
     service: srv?.name,
     agentDir,
     tools: tools.length,

package/lib/agents/middleware/index.js

@@ -25,6 +25,6 @@ export default async function buildMiddleware(srv, options = {}) {
     await statusUpdateMiddleware(),
     ...(await humanInTheLoopMiddleware(srv, tools)),
     toolSelectionMiddleware(),
-    toolWrapMiddleware(),
+    toolWrapMiddleware(srv),
   ].filter(Boolean)
 }

package/lib/agents/middleware/quota-enforcer.js

@@ -6,7 +6,7 @@ import { z } from "zod"
 
 /**
  * Quota enforcement middleware for deep agents.
- * Reads limits from cds.env.agents.pool at check time (not creation time).
+ * Reads limits from cds.env.agents.quotas at check time (not creation time).
  * Returns array to spread into middleware config.
  */
 export async function quotaEnforcerMiddleware() {
@@ -21,12 +21,12 @@ export async function quotaEnforcerMiddleware() {
       afterModel: {
         canJumpTo: ["end"],
         hook: (state) => {
-          const pool = cds.env.agents?.pool || {}
+          const quotas = cds.env.agents?.quotas || {}
           const newCallCount = state.runModelCallCount + 1
 
           // Check LLM invocation limit
-          if (pool.maxLLMInvocationsPerTask && newCallCount > pool.maxLLMInvocationsPerTask) {
-            const reason = `LLM call limit exceeded: ${newCallCount} calls (max ${pool.maxLLMInvocationsPerTask} per task)`
+          if (quotas.maxLLMInvocationsPerTask && newCallCount > quotas.maxLLMInvocationsPerTask) {
+            const reason = `LLM call limit exceeded: ${newCallCount} calls (max ${quotas.maxLLMInvocationsPerTask} per task)`
             audit("QuotaExceeded", {
               data: {
                 service: cds.context?.["agent.service"],
@@ -47,8 +47,8 @@ export async function quotaEnforcerMiddleware() {
           const newTokenCount = state.runTokenCount + consumed
 
           // Check token limit
-          if (pool.maxLLMTokensPerTask && newTokenCount > pool.maxLLMTokensPerTask) {
-            const reason = `Token limit exceeded: ${newTokenCount} tokens (max ${pool.maxLLMTokensPerTask} per task)`
+          if (quotas.maxLLMTokensPerTask && newTokenCount > quotas.maxLLMTokensPerTask) {
+            const reason = `Token limit exceeded: ${newTokenCount} tokens (max ${quotas.maxLLMTokensPerTask} per task)`
             audit("QuotaExceeded", {
               data: {
                 service: cds.context?.["agent.service"],
@@ -67,8 +67,8 @@ export async function quotaEnforcerMiddleware() {
           const newToolCallCount = state.runToolCallCount + toolCalls
 
           // Check tool call limit
-          if (pool.maxToolCallsPerTask && newToolCallCount > pool.maxToolCallsPerTask) {
-            const reason = `Tool call limit exceeded: ${newToolCallCount} calls (max ${pool.maxToolCallsPerTask} per task)`
+          if (quotas.maxToolCallsPerTask && newToolCallCount > quotas.maxToolCallsPerTask) {
+            const reason = `Tool call limit exceeded: ${newToolCallCount} calls (max ${quotas.maxToolCallsPerTask} per task)`
             audit("QuotaExceeded", {
               data: {
                 service: cds.context?.["agent.service"],

package/lib/agents/middleware/remote-mcp.js

@@ -19,13 +19,14 @@ export function remoteMcpMiddleware() {
       const cache = (cds.context.__mcpDynamicTools ??= {})
       const placeholders = (request.tools ?? []).filter((t) => t._mcpDynamic)
       await Promise.all(
-        placeholders.map(async ({ mcpUrl, serviceName, resolveHeaders }) => {
+        placeholders.map(async ({ mcpUrl, serviceName, resolveHeaders, toolFilter }) => {
           if (cache[mcpUrl]) return
           const headers = await resolveHeaders()
           const client = new MultiServerMCPClient({
             mcpServers: { default: { transport: "http", url: mcpUrl, headers } },
           })
-          const raw = await client.getTools()
+          let raw = await client.getTools()
+          if (toolFilter?.length) raw = raw.filter((t) => toolFilter.includes(t.name))
           for (const t of raw) t.name = toolName(`${serviceName}_${t.name}`)
           cache[mcpUrl] = raw
           LOG.debug(

package/lib/agents/middleware/status-update.js

@@ -63,7 +63,7 @@ function resolveToolLabel(tc) {
 /**
  * Publishes a non-final "working" status-update to the eventBus.
  */
-function publishStatus(text) {
+export function publishStatus(text) {
   const eventBus = cds.context?.["agent.eventBus"]
   if (!eventBus || !text) return
 

package/lib/agents/middleware/tool-wrap.js

@@ -10,13 +10,13 @@ const LOG = cds.log("agents")
  * Handles two paths: thrown errors (err.details appended when present)
  * and tools returning artifact.isError=true (@cap-js/mcp action pattern).
  */
-export function toolWrapMiddleware() {
+export function toolWrapMiddleware(srv) {
   return createMiddleware({
     name: "ToolWrapMiddleware",
-    wrapToolCall: async (request, handler) => {
+    wrapToolCall: async function (request, handler) {
       const { name, id, args } = request.toolCall
       try {
-        LOG.debug("[tool]", name, args)
+        LOG.debug(srv.name, "calling tool", name, args)
         const result = await handler(request)
         if (ToolMessage.isInstance(result) && result.artifact?.isError === true) {
           result.status = "error"
@@ -29,12 +29,11 @@ export function toolWrapMiddleware() {
         ) {
           result.status = "error"
         }
-        if (result?.status === "error") LOG.debug("[tool] error", name, result.content)
-        else LOG.debug("[tool] completed", name)
+        if (result?.status === "error") LOG.debug(srv.name, "tool error", name, result.content)
         return result
       } catch (err) {
         if (isGraphInterrupt(err)) throw err
-        LOG.debug("[tool] error", name, err)
+        LOG.debug(srv.name, "tool error", name, err)
         let content = `Error: ${err.message}`
         if (Array.isArray(err.details) && err.details.length > 0) {
           const lines = err.details.map((d) => `- ${d.message}`).join("\n")

package/lib/agents/quota-enforcer-at-start.js

@@ -24,11 +24,9 @@ function secondsUntilMidnightUTC() {
  * Returns null if within limits, or { message, retryAfter } if a limit is breached.
  */
 export default async function quotaEnforcerAtStart() {
-  const pool = cds.env.agents?.pool
-  if (!pool) {
-    LOG.debug(
-      "No quota pool configuration found at cds.env.agents.pool — quota enforcement disabled",
-    )
+  const quotas = cds.env.agents?.quotas
+  if (!quotas) {
+    LOG.debug("No quota configuration found at cds.env.agents.quotas — quota enforcement disabled")
     return null
   }
 
@@ -65,44 +63,49 @@ export default async function quotaEnforcerAtStart() {
       .columns("coalesce(sum(usageLlmTokens),0) as llmTokensThisDay")
       .where({ createdAt: { ">=": today.toISOString() } }),
   ])
-  if (pool.maxConcurrentTasks != null && concurrentTasks >= pool.maxConcurrentTasks) {
+  if (quotas.maxConcurrentTasks != null && concurrentTasks >= quotas.maxConcurrentTasks) {
     return {
-      message: cds.i18n.messages.at("QUOTA_CONCURRENT_TASKS", [pool.maxConcurrentTasks]),
+      message: cds.i18n.messages.at("QUOTA_CONCURRENT_TASKS", [quotas.maxConcurrentTasks]),
       retryAfter: 30,
     }
   }
   if (
-    pool.maxConcurrentTasksPerUser != null &&
-    concurrentTasksThisUser >= pool.maxConcurrentTasksPerUser
+    quotas.maxConcurrentTasksPerUser != null &&
+    concurrentTasksThisUser >= quotas.maxConcurrentTasksPerUser
   ) {
     return {
       message: cds.i18n.messages.at("QUOTA_CONCURRENT_TASKS_PER_USER", [
-        pool.maxConcurrentTasksPerUser,
+        quotas.maxConcurrentTasksPerUser,
       ]),
       retryAfter: 30,
     }
   }
-  if (pool.maxTasksPerHour != null && lastHourTasks >= pool.maxTasksPerHour) {
+  if (quotas.maxTasksPerHour != null && lastHourTasks >= quotas.maxTasksPerHour) {
     return {
-      message: cds.i18n.messages.at("QUOTA_TASKS_PER_HOUR", [pool.maxTasksPerHour]),
+      message: cds.i18n.messages.at("QUOTA_TASKS_PER_HOUR", [quotas.maxTasksPerHour]),
       retryAfter: secondsUntilNextHour(),
     }
   }
-  if (pool.maxTasksPerHourPerUser != null && lastHourTasksThisUser >= pool.maxTasksPerHourPerUser) {
+  if (
+    quotas.maxTasksPerHourPerUser != null &&
+    lastHourTasksThisUser >= quotas.maxTasksPerHourPerUser
+  ) {
     return {
-      message: cds.i18n.messages.at("QUOTA_TASKS_PER_HOUR_PER_USER", [pool.maxTasksPerHourPerUser]),
+      message: cds.i18n.messages.at("QUOTA_TASKS_PER_HOUR_PER_USER", [
+        quotas.maxTasksPerHourPerUser,
+      ]),
       retryAfter: secondsUntilNextHour(),
     }
   }
-  if (pool.maxToolCallsPerHour != null && lastHourToolCalls >= pool.maxToolCallsPerHour) {
+  if (quotas.maxToolCallsPerHour != null && lastHourToolCalls >= quotas.maxToolCallsPerHour) {
     return {
-      message: cds.i18n.messages.at("QUOTA_TOOL_CALLS_PER_HOUR", [pool.maxToolCallsPerHour]),
+      message: cds.i18n.messages.at("QUOTA_TOOL_CALLS_PER_HOUR", [quotas.maxToolCallsPerHour]),
       retryAfter: secondsUntilNextHour(),
     }
   }
-  if (pool.maxLLMTokensPerDay != null && llmTokensThisDay >= pool.maxLLMTokensPerDay) {
+  if (quotas.maxLLMTokensPerDay != null && llmTokensThisDay >= quotas.maxLLMTokensPerDay) {
     return {
-      message: cds.i18n.messages.at("QUOTA_LLM_TOKENS_PER_DAY", [pool.maxLLMTokensPerDay]),
+      message: cds.i18n.messages.at("QUOTA_LLM_TOKENS_PER_DAY", [quotas.maxLLMTokensPerDay]),
       retryAfter: secondsUntilMidnightUTC(),
     }
   }

package/lib/agents/summarize-on-timeout.js

@@ -1,10 +1,11 @@
 import cds from "@sap/cds"
 import { HumanMessage } from "@langchain/core/messages"
 import { short } from "../utils/utils.js"
+import { publishStatus } from "./middleware/status-update.js"
 
 const LOG = cds.log("agents")
 
-const DEFAULT_TIMEOUT = 10_000
+const DEFAULT_TIMEOUT = 20_000
 
 /**
  * Summarize partial work from a graph execution that was interrupted
@@ -17,10 +18,10 @@ const DEFAULT_TIMEOUT = 10_000
  * @param {object} options
  * @param {string} options.contextId
  * @param {string} options.serviceName
- * @param {string} options.reason - Why execution was interrupted (e.g. "timed out", "quota exceeded")
+ * @param {string} options.reason - "timeOut" or "quota"
  * @param {object} [options.checkpointer] - LangGraph checkpointer instance
  * @param {Function} options.getModel - Async function returning a LangChain chat model
- * @param {number} [options.timeout] - Max ms to spend on summarization (default 10s)
+ * @param {number} [options.timeout] - Max ms to spend on summarization (default 20s)
  * @returns {Promise<string>} Summary message or fallback
  */
 export async function summarizePartialWork({
@@ -31,7 +32,10 @@ export async function summarizePartialWork({
   getModel,
   timeout = DEFAULT_TIMEOUT,
 }) {
-  const fallback = `The task was stopped (${reason}). Some work may have been done — please check the results or retry with a simpler request.`
+  publishStatus(cds.i18n.messages.at(`agent_status_summarizing_progress`))
+  const fallback = cds.i18n.messages.at(
+    reason === "timeOut" ? "AGENT_SUMMARY_TIMEOUT_FALLBACK" : "AGENT_SUMMARY_QUOTA_FALLBACK",
+  )
 
   try {
     if (!getModel) return fallback
@@ -52,10 +56,11 @@ export async function summarizePartialWork({
         return `[${role}]: ${content?.slice(0, 500)}`
       })
       .join("\n")
-    const summaryPrompt = `The following agent task was interrupted (${reason}). Based on the conversation so far, provide a brief summary of what was accomplished and what remains. Be concise.
-
-Conversation:
-${conversationSnippet}`
+    let summaryPrompt =
+      reason === "timeOut"
+        ? `Agent task was not completed within its time limit. Write short, precise progress summary so user can decide whether to continue. State completed work and immediate next work. Do not claim work not shown. Start with: Agent did not finish within time! End with: Continue running or stop? No other questions to the user allowed!`
+        : `Agent task was interrupted. Reason: ${reason}. Based on conversation history, provide brief summary of completed work and remaining work. Be concise.`
+    summaryPrompt += `\n\n Conversation Snippet: \n\n ${conversationSnippet.trim()}`
 
     let summaryTimer
     try {
@@ -70,19 +75,19 @@ ${conversationSnippet}`
       ])
 
       const summary =
-        typeof response.content === "string" ? response.content : JSON.stringify(response.content)
+        typeof response.content === "string" ? response.content : response.content?.[0]?.text
+      if (!summary) throw new Error("Summary LLM returned no text")
 
-      LOG.info("partial work summary generated", {
+      LOG.info(serviceName, "partial work summary generated", {
         conversation: short(contextId),
-        service: serviceName,
         reason,
       })
-      return `Task stopped (${reason}). Progress summary: ${summary}`
+      return summary
     } finally {
       clearTimeout(summaryTimer)
     }
   } catch (err) {
-    LOG.debug("partial work summary failed, using fallback", {
+    LOG.debug(serviceName, "partial work summary failed, using fallback", {
       conversation: short(contextId),
       error: err.message,
     })

package/lib/compile.js

@@ -51,9 +51,8 @@ function cds_compile_to_a2a(csn, options = {}) {
     streaming: true,
   })
 
-  if (/^(?:obj|object)$/i.test(options.as)) return agentCard
-
-  return JSON.stringify(agentCard, null, 2)
+  if (process.stdout.isTTY || options.as === "json") return agentCard
+  else return JSON.stringify(agentCard, null, 2)
 }
 
 export default cds_compile_to_a2a

package/lib/config/local.js

@@ -0,0 +1,94 @@
+import path from "node:path"
+import fs from "node:fs"
+import os from "node:os"
+import cds from "@sap/cds"
+
+const HOME = os.homedir() || process.env.HOME || process.env.USERPROFILE
+const local = (file) => file.replace(HOME, "~")
+const LOG = cds.log("agents")
+
+/**
+ * `cds.connect.to` compliant langchain model
+ * for connecting to an Anthropic compatible API,
+ * with autoconfiguration based on env, options,
+ * ~/.claude/settings.json and ~/.config/opencode/opencode.json
+ */
+export function resolve_config(options) {
+  let config = fromEnv()
+  if (!config?.anthropicApiUrl)
+    config = {
+      ...config,
+      ...(fromClaude() || fromOpencode()),
+    }
+  let { model, ...credentials } = config
+  if (!model && !options?.model) return { kind: "mock" }
+  return {
+    kind: "anthropic",
+    model: options?.model || model,
+    credentials: {
+      ...credentials,
+      ...options?.credentials,
+    },
+  }
+}
+
+function fromEnv(env = process.env, silent) {
+  let any,
+    config = {}
+  if ((any = env.ANTHROPIC_BASE_URL)) config.anthropicApiUrl = any
+  if ((any = env.ANTHROPIC_AUTH_TOKEN)) config.apiKey = any
+  if ((any = env.ANTHROPIC_API_KEY)) config.apiKey = any
+  if ((any = env.ANTHROPIC_MODEL)) config.model = any
+  if (!Object.keys(config).length) return null
+  if (!silent) LOG.debug(`Loaded Anthropic settings from env:`, config)
+  return config
+}
+
+function fromClaude() {
+  if ("cached" in fromClaude) return fromClaude.cached
+  const settings_json = path.join(HOME, ".claude/settings.json")
+  try {
+    let settings = JSON.parse(fs.readFileSync(settings_json, "utf8"))
+    // https://www.schemastore.org/claude-code-settings.json
+
+    let conf = (fromClaude.cached = fromEnv(settings?.env, "silent"))
+    if (!conf.model && settings.env) {
+      let family = (settings.model || "sonnet").toUpperCase()
+      conf.model = settings.env[`ANTHROPIC_DEFAULT_${family}_MODEL`] || settings?.model
+    }
+    LOG.debug(`Loaded config from`, local(settings_json), ":", sanitized(conf))
+  } catch {
+    LOG.debug(`Failed loading Claude settings from`, local(settings_json))
+    fromClaude.cached = null
+  }
+  return fromClaude.cached
+}
+
+function fromOpencode() {
+  if ("cached" in fromOpencode) return fromOpencode.cached
+  const opencode_json = path.join(HOME, ".config/opencode/opencode.json")
+  try {
+    let conf = JSON.parse(fs.readFileSync(opencode_json, "utf8"))
+    LOG.debug(`Loaded OpenCode settings from`, local(opencode_json))
+    // https://opencode.ai/config.json
+    let o = conf?.provider?.anthropic?.options
+    if (!o) return (fromOpencode.cached = null)
+    let any,
+      config = {}
+    if ((any = o.anthropicApiUrl ?? o.apiUrl ?? o.baseURL))
+      config.anthropicApiUrl = any.replace(/\/v1$/, "") // opencode expects the versioned baseUrl, others do not
+    if ((any = o.anthropicApiKey ?? o.apiKey)) config.apiKey = any
+    if ((any = conf?.model)) config.model = any.replace("anthropic/", "")
+    fromOpencode.cached = Object.keys(config).length ? config : null
+    LOG.debug(`Loaded config from`, local(opencode_json), ":", sanitized(config))
+  } catch {
+    LOG.debug(`Failed loading OpenCode settings from`, local(opencode_json))
+    fromOpencode.cached = null
+  }
+  return fromOpencode.cached
+}
+
+const sanitized = ({ apiKey, ...rest }) => ({
+  ...rest,
+  apiKey: apiKey ? "***" : undefined,
+})