@cuylabs/agent-core 0.8.0 → 0.9.0

package/dist/chunk-IYWQOJMQ.js

@@ -0,0 +1,102 @@
+// src/presets/patterns.ts
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function matchesPatterns(id, patterns) {
+  return patterns.some((pattern) => globToRegex(pattern).test(id));
+}
+function filterTools(tools, options) {
+  const allowPatterns = options.allow ?? [];
+  const denyPatterns = options.deny ?? [];
+  return tools.filter((tool) => {
+    const matchesAllow = allowPatterns.length === 0 || matchesPatterns(tool.id, allowPatterns);
+    if (!matchesAllow) {
+      return false;
+    }
+    const matchesDeny = denyPatterns.length > 0 && matchesPatterns(tool.id, denyPatterns);
+    if (matchesDeny && allowPatterns.length === 0) {
+      return false;
+    }
+    return true;
+  });
+}
+
+// src/presets/apply.ts
+function applyPreset(preset, availableTools, baseSystemPrompt) {
+  const tools = filterTools(availableTools, {
+    allow: preset.allowTools,
+    deny: preset.denyTools
+  });
+  let systemPrompt = preset.systemPrompt;
+  if (systemPrompt && baseSystemPrompt) {
+    systemPrompt = systemPrompt.replace("{basePrompt}", baseSystemPrompt);
+  }
+  return {
+    name: preset.name,
+    systemPrompt,
+    tools: tools.length > 0 ? tools : void 0,
+    temperature: preset.temperature,
+    maxSteps: preset.maxSteps,
+    reasoningLevel: preset.reasoningLevel,
+    model: preset.model
+  };
+}
+function mergePresets(...presets) {
+  if (presets.length === 0) {
+    throw new Error("mergePresets requires at least one preset");
+  }
+  if (presets.length === 1) {
+    return presets[0];
+  }
+  const [first, ...rest] = presets;
+  const allAllow = [];
+  const allDeny = [];
+  for (const preset of presets) {
+    if (preset.allowTools?.length) {
+      allAllow.push(preset.allowTools);
+    }
+    if (preset.denyTools?.length) {
+      allDeny.push(...preset.denyTools);
+    }
+  }
+  const combinedAllow = allAllow.length > 0 ? allAllow.reduce(
+    (left, right) => left.length <= right.length ? left : right
+  ) : void 0;
+  return {
+    name: presets.map((preset) => preset.name).join("+"),
+    description: presets.map((preset) => preset.description).join(" | "),
+    allowTools: combinedAllow,
+    denyTools: allDeny.length > 0 ? [...new Set(allDeny)] : void 0,
+    systemPrompt: rest.reduce(
+      (value, preset) => preset.systemPrompt ?? value,
+      first.systemPrompt
+    ),
+    temperature: rest.reduce(
+      (value, preset) => preset.temperature ?? value,
+      first.temperature
+    ),
+    maxSteps: rest.reduce(
+      (value, preset) => preset.maxSteps ?? value,
+      first.maxSteps
+    ),
+    reasoningLevel: rest.reduce(
+      (value, preset) => preset.reasoningLevel ?? value,
+      first.reasoningLevel
+    ),
+    model: rest.reduce((value, preset) => preset.model ?? value, first.model)
+  };
+}
+function createPreset(options) {
+  return {
+    description: options.description ?? `Custom preset: ${options.name}`,
+    ...options
+  };
+}
+
+export {
+  filterTools,
+  applyPreset,
+  mergePresets,
+  createPreset
+};

package/dist/{chunk-4BDA7DQY.js → chunk-J4QDGZIA.js}

