@cuylabs/agent-core 0.8.0 → 0.9.0

package/dist/chunk-SQU2AJHO.js

@@ -1,305 +0,0 @@
-import {
-  extractModelId,
-  extractProvider,
-  getDefaultResolver,
-  likelySupportsReasoning
-} from "./chunk-RFEKJKTO.js";
-
-// src/reasoning/types.ts
-var STANDARD_LEVELS = ["off", "low", "medium", "high"];
-var EXTENDED_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
-var FIXED_LEVELS = ["medium"];
-function shouldIncludeReasoningSummary() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env.CODE_AGENT_DISABLE_REASONING_SUMMARY !== "true";
-  }
-  return true;
-}
-
-// src/reasoning/providers.ts
-function buildOpenAIOptions(level, compat) {
-  if (level === "off") return void 0;
-  const options = {};
-  if (compat?.supportsReasoningEffort !== false) {
-    options.reasoningEffort = level;
-  }
-  if (shouldIncludeReasoningSummary()) {
-    options.reasoningSummary = "auto";
-  }
-  return options;
-}
-var ANTHROPIC_BUDGETS = {
-  off: 0,
-  minimal: 2e3,
-  low: 4e3,
-  medium: 8e3,
-  high: 16e3,
-  xhigh: 31999
-};
-function buildAnthropicOptions(level) {
-  if (level === "off") return void 0;
-  return {
-    thinking: {
-      type: "enabled",
-      budgetTokens: ANTHROPIC_BUDGETS[level]
-    }
-  };
-}
-var GOOGLE_BUDGETS = {
-  off: 0,
-  minimal: 2e3,
-  low: 4e3,
-  medium: 8e3,
-  high: 16e3,
-  xhigh: 24576
-};
-function buildGoogleOptions(level, modelId) {
-  if (level === "off") return void 0;
-  if (modelId?.includes("gemini-3") || modelId?.includes("gemini-4")) {
-    return {
-      thinkingConfig: {
-        includeThoughts: true,
-        thinkingLevel: level === "high" || level === "xhigh" ? "high" : "low"
-      }
-    };
-  }
-  return {
-    thinkingConfig: {
-      includeThoughts: true,
-      thinkingBudget: GOOGLE_BUDGETS[level]
-    }
-  };
-}
-function buildXAIOptions(level) {
-  if (level === "off") return void 0;
-  return { reasoningEffort: level };
-}
-function buildGroqOptions(level) {
-  if (level === "off") return void 0;
-  return {
-    includeThoughts: true,
-    thinkingLevel: level === "high" || level === "xhigh" ? "high" : "low"
-  };
-}
-var BEDROCK_ANTHROPIC_BUDGETS = {
-  off: 0,
-  minimal: 2e3,
-  low: 4e3,
-  medium: 8e3,
-  high: 16e3,
-  xhigh: 31999
-};
-function buildBedrockOptions(level, modelId) {
-  if (level === "off") return void 0;
-  if (modelId?.includes("anthropic") || modelId?.includes("claude")) {
-    return {
-      reasoningConfig: {
-        type: "enabled",
-        budgetTokens: BEDROCK_ANTHROPIC_BUDGETS[level]
-      }
-    };
-  }
-  return {
-    reasoningConfig: {
-      type: "enabled",
-      maxReasoningEffort: level
-    }
-  };
-}
-function buildOpenRouterOptions(level) {
-  if (level === "off") return void 0;
-  return {
-    reasoning: { effort: level }
-  };
-}
-var PROVIDER_KEY_MAP = {
-  "openai.chat": "openai",
-  "openai.responses": "openai",
-  "anthropic.messages": "anthropic",
-  "google.generative-ai": "google",
-  "bedrock": "bedrock",
-  "azure": "azure",
-  "xai": "xai",
-  "deepinfra": "deepinfra",
-  "togetherai": "togetherai",
-  "groq": "groq",
-  "mistral": "mistral"
-};
-function getProviderOptionsKey(provider) {
-  return PROVIDER_KEY_MAP[provider] || provider.split(".")[0] || "unknown";
-}
-
-// src/reasoning/config.ts
-async function getReasoningConfig(model) {
-  const resolver = getDefaultResolver();
-  const result = await resolver.resolve(model);
-  const { capabilities, compatibility } = result.entry;
-  const provider = extractProvider(model);
-  const modelId = extractModelId(model).toLowerCase();
-  if (!capabilities.reasoning) {
-    return {
-      supportsReasoning: false,
-      availableLevels: ["off"],
-      getProviderOptions: () => void 0
-    };
-  }
-  if (provider?.includes("openai") || modelId.includes("gpt") || modelId.match(/^o[134]/)) {
-    if (modelId === "o1-mini") {
-      return {
-        supportsReasoning: true,
-        availableLevels: FIXED_LEVELS,
-        getProviderOptions: () => void 0
-      };
-    }
-    const isAdvanced = modelId.includes("gpt-5") || modelId.includes("o3") || modelId.includes("o4");
-    return {
-      supportsReasoning: true,
-      availableLevels: isAdvanced ? EXTENDED_LEVELS : STANDARD_LEVELS,
-      getProviderOptions: (level) => buildOpenAIOptions(level, compatibility)
-    };
-  }
-  if (provider?.includes("anthropic") || modelId.includes("claude")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: ["off", "low", "medium", "high"],
-      getProviderOptions: buildAnthropicOptions
-    };
-  }
-  if (provider?.includes("google") || modelId.includes("gemini")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: STANDARD_LEVELS,
-      getProviderOptions: (level) => buildGoogleOptions(level, modelId)
-    };
-  }
-  if (provider?.includes("xai") || modelId.includes("grok")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: STANDARD_LEVELS,
-      getProviderOptions: buildXAIOptions
-    };
-  }
-  if (provider?.includes("bedrock")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: STANDARD_LEVELS,
-      getProviderOptions: (level) => buildBedrockOptions(level, modelId)
-    };
-  }
-  if (provider?.includes("groq")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: ["off", "low", "high"],
-      getProviderOptions: buildGroqOptions
-    };
-  }
-  if (provider?.includes("openrouter")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: STANDARD_LEVELS,
-      getProviderOptions: buildOpenRouterOptions
-    };
-  }
-  if (modelId.includes("r1") || modelId.includes("deepseek")) {
-    return {
-      supportsReasoning: true,
-      availableLevels: FIXED_LEVELS,
-      getProviderOptions: () => void 0
-    };
-  }
-  return {
-    supportsReasoning: true,
-    availableLevels: STANDARD_LEVELS,
-    getProviderOptions: (level) => buildOpenAIOptions(level, compatibility)
-  };
-}
-function getReasoningConfigSync(model) {
-  const modelId = extractModelId(model).toLowerCase();
-  const provider = extractProvider(model) || "";
-  const supportsReasoning2 = modelId.match(/^o[134]/) !== null || modelId.includes("gpt-5") || modelId.includes("r1") || modelId.includes("thinking") || modelId.includes("reasoning") || modelId.includes("grok") && modelId.includes("mini");
-  if (!supportsReasoning2) {
-    return {
-      supportsReasoning: false,
-      availableLevels: ["off"],
-      getProviderOptions: () => void 0
-    };
-  }
-  const isOpenAI = provider.includes("openai") || !!modelId.match(/^o[134]/) || modelId.includes("gpt");
-  const isAnthropic = provider.includes("anthropic") || modelId.includes("claude");
-  const isGoogle = provider.includes("google") || modelId.includes("gemini");
-  const isXAI = provider.includes("xai") || modelId.includes("grok");
-  const isBedrock = provider.includes("bedrock");
-  const isGroq = provider.includes("groq");
-  const isOpenRouter = provider.includes("openrouter");
-  return {
-    supportsReasoning: true,
-    availableLevels: STANDARD_LEVELS,
-    getProviderOptions: (level) => {
-      if (level === "off") return void 0;
-      if (isOpenAI) {
-        const opts = { reasoningEffort: level };
-        if (shouldIncludeReasoningSummary()) opts.reasoningSummary = "auto";
-        return opts;
-      }
-      if (isAnthropic) return buildAnthropicOptions(level);
-      if (isGoogle) return buildGoogleOptions(level, modelId);
-      if (isXAI) return buildXAIOptions(level);
-      if (isBedrock) return buildBedrockOptions(level, modelId);
-      if (isGroq) return buildGroqOptions(level);
-      if (isOpenRouter) return buildOpenRouterOptions(level);
-      const defaultOpts = { reasoningEffort: level };
-      if (shouldIncludeReasoningSummary()) defaultOpts.reasoningSummary = "auto";
-      return defaultOpts;
-    }
-  };
-}
-async function buildReasoningOptions(model, level) {
-  if (level === "off") return void 0;
-  const config = await getReasoningConfig(model);
-  if (!config.supportsReasoning) return void 0;
-  const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
-  const options = config.getProviderOptions(effectiveLevel);
-  if (!options) return void 0;
-  const provider = extractProvider(model) || "";
-  const providerKey = getProviderOptionsKey(provider);
-  return { [providerKey]: options };
-}
-function buildReasoningOptionsSync(model, level) {
-  if (level === "off") return void 0;
-  const config = getReasoningConfigSync(model);
-  if (!config.supportsReasoning) return void 0;
-  const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
-  const options = config.getProviderOptions(effectiveLevel);
-  if (!options) return void 0;
-  const provider = extractProvider(model) || "";
-  const providerKey = getProviderOptionsKey(provider);
-  return { [providerKey]: options };
-}
-async function supportsReasoning(model) {
-  const resolver = getDefaultResolver();
-  return resolver.supportsReasoning(model);
-}
-function supportsReasoningSync(model) {
-  return likelySupportsReasoning(extractModelId(model));
-}
-
-export {
-  STANDARD_LEVELS,
-  EXTENDED_LEVELS,
-  FIXED_LEVELS,
-  shouldIncludeReasoningSummary,
-  buildOpenAIOptions,
-  buildAnthropicOptions,
-  buildGoogleOptions,
-  buildXAIOptions,
-  buildGroqOptions,
-  buildBedrockOptions,
-  buildOpenRouterOptions,
-  getProviderOptionsKey,
-  getReasoningConfig,
-  getReasoningConfigSync,
-  buildReasoningOptions,
-  buildReasoningOptionsSync,
-  supportsReasoning,
-  supportsReasoningSync
-};

