@cuylabs/agent-core 0.7.0 → 0.9.0

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

@@ -1,7 +1,21 @@
+import {
+  createApprovalHandler
+} from "./chunk-5ARZJWD2.js";
+import {
+  extractModelId,
+  extractProvider
+} from "./chunk-I6PKJ7XQ.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 = []) {
@@ -59,10 +73,7 @@ var MiddlewareRunner = class {
           current = next;
         }
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" model.chunk error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        logMiddlewareWarning(mw.name, "model.chunk", err);
       }
     }
     return current ?? void 0;
@@ -81,10 +92,7 @@ var MiddlewareRunner = class {
           current = next;
         }
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" model.output error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        logMiddlewareWarning(mw.name, "model.output", err);
       }
     }
     return current;
@@ -134,10 +142,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)
-        );
+        logMiddlewareWarning(mw.name, "afterToolCall", err);
       }
     }
     return current;
@@ -164,10 +169,7 @@ var MiddlewareRunner = class {
           sections.push(result);
         }
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" promptSections error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        logMiddlewareWarning(mw.name, "promptSections", err);
       }
     }
     return sections;
@@ -218,10 +220,7 @@ var MiddlewareRunner = class {
       try {
         await mw.onChatStart(sessionId, message);
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" onChatStart error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        logMiddlewareWarning(mw.name, "onChatStart", err);
       }
     }
   }
@@ -240,230 +239,12 @@ var MiddlewareRunner = class {
       try {
         await mw.onChatEnd(sessionId, result);
       } catch (err) {
-        console.warn(
-          `[middleware] "${mw.name}" onChatEnd error:`,
-          err instanceof Error ? err.message : String(err)
-        );
+        logMiddlewareWarning(mw.name, "onChatEnd", err);
       }
     }
   }
 };
 
