@cap-js/agents 0.9.7 → 0.9.8

package/lib/config/local.js

@@ -2,26 +2,35 @@ import path from "node:path"
 import fs from "node:fs"
 import os from "node:os"
 import cds from "@sap/cds"
+import { toml } from "../utils/toml.js"
 
 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
+ * Autoconfiguration for anthropic -> openai -> mock
  */
 export function resolve_config(options) {
-  let config = fromEnv()
+  let config = resolve_anthropic_config(options)
+  if (config?.credentials?.anthropicApiUrl || config?.credentials?.apiKey) return config
+  config = resolve_openai_config(options)
+  if (config?.credentials?.baseURL || config?.credentials?.apiKey) return config
+  return { kind: "mock" }
+}
+
+/**
+ * Anthropic autoconfiguration based on env, options,
+ * ~/.claude/settings.json and ~/.config/opencode/opencode.json
+ */
+export function resolve_anthropic_config(options) {
+  let config = fromAnthropicEnv()
   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,
@@ -32,7 +41,7 @@ export function resolve_config(options) {
   }
 }
 
-function fromEnv(env = process.env, silent) {
+function fromAnthropicEnv(env = process.env, silent) {
   let any,
     config = {}
   if ((any = env.ANTHROPIC_BASE_URL)) config.anthropicApiUrl = any
@@ -51,7 +60,7 @@ function fromClaude() {
     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"))
+    let conf = (fromClaude.cached = fromAnthropicEnv(settings?.env, "silent"))
     if (!conf.model && settings.env) {
       let family = (settings.model || "sonnet").toUpperCase()
       conf.model = settings.env[`ANTHROPIC_DEFAULT_${family}_MODEL`] || settings?.model
@@ -88,6 +97,110 @@ function fromOpencode() {
   return fromOpencode.cached
 }
 
+/**
+ * OpenAI autoconfiguration based on env, options,
+ * ~/.codex/config.toml and ~/.config/opencode/opencode.json
+ */
+export function resolve_openai_config(options = {}) {
+  let config = fromOpenAIEnv()
+  if (!config?.baseURL)
+    config = {
+      ...config,
+      ...fromCodex(),
+      ...fromOpencodeOpenAI(),
+    }
+  let { model, ...credentials } = config
+  return {
+    kind: "openai",
+    model: options?.model || model,
+    credentials: {
+      ...credentials,
+      ...options?.credentials,
+    },
+  }
+}
+
+function fromOpenAIEnv(env = process.env) {
+  let any,
+    config = {}
+  if ((any = env.OPENAI_BASE_URL)) config.baseURL = any
+  if ((any = env.OPENAI_API_KEY)) config.apiKey = any
+  if ((any = env.OPENAI_MODEL)) config.model = any
+  if (!Object.keys(config).length) return null
+  LOG.debug(`Loaded OpenAI settings from env:`, config)
+  return config
+}
+
+function fromCodex() {
+  if ("cached" in fromCodex) return fromCodex.cached
+  const codex_toml = path.join(HOME, ".codex/config.toml")
+  try {
+    let conf = toml.parse(fs.readFileSync(codex_toml, "utf8"))
+    LOG.debug(`Loaded Codex settings from`, local(codex_toml))
+    const provider = conf.model_provider ?? "openai"
+    const p = conf.model_providers?.[provider] ?? {}
+    let apiKey = (p.env_key && process.env[p.env_key]) || p.experimental_bearer_token
+    if (!apiKey && p.requires_openai_auth) apiKey = fromCodexAuth()
+    let any,
+      config = {}
+    if ((any = p.base_url)) config.baseURL = any
+    if (
+      (any =
+        (p.env_key && process.env[p.env_key]) ??
+        p.experimental_bearer_token ??
+        (p.requires_openai_auth && fromCodexAuth()))
+    )
+      config.apiKey = any
+    if ((any = conf.model)) config.model = any
+    fromCodex.cached = Object.keys(config).length ? config : null
+    LOG.debug(`Loaded config from`, local(codex_toml), ":", sanitized(config))
+  } catch {
+    LOG.debug(`Failed loading Codex settings from`, local(codex_toml))
+    fromCodex.cached = null
+  }
+  return fromCodex.cached
+}
+
+function fromCodexAuth() {
+  const auth_json = path.join(HOME, ".codex/auth.json")
+  try {
+    let auth = JSON.parse(fs.readFileSync(auth_json, "utf8"))
+    // auth.json stores the key under OPENAI_API_KEY (or a custom env var name)
+    return auth?.OPENAI_API_KEY ?? null
+  } catch {
+    LOG.debug(`Failed loading Codex auth from`, local(auth_json))
+    return null
+  }
+}
+
+function fromOpencodeOpenAI() {
+  if ("cached" in fromOpencodeOpenAI) return fromOpencodeOpenAI.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?.openai?.options
+    if (!o) return (fromOpencodeOpenAI.cached = null)
+    let any,
+      config = {}
+    if ((any = o.baseURL ?? o.baseURL)) config.baseURL = any
+    if ((any = o.apiKey)) config.apiKey = any
+    if ((any = conf?.model)) config.model = any.replace("openai/", "")
+    fromOpencodeOpenAI.cached = Object.keys(config).length ? config : null
+    LOG.debug(
+      `Loaded config from`,
+      local(opencode_json),
+      ":",
+      sanitized(fromOpencodeOpenAI.cached || {}),
+    )
+  } catch {
+    LOG.debug(`Failed loading OpenCode settings from`, local(opencode_json))
+    fromOpencodeOpenAI.cached = null
+  }
+  return fromOpencodeOpenAI.cached
+}
+
 const sanitized = ({ apiKey, ...rest }) => ({
   ...rest,
   apiKey: apiKey ? "***" : undefined,

package/lib/eval/eval-run.js

@@ -5,6 +5,7 @@ import {
   createEvalRun,
   closeEvalRun,
   logMlflowMetrics,
+  logMlflowRunMetadata,
 } from "../telemetry/mlflow/evaluation.js"
 import { flushMlflowTraces } from "../telemetry/mlflow/tracing.js"
 
@@ -23,6 +24,9 @@ export function evalRun(opts = {}) {
       runId,
       mlflowRunId,
       validationsByTask: new Map(),
+      metricKeys: new Set(),
+      mlflowMetadataLogged: false,
+      prompts: [],
     }
   }
 
@@ -34,15 +38,22 @@ export function evalRun(opts = {}) {
   })
 
   if (typeof afterEach === "function") {
-    afterEach(async () => {
-      if (state) await _flushValidations(state)
+    afterEach(async (testState) => {
+      if (state) {
+        await _flushValidations(state)
+        // Report test failure/success, so aggregated output_correctness respects static asserts
+        _addValidation(
+          { _evalState: state, taskId: "code_asserts" },
+          testState.task.result.state === "pass",
+        )
+      }
     })
   }
 
   afterAll(async () => {
     if (state) await _flushValidations(state)
     await flushMlflowTraces()
-    await closeEvalRun(state?.mlflowRunId).catch(() => {})
+    await closeEvalRun(state).catch(() => {})
     if (cds._activeEvalRun === state) cds._activeEvalRun = null
     state = null
   })
@@ -148,5 +159,40 @@ async function _postAssessmentScore(result, score, comment, config) {
 export async function logMlflowMetricsForResult(result, state = null) {
   state = state ?? cds._activeEvalRun
   if (!state?.mlflowRunId) return
-  await logMlflowMetrics(state.mlflowRunId, result.metrics).catch(() => {})
+  state.prompts = state.prompts.concat(_extractPrompts(result?.spans))
+  await _logMlflowRunMetadataOnce(result, state)
+  await logMlflowMetrics(state, result.metrics).catch(() => {})
+}
+
+// REVISIT: Properly log models as Registered Models in an eval Run to cover the change that an eval run contains multiple models
+async function _logMlflowRunMetadataOnce(result, state) {
+  if (state.mlflowMetadataLogged) return
+  const metadata = _extractMlflowRunMetadata(result?.spans)
+  if (!metadata) return
+  state.mlflowMetadataLogged = true
+  await logMlflowRunMetadata(state.mlflowRunId, metadata).catch(() => {})
+}
+
+function _extractMlflowRunMetadata(spans) {
+  const attrs = spans?.find(
+    (span) => span.attributes?.["gen_ai.operation.name"] === "chat",
+  )?.attributes
+  if (!attrs) return null
+
+  const model = attrs["gen_ai.response.model"]
+  const provider = attrs["gen_ai.provider.name"]
+  const params =
+    attrs["gen_ai.request.model_params"] && JSON.parse(attrs["gen_ai.request.model_params"])
+
+  if (!model && !provider && !Object.keys(params).length) return null
+  return { model, provider, params }
+}
+
+function _extractPrompts(spans) {
+  const attrs = spans?.find(
+    (span) => span.attributes?.["gen_ai.operation.name"] === "invoke_agent",
+  )?.attributes
+  if (!attrs) return []
+  const prompts = JSON.parse(attrs["mlflow.traceTag.mlflow.linkedPrompts"]) ?? []
+  return prompts
 }

package/lib/masking/unstructured/hana.js

@@ -1,5 +1,6 @@
 import cds from "@sap/cds"
 import { generatePseudonymTag } from "../store.js"
+import { circuitBreaker, retry } from "../../utils/resilience.js"
 
 const LOG = cds.log("agents")
 
@@ -13,20 +14,27 @@ const DPP_CATEGORIES = new Map([
   ["URI:IP", "ip"],
 ])
 
-let scriptServerActive = true
+const PAL_CONNECTIVITY_ERROR = "73003604"
+const retryMw = retry(5, {
+  shouldRetry: (err) => String(err?.message ?? "").includes(PAL_CONNECTIVITY_ERROR),
+})
+const circuitBreakerMw = circuitBreaker()
 
 export async function anonymize(text, seed) {
-  if (!scriptServerActive || !text || !seed) return { text }
+  if (!text || !seed) return { text }
   try {
-    return await pseudonymizeText(text, seed)
+    const resilientPseudonymize = circuitBreakerMw({
+      fn: retryMw({ fn: pseudonymizeText }),
+      context: { uri: "hana-script-server" },
+    })
+    return await resilientPseudonymize({ text, seed })
   } catch (err) {
     LOG.error(`SAP HANA Cloud NLS based pseudonymization disabled due to error: `, err)
-    scriptServerActive = false
     return { text }
   }
 }
 
-async function pseudonymizeText(text, seed) {
+async function pseudonymizeText({ text, seed }) {
   const res = await cds.run(buildPalCallSql(), [text])
   const entities = res.changes[1]
   const piiEntities = entities

package/lib/models/aicore.js

@@ -11,6 +11,11 @@ import {
   withPromptCachingOptions,
   withPromptCachingParams,
 } from "../utils/caching.js"
+import {
+  isAdditiveCacheUsageModel,
+  normalizeAdditiveCacheUsage,
+  normalizeAdditiveCacheUsageChunk,
+} from "../utils/usage.js"
 import { syncSystemPrompt } from "../telemetry/mlflow/prompts.js"
 
 const LOG = cds.log("agents")
@@ -29,8 +34,12 @@ function noTemp0Support(model) {
 }
 
 const llmError = (err) => {
-  LOG.error(`AI Core request failed!`, err.rootCause || err)
-  cds.error(cds.i18n.messages.at("LLM_UNAVAILABLE"))
+  if (err.rootCause?.message.match(/Could not find service credentials for AI Core/)) {
+    throw err.rootCause
+  } else {
+    LOG.error(`AI Core request failed!`, err.rootCause || err)
+    cds.error(cds.i18n.messages.at("LLM_UNAVAILABLE"))
+  }
 }
 
 class _InstrumentedOrchestrationClient extends OrchestrationClient {
@@ -83,6 +92,8 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
         // works for every agent regardless of this flag (deep or managed alike).
         // Default on; `streaming: false` opts out.
         streaming: streaming !== false,
+        // p-retry from langchain = 0, retry for AI Core completion is still set to 2
+        maxRetries: 0,
         onFailedAttempt: (err) => {
           // Abort retries when circuit breaker is open (otherwise pRetry delays ~30-60s)
           if (err.code === "EOPENBREAKER" || err.message === "Breaker is open") {
@@ -108,7 +119,8 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
     opts = _withMiddleware(this, opts)
     const prepared = _prepareMessages(messages, { flatten, model, opts })
     try {
-      return super._generate(prepared.inputMessages, prepared.opts, runManager)
+      const result = await super._generate(prepared.inputMessages, prepared.opts, runManager)
+      return isAdditiveCacheUsageModel(model) ? normalizeAdditiveCacheUsage(result) : result
     } catch (err) {
       llmError(err)
     }
@@ -135,6 +147,7 @@ class _InstrumentedOrchestrationClient extends OrchestrationClient {
     let turnHasToolCall = false
     try {
       for await (const chunk of super._streamResponseChunks(inputMessages, opts, runManager)) {
+        if (isAdditiveCacheUsageModel(model)) normalizeAdditiveCacheUsageChunk(chunk)
         if (chunk.message?.tool_call_chunks?.length > 0) turnHasToolCall = true
         const text = chunk.text || extractTextFromContentBlocks(chunk)
         const reasoning = extractReasoningFromChunk(chunk)

package/lib/models/openai.js

@@ -0,0 +1,9 @@
+import { ChatOpenAI } from "@langchain/openai"
+
+export default class ChatOpenAIService extends ChatOpenAI {
+  constructor(name, options = {}) {
+    const { credentials = {} } = options
+    super({ ...options, configuration: credentials })
+    this.name = name
+  }
+}