package/dist/reasoning/index.d.ts

@@ -1,116 +0,0 @@
-import { R as ReasoningLevel, a as ReasoningConfig } from '../types-CQaXbRsS.js';
-export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
-import { P as ProviderCompatibility } from '../types-QA4WhEfz.js';
-import { LanguageModel } from 'ai';
-import { ProviderOptions } from '@ai-sdk/provider-utils';
-
-/**
- * Provider-Specific Reasoning Option Builders
- *
- * Each function takes a {@link ReasoningLevel} and returns the
- * provider-options object expected by the Vercel AI SDK's
- * `providerOptions` parameter.
- *
- * Provider key mapping (`getProviderOptionsKey`) is also defined
- * here so that callers can wrap the raw options correctly.
- */
-
-/**
- * Build OpenAI reasoning options.
- *
- * OpenAI reasoning models use:
- * - `reasoningEffort` — controls depth
- * - `reasoningSummary` — controls whether reasoning is streamed
- *   (`"auto"` = condensed summary, `"detailed"` = full)
- *
- * `reasoningSummary` requires a verified OpenAI organisation.
- * Set `CODE_AGENT_DISABLE_REASONING_SUMMARY=true` to skip it.
- */
-declare function buildOpenAIOptions(level: ReasoningLevel, compat?: ProviderCompatibility): Record<string, unknown> | undefined;
-/**
- * Build Anthropic thinking options.
- *
- * Uses `thinking.type: "enabled"` with `budgetTokens`.
- */
-declare function buildAnthropicOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Build Google / Gemini reasoning options.
- *
- * - **Gemini 3+** uses `thinkingLevel` (`"low"` / `"high"`)
- * - **Gemini 2.5 and earlier** uses `thinkingBudget` (token count)
- */
-declare function buildGoogleOptions(level: ReasoningLevel, modelId?: string): Record<string, unknown> | undefined;
-/**
- * Build xAI / Grok reasoning options.
- */
-declare function buildXAIOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Build Groq reasoning options.
- */
-declare function buildGroqOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Build Amazon Bedrock reasoning options.
- *
- * - Anthropic / Claude models use `budgetTokens`
- * - Amazon Nova models use `maxReasoningEffort`
- */
-declare function buildBedrockOptions(level: ReasoningLevel, modelId?: string): Record<string, unknown> | undefined;
-/**
- * Build OpenRouter reasoning options.
- */
-declare function buildOpenRouterOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
-/**
- * Resolve the `providerOptions` key for a given SDK provider string.
- *
- * Falls back to the first dot-segment (e.g. `"foo.bar"` → `"foo"`).
- */
-declare function getProviderOptionsKey(provider: string): string;
-
-/**
- * Reasoning Configuration & Option Builders
- *
- * Orchestrates capability detection and provider-specific option
- * building to produce ready-to-use `providerOptions` for the
- * Vercel AI SDK.
- *
- * Two flavours of every function are provided:
- * - **Async** (`getReasoningConfig`, `buildReasoningOptions`) —
- *   uses the full capability resolver (network + cache).
- * - **Sync** (`getReasoningConfigSync`, `buildReasoningOptionsSync`) —
- *   uses fast pattern-matching only (no network).
- */
-
-/**
- * Get the reasoning configuration for a model.
- *
- * Uses the full capability resolver (including network lookups)
- * for the most accurate result.
- */
-declare function getReasoningConfig(model: LanguageModel): Promise<ReasoningConfig>;
-/**
- * Synchronous reasoning config using pattern-matching only.
- *
- * Faster but less accurate than {@link getReasoningConfig}.
- * Good for hot paths where async is impractical.
- */
-declare function getReasoningConfigSync(model: LanguageModel): ReasoningConfig;
-/**
- * Build `providerOptions` for a reasoning level (async).
- *
- * Returns `undefined` when reasoning is off or unsupported.
- */
-declare function buildReasoningOptions(model: LanguageModel, level: ReasoningLevel): Promise<ProviderOptions | undefined>;
-/**
- * Build `providerOptions` for a reasoning level (sync / pattern-only).
- */
-declare function buildReasoningOptionsSync(model: LanguageModel, level: ReasoningLevel): ProviderOptions | undefined;
-/**
- * Check whether a model supports reasoning (async, full resolver).
- */
-declare function supportsReasoning(model: LanguageModel): Promise<boolean>;
-/**
- * Synchronous check using pattern-matching only.
- */
-declare function supportsReasoningSync(model: LanguageModel): boolean;
-
-export { ReasoningConfig, ReasoningLevel, buildAnthropicOptions, buildBedrockOptions, buildGoogleOptions, buildGroqOptions, buildOpenAIOptions, buildOpenRouterOptions, buildReasoningOptions, buildReasoningOptionsSync, buildXAIOptions, getProviderOptionsKey, getReasoningConfig, getReasoningConfigSync, supportsReasoning, supportsReasoningSync };

