@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/{chunk-RZITT45F.js → chunk-N3VX7FEE.js}

@@ -1,4 +1,4 @@
-// src/errors/classify.ts
+// src/inference/errors/classify.ts
 function isRetryableCategory(category) {
   switch (category) {
     case "rate_limit":
@@ -80,7 +80,7 @@ function parseRetryDelay(headers) {
   return void 0;
 }
 
-// src/errors/extract.ts
+// src/inference/errors/extract.ts
 function extractFromAISDKError(error) {
   const result = {};
   const anyError = error;
@@ -111,7 +111,31 @@ function extractFromAISDKError(error) {
   return result;
 }
 
-// src/errors/llm-error.ts
+// src/inference/errors/llm-error.ts
+function extractMessage(error) {
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+    }
+  }
+  return String(error);
+}
+function sanitizeErrorMessage(message) {
+  const trimmed = message.trim();
+  const stackIndex = trimmed.indexOf("\n    at ");
+  if (stackIndex >= 0) {
+    return trimmed.slice(0, stackIndex).trim();
+  }
+  return trimmed.split("\n").map((line) => line.trim()).find(Boolean) ?? trimmed;
+}
+function isNoOutputGeneratedError(error) {
+  return error.name === "AI_NoOutputGeneratedError" || error.name === "NoOutputGeneratedError" || error.message.includes("No output generated. Check the stream for errors.");
+}
 var LLMError = class _LLMError extends Error {
   category;
   status;
@@ -147,15 +171,24 @@ var LLMError = class _LLMError extends Error {
           ...context
         });
       }
+      if (isNoOutputGeneratedError(error)) {
+        return new _LLMError({
+          message: "No output generated. Check the underlying provider error.",
+          cause: error,
+          category: "unknown",
+          ...extractFromAISDKError(error),
+          ...context
+        });
+      }
       return new _LLMError({
-        message: error.message,
+        message: sanitizeErrorMessage(error.message),
         cause: error,
         ...extractFromAISDKError(error),
         ...context
       });
     }
     return new _LLMError({
-      message: String(error),
+      message: extractMessage(error),
       category: "unknown",
       ...context
     });
@@ -171,7 +204,7 @@ var LLMError = class _LLMError extends Error {
   }
 };
 
-// src/errors/utils.ts
+// src/inference/errors/utils.ts
 function isRetryable(error) {
   if (error instanceof LLMError) {
     return error.isRetryable;

package/dist/{chunk-YSLSEQ6B.js → chunk-NDZWXCBZ.js}

@@ -1,19 +1,28 @@
 import {
-  createApprovalHandler
-} from "./chunk-BFM2YHNM.js";
+  DEFAULT_AGENT_NAME,
+  isBlockedModelCall
+} from "./chunk-CJI7PVS2.js";
 import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
+  extractModelId,
+  extractProvider
+} from "./chunk-I6PKJ7XQ.js";
+import {
+  ApprovalDeniedError,
+  createApprovalCorrection,
+  createApprovalHandler,
+  formatApprovalDeniedReason
+} from "./chunk-V4RFNEET.js";
+import {
+  silentLogger
+} from "./chunk-T4UIX5D7.js";
 
 // src/middleware/runner.ts
