@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/{chunk-QWFMX226.js → chunk-RFEKJKTO.js}

@@ -3,7 +3,183 @@ import {
   getProviderId
 } from "./chunk-DWYX7ASF.js";
 
-// src/capabilities/types.ts
+// src/models/resolver.ts
+function parseKey(input) {
+  const [engineId, ...rest] = input.split("/");
+  if (!engineId || rest.length === 0) return null;
+  return { engineId, modelId: rest.join("/") };
+}
+function mergeSettings(base, override) {
+  return {
+    apiKey: override?.apiKey ?? base?.apiKey,
+    baseUrl: override?.baseUrl ?? base?.baseUrl,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
+    },
+    extra: {
+      ...base?.extra ?? {},
+      ...override?.extra ?? {}
+    }
+  };
+}
+function settingsKey(settings, adapter, engineId) {
+  return JSON.stringify({
+    engineId,
+    adapter,
+    apiKey: settings.apiKey ?? "",
+    baseUrl: settings.baseUrl ?? "",
+    headers: settings.headers ?? {},
+    extra: settings.extra ?? {}
+  });
+}
+function buildOptions(settings) {
+  const opts = { ...settings.extra ?? {} };
+  if (settings.apiKey) opts.apiKey = settings.apiKey;
+  if (settings.baseUrl) opts.baseURL = settings.baseUrl;
+  if (settings.headers && Object.keys(settings.headers).length > 0) opts.headers = settings.headers;
+  return opts;
+}
+async function createFactory(adapter, settings) {
+  const asModel = (m) => m;
+  const opts = buildOptions(settings);
+  switch (adapter) {
+    case "openai": {
+      const { createOpenAI } = await import("@ai-sdk/openai").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/openai" is required for the "openai" adapter. Install it with: pnpm add @ai-sdk/openai`
+        );
+      });
+      const provider = createOpenAI(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "anthropic": {
+      const { createAnthropic } = await import("@ai-sdk/anthropic").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/anthropic" is required for the "anthropic" adapter. Install it with: pnpm add @ai-sdk/anthropic`
+        );
+      });
+      const provider = createAnthropic(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "google": {
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/google" is required for the "google" adapter. Install it with: pnpm add @ai-sdk/google`
+        );
+      });
+      const provider = createGoogleGenerativeAI(opts);
+      return (modelId) => asModel(provider.languageModel(modelId));
+    }
+    case "openai-compatible": {
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/openai-compatible" is required for the "openai-compatible" adapter. Install it with: pnpm add @ai-sdk/openai-compatible`
+        );
+      });
+      const provider = createOpenAICompatible({
+        name: opts.name ?? "custom",
+        baseURL: opts.baseURL ?? "",
+        ...opts.apiKey ? { apiKey: opts.apiKey } : {},
+        ...opts.headers ? { headers: opts.headers } : {}
+      });
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "openrouter": {
+      const { createOpenRouter } = await import("@openrouter/ai-sdk-provider").catch(() => {
+        throw new Error(
+          `Provider "@openrouter/ai-sdk-provider" is required for the "openrouter" adapter. Install it with: pnpm add @openrouter/ai-sdk-provider`
+        );
+      });
+      const provider = createOpenRouter(opts);
+      return (modelId) => asModel(provider.languageModel(modelId));
+    }
+    case "azure": {
+      const { createAzure } = await import("@ai-sdk/azure").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/azure" is required for the "azure" adapter. Install it with: pnpm add @ai-sdk/azure`
+        );
+      });
+      const provider = createAzure(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "bedrock": {
+      const { createAmazonBedrock } = await import("@ai-sdk/amazon-bedrock").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/amazon-bedrock" is required for the "bedrock" adapter. Install it with: pnpm add @ai-sdk/amazon-bedrock`
+        );
+      });
+      const provider = createAmazonBedrock(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "vertex": {
+      const { createVertex } = await import("@ai-sdk/google-vertex").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/google-vertex" is required for the "vertex" adapter. Install it with: pnpm add @ai-sdk/google-vertex`
+        );
+      });
+      const provider = createVertex(opts);
+      return (modelId) => asModel(provider.languageModel(modelId));
+    }
+    case "xai": {
+      const { createXai } = await import("@ai-sdk/xai").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/xai" is required for the "xai" adapter. Install it with: pnpm add @ai-sdk/xai`
+        );
+      });
+      const provider = createXai(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "mistral": {
+      const { createMistral } = await import("@ai-sdk/mistral").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/mistral" is required for the "mistral" adapter. Install it with: pnpm add @ai-sdk/mistral`
+        );
+      });
+      const provider = createMistral(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    case "groq": {
+      const { createGroq } = await import("@ai-sdk/groq").catch(() => {
+        throw new Error(
+          `Provider "@ai-sdk/groq" is required for the "groq" adapter. Install it with: pnpm add @ai-sdk/groq`
+        );
+      });
+      const provider = createGroq(opts);
+      return (modelId) => provider.languageModel(modelId);
+    }
+    default:
+      throw new Error(`No factory registered for adapter: ${adapter}`);
+  }
+}
+function createResolver(directory) {
+  const factoryCache = /* @__PURE__ */ new Map();
+  return async (key) => {
+    const parsed = parseKey(key);
+    const entry = parsed ? void 0 : directory.entries?.[key];
+    const engineId = parsed?.engineId ?? entry?.engine;
+    const modelId = parsed?.modelId ?? entry?.id;
+    if (!engineId || !modelId) {
+      throw new Error(`Unknown model reference: ${key}`);
+    }
+    const engine = directory.engines[engineId];
+    if (!engine) {
+      throw new Error(`Unknown engine: ${engineId}`);
+    }
+    const settings = mergeSettings(engine.settings, entry?.settings);
+    if (engine.build) {
+      return engine.build(modelId, settings);
+    }
+    const cacheKey2 = settingsKey(settings, engine.adapter, engineId);
+    const cached = factoryCache.get(cacheKey2);
+    if (cached) return cached(modelId);
+    const factory = await createFactory(engine.adapter, settings);
+    factoryCache.set(cacheKey2, factory);
+    return factory(modelId);
+  };
+}
+
+// src/models/types.ts
 var SourcePriority = /* @__PURE__ */ ((SourcePriority3) => {
   SourcePriority3[SourcePriority3["UserConfig"] = 0] = "UserConfig";
   SourcePriority3[SourcePriority3["LocalCache"] = 1] = "LocalCache";
@@ -23,7 +199,7 @@ var DEFAULT_RESOLVER_OPTIONS = {
   modelOverrides: {}
 };
 
-// src/capabilities/patterns.ts
+// src/models/profiles.ts
 var REASONING_PATTERNS = [
   // OpenAI o-series
   {
@@ -110,6 +286,63 @@ var PROVIDER_PATTERNS = [
   { 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) {
@@ -160,7 +393,8 @@ var PatternCapabilitySource = class {
         provider: match.rule.provider || provider || "unknown",
         capabilities: {
           ...baseCapabilities,
-          ...match.rule.capabilities
+          ...match.rule.capabilities,
+          contextWindow: inferContextWindow(modelId)
         },
         compatibility: match.rule.compatibility
       };
@@ -175,7 +409,10 @@ var PatternCapabilitySource = class {
         id: modelId,
         name: modelId,
         provider: provider || "unknown",
-        capabilities: baseCapabilities
+        capabilities: {
+          ...baseCapabilities,
+          contextWindow: inferContextWindow(modelId)
+        }
       },
       source: this.priority,
       confident: false
@@ -194,7 +431,7 @@ function getProviderCompatibility(modelId, provider) {
   return match?.rule.compatibility;
 }
 
-// src/capabilities/overrides.ts
+// src/models/overrides.ts
 function normalizeKey(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
@@ -228,7 +465,7 @@ function applyCapabilityOverride(entry, override) {
   };
 }
 
-// src/capabilities/cache/adapters.ts
+// src/models/cache/adapters.ts
 function isNodeEnvironment() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
@@ -325,7 +562,7 @@ function createCapabilityCacheAdapter(cachePath) {
   return new MemoryAdapter();
 }
 
-// src/capabilities/cache/types.ts
+// src/models/cache/types.ts
 var CACHE_VERSION = 1;
 function cacheKey(modelId, provider) {
   return provider ? `${provider}:${modelId}` : modelId;
@@ -334,7 +571,7 @@ function isExpired(data) {
   return Date.now() > new Date(data.expiresAt).getTime();
 }
 
-// src/capabilities/cache/manager.ts
+// src/models/cache/manager.ts
 var CapabilityCache = class {
   adapter;
   memoryCache = /* @__PURE__ */ new Map();
@@ -436,7 +673,7 @@ var CacheCapabilitySource = class {
   }
 };
 
-// src/capabilities/remote/network.ts
+// src/models/remote/network.ts
 function hasBrowserNetworkAPI() {
   return typeof globalThis.navigator !== "undefined" && "onLine" in globalThis.navigator;
 }
@@ -509,7 +746,7 @@ async function fetchWithTimeout(url, timeoutMs) {
   }
 }
 
-// src/capabilities/remote/transform.ts
+// src/models/remote/transform.ts
 function transformModelsDevEntry(raw) {
   const capabilities = {
     reasoning: raw.reasoning ?? false,
@@ -533,7 +770,7 @@ function transformModelsDevEntry(raw) {
   };
 }
 
-// src/capabilities/remote/fetcher.ts
+// src/models/remote/fetcher.ts
 var RemoteCapabilityFetcher = class {
   apiUrl;
   timeoutMs;
@@ -592,7 +829,7 @@ var RemoteCapabilityFetcher = class {
   }
 };
 
-// src/capabilities/remote/source.ts
+// src/models/remote/source.ts
 var RemoteCapabilitySource = class {
   priority = 4 /* RemoteAPI */;
   name = "Remote API (models.dev)";
@@ -659,7 +896,7 @@ var RemoteCapabilitySource = class {
   }
 };
 
-// src/capabilities/resolver.ts
+// src/models/capability-resolver.ts
 function extractModelId(model) {
   return getModelId(model);
 }
@@ -858,8 +1095,10 @@ function configureResolver(options) {
 }
 
 export {
+  createResolver,
   SourcePriority,
   DEFAULT_RESOLVER_OPTIONS,
+  inferContextWindow,
   inferProvider,
   PatternCapabilitySource,
   likelySupportsReasoning,

package/dist/chunk-RZITT45F.js

@@ -0,0 +1,202 @@
+// src/errors/classify.ts
+function isRetryableCategory(category) {
+  switch (category) {
+    case "rate_limit":
+    case "overloaded":
+    case "network":
+    case "timeout":
+      return true;
+    case "auth":
+    case "invalid_request":
+    case "context_overflow":
+    case "content_filter":
+    case "cancelled":
+    case "unknown":
+      return false;
+  }
+}
+function classifyFromStatusAndMessage(status, message) {
+  const lowerMessage = message.toLowerCase();
+  if (status) {
+    if (status === 429) return "rate_limit";
+    if (status === 401 || status === 403) return "auth";
+    if (status === 400) {
+      if (lowerMessage.includes("context") || lowerMessage.includes("token")) {
+        return "context_overflow";
+      }
+      return "invalid_request";
+    }
+    if (status === 503 || status === 502) return "overloaded";
+    if (status >= 500) return "network";
+  }
+  if (lowerMessage.includes("rate") && lowerMessage.includes("limit")) {
+    return "rate_limit";
+  }
+  if (lowerMessage.includes("overload") || lowerMessage.includes("capacity")) {
+    return "overloaded";
+  }
+  if (lowerMessage.includes("too_many_requests")) {
+    return "rate_limit";
+  }
+  if (lowerMessage.includes("unauthorized") || lowerMessage.includes("invalid api key")) {
+    return "auth";
+  }
+  if (lowerMessage.includes("context") && lowerMessage.includes("length")) {
+    return "context_overflow";
+  }
+  if (lowerMessage.includes("content") && lowerMessage.includes("filter")) {
+    return "content_filter";
+  }
+  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    return "timeout";
+  }
+  if (lowerMessage.includes("network") || lowerMessage.includes("econnrefused") || lowerMessage.includes("econnreset")) {
+    return "network";
+  }
+  return "unknown";
+}
+function parseRetryDelay(headers) {
+  const retryAfterMs = headers["retry-after-ms"];
+  if (retryAfterMs) {
+    const parsed = parseFloat(retryAfterMs);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  const retryAfter = headers["retry-after"];
+  if (retryAfter) {
+    const seconds = parseFloat(retryAfter);
+    if (!Number.isNaN(seconds) && seconds > 0) {
+      return Math.ceil(seconds * 1e3);
+    }
+    const dateMs = Date.parse(retryAfter);
+    if (!Number.isNaN(dateMs)) {
+      const delayMs = dateMs - Date.now();
+      if (delayMs > 0) {
+        return Math.ceil(delayMs);
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/errors/extract.ts
+function extractFromAISDKError(error) {
+  const result = {};
+  const anyError = error;
+  if (typeof anyError.status === "number") {
+    result.status = anyError.status;
+  } else if (typeof anyError.statusCode === "number") {
+    result.status = anyError.statusCode;
+  }
+  if (anyError.responseHeaders && typeof anyError.responseHeaders === "object") {
+    result.headers = anyError.responseHeaders;
+  } else if (anyError.headers && typeof anyError.headers === "object") {
+    result.headers = anyError.headers;
+  }
+  if (anyError.data && typeof anyError.data === "object") {
+    const data = anyError.data;
+    if (data.type === "error" && typeof data.error === "object") {
+      const innerError = data.error;
+      if (innerError.type === "too_many_requests") {
+        result.category = "rate_limit";
+      } else if (innerError.type === "overloaded") {
+        result.category = "overloaded";
+      }
+    }
+    if (typeof data.isRetryable === "boolean" && !data.isRetryable && !result.category) {
+      result.category = "invalid_request";
+    }
+  }
+  return result;
+}
+
+// src/errors/llm-error.ts
+var LLMError = class _LLMError extends Error {
+  category;
+  status;
+  headers;
+  provider;
+  model;
+  isRetryable;
+  retryDelayMs;
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "LLMError";
+    this.status = options.status;
+    this.headers = options.headers;
+    this.provider = options.provider;
+    this.model = options.model;
+    this.category = options.category ?? classifyFromStatusAndMessage(
+      options.status,
+      options.message
+    );
+    this.isRetryable = isRetryableCategory(this.category);
+    this.retryDelayMs = this.headers ? parseRetryDelay(this.headers) : void 0;
+  }
+  static from(error, context) {
+    if (error instanceof _LLMError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError" || error.message.includes("abort")) {
+        return new _LLMError({
+          message: error.message,
+          category: "cancelled",
+          cause: error,
+          ...context
+        });
+      }
+      return new _LLMError({
+        message: error.message,
+        cause: error,
+        ...extractFromAISDKError(error),
+        ...context
+      });
+    }
+    return new _LLMError({
+      message: String(error),
+      category: "unknown",
+      ...context
+    });
+  }
+  get description() {
+    const parts = [this.message];
+    if (this.provider) parts.unshift(`[${this.provider}]`);
+    if (this.status) parts.push(`(HTTP ${this.status})`);
+    if (this.isRetryable && this.retryDelayMs) {
+      parts.push(`retry in ${Math.ceil(this.retryDelayMs / 1e3)}s`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/errors/utils.ts
+function isRetryable(error) {
+  if (error instanceof LLMError) {
+    return error.isRetryable;
+  }
+  return LLMError.from(error).isRetryable;
+}
+function getRetryDelay(error) {
+  if (error instanceof LLMError) {
+    return error.isRetryable ? error.retryDelayMs : void 0;
+  }
+  const llmError = LLMError.from(error);
+  return llmError.isRetryable ? llmError.retryDelayMs : void 0;
+}
+function getErrorCategory(error) {
+  if (error instanceof LLMError) {
+    return error.category;
+  }
+  return LLMError.from(error).category;
+}
+
+export {
+  isRetryableCategory,
+  parseRetryDelay,
+  LLMError,
+  isRetryable,
+  getRetryDelay,
+  getErrorCategory
+};

package/dist/{chunk-X635CM2F.js → chunk-SQU2AJHO.js}

@@ -3,7 +3,7 @@ import {
   extractProvider,
   getDefaultResolver,
   likelySupportsReasoning
-} from "./chunk-QWFMX226.js";
+} from "./chunk-RFEKJKTO.js";
 
 // src/reasoning/types.ts
 var STANDARD_LEVELS = ["off", "low", "medium", "high"];