@cap-js/agents 0.9.3 → 0.9.5

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,
+})

package/lib/eval/eval-run.js

@@ -70,15 +70,20 @@ async function _flushValidations(state) {
       tasks.push(
         flushMlflowTraces().then(() =>
           Promise.all([
-            postMlflowAssessment(traceId, success_rate, "", "success_rate", null, codeOpts).catch(
-              () => {},
-            ),
+            postMlflowAssessment(
+              traceId,
+              success_rate,
+              "",
+              "success_rate",
+              "cap-js/agents",
+              codeOpts,
+            ).catch(() => {}),
             postMlflowAssessment(
               traceId,
               output_correctness,
               "",
               "output_correctness",
-              null,
+              "cap-js/agents",
               codeOpts,
             ).catch(() => {}),
           ]),
@@ -124,7 +129,7 @@ async function _postAssessmentScore(result, score, comment, config) {
       score,
       comment ?? "",
       config.assessmentName,
-      config.model ?? null,
+      config.model ?? config.assessmentName ?? "judge",
       { ...opts, metadata: { "mlflow.trace.session": config.sessionId ?? "" } },
     )
   } else {
@@ -134,7 +139,7 @@ async function _postAssessmentScore(result, score, comment, config) {
       score,
       comment ?? "",
       config.assessmentName,
-      config.model ?? null,
+      config.model ?? config.assessmentName ?? "judge",
       opts,
     )
   }

package/lib/index.js

@@ -15,6 +15,9 @@ import * as metrics from "./telemetry/metrics.js"
 
 const LOG = cds.log("agents")
 
+const TRUNCATE = cds.env.agents?.truncate || 111
+const truncated = (msg) => (msg?.length > TRUNCATE ? msg.slice(0, TRUNCATE) + "..." : msg)
+
 // SSE wire-format helpers, mirroring @a2a-js/sdk's sse_utils so the adapter
 // streams message/stream responses identically to the SDK's reference
 // Express handler. Inlined (not imported) because the SDK does not export
@@ -215,11 +218,10 @@ export default function A2AProtocolAdapter(srv, options = {}) {
     if (method === "message/send" || method === "message/stream") {
       const text = userText
 
-      const maxLen = cds.env.agents?.pool?.maxIncomingMessageLength
+      const maxLen = cds.env.agents?.quotas?.maxIncomingMessageLength
       if (maxLen > 0 && text?.length > maxLen) {
-        LOG.warn("message too long", {
+        LOG.warn(srv.name, "message too long", {
           conversation: short(contextId),
-          service: srv.name,
         })
         metrics.errorsTotal.add(1, { ...requestAttrs, "agent.error.code": 400 })
 
@@ -245,15 +247,13 @@ export default function A2AProtocolAdapter(srv, options = {}) {
         return
       }
 
-      const truncated = text?.length > 80 ? text.slice(0, 80) + "..." : text
-      LOG.info("request", {
+      LOG.info(srv.name, "request", {
         conversation: short(contextId),
-        service: srv.name,
         method,
-        text: truncated,
+        text: truncated(text),
       })
     } else {
-      LOG.debug("request", { conversation: short(contextId), service: srv.name, method })
+      LOG.debug(srv.name, "request", { conversation: short(contextId), method })
     }
 
     try {
@@ -264,9 +264,8 @@ export default function A2AProtocolAdapter(srv, options = {}) {
           await import("./agents/quota-enforcer-at-start.js")
         const quotaResult = await quotaEnforcerAtStart()
         if (quotaResult) {
-          LOG.warn("quota exceeded", {
+          LOG.warn(srv.name, "quota exceeded", {
             conversation: short(contextId),
-            service: srv.name,
             reason: quotaResult.message,
           })
           metrics.errorsTotal.add(1, { ...requestAttrs, "agent.error.code": 429 })
@@ -416,8 +415,6 @@ export default function A2AProtocolAdapter(srv, options = {}) {
       })
   })
 
-  LOG.debug("Adapter initialized", { service: srv.name })
-
   router.router = router
   return router
 }

package/lib/models/aicore.js

@@ -2,24 +2,53 @@ import cds from "@sap/cds"
 import { OrchestrationClient } from "@sap-ai-sdk/langchain"
 import { circuitBreaker, timeout } from "../utils/resilience.js"
 
-import { SystemMessage, ToolMessage, HumanMessage, AIMessage } from "@langchain/core/messages"
+import { SystemMessage, ToolMessage, AIMessage } from "@langchain/core/messages"
 import { ms4 } from "../utils/utils.js"
+import {
+  isPromptCachingModel,
+  PROMPT_CACHE_MODEL_PARAMS,
+  withPromptCachingMessages,
+  withPromptCachingOptions,
+  withPromptCachingParams,
+} from "../utils/caching.js"
 import { syncSystemPrompt } from "../telemetry/mlflow/prompts.js"
 
 const LOG = cds.log("agents")
 const DEFAULT_STREAM_DELIMITERS = [".", "!", "?"]
 
+function noTemp0Support(model) {
+  switch (model) {
+    case "gpt-5.6-sol":
+    case "gpt-5.6-luna":
+    case "gpt-5.6-terra":
+    case "gpt-6-astra":
+      return true
+    default:
+      return false
+  }
+}
+
+const llmError = (err) => {
+  LOG.error(`AI Core request failed!`, err.rootCause || err)
+  cds.error(cds.i18n.messages.at("LLM_UNAVAILABLE"))
+}
+
 class _InstrumentedOrchestrationClient extends OrchestrationClient {
   constructor(name, options) {
     const { model, deepAgent, streaming, destinationName, resourceGroup } = options
     const flatten = options.flatten ?? (deepAgent ? true : false)
 
-    // Restore pre-72ef6fa params resolution: caller > deep-agent default > root
+    // params resolution: caller > deep-agent default > root
     // cds.env.agents.params. Without this, AI Core silently applies its own
     // defaults (temperature ≈ 1, verbose model → repeated max_tokens truncation
-    // and extra ReAct iterations — see PR #188 review).
-    const params =
+    // and extra ReAct iterations).
+    const rawParams =
       options.params || (deepAgent ? { max_tokens: 4096, temperature: 0 } : cds.env.agents?.params)
+    const params = withPromptCachingParams(model, rawParams)
+    if (params.temperature === 0 && noTemp0Support(model)) {
+      delete params.temperature
+    }
+
     const auditParams = params && typeof params === "object" ? { ...params } : params
 
     LOG.debug("Initializing LLM", { model, deepAgent: !!deepAgent })
@@ -65,14 +94,24 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
       destination,
     )
     this.name = name
-    this.options = { ...options, params: auditParams, contentFilter, flatten }
+    this.options = {
+      ...options,
+      params: auditParams,
+      contentFilter,
+      flatten,
+      promptCaching: isPromptCachingModel(model),
+    }
   }
 
   async _generate(messages, opts, runManager) {
     const { model, flatten } = this.options
     opts = _withMiddleware(this, opts)
     const prepared = _prepareMessages(messages, { flatten, model, opts })
-    return super._generate(prepared.inputMessages, prepared.opts, runManager)
+    try {
+      return super._generate(prepared.inputMessages, prepared.opts, runManager)
+    } catch (err) {
+      llmError(err)
+    }
   }
 
   /**
@@ -80,8 +119,8 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
    *
    * 1. Message flattening / normalization — same as _generate: content arrays
    *    must be reduced to text before reaching AI Core's assistant template.
-   * 2. Claude prompt caching — injectCacheControl must run here too, or
-   *    cache_control is silently skipped on the streaming path.
+   * 2. Prompt caching options — same as _generate, or caching is skipped on
+   *    the streaming path.
    * 3. Content extraction — @sap-ai-sdk/langchain getDeltaContent() only handles
    *    string deltas; Anthropic streams content-block arrays (and reasoning in a
    *    sibling field), so we re-extract and re-emit them via buildStreamBlocks().
@@ -94,17 +133,44 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
     opts = withDefaultStreamDelimiters(prepared.opts)
 
     let turnHasToolCall = false
-    for await (const chunk of super._streamResponseChunks(inputMessages, opts, runManager)) {
-      if (chunk.message?.tool_call_chunks?.length > 0) turnHasToolCall = true
-      const text = chunk.text || extractTextFromContentBlocks(chunk)
-      const reasoning = extractReasoningFromChunk(chunk)
-      const blocks = buildStreamBlocks(text, reasoning, turnHasToolCall)
-
-      if (!blocks.length && !(text && turnHasToolCall)) {
-        yield chunk
-        continue
+    try {
+      for await (const chunk of super._streamResponseChunks(inputMessages, opts, runManager)) {
+        if (chunk.message?.tool_call_chunks?.length > 0) turnHasToolCall = true
+        const text = chunk.text || extractTextFromContentBlocks(chunk)
+        const reasoning = extractReasoningFromChunk(chunk)
+        const blocks = buildStreamBlocks(text, reasoning, turnHasToolCall)
+
+        if (!blocks.length && !(text && turnHasToolCall)) {
+          yield chunk
+          continue
+        }
+        yield patchChunkContent(chunk, blocks)
       }
-      yield patchChunkContent(chunk, blocks)
+    } catch (err) {
+      llmError(err)
+    }
+  }
+
+  mergeOrchestrationConfig(orchestrationConfig, options) {
+    const config = super.mergeOrchestrationConfig(orchestrationConfig, options)
+    const modelParams = options?.[PROMPT_CACHE_MODEL_PARAMS]
+    if (!modelParams) return config
+    const currentParams = config.promptTemplating?.model?.params || {}
+    const nextParams = { ...modelParams }
+    if (currentParams.prompt_cache_key !== undefined) delete nextParams.prompt_cache_key
+    if (!Object.keys(nextParams).length) return config
+    return {
+      ...config,
+      promptTemplating: {
+        ...config.promptTemplating,
+        model: {
+          ...config.promptTemplating?.model,
+          params: {
+            ...currentParams,
+            ...nextParams,
+          },
+        },
+      },
     }
   }
 }
@@ -113,15 +179,11 @@ export default _InstrumentedOrchestrationClient
 
 // ─── SDK helpers ─────────────────────────────────────────────────────────────
 
-function isClaude(model) {
-  return /anthropic|claude/i.test(model || "")
-}
-
 /**
  * Inject timeout and circuit breaker middleware into opts.
  */
 function _withMiddleware(instance, opts) {
-  const llmTimeout = ms4(cds.env.agents?.pool?.maxLLMCallTimeout || "120s")
+  const llmTimeout = ms4(cds.env.agents?.quotas?.maxLLMCallTimeout || "120s")
   const middleware = [timeout(llmTimeout), circuitBreaker()]
   return {
     ...opts,
@@ -130,23 +192,16 @@ function _withMiddleware(instance, opts) {
 }
 
 /**
- * Prepare input messages: flatten, normalize assistant content, inject cache_control.
- * Returns { inputMessages, opts } (opts may be mutated with cache_control on last tool).
+ * Prepare input messages: flatten, normalize assistant content, and set prompt
+ * caching call options/model params.
  */
 function _prepareMessages(messages, { flatten, model, opts }) {
   let inputMessages = flatten ? flattenMessages(messages) : messages
   inputMessages = normalizeAssistantContent(inputMessages)
-  if (isClaude(model)) {
-    inputMessages = injectCacheControl(inputMessages)
-    if (opts?.tools?.length > 0) {
-      const tools = [...opts.tools]
-      tools[tools.length - 1] = {
-        ...tools[tools.length - 1],
-        cache_control: CACHE_CONTROL_EPHEMERAL,
-      }
-      opts = { ...opts, tools }
-    }
-  }
+  const cached = withPromptCachingMessages(model, inputMessages, opts)
+  inputMessages = cached.messages
+  opts = cached.opts
+  opts = withPromptCachingOptions(model, opts)
   syncSystemPrompt(inputMessages)
   return { inputMessages, opts }
 }
@@ -164,97 +219,6 @@ export function withDefaultStreamDelimiters(opts = {}) {
   }
 }
 
-// Claude currently only supports caching of type ephemeral. TTL can differ between 5min or 1h but
-// we use the 5min default
-const CACHE_CONTROL_EPHEMERAL = { type: "ephemeral" }
-
-/**
- * Marks: all system messages, the last AI message (with text content), and the last human message.
- * Converts string content to content-block arrays where needed so cache_control
- * can be attached per the Anthropic/SAP AI Core API format.
- */
-function injectCacheControl(messages) {
-  if (!messages || messages.length === 0) return messages
-
-  const result = messages.map((m) => {
-    // Clone to avoid mutating original
-    if (m._getType?.() === "system" || m.type === "system") {
-      return _withCacheControl(m)
-    }
-    return m
-  })
-  // Mark last AI message with non-empty text content (stable breakpoint for multi-turn)
-  for (let i = result.length - 1; i >= 0; i--) {
-    const type = result[i]._getType?.() || result[i].type
-    if (type === "ai" && _hasTextContent(result[i])) {
-      result[i] = _withCacheControl(result[i])
-      break
-    }
-  }
-  // Mark last human message
-  for (let i = result.length - 1; i >= 0; i--) {
-    const type = result[i]._getType?.() || result[i].type
-    if (type === "human") {
-      result[i] = _withCacheControl(result[i])
-      break
-    }
-  }
-  return result
-}
-
-/**
- * Check if a message has non-empty text content (not just tool_calls).
- */
-function _hasTextContent(msg) {
-  const content = msg.content
-  if (typeof content === "string") return content.length > 0
-  if (Array.isArray(content)) return content.some((b) => b.type === "text" && b.text?.length > 0)
-  return false
-}
-
-/**
- * If content is a string, convert to [{type:"text", text, cache_control}].
- * If content is an array, add cache_control to the last text block.
- */
-function _withCacheControl(msg) {
-  const content = msg.content
-  if (typeof content === "string") {
-    // Convert to content blocks with cache_control on the block
-    const newContent = [{ type: "text", text: content, cache_control: CACHE_CONTROL_EPHEMERAL }]
-    return _cloneMessageWithContent(msg, newContent)
-  }
-  if (Array.isArray(content) && content.length > 0) {
-    const newContent = [...content]
-    // Find last text block and add cache_control
-    for (let i = newContent.length - 1; i >= 0; i--) {
-      if (newContent[i].type === "text") {
-        newContent[i] = { ...newContent[i], cache_control: CACHE_CONTROL_EPHEMERAL }
-        break
-      }
-    }
-    return _cloneMessageWithContent(msg, newContent)
-  }
-  return msg
-}
-
-function _cloneMessageWithContent(msg, newContent) {
-  const type = msg._getType?.() || msg.type
-  if (type === "system") {
-    return new SystemMessage({ content: newContent })
-  }
-  if (type === "ai") {
-    return new AIMessage({ content: newContent, tool_calls: msg.tool_calls })
-  }
-  if (type === "human") {
-    return new HumanMessage({ content: newContent })
-  }
-  if (type === "tool") {
-    return new ToolMessage({ content: newContent, tool_call_id: msg.tool_call_id, name: msg.name })
-  }
-  // Fallback: shallow clone with new content
-  return { ...msg, content: newContent }
-}
-
 export function flattenMessages(messages) {
   return messages.map((m) => {
     if (!Array.isArray(m.content)) return m

package/lib/models/anthropic.js

@@ -1,77 +1,20 @@
 import { ChatAnthropic } from '@langchain/anthropic'
-import path from 'node:path'
-import fs from 'node:fs'
-import os from 'node:os'
-import cds from '@sap/cds'
+import { withPromptCachingMessages } from '../utils/caching.js'
 
-const HOME = os.homedir() || process.env.HOME || process.env.USERPROFILE
-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 default class ChatAnthropicService extends ChatAnthropic {
-  constructor (name, options) {
-    // REVISIT: may be better handled via options.credentials?
-    let config = { ...options, ...fromEnv() }
-    if (!config.anthropicApiUrl) config = {
-      ...fromClaude() || fromOpencode(),
-      ...config
-    }
-    LOG.debug (`Using effective config for ChatAnthropic:`, config)
-    super (config)
+  constructor (name, options = {}) {
+    const { credentials = {} } = options
+    super ({ ...credentials, ...options })
     this.name = name
-    this.options = config
   }
-}
 
-function fromEnv (env = process.env) {
-  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
-  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 conf = JSON.parse (fs.readFileSync (settings_json,'utf8'))
-    // https://www.schemastore.org/claude-code-settings.json
-    fromClaude.cached = conf = fromEnv (conf?.env)
-    LOG.debug(`Loaded Claude settings from`, settings_json, ':', conf)
-  } catch {
-    LOG.debug(`Failed loading Claude settings from`, settings_json)
-    fromClaude.cached = null
+  async _generate (messages, options, runManager) {
+    const cached = withPromptCachingMessages(this.model, messages, options)
+    return super._generate(cached.messages, cached.opts, runManager)
   }
-  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`, 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 OpenCode settings from`, opencode_json, ':', conf)
-  } catch {
-    LOG.debug(`Failed loading OpenCode settings from`, opencode_json)
-    fromOpencode.cached = null
+  async *_streamResponseChunks (messages, options, runManager) {
+    const cached = withPromptCachingMessages(this.model, messages, options)
+    yield* super._streamResponseChunks(cached.messages, cached.opts, runManager)
   }
-  return fromOpencode.cached
 }