@cuylabs/agent-core 0.8.0 → 0.9.0

package/dist/{builder-UpOWQMW3.d.ts → builder-BgZ_j4Vs.d.ts}

@@ -1,5 +1,6 @@
-import { P as PromptConfig, a as PromptBuildContext, M as MiddlewareRunner, b as PromptSection, c as ModelFamily } from './runner-e2YRcUoX.js';
+import { d as PromptConfig, P as PromptBuildContext, c as PromptSection, e as ModelFamily } from './types-DTSkxakL.js';
 import { S as SkillRegistry } from './registry-DwYqsQkX.js';
+import { M as MiddlewareRunner } from './runner-CI-XeR16.js';
 
 interface PromptSectionPreview {
     id: string;

package/dist/{chunk-RZITT45F.js → chunk-4QFNWPIF.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,7 @@ function extractFromAISDKError(error) {
   return result;
 }
 
-// src/errors/llm-error.ts
+// src/inference/errors/llm-error.ts
 var LLMError = class _LLMError extends Error {
   category;
   status;
@@ -171,7 +171,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-BFM2YHNM.js → chunk-5ARZJWD2.js}

@@ -1,4 +1,4 @@
-// src/safety/approval/risk.ts
+// src/safety/risk.ts
 var DEFAULT_TOOL_RISKS = {
   read: "safe",
   read_file: "safe",
@@ -31,7 +31,7 @@ function getToolRisk(tool, customRisks) {
   return "moderate";
 }
 
-// src/safety/approval/errors.ts
+// src/safety/errors.ts
 var ApprovalDeniedError = class extends Error {
   constructor(tool, args, message) {
     super(message || `Operation denied: ${tool}`);
@@ -49,10 +49,35 @@ var ApprovalTimeoutError = class extends Error {
   }
 };
 
-// src/safety/approval/patterns.ts
+// src/safety/patterns.ts
 function matchApprovalPattern(pattern, value) {
-  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${regex}$`, "i").test(value);
+  if (pattern.length > 500) return false;
+  const p = pattern.toLowerCase();
+  const v = value.toLowerCase();
+  let pi = 0;
+  let vi = 0;
+  let starPi = -1;
+  let starVi = -1;
+  while (vi < v.length) {
+    if (pi < p.length && (p[pi] === "?" || p[pi] === v[vi])) {
+      pi++;
+      vi++;
+    } else if (pi < p.length && p[pi] === "*") {
+      starPi = pi;
+      starVi = vi;
+      pi++;
+    } else if (starPi !== -1) {
+      pi = starPi + 1;
+      starVi++;
+      vi = starVi;
+    } else {
+      return false;
+    }
+  }
+  while (pi < p.length && p[pi] === "*") {
+    pi++;
+  }
+  return pi === p.length;
 }
 function extractApprovalPatterns(tool, args) {
   if (!args || typeof args !== "object") {
@@ -101,13 +126,15 @@ function describeApprovalOperation(tool, args) {
       return `Search for: ${record.pattern}`;
     case "glob":
       return `Find files: ${record.pattern}`;
-    default:
-      return `${tool}(${JSON.stringify(args).slice(0, 50)}...)`;
+    default: {
+      const json = JSON.stringify(args);
+      const truncated = json.length > 50 ? `${json.slice(0, 50)}...` : json;
+      return `${tool}(${truncated})`;
+    }
   }
 }
 
-// src/safety/approval/handler.ts
-var requestCounter = 0;
+// src/safety/handler.ts
 function findMatchingRule(rules, tool, patterns) {
   for (let index = rules.length - 1; index >= 0; index--) {
     const rule = rules[index];
@@ -127,8 +154,10 @@ function createApprovalHandler(config = {}) {
     timeout = 5 * 60 * 1e3,
     onRequest
   } = config;
+  let requestCounter = 0;
+  const initialRuleCount = config.rules?.length ?? 0;
   const rules = [...config.rules ?? []];
-  const pending = /* @__PURE__ */ new Map();
+  const activeRequests = /* @__PURE__ */ new Set();
   async function request(sessionId, tool, args, customRisks) {
     const risk = getToolRisk(tool, customRisks);
     const patterns = extractApprovalPatterns(tool, args);
@@ -166,35 +195,43 @@ function createApprovalHandler(config = {}) {
       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;
+    const ac = new AbortController();
+    activeRequests.add(ac);
+    let timeoutId;
+    try {
+      const action = await Promise.race([
+        onRequest(requestData),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            reject(new ApprovalTimeoutError(tool, timeout));
+          }, timeout);
+          ac.signal.addEventListener("abort", () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Cancelled"));
+          }, { once: true });
+        })
+      ]);
+      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;
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      activeRequests.delete(ac);
     }
   }
-  function cancelAll(reason) {
-    for (const [id, { reject }] of pending) {
-      reject(new Error(reason ?? "Cancelled"));
-      pending.delete(id);
+  function cancelAll(_reason) {
+    for (const ac of activeRequests) {
+      ac.abort();
     }
+    activeRequests.clear();
   }
   function addRule(rule) {
     rules.push(rule);
@@ -203,7 +240,7 @@ function createApprovalHandler(config = {}) {
     return rules;
   }
   function clearSessionRules() {
-    rules.length = config.rules?.length ?? 0;
+    rules.splice(initialRuleCount);
   }
   return {
     request,

package/dist/{chunk-KUVSERLJ.js → chunk-DXFBQMXP.js}

@@ -10,9 +10,12 @@ var LocalSignal = class {
       set = /* @__PURE__ */ new Set();
       this.typed.set(type, set);
     }
-    set.add(handler);
+    const wrapped = (event) => {
+      handler(event);
+    };
+    set.add(wrapped);
     return () => {
-      set.delete(handler);
+      set.delete(wrapped);
       if (set.size === 0) this.typed.delete(type);
     };
   }

package/dist/{chunk-CAA7FHIH.js → chunk-EKR6PKXU.js}

@@ -1,99 +1,3 @@
-// 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
-  };
-}
-
 // src/presets/builtins.ts
 var explore = {
   name: "explore",
@@ -265,10 +169,6 @@ var Presets = {
 };
 
 export {
-  filterTools,
-  applyPreset,
-  mergePresets,
-  createPreset,
   explore,
   plan,
   review,

package/dist/{chunk-IVUJDISU.js → chunk-GFTW23FV.js}

@@ -1,22 +1,13 @@
 import {
   createSkillRegistry,
   emptySkillRegistry
-} from "./chunk-LRHOS4ZN.js";
+} from "./chunk-SPILYYDF.js";
+import {
+  extractModelId,
+  extractProvider
+} from "./chunk-I6PKJ7XQ.js";
 
 // src/prompt/templates.ts
-function extractModelId(model) {
-  if (typeof model === "string") return model;
-  if (typeof model === "object" && model !== null && "modelId" in model) {
-    return String(model.modelId);
-  }
-  return void 0;
-}
-function extractProvider(model) {
-  if (typeof model === "object" && model !== null && "provider" in model) {
-    return String(model.provider);
-  }
-  return void 0;
-}
 function detectModelFamily(model) {
   const provider = extractProvider(model);
   const modelId = extractModelId(model);

package/dist/{chunk-7VKQ4WPB.js → chunk-H3FUYU52.js}

@@ -21,7 +21,7 @@ async function executeAgentToolCall(options) {
       }
     },
     async () => {
-      const initialized = await options.tool.init({ cwd: options.cwd });
+      const initialized = options.initialized ?? await options.tool.init({ cwd: options.cwd });
       const ctx = {
         cwd: options.cwd,
         abort: options.abort,
@@ -61,9 +61,17 @@ async function executeAgentToolCall(options) {
           result,
           ctx
         );
-        return { output: transformed.output };
+        return {
+          output: transformed.output,
+          title: transformed.title,
+          metadata: transformed.metadata
+        };
       }
-      return { output: result.output };
+      return {
+        output: result.output,
+        title: result.title,
+        metadata: result.metadata
+      };
     }
   );
 }

package/dist/chunk-I6PKJ7XQ.js

@@ -0,0 +1,292 @@
+// src/models/types.ts
+var SourcePriority = /* @__PURE__ */ ((SourcePriority2) => {
+  SourcePriority2[SourcePriority2["UserConfig"] = 0] = "UserConfig";
+  SourcePriority2[SourcePriority2["LocalCache"] = 1] = "LocalCache";
+  SourcePriority2[SourcePriority2["BundledData"] = 2] = "BundledData";
+  SourcePriority2[SourcePriority2["PatternMatch"] = 3] = "PatternMatch";
+  SourcePriority2[SourcePriority2["RemoteAPI"] = 4] = "RemoteAPI";
+  return SourcePriority2;
+})(SourcePriority || {});
+var DEFAULT_RESOLVER_OPTIONS = {
+  enableRemoteFetch: false,
+  remoteApiUrl: "https://models.dev",
+  cachePath: ".agent-core/cache",
+  cacheTtlMs: 60 * 60 * 1e3,
+  // 1 hour
+  networkTimeoutMs: 10 * 1e3,
+  // 10 seconds
+  modelOverrides: {}
+};
+
+// src/models/profiles.ts
+var REASONING_PATTERNS = [
+  // OpenAI o-series
+  {
+    pattern: /^o[134]-?(mini|pro|preview)?$/i,
+    provider: "openai",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
+    confidence: 0.95
+  },
+  // OpenAI GPT-5.x
+  {
+    pattern: /gpt-?5(\.\d)?/i,
+    provider: "openai",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
+    confidence: 0.9
+  },
+  // DeepSeek R1 variants
+  {
+    pattern: /deepseek[_-]?r1|r1[_-]distill/i,
+    capabilities: { reasoning: true, toolCalling: false },
+    confidence: 0.95
+  },
+  // Anthropic Claude with thinking
+  {
+    pattern: /claude.*thinking|thinking.*claude/i,
+    provider: "anthropic",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "anthropic" },
+    confidence: 0.9
+  },
+  // Claude 4.x series (reasoning capable)
+  {
+    pattern: /claude[_-]?(opus|sonnet)[_-]?4/i,
+    provider: "anthropic",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "anthropic" },
+    confidence: 0.85
+  },
+  // Gemini thinking models
+  {
+    pattern: /gemini.*thinking|gemini[_-]?2\.5[_-]?pro/i,
+    provider: "google",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "google" },
+    confidence: 0.85
+  },
+  // Gemini 3.x (future-proofing)
+  {
+    pattern: /gemini[_-]?3/i,
+    provider: "google",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "google" },
+    confidence: 0.8
+  },
+  // Grok reasoning models
+  {
+    pattern: /grok[_-]?\d[_-]?(mini|reasoning)/i,
+    provider: "xai",
+    capabilities: { reasoning: true, toolCalling: true },
+    confidence: 0.85
+  },
+  // Qwen thinking models
+  {
+    pattern: /qwen.*thinking|qwen3/i,
+    capabilities: { reasoning: true, toolCalling: true },
+    confidence: 0.8
+  },
+  // Generic reasoning/thinking in name
+  {
+    pattern: /reasoning|thinking/i,
+    capabilities: { reasoning: true },
+    confidence: 0.7
+  }
+];
+var PROVIDER_PATTERNS = [
+  { pattern: /^(gpt|o[134]|chatgpt|davinci)/i, provider: "openai" },
+  { pattern: /^claude/i, provider: "anthropic" },
+  { pattern: /^gemini|^palm/i, provider: "google" },
+  { pattern: /^grok/i, provider: "xai" },
+  { pattern: /^deepseek/i, provider: "deepseek" },
+  { pattern: /^mistral|^mixtral|codestral/i, provider: "mistral" },
+  { pattern: /^llama/i, provider: "meta" },
+  { pattern: /^qwen/i, provider: "alibaba" },
+  { pattern: /^command/i, provider: "cohere" }
+];
+var CONTEXT_WINDOW_PROFILES = [
+  // Anthropic Claude 4.x — 200k
+  { pattern: /claude[_-]?(opus|sonnet)[_-]?4/i, tokens: 2e5 },
+  // Anthropic Claude 3.5 — 200k
+  { pattern: /claude[_-]?3[._-]?5/i, tokens: 2e5 },
+  // Anthropic Claude 3 Opus/Sonnet/Haiku — 200k
+  { pattern: /claude[_-]?3/i, tokens: 2e5 },
+  // Anthropic Claude 2 — 100k
+  { pattern: /claude[_-]?2/i, tokens: 1e5 },
+  // OpenAI o-series (o1, o3, o4) — 200k
+  { pattern: /^o[134]-?(mini|pro|preview)?$/i, tokens: 2e5 },
+  // OpenAI GPT-5.x — 1M
+  { pattern: /gpt-?5/i, tokens: 1e6 },
+  // OpenAI GPT-4o — 128k
+  { pattern: /gpt-?4o/i, tokens: 128e3 },
+  // OpenAI GPT-4 turbo — 128k
+  { pattern: /gpt-?4[_-]?turbo/i, tokens: 128e3 },
+  // OpenAI GPT-4 — 8k (original)
+  { pattern: /gpt-?4(?!o|[_-]?turbo)/i, tokens: 8192 },
+  // OpenAI GPT-3.5 turbo — 16k
+  { pattern: /gpt-?3[._-]?5/i, tokens: 16384 },
+  // Google Gemini 2.5 Pro — 1M
+  { pattern: /gemini[_-]?2[._-]?5[_-]?pro/i, tokens: 1e6 },
+  // Google Gemini 2.x Flash — 1M
+  { pattern: /gemini[_-]?2.*flash/i, tokens: 1e6 },
+  // Google Gemini 2.x Pro — 1M
+  { pattern: /gemini[_-]?2[._-]?\d?[_-]?pro/i, tokens: 1e6 },
+  // Google Gemini 1.5 Pro/Flash — 1M
+  { pattern: /gemini[_-]?1[._-]?5/i, tokens: 1e6 },
+  // xAI Grok 3+ — 128k
+  { pattern: /grok[_-]?\d/i, tokens: 128e3 },
+  // Mistral Large — 128k
+  { pattern: /mistral[_-]?large/i, tokens: 128e3 },
+  // Mistral Medium — 32k
+  { pattern: /mistral[_-]?medium/i, tokens: 32768 },
+  // Codestral — 256k
+  { pattern: /codestral/i, tokens: 256e3 },
+  // Mistral generic — 32k
+  { pattern: /mistral|mixtral/i, tokens: 32768 },
+  // DeepSeek R1/V3 — 128k
+  { pattern: /deepseek/i, tokens: 128e3 },
+  // Qwen 3 — 128k
+  { pattern: /qwen/i, tokens: 128e3 },
+  // Meta Llama 3 — 128k
+  { pattern: /llama[_-]?3/i, tokens: 128e3 },
+  // Cohere Command R+ — 128k
+  { pattern: /command[_-]?r/i, tokens: 128e3 }
+];
+function inferContextWindow(modelId) {
+  const normalized = modelId.toLowerCase();
+  for (const { pattern, tokens } of CONTEXT_WINDOW_PROFILES) {
+    if (pattern.test(normalized)) {
+      return tokens;
+    }
+  }
+  return void 0;
+}
+function inferProvider(modelId) {
+  const normalized = modelId.toLowerCase();
+  for (const { pattern, provider } of PROVIDER_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return provider;
+    }
+  }
+  if (modelId.includes("/")) {
+    return modelId.split("/")[0];
+  }
+  return void 0;
+}
+function matchPatterns(modelId, providerHint) {
+  const normalized = modelId.toLowerCase();
+  for (const rule of REASONING_PATTERNS) {
+    if (rule.provider && providerHint && rule.provider !== providerHint) {
+      continue;
+    }
+    const matches = typeof rule.pattern === "string" ? normalized.includes(rule.pattern.toLowerCase()) : rule.pattern.test(normalized);
+    if (matches) {
+      return { rule, confidence: rule.confidence };
+    }
+  }
+  return void 0;
+}
+function createDefaultCapabilities() {
+  return {
+    reasoning: false,
+    toolCalling: true,
+    temperature: true,
+    attachments: false,
+    streaming: true,
+    inputModalities: ["text"],
+    outputModalities: ["text"]
+  };
+}
+var PatternCapabilitySource = class {
+  priority = 3 /* PatternMatch */;
+  name = "Pattern Matching";
+  async lookup(modelId, providerHint) {
+    const provider = providerHint || inferProvider(modelId);
+    const match = matchPatterns(modelId, provider);
+    const baseCapabilities = createDefaultCapabilities();
+    if (match) {
+      const entry = {
+        id: modelId,
+        name: modelId,
+        provider: match.rule.provider || provider || "unknown",
+        capabilities: {
+          ...baseCapabilities,
+          ...match.rule.capabilities,
+          contextWindow: inferContextWindow(modelId)
+        },
+        compatibility: match.rule.compatibility
+      };
+      return {
+        entry,
+        source: this.priority,
+        confident: match.confidence > 0.8
+      };
+    }
+    return {
+      entry: {
+        id: modelId,
+        name: modelId,
+        provider: provider || "unknown",
+        capabilities: {
+          ...baseCapabilities,
+          contextWindow: inferContextWindow(modelId)
+        }
+      },
+      source: this.priority,
+      confident: false
+    };
+  }
+  async isAvailable() {
+    return true;
+  }
+};
+function likelySupportsReasoning(modelId) {
+  const match = matchPatterns(modelId);
+  return match !== void 0 && match.rule.capabilities.reasoning === true;
+}
+function getProviderCompatibility(modelId, provider) {
+  const match = matchPatterns(modelId, provider);
+  return match?.rule.compatibility;
+}
+
+// src/models/identifiers.ts
+function getModelId(model) {
+  if (typeof model === "string") return model;
+  if (typeof model === "object" && model !== null && "modelId" in model) {
+    return String(model.modelId);
+  }
+  return String(model);
+}
+function getProviderId(model) {
+  if (typeof model === "string") {
+    if (model.includes("/")) {
+      return model.split("/")[0];
+    }
+    return void 0;
+  }
+  if (typeof model === "object" && model !== null && "provider" in model) {
+    const provider = String(model.provider);
+    return provider.split(".")[0];
+  }
+  return void 0;
+}
+var extractModelId = getModelId;
+function extractProvider(model) {
+  const provider = getProviderId(model);
+  return provider ?? inferProvider(getModelId(model));
+}
+
+export {
+  SourcePriority,
+  DEFAULT_RESOLVER_OPTIONS,
+  inferContextWindow,
+  inferProvider,
+  PatternCapabilitySource,
+  likelySupportsReasoning,
+  getProviderCompatibility,
+  getModelId,
+  getProviderId,
+  extractModelId,
+  extractProvider
+};