@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/{chunk-4QFNWPIF.js → chunk-N3VX7FEE.js}

@@ -112,6 +112,30 @@ function extractFromAISDKError(error) {
 }
 
 // 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
     });

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

@@ -1,25 +1,28 @@
 import {
-  createApprovalHandler
-} from "./chunk-5ARZJWD2.js";
+  DEFAULT_AGENT_NAME,
+  isBlockedModelCall
+} from "./chunk-CJI7PVS2.js";
 import {
   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;
-}
-function logMiddlewareWarning(middlewareName, hook, error) {
-  console.warn(
-    `[middleware] "${middlewareName}" ${hook} error:`,
-    error instanceof Error ? error.message : String(error)
-  );
-}
 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() {
@@ -73,7 +76,7 @@ var MiddlewareRunner = class {
           current = next;
         }
       } catch (err) {
-        logMiddlewareWarning(mw.name, "model.chunk", err);
+        this.log.warn(`"${mw.name}" model.chunk error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return current ?? void 0;
@@ -92,7 +95,7 @@ var MiddlewareRunner = class {
           current = next;
         }
       } catch (err) {
-        logMiddlewareWarning(mw.name, "model.output", 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,7 +158,7 @@ var MiddlewareRunner = class {
       try {
         current = await mw.afterToolCall(tool, args, current, ctx);
       } catch (err) {
-        logMiddlewareWarning(mw.name, "afterToolCall", err);
+        this.log.warn(`"${mw.name}" afterToolCall error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return current;
@@ -169,7 +185,7 @@ var MiddlewareRunner = class {
           sections.push(result);
         }
       } catch (err) {
-        logMiddlewareWarning(mw.name, "promptSections", err);
+        this.log.warn(`"${mw.name}" promptSections error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     return sections;
@@ -196,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;
@@ -214,13 +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) {
-        logMiddlewareWarning(mw.name, "onChatStart", err);
+        this.log.warn(`"${mw.name}" onChatStart error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
   }
@@ -233,30 +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) {
-        logMiddlewareWarning(mw.name, "onChatEnd", 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
+          )
+        };
       }
     }
   };
@@ -264,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";
@@ -292,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();
@@ -303,6 +388,9 @@ function otelMiddleware(config = {}) {
     if (tracer) {
       return tracer;
     }
+    if (config.providerReady) {
+      await config.providerReady;
+    }
     otel = await getOtelModule();
     if (!otel) {
       return null;
@@ -312,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;
       }
@@ -337,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
         })
@@ -358,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}`,
@@ -380,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,
@@ -396,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);
@@ -414,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;
     },
@@ -427,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);
         }
@@ -443,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;
       }
@@ -477,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,
@@ -512,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"),
@@ -630,8 +764,9 @@ function promptCacheMiddleware(config) {
 
 export {
   MiddlewareRunner,
+  isApprovalMiddleware,
+  approvalMiddleware,
   otelMiddleware,
   createTelemetryConfig,
-  approvalMiddleware,
   promptCacheMiddleware
 };

package/dist/{chunk-MHKK374K.js → chunk-Q742PSH3.js}

@@ -89,11 +89,6 @@ ${end}`;
     outputPath
   };
 }
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
 
 // src/tool/tool.ts
 import { z } from "zod";
@@ -106,13 +101,17 @@ var Tool;
     );
     return {
       id,
+      capabilitiesHint: options.capabilitiesHint,
       replayPolicy: staticReplayPolicy,
+      deferred: options.deferred,
+      searchKeywords: options.searchKeywords,
       init: async (initCtx) => {
         const toolInfo = typeof init === "function" ? await init(initCtx) : init;
         const replayPolicy = normalizeToolReplayPolicy(
           toolInfo.replayPolicy ?? staticReplayPolicy,
           toolInfo.fileOps
         );
+        const perToolMaxBytes = toolInfo.capabilities?.maxOutputChars;
         const originalExecute = toolInfo.execute;
         const execute = async (params, ctx) => {
           let validated;
@@ -131,15 +130,18 @@ Please rewrite the input so it satisfies the expected schema.`,
             );
           }
           const result = await originalExecute(validated, ctx);
-          if (result.metadata.truncated !== void 0) {
+          const meta = result.metadata ?? {};
+          if (meta.truncated !== void 0) {
             return result;
           }
-          const truncated = truncateOutput(result.output);
+          const truncated = truncateOutput(result.output, {
+            ...perToolMaxBytes !== void 0 ? { maxBytes: perToolMaxBytes } : {}
+          });
           return {
             ...result,
             output: truncated.content,
             metadata: {
-              ...result.metadata,
+              ...meta,
               truncated: truncated.truncated,
               ...truncated.truncated && { outputPath: truncated.outputPath }
             }
@@ -155,29 +157,11 @@ Please rewrite the input so it satisfies the expected schema.`,
   }
   Tool2.define = define;
 })(Tool || (Tool = {}));
-function defineTool(definition) {
-  return Tool.define(definition.id, {
-    description: definition.description,
-    parameters: definition.parameters,
-    execute: async (params, ctx) => {
-      const result = await definition.execute(params, ctx);
-      return {
-        title: result.title,
-        output: result.output,
-        metadata: result.metadata ?? {}
-      };
-    }
-  });
-}
 
 export {
   normalizeToolReplayPolicy,
   MAX_LINES,
   MAX_BYTES,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
   truncateOutput,
-  formatSize,
-  Tool,
-  defineTool
+  Tool
 };