@@ -3,16 +3,23 @@ import {
 } from "./chunk-WWYYNWEW.js";
 import {
   Inference
-} from "./chunk-N6HWIEEA.js";
+} from "./chunk-WKHDSSXG.js";
 import {
   executeAgentToolCall
-} from "./chunk-7VKQ4WPB.js";
+} from "./chunk-H3FUYU52.js";
+import {
+  LLMError
+} from "./chunk-4QFNWPIF.js";
 import {
   currentScope,
   snapshotScope,
   streamWithinScope,
   withinScope
 } from "./chunk-N7P4PN3O.js";
+import {
+  extractModelId,
+  extractProvider
+} from "./chunk-I6PKJ7XQ.js";
 
 // src/runtime/task/observer.ts
 function defaultAgentTaskCheckpointStrategy(input) {
@@ -763,6 +770,7 @@ async function handleContextOverflow(options) {
 // src/runtime/step-processing/process.ts
 async function processStepStream(stream, options) {
   const { abort, onEvent } = options;
+  const normalizeError = options.normalizeError ?? ((error2) => error2 instanceof Error ? error2 : new Error(String(error2)));
   const doomLoopThreshold = options.doomLoopThreshold ?? DEFAULT_DOOM_LOOP_THRESHOLD;
   const maxSteps = options.maxSteps ?? 50;
   let stepCount = options.currentStep ?? 1;
@@ -914,7 +922,7 @@ async function processStepStream(stream, options) {
       }
     }
   } catch (caught) {
-    error = caught instanceof Error ? caught : new Error(String(caught));
+    error = normalizeError(caught);
     await onEvent({ type: "status", status: "error" });
     await onEvent({ type: "error", error });
   }
@@ -950,6 +958,13 @@ function buildModelCallContext(options) {
     scope: snapshotScope()
   };
 }