package/dist/types-QA4WhEfz.d.ts

@@ -1,138 +0,0 @@
-/**
- * Model Capability Types for @cuylabs/agent-core
- *
- * Defines the structure for model capabilities that can be sourced from
- * static patterns, local cache, or remote APIs.
- */
-/**
- * Input modalities a model can accept
- */
-type InputModality = "text" | "image" | "audio" | "video" | "pdf";
-/**
- * Output modalities a model can produce
- */
-type OutputModality = "text" | "image" | "audio" | "video";
-/**
- * Comprehensive model capabilities
- */
-interface ModelCapabilities {
-    /** Model supports extended reasoning/thinking */
-    reasoning: boolean;
-    /** Model supports function/tool calling */
-    toolCalling: boolean;
-    /** Model supports temperature adjustment */
-    temperature: boolean;
-    /** Model supports file attachments */
-    attachments: boolean;
-    /** Model supports streaming responses */
-    streaming: boolean;
-    /** Supported input modalities */
-    inputModalities: InputModality[];
-    /** Supported output modalities */
-    outputModalities: OutputModality[];
-    /** Maximum context window in tokens */
-    contextWindow?: number;
-    /** Maximum output tokens */
-    maxOutput?: number;
-}
-/**
- * Provider-specific compatibility flags
- * These handle quirks in different provider implementations
- */
-interface ProviderCompatibility {
-    /** Supports OpenAI-style reasoning_effort parameter */
-    supportsReasoningEffort?: boolean;
-    /** Supports developer/system role distinction */
-    supportsDeveloperRole?: boolean;
-    /** Field name for max tokens (varies by provider) */
-    maxTokensField?: "max_tokens" | "max_completion_tokens";
-    /** Requires thinking as text tags vs structured */
-    requiresThinkingTags?: boolean;
-    /** Provider-specific thinking format */
-    thinkingFormat?: "openai" | "anthropic" | "google" | "zai";
-}
-/**
- * Complete model entry with metadata
- */
-interface ModelEntry {
-    /** Model identifier (e.g., "gpt-4o", "claude-sonnet-4") */
-    id: string;
-    /** Human-readable model name */
-    name: string;
-    /** Provider identifier (e.g., "openai", "anthropic") */
-    provider: string;
-    /** Model capabilities */
-    capabilities: ModelCapabilities;
-    /** Provider-specific compatibility settings */
-    compatibility?: ProviderCompatibility;
-    /** Cost per million tokens (input) */
-    costInput?: number;
-    /** Cost per million tokens (output) */
-    costOutput?: number;
-    /** When this entry was last updated */
-    updatedAt?: string;
-}
-/**
- * Priority levels for capability sources
- */
-declare enum SourcePriority {
-    /** User configuration overrides everything */
-    UserConfig = 0,
-    /** Local cache from previous fetch */
-    LocalCache = 1,
-    /** Bundled static data (build-time) */
-    BundledData = 2,
-    /** Pattern-based inference (fallback) */
-    PatternMatch = 3,
-    /** Remote API (if network available) */
-    RemoteAPI = 4
-}
-/**
- * Result from a capability source lookup
- */
-interface SourceResult {
-    /** The model entry if found */
-    entry?: ModelEntry;
-    /** Which source provided this result */
-    source: SourcePriority;
-    /** Whether this is a confident match */
-    confident: boolean;
-    /** Error message if lookup failed */
-    error?: string;
-}
-/**
- * Capability source interface
- */
-interface CapabilitySource {
-    /** Source priority (lower = higher priority) */
-    priority: SourcePriority;
-    /** Human-readable source name */
-    name: string;
-    /** Look up capabilities for a model */
-    lookup(modelId: string, provider?: string): Promise<SourceResult>;
-    /** Check if this source is available */
-    isAvailable(): Promise<boolean>;
-}
-/**
- * Options for the capability resolver
- */
-interface ResolverOptions {
-    /** Enable remote API fetching (default: false) */
-    enableRemoteFetch?: boolean;
-    /** Remote API URL (default: https://models.dev) */
-    remoteApiUrl?: string;
-    /** Cache directory path */
-    cachePath?: string;
-    /** Cache TTL in milliseconds (default: 1 hour) */
-    cacheTtlMs?: number;
-    /** Network timeout in milliseconds (default: 10 seconds) */
-    networkTimeoutMs?: number;
-    /** Custom user overrides for specific models */
-    modelOverrides?: Record<string, Partial<ModelCapabilities>>;
-}
-/**
- * Default resolver options
- */
-declare const DEFAULT_RESOLVER_OPTIONS: Required<ResolverOptions>;
-
-export { type CapabilitySource as C, DEFAULT_RESOLVER_OPTIONS as D, type InputModality as I, type ModelCapabilities as M, type OutputModality as O, type ProviderCompatibility as P, type ResolverOptions as R, SourcePriority as S, type ModelEntry as a, type SourceResult as b };