@cuylabs/agent-core 0.5.0 → 0.7.0

package/dist/inference/index.d.ts

@@ -0,0 +1,59 @@
+import { ToolSet } from 'ai';
+import { T as Tool } from '../tool-Db1Ue-1U.js';
+import { T as ToolHost } from '../types-CHiPh8U2.js';
+import { M as MiddlewareRunner } from '../runner-DSKaEz3z.js';
+export { S as StreamChunk } from '../runner-DSKaEz3z.js';
+import { d as TurnTrackerContext } from '../tool-HUtkiVBx.js';
+import { T as ToolExecutionMode, I as InferenceStreamInput, A as AnyInferenceResult } from '../types-FRpzzg_9.js';
+export { a as AnyStreamResult, C as CustomStreamProvider, b as CustomStreamResult, D as DEFAULT_MAX_OUTPUT_TOKENS, c as InferenceCustomResult, d as InferenceStepInfo, e as InferenceStreamResult, L as LLMStreamInput, f as LLMStreamResult, O as OUTPUT_TOKEN_MAX, S as StepInfo } from '../types-FRpzzg_9.js';
+import 'zod';
+import '@ai-sdk/provider-utils';
+import '../messages-BYWGn8TY.js';
+import '../types-9jGQUjqW.js';
+import '../types-CQaXbRsS.js';
+
+/**
+ * Build a Vercel AI SDK `ToolSet` from `Tool.Info` definitions.
+ */
+declare function buildToolSet(options: {
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    sessionID: string;
+    messageID: string;
+    abort: AbortSignal;
+    turnTracker?: TurnTrackerContext;
+    host?: ToolHost;
+    middleware?: MiddlewareRunner;
+    executionMode?: ToolExecutionMode;
+}): Promise<ToolSet>;
+
+/**
+ * Create a model inference stream with optional retry support.
+ */
+declare function stream(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+/**
+ * Create a stream without retry.
+ */
+declare function streamOnce(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+/**
+ * Create a single-step stream.
+ */
+declare function streamStep(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+
+declare const Inference: {
+    readonly buildToolSet: typeof buildToolSet;
+    readonly stream: typeof stream;
+    readonly streamOnce: typeof streamOnce;
+    readonly streamStep: typeof streamStep;
+};
+/**
+ * @deprecated Use `Inference`.
+ */
+declare const LLM: {
+    readonly buildToolSet: typeof buildToolSet;
+    readonly stream: typeof stream;
+    readonly streamOnce: typeof streamOnce;
+    readonly streamStep: typeof streamStep;
+};
+
+export { AnyInferenceResult, Inference, InferenceStreamInput, LLM, ToolExecutionMode, buildToolSet, stream, streamOnce, streamStep };

package/dist/inference/index.js

@@ -0,0 +1,25 @@
+import {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+} from "../chunk-5K7AQVOU.js";
+import "../chunk-ZPMACVZK.js";
+import "../chunk-IEFIQENH.js";
+import "../chunk-N7P4PN3O.js";
+import "../chunk-VEKUXUVF.js";
+import "../chunk-QGOGIP7T.js";
+export {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+};

package/dist/middleware/index.d.ts

@@ -1,7 +1,11 @@
-export { f as AgentMiddleware, M as MiddlewareRunner, T as ToolCallDecision } from '../runner-C7aMP_x3.js';
-export { c as ApprovalMiddlewareConfig, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from '../index-tmhaADz5.js';
+export { h as AgentMiddleware, i as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, m as ModelCallContext, e as ModelCallInput, n as ModelCallOutput, T as ToolCallDecision } from '../runner-DSKaEz3z.js';
+export { c as ApprovalMiddlewareConfig, C as CacheTTL, O as OtelMiddlewareConfig, P as PromptCacheConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware, p as promptCacheMiddleware } from '../index-CfBGYrpd.js';
 import 'ai';
+import '@ai-sdk/provider-utils';
 import '../messages-BYWGn8TY.js';
-import '../tool-pFAnJc5Y.js';
+import '../tool-Db1Ue-1U.js';
 import 'zod';
-import '../tool-DYp6-cC3.js';
+import '../tool-HUtkiVBx.js';
+import '../types-CHiPh8U2.js';
+import '../types-9jGQUjqW.js';
+import '../types-CQaXbRsS.js';

package/dist/middleware/index.js

@@ -2,11 +2,13 @@ import {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
-  otelMiddleware
-} from "../chunk-OTUGSCED.js";
+  otelMiddleware,
+  promptCacheMiddleware
+} from "../chunk-CDTV2UYU.js";
 export {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
-  otelMiddleware
+  otelMiddleware,
+  promptCacheMiddleware
 };

package/dist/models/index.d.ts

@@ -1,5 +1,15 @@
-export { g as getModelId, a as getProviderId } from '../identifiers-BLUxFqV_.js';
 import { LanguageModel } from 'ai';
+import { C as CapabilitySource, S as SourcePriority, d as SourceResult, P as ProviderCompatibility, c as ResolverOptions, b as ModelEntry, M as ModelCapabilities, N as NetworkStatus } from '../capability-resolver-CgRGsWVX.js';
+export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, a as ModelCapabilityResolver, O as OutputModality, R as ResolutionResult, e as configureResolver, f as extractModelId, g as extractProvider, h as getDefaultResolver } from '../capability-resolver-CgRGsWVX.js';
+
+/**
+ * Extract a model ID string from a LanguageModel instance.
+ */
+declare function getModelId(model: LanguageModel): string;
+/**
+ * Extract a provider identifier from a LanguageModel instance.
+ */
+declare function getProviderId(model: LanguageModel): string | undefined;
 
 type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible";
 type AdapterSettings = {
@@ -30,4 +40,96 @@ type Resolver = (key: string) => Promise<LanguageModel>;
 type SyncResolver = (key: string) => LanguageModel;
 declare function createResolver(directory: Directory): Resolver;
 
-export { type AdapterSettings, type Directory, type EngineSpec, type ModelSpec, type Resolver, type SyncResolver, createResolver };
+/**
+ * Profile-Based Capability Detection for @cuylabs/agent-core
+ *
+ * Static pattern matching for model capabilities when no external data is available.
+ * This is the fallback layer — always works offline.
+ */
+
+/**
+ * Infer provider from model ID
+ */
+declare function inferProvider(modelId: string): string | undefined;
+/**
+ * Pattern-based capability source
+ * Always available, uses heuristics to detect capabilities
+ */
+declare class PatternCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.PatternMatch;
+    readonly name = "Pattern Matching";
+    lookup(modelId: string, providerHint?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Quick check if a model ID likely supports reasoning
+ */
+declare function likelySupportsReasoning(modelId: string): boolean;
+/**
+ * Get provider compatibility for a model
+ */
+declare function getProviderCompatibility(modelId: string, provider?: string): ProviderCompatibility | undefined;
+
+type CapabilityOverrides = ResolverOptions["modelOverrides"];
+type OverrideLookup = {
+    override?: Partial<ModelCapabilities>;
+    matchedKey?: string;
+};
+declare function findCapabilityOverride(overrides: CapabilityOverrides, modelId: string, provider?: string): OverrideLookup;
+declare function applyCapabilityOverride(entry: ModelEntry, override?: Partial<ModelCapabilities>): ModelEntry;
+
+declare class CapabilityCache {
+    private adapter;
+    private memoryCache;
+    private ttlMs;
+    private loaded;
+    constructor(options?: Partial<ResolverOptions>);
+    private load;
+    get(modelId: string, provider?: string): Promise<ModelEntry | undefined>;
+    set(entry: ModelEntry): Promise<void>;
+    setMany(entries: ModelEntry[]): Promise<void>;
+    persist(): Promise<void>;
+    clear(): Promise<void>;
+    stats(): {
+        size: number;
+        loaded: boolean;
+    };
+    getAll(): Promise<ModelEntry[]>;
+    getAllByProvider(): Promise<Record<string, ModelEntry[]>>;
+}
+declare class CacheCapabilitySource implements CapabilitySource {
+    private cache;
+    readonly priority = SourcePriority.LocalCache;
+    readonly name = "Local Cache";
+    constructor(cache: CapabilityCache);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+
+declare function getNetworkStatus(): NetworkStatus;
+
+declare class RemoteCapabilityFetcher {
+    private apiUrl;
+    private timeoutMs;
+    private cache;
+    private lastFetchTime;
+    private minFetchInterval;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    fetchAll(): Promise<ModelEntry[]>;
+    ping(): Promise<boolean>;
+}
+
+declare class RemoteCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.RemoteAPI;
+    readonly name = "Remote API (models.dev)";
+    private fetcher;
+    private cache;
+    private fetchPromise;
+    private enabled;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+    refresh(): Promise<void>;
+}
+
+export { type AdapterSettings, CacheCapabilitySource, CapabilityCache, type CapabilityOverrides, CapabilitySource, type Directory, type EngineSpec, ModelCapabilities, ModelEntry, type ModelSpec, NetworkStatus, PatternCapabilitySource, ProviderCompatibility, RemoteCapabilityFetcher, RemoteCapabilitySource, type Resolver, ResolverOptions, SourcePriority, SourceResult, type SyncResolver, applyCapabilityOverride, createResolver, findCapabilityOverride, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferProvider, likelySupportsReasoning };

package/dist/models/index.js

@@ -1,12 +1,46 @@
 import {
-  createResolver
-} from "../chunk-6TDTQJ4P.js";
-import {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
+  createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
   getModelId,
-  getProviderId
-} from "../chunk-DWYX7ASF.js";
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferProvider,
+  likelySupportsReasoning
+} from "../chunk-QGOGIP7T.js";
 export {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
   createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
   getModelId,
-  getProviderId
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferProvider,
+  likelySupportsReasoning
 };

package/dist/prompt/index.d.ts

@@ -1,11 +1,15 @@
-import { c as ModelFamily, E as EnvironmentInfo, I as InstructionFile } from '../runner-C7aMP_x3.js';
-export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-C7aMP_x3.js';
+import { c as ModelFamily, l as EnvironmentInfo, I as InstructionFile } from '../runner-DSKaEz3z.js';
+export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-DSKaEz3z.js';
 import { LanguageModel } from 'ai';
-export { P as PromptBuilder, c as createPromptBuilder } from '../builder-RcTZuYnO.js';
-export { d as SkillConfig } from '../tool-pFAnJc5Y.js';
+export { P as PromptBuilder, c as createPromptBuilder } from '../builder-BRvqCcIk.js';
+export { d as SkillConfig } from '../tool-Db1Ue-1U.js';
+import '@ai-sdk/provider-utils';
 import '../messages-BYWGn8TY.js';
-import '../tool-DYp6-cC3.js';
-import '../registry-CuRWWtcT.js';
+import '../types-9jGQUjqW.js';
+import '../tool-HUtkiVBx.js';
+import '../types-CHiPh8U2.js';
+import '../types-CQaXbRsS.js';
+import '../registry-BDLIHOQB.js';
 import 'zod';
 
 /**

package/dist/reasoning/index.d.ts

@@ -1,10 +1,9 @@
-import { R as ReasoningLevel } from '../types-CQaXbRsS.js';
-export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, a as ReasoningConfig, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
-import { P as ProviderCompatibility } from '../resolver-DOfZ-xuk.js';
-export { e as extractModelId, a as extractProvider } from '../resolver-DOfZ-xuk.js';
-export { b as buildReasoningOptions, a as buildReasoningOptionsSync, g as getReasoningConfig, c as getReasoningConfigSync, s as supportsReasoning, d as supportsReasoningSync } from '../config-D2xeGEHK.js';
-import 'ai';
-import '@ai-sdk/provider-utils';
+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 '../capability-resolver-CgRGsWVX.js';
+export { f as extractModelId, g as extractProvider } from '../capability-resolver-CgRGsWVX.js';
+import { LanguageModel } from 'ai';
+import { ProviderOptions } from '@ai-sdk/provider-utils';
 
 /**
  * Provider-Specific Reasoning Option Builders
@@ -68,4 +67,51 @@ declare function buildOpenRouterOptions(level: ReasoningLevel): Record<string, u
  */
 declare function getProviderOptionsKey(provider: string): string;
 
-export { ReasoningLevel, buildAnthropicOptions, buildBedrockOptions, buildGoogleOptions, buildGroqOptions, buildOpenAIOptions, buildOpenRouterOptions, buildXAIOptions, getProviderOptionsKey };
+/**
+ * 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/reasoning/index.js

@@ -17,12 +17,11 @@ import {
   shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "../chunk-X635CM2F.js";
+} from "../chunk-ZPMACVZK.js";
 import {
   extractModelId,
   extractProvider
-} from "../chunk-QWFMX226.js";
-import "../chunk-DWYX7ASF.js";
+} from "../chunk-QGOGIP7T.js";
 export {
   EXTENDED_LEVELS,
   FIXED_LEVELS,

package/dist/{registry-CuRWWtcT.d.ts → registry-BDLIHOQB.d.ts}

@@ -1,4 +1,4 @@
-import { S as SkillDiscoveryResult, a as SkillMetadata, b as SkillContent, c as SkillResource, d as SkillConfig } from './tool-pFAnJc5Y.js';
+import { S as SkillDiscoveryResult, a as SkillMetadata, b as SkillContent, c as SkillResource, d as SkillConfig } from './tool-Db1Ue-1U.js';
 
 /**
  * Skill Registry — in-memory store for discovered skills