+function normalizeModelStepError(options, error) {
+  const model = options.preparedStep.inferenceInput.model;
+  return LLMError.from(error, {
+    provider: extractProvider(model),
+    model: extractModelId(model)
+  });
+}
 async function* runModelStep(options) {
   return yield* streamWithinScope(
     {
@@ -983,6 +998,7 @@ async function* runModelStep(options) {
       const processPromise = processStepStream(stream, {
         sessionID: preparedStep.inferenceInput.sessionID,
         abort: preparedStep.inferenceInput.abort,
+        normalizeError: (error) => normalizeModelStepError(options, error),
         currentStep: preparedStep.step,
         maxSteps: preparedStep.stepProcessing.maxSteps,
         doomLoopThreshold: preparedStep.stepProcessing.doomLoopThreshold ?? 3,

package/dist/{chunk-7MUFEN4K.js → chunk-JLXG2SH7.js}

@@ -1,6 +1,9 @@
+import {
+  Presets
+} from "./chunk-EKR6PKXU.js";
 import {
   Tool
-} from "./chunk-P6YF7USR.js";
+} from "./chunk-MHKK374K.js";
 
 // src/sub-agent/types.ts
 var DEFAULT_MAX_CONCURRENT = 6;
@@ -169,7 +172,7 @@ var SubAgentTracker = class {
     }
     if (timeoutMs !== void 0 && timeoutMs > 0) {
       const timeout = new Promise(
-        (resolve) => setTimeout(() => resolve({ timedOut: true }), timeoutMs)
+        (resolve2) => setTimeout(() => resolve2({ timedOut: true }), timeoutMs)
       );
       return Promise.race([...races, timeout]);
     }
@@ -550,10 +553,353 @@ function createSubAgentTools(parent, config) {
   return tools;
 }
 
+// src/sub-agent/markdown-profile.ts
+var FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+var VALID_REASONING_LEVELS = /* @__PURE__ */ new Set([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function parseAgentFrontmatter(raw) {
+  const result = {};
+  const lines = raw.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "|") {
+      const blockLines = [];
+      i++;
+      while (i < lines.length) {
+        const blockLine = lines[i];
+        if (blockLine.length > 0 && !blockLine.startsWith(" ") && !blockLine.startsWith("	")) {
+          break;
+        }
+        blockLines.push(blockLine);
+        i++;
+      }
+      const minIndent = blockLines.filter((l) => l.trim().length > 0).reduce((min, l) => {
+        const indent = l.match(/^(\s*)/)?.[1].length ?? 0;
+        return Math.min(min, indent);
+      }, Infinity);
+      result[key] = blockLines.map((l) => l.trim().length === 0 ? "" : l.slice(minIndent)).join("\n").trim();
+      continue;
+    }
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key.length > 0) {
+      result[key] = value;
+    }
+    i++;
+  }
+  return result;
+}
+function parseMarkdownAgent(content, filePath) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    return null;
+  }
+  const [, rawFrontmatter, body] = match;
+  const fields = parseAgentFrontmatter(rawFrontmatter);
+  if (!fields.name || !fields.description) {
+    return null;
+  }
+  const frontmatter = {
+    name: fields.name,
+    description: fields.description
+  };
+  if (fields.preset) frontmatter.preset = fields.preset;
+  if (fields.extends) frontmatter.extends = fields.extends;
+  if (fields.model) frontmatter.model = fields.model;
+  if (fields.maxSteps) frontmatter.maxSteps = fields.maxSteps;
+  if (fields.temperature) frontmatter.temperature = fields.temperature;
+  if (fields.reasoning) frontmatter.reasoning = fields.reasoning;
+  if (fields.tools) frontmatter.tools = fields.tools;
+  if (fields.skills) frontmatter.skills = fields.skills;
+  if (fields.canSpawn) frontmatter.canSpawn = fields.canSpawn;
+  return {
+    frontmatter,
+    body: body.trim(),
+    filePath
+  };
+}
+function parseToolSpec(raw) {
+  if (raw === void 0 || raw.trim() === "") {
+    return { mode: "inherit" };
+  }
+  const items = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  if (items.length === 0) {
+    return { mode: "inherit" };
+  }
+  const hasModifiers = items.some((item) => item.startsWith("+") || item.startsWith("-"));
+  if (hasModifiers) {
+    const modifiers = items.map((item) => {
+      if (item.startsWith("+")) {
+        return { kind: "add", pattern: item.slice(1) };
+      }
+      if (item.startsWith("-")) {
+        return { kind: "remove", pattern: item.slice(1) };
+      }
+      return { kind: "add", pattern: item };
+    });
+    return { mode: "modifiers", modifiers };
+  }
+  return { mode: "explicit", patterns: items };
+}
+function toAgentProfile(parsed, resolvers = {}) {
+  const { frontmatter, body } = parsed;
+  const parent = frontmatter.extends ? resolvers.resolveParent?.(frontmatter.extends) : void 0;
+  const preset = frontmatter.preset ? resolvers.resolvePreset?.(frontmatter.preset) : parent?.preset;
+  let systemPrompt;
+  if (body.length > 0) {
+    const parentPrompt = parent?.systemPrompt ?? preset?.systemPrompt ?? "";
+    systemPrompt = body.includes("{basePrompt}") ? body.replace("{basePrompt}", parentPrompt) : body;
+  } else if (parent?.systemPrompt) {
+    systemPrompt = parent.systemPrompt;
+  }
+  const maxSteps = frontmatter.maxSteps ? parseInt(frontmatter.maxSteps, 10) : parent?.maxSteps;
+  let resolvedPreset = preset;
+  const temperature = frontmatter.temperature ? parseFloat(frontmatter.temperature) : void 0;
+  const reasoning = frontmatter.reasoning;
+  if (temperature !== void 0 || reasoning !== void 0) {
+    resolvedPreset = {
+      ...preset ?? { name: "custom", description: "Markdown-defined agent" },
+      ...temperature !== void 0 ? { temperature } : {},
+      ...reasoning !== void 0 && VALID_REASONING_LEVELS.has(reasoning) ? { reasoningLevel: reasoning } : {}
+    };
+  }
+  const toolSpec = parseToolSpec(frontmatter.tools);
+  if (toolSpec.mode === "explicit" || toolSpec.mode === "modifiers") {
+    resolvedPreset = {
+      ...resolvedPreset ?? { name: "custom", description: "Markdown-defined agent" }
+    };
+    if (toolSpec.mode === "explicit") {
+      resolvedPreset.allowTools = toolSpec.patterns;
+      resolvedPreset.denyTools = void 0;
+    } else {
+      const baseAllow = [...resolvedPreset.allowTools ?? []];
+      const baseDeny = [...resolvedPreset.denyTools ?? []];
+      for (const mod of toolSpec.modifiers) {
+        if (mod.kind === "add") {
+          baseAllow.push(mod.pattern);
+          const denyIdx = baseDeny.indexOf(mod.pattern);
+          if (denyIdx !== -1) baseDeny.splice(denyIdx, 1);
+        } else {
+          baseDeny.push(mod.pattern);
+          const allowIdx = baseAllow.indexOf(mod.pattern);
+          if (allowIdx !== -1) baseAllow.splice(allowIdx, 1);
+        }
+      }
+      if (baseAllow.length > 0) resolvedPreset.allowTools = baseAllow;
+      if (baseDeny.length > 0) resolvedPreset.denyTools = baseDeny;
+    }
+  }
+  const canSpawn = frontmatter.canSpawn ? frontmatter.canSpawn === "true" : parent?.canSpawn;
+  const profile = {
+    name: frontmatter.name,
+    description: frontmatter.description
+  };
+  if (resolvedPreset) profile.preset = resolvedPreset;
+  if (systemPrompt) profile.systemPrompt = systemPrompt;
+  if (maxSteps !== void 0 && !isNaN(maxSteps)) profile.maxSteps = maxSteps;
+  if (canSpawn !== void 0) profile.canSpawn = canSpawn;
+  if (frontmatter.model) {
+    profile._modelId = frontmatter.model;
+  }
+  if (frontmatter.skills) {
+    profile._skillNames = frontmatter.skills.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  profile._source = parsed.filePath;
+  return profile;
+}
+function isMarkdownProfile(profile) {
+  return "_source" in profile;
+}
+
+// src/sub-agent/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, isAbsolute, resolve } from "path";
+var DEFAULT_USER_DIR = join(homedir(), ".cuylabs", "agents");
+var DEFAULT_PROJECT_DIR = ".cuylabs/agents";
+var PRESET_MAP = {
+  explore: Presets.explore,
+  plan: Presets.plan,
+  review: Presets.review,
+  quick: Presets.quick,
+  careful: Presets.careful,
+  code: Presets.code,
+  watch: Presets.watch
+};
+function defaultResolvePreset(name) {
+  return PRESET_MAP[name.toLowerCase()];
+}
+function isLoadableMarkdown(filename) {
+  return filename.endsWith(".md") && !filename.startsWith("_") && !filename.startsWith(".");
+}
+function loadAgentDir(dir, source, resolvers, errors) {
+  if (!existsSync(dir)) return [];
+  let stat;
+  try {
+    stat = statSync(dir);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) return [];
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (!isLoadableMarkdown(entry.name)) continue;
+    const filePath = join(dir, entry.name);
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const parsed = parseMarkdownAgent(content, filePath);
+      if (!parsed) {
+        errors.push({ path: filePath, error: "Missing required frontmatter (name, description)" });
+        continue;
+      }
+      const profile = toAgentProfile(parsed, resolvers);
+      results.push({ profile, source, filePath });
+    } catch (err) {
+      errors.push({
+        path: filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+function loadAgentFile(filePath, source, resolvers, errors) {
+  if (!existsSync(filePath)) {
+    errors.push({ path: filePath, error: "File not found" });
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseMarkdownAgent(content, filePath);
+    if (!parsed) {
+      errors.push({ path: filePath, error: "Missing required frontmatter (name, description)" });
+      return null;
+    }
+    const profile = toAgentProfile(parsed, resolvers);
+    return { profile, source, filePath };
+  } catch (err) {
+    errors.push({
+      path: filePath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+function discoverAgentProfiles(options) {
+  const {
+    cwd,
+    userDir = DEFAULT_USER_DIR,
+    projectDir = DEFAULT_PROJECT_DIR,
+    configPaths = [],
+    builtInProfiles = [],
+    resolvePreset: customResolvePreset
+  } = options;
+  const errors = [];
+  const discovered = [];
+  const presetResolver = customResolvePreset ?? defaultResolvePreset;
+  const firstPassResolvers = {
+    resolvePreset: presetResolver
+    // resolveParent deferred to merge phase
+  };
+  for (const profile of builtInProfiles) {
+    discovered.push({ profile, source: "builtin" });
+  }
+  const userProfiles = loadAgentDir(userDir, "user", firstPassResolvers, errors);
+  discovered.push(...userProfiles);
+  const projectAgentsDir = resolve(cwd, projectDir);
+  const projectProfiles = loadAgentDir(projectAgentsDir, "project", firstPassResolvers, errors);
+  discovered.push(...projectProfiles);
+  for (const configPath of configPaths) {
+    const resolved = isAbsolute(configPath) ? configPath : resolve(cwd, configPath);
+    const entry = loadAgentFile(resolved, "config", firstPassResolvers, errors);
+    if (entry) discovered.push(entry);
+  }
+  const profileMap = /* @__PURE__ */ new Map();
+  for (const entry of discovered) {
+    profileMap.set(entry.profile.name, entry);
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const [name, entry] of profileMap) {
+    const profile = entry.profile;
+    const md = profile;
+    if ("_source" in md) {
+    }
+    merged.set(name, profile);
+  }
+  const allProfiles = merged;
+  for (const [name, entry] of profileMap) {
+    const profile = entry.profile;
+    if (!("_source" in profile)) continue;
+    const md = profile;
+    if (!md._source) continue;
+    try {
+      const content = readFileSync(md._source, "utf-8");
+      const parsed = parseMarkdownAgent(content, md._source);
+      if (parsed?.frontmatter.extends) {
+        const parentName = parsed.frontmatter.extends;
+        const parent = allProfiles.get(parentName);
+        if (parent) {
+          const resolvedProfile = toAgentProfile(parsed, {
+            resolvePreset: presetResolver,
+            resolveParent: (n) => allProfiles.get(n)
+          });
+          merged.set(name, resolvedProfile);
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    profiles: Array.from(merged.values()),
+    discovered: Array.from(profileMap.values()),
+    errors
+  };
+}
+function getUserAgentsDir() {
+  return DEFAULT_USER_DIR;
+}
+function getProjectAgentsDir(cwd) {
+  return resolve(cwd, DEFAULT_PROJECT_DIR);
+}
+
 export {
   DEFAULT_MAX_CONCURRENT,
   DEFAULT_MAX_SPAWN_DEPTH,
   DEFAULT_SESSION_TITLE_PREFIX,
   SubAgentTracker,
-  createSubAgentTools
+  createSubAgentTools,
+  parseAgentFrontmatter,
+  parseMarkdownAgent,
+  parseToolSpec,
+  toAgentProfile,
+  isMarkdownProfile,
+  discoverAgentProfiles,
+  getUserAgentsDir,
+  getProjectAgentsDir
 };

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

@@ -1,15 +1,21 @@
 import {
   createApprovalHandler
-} from "./chunk-BFM2YHNM.js";
+} from "./chunk-5ARZJWD2.js";
 import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
+  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 = []) {
@@ -67,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;
@@ -89,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;
@@ -142,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;
@@ -172,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;
@@ -226,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);
       }
     }
   }
@@ -248,10 +239,7 @@ 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);
       }
     }
   }
@@ -547,14 +535,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";
 }