@cuylabs/agent-core 0.7.0 → 0.9.0

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-IEFIQENH.js → chunk-H3FUYU52.js}

@@ -1,11 +1,11 @@
-import {
-  snapshotScope,
-  withinScope
-} from "./chunk-N7P4PN3O.js";
 import {
   extractFilePathsFromArgs,
   shouldCaptureBaseline
 } from "./chunk-VEKUXUVF.js";
+import {
+  snapshotScope,
+  withinScope
+} from "./chunk-N7P4PN3O.js";
 
 // src/tool/executor.ts
 async function executeAgentToolCall(options) {
@@ -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
+};

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-3HNO5SVI.js → chunk-J4QDGZIA.js}

@@ -1,18 +1,25 @@
 import {
   DEFAULT_CONTEXT_LIMITS
-} from "./chunk-BNSHUWCV.js";
+} from "./chunk-WWYYNWEW.js";
 import {
   Inference
-} from "./chunk-5K7AQVOU.js";
+} from "./chunk-WKHDSSXG.js";
 import {
   executeAgentToolCall
-} from "./chunk-IEFIQENH.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,