-function isBlockedModelCall(value) {
-  return "block" in value && value.block === true;
-}
 var MiddlewareRunner = class {
   stack;
-  constructor(middleware = []) {
+  log;
+  constructor(middleware = [], logger) {
     this.stack = Object.freeze([...middleware]);
+    this.log = logger?.child("middleware") ?? silentLogger;
   }
   /** Number of registered middleware */
   get count() {
@@ -67,10 +76,7 @@ var MiddlewareRunner = class {
           current = next;
         }
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" model.chunk error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        this.log.warn(`"${mw.name}" model.chunk error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return current ?? void 0;
@@ -89,10 +95,7 @@ var MiddlewareRunner = class {
           current = next;
         }
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" model.output error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        this.log.warn(`"${mw.name}" model.output error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return current;
@@ -106,15 +109,24 @@ var MiddlewareRunner = class {
    * Returns `{ action: "allow" }` if all middleware allow (or have no hook).
    * Returns `{ action: "deny", reason }` on first denial — remaining
    * middleware are skipped.
+   *
+   * When a middleware rewrites args via `decision.args`, subsequent
+   * middleware in the chain receive the rewritten args.
    */
   async runBeforeToolCall(tool, args, ctx) {
+    let currentArgs = args;
+    let rewritten = false;
     for (const mw of this.stack) {
       if (!mw.beforeToolCall) continue;
       try {
-        const decision = await mw.beforeToolCall(tool, args, ctx);
+        const decision = await mw.beforeToolCall(tool, currentArgs, ctx);
         if (decision.action === "deny") {
           return decision;
         }
+        if (decision.args !== void 0) {
+          currentArgs = decision.args;
+          rewritten = true;
+        }
       } catch (err) {
         return {
           action: "deny",
@@ -122,7 +134,7 @@ var MiddlewareRunner = class {
         };
       }
     }
-    return { action: "allow" };
+    return rewritten ? { action: "allow", args: currentArgs } : { action: "allow" };
   }
   // --------------------------------------------------------------------------
   // afterToolCall — reverse order (innermost first)
@@ -133,6 +145,10 @@ var MiddlewareRunner = class {
    * Each hook receives the result from the previous hook (or the
    * original tool result for the first hook). Errors are caught
    * and logged — the original result passes through.
+   *
+   * Middleware can add a `supplement` to inject extra text the model
+   * sees alongside the tool output. Supplements chain naturally —
+   * each middleware receives any supplement added by earlier hooks.
    */
   async runAfterToolCall(tool, args, result, ctx) {
     let current = result;
@@ -142,10 +158,7 @@ var MiddlewareRunner = class {
       try {
         current = await mw.afterToolCall(tool, args, current, ctx);
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" afterToolCall error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        this.log.warn(`"${mw.name}" afterToolCall error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return current;
@@ -172,10 +185,7 @@ var MiddlewareRunner = class {
           sections.push(result);
         }
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" promptSections error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        this.log.warn(`"${mw.name}" promptSections error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return sections;
@@ -202,11 +212,11 @@ var MiddlewareRunner = class {
    * Get the OTel context for a session from the telemetry middleware.
    * Returns undefined if no telemetry middleware is registered.
    */
-  getOtelContext(sessionId) {
+  getOtelContext(sessionId, ctx) {
     for (const mw of this.stack) {
       if (mw.getOtelContext) {
-        const ctx = mw.getOtelContext(sessionId);
-        if (ctx) return ctx;
+        const otelCtx = mw.getOtelContext(sessionId, ctx);
+        if (otelCtx) return otelCtx;
       }
     }
     return void 0;
@@ -220,16 +230,13 @@ var MiddlewareRunner = class {
    * Errors are caught and logged — a broken logger should not
    * prevent the chat from starting.
    */
-  async runChatStart(sessionId, message) {
+  async runChatStart(sessionId, message, ctx) {
     for (const mw of this.stack) {
       if (!mw.onChatStart) continue;
       try {
-        await mw.onChatStart(sessionId, message);
+        await mw.onChatStart(sessionId, message, ctx);
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" onChatStart error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        this.log.warn(`"${mw.name}" onChatStart error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
   }
@@ -242,33 +249,49 @@ var MiddlewareRunner = class {
    * Always called, even when the stream errored. Errors in handlers
    * are caught and logged.
    */
-  async runChatEnd(sessionId, result) {
+  async runChatEnd(sessionId, result, ctx) {
     for (const mw of this.stack) {
       if (!mw.onChatEnd) continue;
       try {
-        await mw.onChatEnd(sessionId, result);
+        await mw.onChatEnd(sessionId, result, ctx);
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" onChatEnd error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        this.log.warn(`"${mw.name}" onChatEnd error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
   }
 };
 
 // src/middleware/approval.ts
+function isApprovalMiddleware(value) {
+  return value.name === "approval" && "approvalHandler" in value && typeof value.approvalHandler === "object" && value.approvalHandler !== null;
+}
 function approvalMiddleware(config = {}) {
   const handler = createApprovalHandler(config);
   return {
     name: "approval",
+    approvalHandler: handler,
+    ...config.customRisks ? { approvalCustomRisks: config.customRisks } : {},
     async beforeToolCall(tool, args, ctx) {
       try {
-        await handler.request(ctx.sessionID, tool, args, config.customRisks);
+        await handler.request(
+          ctx.sessionID,
+          tool,
+          args,
+          config.customRisks,
+          ctx.toolCapabilities,
+          ctx.permissionPatterns
+        );
         return { action: "allow" };
       } catch (err) {
-        const reason = err instanceof Error ? err.message : `Approval denied: ${tool}`;
-        return { action: "deny", reason };
+        const reason = err instanceof Error ? err.message : formatApprovalDeniedReason(tool);
+        return {
+          action: "deny",
+          reason,
+          correction: createApprovalCorrection(
+            tool,
+            err instanceof ApprovalDeniedError ? err.feedback : void 0
+          )
+        };
       }
     }
   };
@@ -276,6 +299,56 @@ function approvalMiddleware(config = {}) {
 
 // src/middleware/telemetry/otel.ts
 var otelModulePromise;
+function resolveToolCallId(args, ctx) {
+  const extraToolCallId = ctx?.extra?.toolCallId;
+  if (typeof extraToolCallId === "string" && extraToolCallId.length > 0) {
+    return extraToolCallId;
+  }
+  if (ctx?.messageID) {
+    return ctx.messageID;
+  }
+  try {
+    return JSON.stringify(args);
+  } catch {
+    return String(args);
+  }
+}
+function makeToolSpanKey(toolName, toolCallId) {
+  return `${toolName}:${toolCallId}`;
+}
+function makeChatSpanKey(sessionId, turnId) {
+  return turnId ? `${sessionId}:${turnId}` : sessionId;
+}
+function findChatSpanKey(spans, sessionId, ctx) {
+  const exactKey = makeChatSpanKey(sessionId, ctx?.turnId);
+  if (spans.has(exactKey)) {
+    return exactKey;
+  }
+  if (!ctx?.turnId && spans.has(sessionId)) {
+    return sessionId;
+  }
+  for (const key of spans.keys()) {
+    if (key === sessionId || key.startsWith(`${sessionId}:`)) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function removeSpanEntry(spans, key) {
+  const entry = spans.get(key);
+  if (entry) {
+    spans.delete(key);
+  }
+  return entry;
+}
+function findSpanEntryByTool(spans, toolName) {
+  for (const [key, entry] of spans) {
+    if (key.startsWith(`${toolName}:`)) {
+      return [key, entry];
+    }
+  }
+  return void 0;
+}
 function getInputMimeType(value) {
   const trimmed = value.trimStart();
   return trimmed.startsWith("{") || trimmed.startsWith("[") ? "application/json" : "text/plain";
@@ -304,7 +377,7 @@ function scheduleSpanTimeout(options) {
 function otelMiddleware(config = {}) {
   const recordInputs = config.recordInputs ?? true;
   const recordOutputs = config.recordOutputs ?? true;
-  const agentName = config.agentName ?? "agent";
+  const agentName = config.agentName ?? DEFAULT_AGENT_NAME;
   const emitToolSpans = config.emitToolSpans ?? true;
   const spanTimeoutMs = config.spanTimeoutMs ?? 5 * 60 * 1e3;
   const chatSpans = /* @__PURE__ */ new Map();
@@ -315,6 +388,9 @@ function otelMiddleware(config = {}) {
     if (tracer) {
       return tracer;
     }
+    if (config.providerReady) {
+      await config.providerReady;
+    }
     otel = await getOtelModule();
     if (!otel) {
       return null;
@@ -324,20 +400,25 @@ function otelMiddleware(config = {}) {
   }
   return {
     name: "opentelemetry",
-    getOtelContext(sessionId) {
-      return chatSpans.get(sessionId)?.ctx;
+    getOtelContext(sessionId, ctx) {
+      const key = findChatSpanKey(chatSpans, sessionId, ctx);
+      return key ? chatSpans.get(key)?.ctx : void 0;
     },
-    async onChatStart(sessionId, message) {
+    async onChatStart(sessionId, message, chatCtx) {
       const activeTracer = await ensureTracer();
       if (!activeTracer || !otel) {
         return;
       }
+      const key = makeChatSpanKey(sessionId, chatCtx?.turnId);
       const attributes = {
         "openinference.span.kind": "AGENT",
         "gen_ai.operation.name": "invoke_agent",
         "gen_ai.agent.name": agentName,
         "gen_ai.agent.session_id": sessionId
       };
+      if (chatCtx?.turnId) {
+        attributes["gen_ai.agent.turn_id"] = chatCtx.turnId;
+      }
       if (config.agentDescription) {
         attributes["gen_ai.agent.description"] = config.agentDescription;
       }
@@ -349,13 +430,13 @@ function otelMiddleware(config = {}) {
       const span = activeTracer.startSpan(`invoke_agent ${agentName}`, {
         attributes
       });
-      const ctx = otel.trace.setSpan(otel.context.active(), span);
-      chatSpans.set(sessionId, {
+      const spanCtx = otel.trace.setSpan(otel.context.active(), span);
+      chatSpans.set(key, {
         span,
-        ctx,
+        ctx: spanCtx,
         timer: scheduleSpanTimeout({
           spans: chatSpans,
-          key: sessionId,
+          key,
           otel,
           timeoutMs: spanTimeoutMs
         })
@@ -370,7 +451,10 @@ function otelMiddleware(config = {}) {
         return { action: "allow" };
       }
       const sessionId = ctx?.sessionID;
-      const parent = sessionId ? chatSpans.get(sessionId) : void 0;
+      const parentKey = sessionId ? findChatSpanKey(chatSpans, sessionId, {
+        turnId: ctx?.turnID
+      }) : void 0;
+      const parent = parentKey ? chatSpans.get(parentKey) : void 0;
       const parentCtx = parent?.ctx ?? otel.context.active();
       const span = activeTracer.startSpan(
         `execute_tool ${tool}`,
@@ -392,8 +476,8 @@ function otelMiddleware(config = {}) {
         },
         parentCtx
       );
-      const callId = ctx?.messageID ?? JSON.stringify(args);
-      const key = `${tool}:${callId}`;
+      const callId = resolveToolCallId(args, ctx);
+      const key = makeToolSpanKey(tool, callId);
       const toolCtx = otel.trace.setSpan(parentCtx, span);
       toolSpans.set(key, {
         span,
@@ -408,12 +492,13 @@ function otelMiddleware(config = {}) {
       return { action: "allow" };
     },
     async afterToolCall(tool, args, result, ctx) {
-      const callId = ctx?.messageID ?? JSON.stringify(args);
-      const keyPrefix = `${tool}:`;
-      const key = `${tool}:${callId}`;
-      const entry = toolSpans.get(key) ?? Array.from(toolSpans.entries()).find(
-        ([candidate]) => candidate.startsWith(keyPrefix)
-      )?.[1];
+      const callId = resolveToolCallId(args, ctx);
+      const key = makeToolSpanKey(tool, callId);
+      const fallback = findSpanEntryByTool(toolSpans, tool);
+      const entry = removeSpanEntry(toolSpans, key) ?? (fallback ? (() => {
+        toolSpans.delete(fallback[0]);
+        return fallback[1];
+      })() : void 0);
       if (entry) {
         if (entry.timer) {
           clearTimeout(entry.timer);
@@ -426,12 +511,6 @@ function otelMiddleware(config = {}) {
         }
         entry.span.setStatus({ code: otel?.SpanStatusCode.OK ?? 1 });
         entry.span.end();
-        for (const [candidateKey, candidateEntry] of toolSpans) {
-          if (candidateEntry === entry) {
-            toolSpans.delete(candidateKey);
-            break;
-          }
-        }
       }
       return result;
     },
@@ -439,10 +518,13 @@ function otelMiddleware(config = {}) {
       if (event.type !== "tool-error") {
         return;
       }
-      for (const [key, entry] of toolSpans) {
-        if (!key.startsWith(`${event.toolName}:`)) {
-          continue;
-        }
+      const key = makeToolSpanKey(event.toolName, event.toolCallId);
+      const fallback = findSpanEntryByTool(toolSpans, event.toolName);
+      const entry = removeSpanEntry(toolSpans, key) ?? (fallback ? (() => {
+        toolSpans.delete(fallback[0]);
+        return fallback[1];
+      })() : void 0);
+      if (entry) {
         if (entry.timer) {
           clearTimeout(entry.timer);
         }
@@ -455,12 +537,14 @@ function otelMiddleware(config = {}) {
           message: event.error
         });
         entry.span.end();
-        toolSpans.delete(key);
-        break;
       }
     },
-    async onChatEnd(sessionId, result) {
-      const entry = chatSpans.get(sessionId);
+    async onChatEnd(sessionId, result, ctx) {
+      const key = findChatSpanKey(chatSpans, sessionId, ctx);
+      if (!key) {
+        return;
+      }
+      const entry = chatSpans.get(key);
       if (!entry) {
         return;
       }
@@ -489,34 +573,38 @@ function otelMiddleware(config = {}) {
         entry.span.setStatus({ code: otel?.SpanStatusCode.OK ?? 1 });
       }
       entry.span.end();
-      chatSpans.delete(sessionId);
+      chatSpans.delete(key);
     }
   };
 }
 
 // src/middleware/telemetry/provider.ts
+var sharedProviderState;
 function createTelemetryConfig(config) {
+  const recordInputs = config.recordInputs ?? true;
+  const recordOutputs = config.recordOutputs ?? true;
+  let providerPromise;
+  if (config.spanProcessor) {
+    providerPromise = acquireSharedProvider(
+      config.spanProcessor,
+      config.serviceName ?? config.agentName
+    );
+  }
   const middleware = otelMiddleware({
     agentName: config.agentName,
     agentDescription: config.agentDescription,
-    recordInputs: config.recordInputs,
-    recordOutputs: config.recordOutputs,
+    recordInputs,
+    recordOutputs,
     emitToolSpans: config.emitToolSpans,
-    spanTimeoutMs: config.spanTimeoutMs
+    spanTimeoutMs: config.spanTimeoutMs,
+    providerReady: providerPromise
   });
   const telemetry = {
     isEnabled: true,
     functionId: config.agentName,
-    recordInputs: config.recordInputs,
-    recordOutputs: config.recordOutputs
+    recordInputs,
+    recordOutputs
   };
-  let providerPromise;
-  if (config.spanProcessor) {
-    providerPromise = createAndRegisterProvider(
-      config.spanProcessor,
-      config.serviceName ?? config.agentName
-    );
-  }
   return {
     middleware,
     telemetry,
@@ -524,12 +612,46 @@ function createTelemetryConfig(config) {
       if (!providerPromise) {
         return;
       }
-      const provider = await providerPromise;
-      await provider.forceFlush();
-      await provider.shutdown();
+      await releaseSharedProvider(providerPromise);
     }
   };
 }
+function acquireSharedProvider(spanProcessor, serviceName) {
+  if (!sharedProviderState) {
+    const promise = createAndRegisterProvider(spanProcessor, serviceName).catch(
+      (error) => {
+        if (sharedProviderState?.promise === promise) {
+          sharedProviderState = void 0;
+        }
+        throw error;
+      }
+    );
+    sharedProviderState = {
+      promise,
+      refCount: 0
+    };
+  }
+  sharedProviderState.refCount += 1;
+  return sharedProviderState.promise;
+}
+async function releaseSharedProvider(providerPromise) {
+  if (!sharedProviderState || sharedProviderState.promise !== providerPromise) {
+    return;
+  }
+  sharedProviderState.refCount -= 1;
+  if (sharedProviderState.refCount > 0) {
+    return;
+  }
+  const provider = await providerPromise;
+  try {
+    await provider.forceFlush();
+    await provider.shutdown();
+  } finally {
+    if (sharedProviderState?.promise === providerPromise) {
+      sharedProviderState = void 0;
+    }
+  }
+}
 async function createAndRegisterProvider(spanProcessor, serviceName) {
   const [{ NodeTracerProvider }, { resourceFromAttributes }, { ATTR_SERVICE_NAME }] = await Promise.all([
     import("@opentelemetry/sdk-trace-node"),
@@ -547,14 +669,14 @@ async function createAndRegisterProvider(spanProcessor, serviceName) {
 
 // src/middleware/prompt-cache/cache.ts
 function detectCacheProvider(input) {
-  const provider = getProviderId(input.model);
+  const provider = extractProvider(input.model);
   if (provider) {
     const p = provider.toLowerCase();
     if (p === "anthropic") return "anthropic";
     if (p === "openai") return "openai";
     if (p === "google") return "google";
   }
-  const modelId = getModelId(input.model);
+  const modelId = extractModelId(input.model);
   if (/claude/i.test(modelId)) return "anthropic";
   return "unknown";
 }
@@ -642,8 +764,9 @@ function promptCacheMiddleware(config) {
 
 export {
   MiddlewareRunner,
+  isApprovalMiddleware,
+  approvalMiddleware,
   otelMiddleware,
   createTelemetryConfig,
-  approvalMiddleware,
   promptCacheMiddleware
 };