-// src/safety/approval/risk.ts
-var DEFAULT_TOOL_RISKS = {
-  read: "safe",
-  read_file: "safe",
-  grep: "safe",
-  glob: "safe",
-  list_dir: "safe",
-  invoke_agent: "safe",
-  wait_agent: "safe",
-  close_agent: "safe",
-  skill: "safe",
-  skill_resource: "safe",
-  write: "moderate",
-  write_file: "moderate",
-  edit: "moderate",
-  edit_file: "moderate",
-  create_file: "moderate",
-  bash: "dangerous",
-  shell: "dangerous",
-  delete_file: "dangerous",
-  remove: "dangerous"
-};
-function getToolRisk(tool, customRisks) {
-  if (customRisks?.[tool]) {
-    return customRisks[tool];
-  }
-  if (DEFAULT_TOOL_RISKS[tool]) {
-    return DEFAULT_TOOL_RISKS[tool];
-  }
-  return "moderate";
-}
-
-// src/safety/approval/errors.ts
-var ApprovalDeniedError = class extends Error {
-  constructor(tool, args, message) {
-    super(message || `Operation denied: ${tool}`);
-    this.tool = tool;
-    this.args = args;
-    this.name = "ApprovalDeniedError";
-  }
-};
-var ApprovalTimeoutError = class extends Error {
-  constructor(tool, timeoutMs) {
-    super(`Approval timeout after ${timeoutMs}ms for: ${tool}`);
-    this.tool = tool;
-    this.timeoutMs = timeoutMs;
-    this.name = "ApprovalTimeoutError";
-  }
-};
-
-// src/safety/approval/patterns.ts
-function matchApprovalPattern(pattern, value) {
-  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${regex}$`, "i").test(value);
-}
-function extractApprovalPatterns(tool, args) {
-  if (!args || typeof args !== "object") {
-    return [tool];
-  }
-  const record = args;
-  if ("path" in record && typeof record.path === "string" || "filePath" in record && typeof record.filePath === "string") {
-    const path = record.path ?? record.filePath;
-    const dir = path.substring(0, path.lastIndexOf("/") + 1);
-    return [dir ? `${dir}*` : path];
-  }
-  if ("command" in record && typeof record.command === "string") {
-    const command = record.command.split(/\s+/)[0];
-    return [command];
-  }
-  if ("pattern" in record && typeof record.pattern === "string") {
-    return [record.pattern];
-  }
-  return [tool];
-}
-function describeApprovalOperation(tool, args) {
-  if (!args || typeof args !== "object") {
-    return `Execute ${tool}`;
-  }
-  const record = args;
-  switch (tool) {
-    case "read":
-    case "read_file":
-      return `Read file: ${record.path ?? record.filePath}`;
-    case "write":
-    case "write_file":
-    case "create_file":
-      return `Write file: ${record.path ?? record.filePath}`;
-    case "edit":
-    case "edit_file":
-      return `Edit file: ${record.path ?? record.filePath}`;
-    case "delete_file":
-    case "remove":
-      return `Delete: ${record.path}`;
-    case "bash":
-    case "shell": {
-      const command = String(record.command);
-      return `Run command: ${command.slice(0, 100)}${command.length > 100 ? "..." : ""}`;
-    }
-    case "grep":
-      return `Search for: ${record.pattern}`;
-    case "glob":
-      return `Find files: ${record.pattern}`;
-    default:
-      return `${tool}(${JSON.stringify(args).slice(0, 50)}...)`;
-  }
-}
-
-// src/safety/approval/handler.ts
-var requestCounter = 0;
-function findMatchingRule(rules, tool, patterns) {
-  for (let index = rules.length - 1; index >= 0; index--) {
-    const rule = rules[index];
-    const toolMatches = rule.tool === "*" || matchApprovalPattern(rule.tool, tool);
-    const patternMatches = patterns.some(
-      (pattern) => matchApprovalPattern(rule.pattern, pattern)
-    );
-    if (toolMatches && patternMatches) {
-      return rule;
-    }
-  }
-  return void 0;
-}
-function createApprovalHandler(config = {}) {
-  const {
-    defaultAction = "ask",
-    timeout = 5 * 60 * 1e3,
-    onRequest
-  } = config;
-  const rules = [...config.rules ?? []];
-  const pending = /* @__PURE__ */ new Map();
-  async function request(sessionId, tool, args, customRisks) {
-    const risk = getToolRisk(tool, customRisks);
-    const patterns = extractApprovalPatterns(tool, args);
-    const matchingRule = findMatchingRule(rules, tool, patterns);
-    if (matchingRule) {
-      if (matchingRule.action === "allow") {
-        return;
-      }
-      throw new ApprovalDeniedError(
-        tool,
-        args,
-        `Denied by rule: ${matchingRule.pattern}`
-      );
-    }
-    if (risk === "safe" && defaultAction !== "deny") {
-      return;
-    }
-    if (!onRequest) {
-      if (defaultAction === "allow") {
-        return;
-      }
-      if (defaultAction === "deny") {
-        throw new ApprovalDeniedError(tool, args);
-      }
-      throw new ApprovalDeniedError(tool, args, "No approval handler configured");
-    }
-    const id = `approval-${++requestCounter}-${Date.now()}`;
-    const requestData = {
-      id,
-      sessionId,
-      tool,
-      args,
-      description: describeApprovalOperation(tool, args),
-      risk,
-      patterns,
-      timestamp: Date.now()
-    };
-    const action = await Promise.race([
-      new Promise((resolve, reject) => {
-        pending.set(id, { resolve, reject });
-        onRequest(requestData).then(resolve).catch(reject).finally(() => pending.delete(id));
-      }),
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          pending.delete(id);
-          reject(new ApprovalTimeoutError(tool, timeout));
-        }, timeout);
-      })
-    ]);
-    switch (action) {
-      case "allow":
-        return;
-      case "deny":
-        throw new ApprovalDeniedError(tool, args);
-      case "remember":
-        for (const pattern of patterns) {
-          rules.push({ pattern, tool, action: "allow" });
-        }
-        return;
-    }
-  }
-  function cancelAll(reason) {
-    for (const [id, { reject }] of pending) {
-      reject(new Error(reason ?? "Cancelled"));
-      pending.delete(id);
-    }
-  }
-  function addRule(rule) {
-    rules.push(rule);
-  }
-  function getRules() {
-    return rules;
-  }
-  function clearSessionRules() {
-    rules.length = config.rules?.length ?? 0;
-  }
-  return {
-    request,
-    cancelAll,
-    addRule,
-    getRules,
-    clearSessionRules
-  };
-}
-
 // src/middleware/approval.ts
 function approvalMiddleware(config = {}) {
   const handler = createApprovalHandler(config);
@@ -753,28 +534,48 @@ async function createAndRegisterProvider(spanProcessor, serviceName) {
 }
 
 // src/middleware/prompt-cache/cache.ts
+function detectCacheProvider(input) {
+  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 = extractModelId(input.model);
+  if (/claude/i.test(modelId)) return "anthropic";
+  return "unknown";
+}
 var MAX_ANTHROPIC_BREAKPOINTS = 4;
-var DEFAULT_TTL = "5m";
-var DEFAULT_MESSAGE_BREAKPOINTS = 1;
-function isAnthropicModel(model) {
-  if (typeof model === "object" && model !== null) {
-    if ("provider" in model && typeof model.provider === "string") {
-      if (model.provider.toLowerCase().startsWith("anthropic")) return true;
-    }
-    if ("modelId" in model && typeof model.modelId === "string") {
-      if (/claude/i.test(model.modelId)) return true;
+function applyAnthropicCache(input, ttl, maxMsgBreakpoints) {
+  const hasSystem = input.system.some((s) => s.length > 0);
+  if (hasSystem) {
+    input.systemMessages = buildAnthropicSystemMessages(input.system, ttl);
+  }
+  if (maxMsgBreakpoints > 0) {
+    const breakpointIndices = findMessageBreakpointIndices(
+      input.messages,
+      maxMsgBreakpoints
+    );
+    const cacheControl = buildAnthropicCacheControl(ttl);
+    for (const idx of breakpointIndices) {
+      const msg = input.messages[idx];
+      msg.providerOptions = {
+        ...msg.providerOptions,
+        ...cacheControl
+      };
     }
   }
-  return false;
+  return input;
 }
-function buildCacheControl(ttl) {
+function buildAnthropicCacheControl(ttl) {
   return {
     anthropic: {
       cacheControl: { type: "ephemeral", ttl }
     }
   };
 }
-function buildCachedSystemMessages(system, ttl) {
+function buildAnthropicSystemMessages(system, ttl) {
   const filtered = system.filter(Boolean);
   if (filtered.length === 0) return [];
   return filtered.map((content, i) => {
@@ -784,7 +585,7 @@ function buildCachedSystemMessages(system, ttl) {
       content
     };
     if (isLast) {
-      msg.providerOptions = buildCacheControl(ttl);
+      msg.providerOptions = buildAnthropicCacheControl(ttl);
     }
     return msg;
   });
@@ -800,37 +601,28 @@ function findMessageBreakpointIndices(messages, count) {
   }
   return indices;
 }
+var DEFAULT_TTL = "5m";
+var DEFAULT_MESSAGE_BREAKPOINTS = 1;
 function promptCacheMiddleware(config) {
   const ttl = config?.ttl ?? DEFAULT_TTL;
   const maxMsgBreakpoints = Math.min(
     config?.messageBreakpoints ?? DEFAULT_MESSAGE_BREAKPOINTS,
     MAX_ANTHROPIC_BREAKPOINTS - 1
-    // Reserve 1 for system
   );
   return {
     name: "prompt-cache",
     model: {
       async input(input, _ctx) {
-        if (!isAnthropicModel(input.model)) return;
-        const hasSystem = input.system.some((s) => s.length > 0);
-        if (hasSystem) {
-          input.systemMessages = buildCachedSystemMessages(input.system, ttl);
-        }
-        if (maxMsgBreakpoints > 0) {
-          const breakpointIndices = findMessageBreakpointIndices(
-            input.messages,
-            maxMsgBreakpoints
-          );
-          const cacheControl = buildCacheControl(ttl);
-          for (const idx of breakpointIndices) {
-            const msg = input.messages[idx];
-            msg.providerOptions = {
-              ...msg.providerOptions,
-              ...cacheControl
-            };
-          }
+        const provider = detectCacheProvider(input);
+        switch (provider) {
+          case "anthropic":
+            return applyAnthropicCache(input, ttl, maxMsgBreakpoints);
+          // OpenAI caches prefixes automatically — no client action needed.
+          // case "openai":
+          //   return applyOpenAICache(input);
+          default:
+            return;
         }
-        return input;
       }
     }
   };
@@ -840,10 +632,6 @@ export {
   MiddlewareRunner,
   otelMiddleware,
   createTelemetryConfig,
-  getToolRisk,
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  createApprovalHandler,
   approvalMiddleware,
   promptCacheMiddleware
 };

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

@@ -34,7 +34,7 @@ function normalizeToolReplayPolicy(policy, fileOps) {
 }
 
 // src/tool/truncation.ts
-import * as fs from "fs/promises";
+import * as fsSync from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
@@ -55,8 +55,11 @@ function truncateOutput(output, options = {}) {
   }
   const hash = crypto.createHash("sha256").update(output).digest("hex").slice(0, 16);
   const outputPath = path.join(TRUNCATE_DIR, `output-${hash}.txt`);
-  fs.mkdir(TRUNCATE_DIR, { recursive: true }).then(() => fs.writeFile(outputPath, output, "utf-8")).catch(() => {
-  });
+  try {
+    fsSync.mkdirSync(TRUNCATE_DIR, { recursive: true });
+    fsSync.writeFileSync(outputPath, output, "utf-8");
+  } catch {
+  }
   let truncated;
   if (lines.length > maxLines) {
     const keepLines = Math.floor(maxLines / 2);
@@ -71,9 +74,10 @@ function truncateOutput(output, options = {}) {
       ...lastPart
     ].join("\n");
   } else {
+    const buf = Buffer.from(output, "utf-8");
     const keepBytes = Math.floor(maxBytes / 2);
-    const start = output.slice(0, keepBytes);
-    const end = output.slice(-keepBytes);
+    const start = buf.subarray(0, keepBytes).toString("utf-8");
+    const end = buf.subarray(buf.length - keepBytes).toString("utf-8");
     const omittedBytes = bytes - keepBytes * 2;
     truncated = `${start}
 ... (${omittedBytes} bytes omitted, full output saved to ${outputPath}) ...
@@ -111,8 +115,9 @@ var Tool;
         );
         const originalExecute = toolInfo.execute;
         const execute = async (params, ctx) => {
+          let validated;
           try {
-            toolInfo.parameters.parse(params);
+            validated = toolInfo.parameters.parse(params);
           } catch (error) {
             if (error instanceof z.ZodError && toolInfo.formatValidationError) {
               throw new Error(toolInfo.formatValidationError(error), {
@@ -125,7 +130,7 @@ Please rewrite the input so it satisfies the expected schema.`,
               { cause: error }
             );
           }
-          const result = await originalExecute(params, ctx);
+          const result = await originalExecute(validated, ctx);
           if (result.metadata.truncated !== void 0) {
             return result;
           }
@@ -149,10 +154,6 @@ Please rewrite the input so it satisfies the expected schema.`,
     };
   }
   Tool2.define = define;
-  function defineSimple(id, config) {
-    return define(id, config);
-  }
-  Tool2.defineSimple = defineSimple;
 })(Tool || (Tool = {}));
 function defineTool(definition) {
   return Tool.define(definition.id, {

package/dist/{chunk-VBWWUHWI.js → chunk-OFDKHNCX.js}

@@ -508,6 +508,9 @@ async function createGitStyleDiffPlaceholder() {
 }
 
 // src/tracking/turn-tracker/tracker.ts
+function logTurnTrackerWarning(message) {
+  console.warn(message);
+}
 var TurnChangeTracker = class {
   config;
   currentTurn = null;
@@ -584,7 +587,7 @@ var TurnChangeTracker = class {
       return false;
     }
     if (this.currentTurn.baselines.size >= this.config.maxTrackedFiles) {
-      console.warn(
+      logTurnTrackerWarning(
         `[TurnTracker] Max tracked files (${this.config.maxTrackedFiles}) reached, skipping: ${filePath}`
       );
       return false;

package/dist/{chunk-YUUJK53A.js → chunk-RKEW5WXI.js}

@@ -1,6 +1,6 @@
 import {
   Tool
-} from "./chunk-P6YF7USR.js";
+} from "./chunk-MHKK374K.js";
 
 // src/skill/tools.ts
 import { z } from "zod";

package/dist/{chunk-LRHOS4ZN.js → chunk-SPILYYDF.js}

@@ -487,9 +487,10 @@ var SkillRegistry = class {
     for (const skill of this.skills.values()) {
       lines.push("");
       lines.push(`<skill name="${skill.name}" scope="${skill.scope}">`);
-      lines.push(skill.description);
+      lines.push(`  <description>${skill.description}</description>`);
+      lines.push(`  <file>${skill.filePath}</file>`);
       if (skill.dependencies && skill.dependencies.length > 0) {
-        lines.push(`Depends on: ${skill.dependencies.join(", ")}`);
+        lines.push(`  <depends-on>${skill.dependencies.join(", ")}</depends-on>`);
       }
       lines.push("</skill>");
     }