@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/types-QKHHQLLq.d.ts

@@ -0,0 +1,336 @@
+import { LanguageModel, TelemetrySettings, ModelMessage, ToolSet } from 'ai';
+import { T as Tool } from './tool-BHbyUAy3.js';
+import { T as ToolHost } from './types-CHiPh8U2.js';
+import { d as StreamProvider, M as MiddlewareRunner } from './runner-e2YRcUoX.js';
+import { g as InterventionController, T as ToolExecutionMode, I as InferenceStreamInput } from './types-KKDrdU9Y.js';
+import { R as ReasoningLevel } from './types-CQaXbRsS.js';
+import { N as NormalizedToolReplayPolicy, d as TurnTrackerContext } from './tool-DLXAR9Ce.js';
+import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
+import { S as StepProcessingResult, A as AgentEvent, b as AgentTurnBoundaryKind } from './events-CE72w8W4.js';
+
+/**
+ * Doom-loop handling contracts for repeated tool invocations.
+ */
+/**
+ * Response from a doom-loop handler.
+ */
+type DoomLoopAction = "allow" | "deny" | "remember";
+/**
+ * Doom-loop detection request.
+ */
+interface DoomLoopRequest {
+    /** The tool being called repeatedly */
+    tool: string;
+    /** How many times it has been called with the same input */
+    repeatCount: number;
+    /** The repeated input */
+    input: unknown;
+    /** Session ID */
+    sessionId: string;
+}
+/**
+ * Handler for doom-loop situations.
+ */
+type DoomLoopHandler = (request: DoomLoopRequest) => Promise<DoomLoopAction>;
+
+/**
+ * Options for processing a streamed model result.
+ */
+interface StepProcessingOptions {
+    /** Session ID (optional - for tracking purposes) */
+    sessionID?: string;
+    /** Abort signal */
+    abort: AbortSignal;
+    /** Event callback */
+    onEvent: (event: AgentEvent) => void | Promise<void>;
+    /** Doom loop threshold (default: 3) */
+    doomLoopThreshold?: number;
+    /** Enforce doom loop (throw error vs warn) when no handler is provided */
+    enforceDoomLoop?: boolean;
+    /**
+     * Handler for doom loop detection.
+     * Allows user choice: allow, deny, or remember.
+     */
+    onDoomLoop?: DoomLoopHandler;
+    /** Tools that are "remembered" (allowed without asking) */
+    rememberedDoomLoopTools?: Set<string>;
+    /** Token limit for context overflow detection */
+    contextTokenLimit?: number;
+    /** Callback for context overflow */
+    onContextOverflow?: (tokens: number, limit: number) => void | Promise<void>;
+    /** Current step number */
+    currentStep?: number;
+    /** Max steps */
+    maxSteps?: number;
+}
+/**
+ * Result of stream processing.
+ */
+interface StepProcessingOutput {
+    /** Processing result */
+    result: StepProcessingResult;
+    /** Accumulated text */
+    text: string;
+    /** Tool results */
+    toolResults: Array<{
+        toolName: string;
+        toolCallId: string;
+        result: unknown;
+    }>;
+    /** Final usage */
+    usage?: TokenUsage;
+    /** Finish reason reported by the most recent completed step */
+    finishReason?: string;
+    /** Error if any */
+    error?: Error;
+}
+/**
+ * @deprecated Use `StepProcessingOptions`.
+ */
+type ProcessorOptions = StepProcessingOptions;
+/**
+ * @deprecated Use `StepProcessingOutput`.
+ */
+type ProcessorOutput = StepProcessingOutput;
+
+interface AgentTurnEngineOptions {
+    sessionId: string;
+    startedAt: string;
+    getToolReplayPolicy?: (toolName: string) => NormalizedToolReplayPolicy | undefined;
+}
+interface AgentTurnBoundaryMetadata {
+    step?: number;
+    messageRole?: Message["role"];
+    pendingToolCallCount?: number;
+}
+interface AgentTurnStepCommitToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+interface AgentTurnStepCommitToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+interface AgentTurnStepCommitSnapshot {
+    toolCalls: AgentTurnStepCommitToolCall[];
+    toolResults: AgentTurnStepCommitToolResult[];
+}
+interface CreateAgentTurnStepCommitBatchOptions {
+    assistantMessageId?: string;
+    toolMessageIds?: Record<string, string>;
+    createdAt?: Date;
+}
+interface AgentTurnCommitBatch {
+    startBoundary: AgentEvent & {
+        type: "turn-boundary";
+    };
+    finishBoundary: AgentEvent & {
+        type: "turn-boundary";
+    };
+    messages: Message[];
+}
+interface AgentTurnOutputCommitOptions {
+    text: string;
+    usage?: TokenUsage;
+    createdAt?: Date;
+    id?: string;
+}
+type AgentTurnBoundaryEvent = AgentEvent & {
+    type: "turn-boundary";
+};
+
+type AgentTurnPhase = "initializing" | "committing-input" | "running-model" | "running-tools" | "committing-step" | "committing-output" | "completed" | "failed";
+interface AgentTurnBoundarySnapshot {
+    kind: AgentTurnBoundaryKind;
+    createdAt: string;
+    step?: number;
+    messageRole?: "system" | "user" | "assistant" | "tool";
+    pendingToolCallCount?: number;
+}
+interface AgentTurnActiveToolCall {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    startedAt: string;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+interface AgentTurnResolvedToolCall {
+    toolCallId: string;
+    toolName: string;
+    outcome: "result" | "error";
+    value: unknown;
+    resolvedAt: string;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+/**
+ * Neutral state model for a single in-flight agent turn.
+ *
+ * This is intentionally infrastructure-agnostic. Runtime adapters can persist
+ * or inspect it without coupling `agent-core` to Dapr, queues, or workflow
+ * engines. The current shape is suitable for durable tracking and forms the
+ * basis for future workflow-level resume support.
+ */
+interface AgentTurnState {
+    sessionId: string;
+    phase: AgentTurnPhase;
+    step: number;
+    maxSteps?: number;
+    response: string;
+    usage: TokenUsage;
+    eventCount: number;
+    activeToolCalls: AgentTurnActiveToolCall[];
+    resolvedToolCalls: AgentTurnResolvedToolCall[];
+    lastFinishReason?: string;
+    lastBoundary?: AgentTurnBoundarySnapshot;
+    lastEvent?: AgentEvent;
+    error?: string;
+    startedAt: string;
+    updatedAt: string;
+}
+interface CreateAgentTurnStateOptions {
+    sessionId: string;
+    startedAt: string;
+}
+interface AgentTurnStateAdvanceOptions {
+    toolReplayPolicy?: NormalizedToolReplayPolicy;
+}
+/**
+ * Create the initial neutral state for a single agent turn.
+ */
+declare function createAgentTurnState(options: CreateAgentTurnStateOptions): AgentTurnState;
+/**
+ * Advance neutral turn state from a streamed `AgentEvent`.
+ *
+ * This reducer deliberately models coarse but deterministic boundaries:
+ * step start, tool activity, step finish, completion, and failure. Runtime
+ * adapters can persist the resulting state now, and future resume-capable
+ * engines can build on the same state transitions.
+ */
+declare function advanceAgentTurnState(state: AgentTurnState, event: AgentEvent, updatedAt: string, options?: AgentTurnStateAdvanceOptions): AgentTurnState;
+/**
+ * Mark the turn as failed when execution aborts without a terminal `error`
+ * event. This covers exceptions thrown by the stream itself or runtime
+ * wrappers around the loop.
+ */
+declare function failAgentTurnState(state: AgentTurnState, error: Error, updatedAt: string): AgentTurnState;
+
+/**
+ * Neutral internal turn engine for one in-flight agent turn.
+ */
+declare class AgentTurnEngine {
+    private turnState;
+    private readonly pendingToolCalls;
+    private readonly pendingToolResults;
+    private readonly getToolReplayPolicy?;
+    constructor(options: AgentTurnEngineOptions);
+    getState(): AgentTurnState;
+    hasPendingToolCalls(): boolean;
+    createStepCommitSnapshot(): AgentTurnStepCommitSnapshot | undefined;
+    recordEvent(event: AgentEvent, updatedAt: string): AgentTurnState;
+    createBoundaryEvent(boundary: AgentTurnBoundaryKind, metadata?: AgentTurnBoundaryMetadata): AgentTurnBoundaryEvent;
+    createInputCommit(options: {
+        content: string;
+        system?: string;
+        createdAt?: Date;
+        id?: string;
+    }): AgentTurnCommitBatch;
+    createInterventionCommit(options: {
+        id: string;
+        content: string;
+        createdAt?: Date;
+    }): AgentTurnCommitBatch;
+    consumeStepCommit(step: number): AgentTurnCommitBatch | undefined;
+    createOutputCommit(options: AgentTurnOutputCommitOptions): AgentTurnCommitBatch | undefined;
+}
+declare function createAgentTurnEngine(options: AgentTurnEngineOptions): AgentTurnEngine;
+
+interface AgentTurnCommitOptions {
+    emitMessages?: boolean;
+}
+type AgentTurnCommitApplier = (batch: AgentTurnCommitBatch, options?: AgentTurnCommitOptions) => AsyncGenerator<AgentEvent>;
+interface AgentTurnStepRuntimeConfig {
+    model: LanguageModel;
+    cwd: string;
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+    maxSteps: number;
+    doomLoopThreshold?: number;
+    enforceDoomLoop?: boolean;
+    onDoomLoop?: DoomLoopHandler;
+    contextWindow?: number;
+    streamProvider?: StreamProvider;
+    telemetry?: TelemetrySettings;
+}
+interface PrepareModelStepOptions {
+    sessionId: string;
+    step: number;
+    systemPrompts: string[];
+    messages: Message[];
+    toModelMessages: (messages: Message[]) => ModelMessage[];
+    abort: AbortSignal;
+    tools: Record<string, Tool.Info>;
+    mcpTools?: ToolSet;
+    config: AgentTurnStepRuntimeConfig;
+    host?: ToolHost;
+    turnTracker?: TurnTrackerContext;
+    intervention?: InterventionController;
+    middleware?: MiddlewareRunner;
+    reasoningLevel?: ReasoningLevel;
+    toolExecutionMode?: ToolExecutionMode;
+}
+interface PreparedAgentModelStep {
+    step: number;
+    messages: Message[];
+    modelMessages: ModelMessage[];
+    inferenceInput: InferenceStreamInput;
+    stepProcessing: {
+        maxSteps: number;
+        doomLoopThreshold?: number;
+        enforceDoomLoop?: boolean;
+        onDoomLoop?: DoomLoopHandler;
+        contextTokenLimit?: number;
+    };
+}
+interface RunModelStepOptions {
+    preparedStep: PreparedAgentModelStep;
+    turnEngine: AgentTurnEngine;
+    applyCommitBatch: AgentTurnCommitApplier;
+    rememberedDoomLoopTools?: Set<string>;
+}
+interface CommitStepOptions {
+    step: number;
+    finishReason?: string;
+    turnEngine: AgentTurnEngine;
+    applyCommitBatch: AgentTurnCommitApplier;
+}
+interface CommitOutputOptions {
+    text: string;
+    usage?: StepProcessingOutput["usage"];
+    turnEngine: AgentTurnEngine;
+    applyCommitBatch: AgentTurnCommitApplier;
+}
+interface RunToolBatchOptions {
+    sessionId: string;
+    snapshot: AgentTurnStepCommitSnapshot;
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    abort: AbortSignal;
+    host?: ToolHost;
+    turnTracker?: TurnTrackerContext;
+    middleware?: MiddlewareRunner;
+    turnState?: AgentTurnState;
+}
+interface RunToolBatchResult {
+    snapshot: AgentTurnStepCommitSnapshot;
+    turnState?: AgentTurnState;
+    events: Array<Extract<AgentEvent, {
+        type: "tool-result" | "tool-error";
+    }>>;
+}
+
+export { type AgentTurnActiveToolCall as A, advanceAgentTurnState as B, type CommitOutputOptions as C, type DoomLoopAction as D, createAgentTurnEngine as E, createAgentTurnState as F, failAgentTurnState as G, type PrepareModelStepOptions as P, type RunModelStepOptions as R, type StepProcessingOptions as S, type AgentTurnBoundaryMetadata as a, type AgentTurnBoundarySnapshot as b, type AgentTurnCommitApplier as c, type AgentTurnCommitBatch as d, type AgentTurnCommitOptions as e, AgentTurnEngine as f, type AgentTurnEngineOptions as g, type AgentTurnPhase as h, type AgentTurnResolvedToolCall as i, type AgentTurnState as j, type AgentTurnStateAdvanceOptions as k, type AgentTurnStepCommitSnapshot as l, type AgentTurnStepCommitToolCall as m, type AgentTurnStepCommitToolResult as n, type AgentTurnStepRuntimeConfig as o, type CommitStepOptions as p, type CreateAgentTurnStateOptions as q, type CreateAgentTurnStepCommitBatchOptions as r, type DoomLoopHandler as s, type DoomLoopRequest as t, type PreparedAgentModelStep as u, type ProcessorOptions as v, type ProcessorOutput as w, type RunToolBatchOptions as x, type RunToolBatchResult as y, type StepProcessingOutput as z };

package/dist/types-YuWV4ag7.d.ts

@@ -0,0 +1,72 @@
+import { A as AgentEvent } from './events-CE72w8W4.js';
+
+/**
+ * Agent Signal — typed event dispatch interface.
+ *
+ * Defines how consumers subscribe to {@link AgentEvent}s without being
+ * part of the middleware stack.  Each Agent owns a signal; events are
+ * scoped to that agent instance.
+ *
+ * The default implementation (`LocalSignal`) dispatches in-process via
+ * plain function calls.  A distributed runtime can supply its own
+ * implementation that bridges to external infrastructure.
+ */
+
+/**
+ * Extract a single variant from the AgentEvent union by its `type` tag.
+ */
+type EventOf<T extends AgentEvent["type"]> = Extract<AgentEvent, {
+    type: T;
+}>;
+/** Handler for a specific event type. */
+type TypedHandler<T extends AgentEvent["type"]> = (event: EventOf<T>) => void;
+/** Handler that receives every event regardless of type. */
+type WildcardHandler = (event: AgentEvent) => void;
+/** Call to remove a previously registered handler. */
+type Unsubscribe = () => void;
+/**
+ * Typed, multi-consumer event dispatch.
+ *
+ * Subscribe to agent events from anywhere — SSE routes, TUI renderers,
+ * plugins, tests.  The interface is deliberately minimal so that backend
+ * implementations (in-process, Dapr, Redis, …) have a small contract to
+ * fulfil.
+ *
+ * @example
+ * ```ts
+ * // Subscribe to a specific event
+ * const off = agent.signal.on("text-delta", (e) => process.stdout.write(e.text));
+ *
+ * // Subscribe to everything
+ * const off2 = agent.signal.onAny((e) => logger.info(e.type));
+ *
+ * // Clean up
+ * off();
+ * off2();
+ * ```
+ */
+interface AgentSignal {
+    /**
+     * Subscribe to a specific event type.
+     *
+     * @returns An unsubscribe function.
+     */
+    on<T extends AgentEvent["type"]>(type: T, handler: TypedHandler<T>): Unsubscribe;
+    /**
+     * Subscribe to all events.
+     *
+     * @returns An unsubscribe function.
+     */
+    onAny(handler: WildcardHandler): Unsubscribe;
+    /**
+     * Dispatch an event to every matching handler.
+     *
+     * Called internally by the Agent — but nothing prevents external code
+     * from injecting a synthetic event (useful for testing or bridging).
+     */
+    emit(event: AgentEvent): void;
+    /** Remove all handlers.  Called during agent disposal. */
+    clear(): void;
+}
+
+export type { AgentSignal as A, EventOf as E, TypedHandler as T, Unsubscribe as U, WildcardHandler as W };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/agent-core",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Embeddable AI agent infrastructure — execution, sessions, tools, skills, sub-agents, tracing",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,6 +21,11 @@
       "import": "./dist/runtime/index.js",
       "default": "./dist/runtime/index.js"
     },
+    "./inference": {
+      "types": "./dist/inference/index.d.ts",
+      "import": "./dist/inference/index.js",
+      "default": "./dist/inference/index.js"
+    },
     "./tracking": {
       "types": "./dist/tracking/index.d.ts",
       "import": "./dist/tracking/index.js",
@@ -61,11 +66,6 @@
       "import": "./dist/reasoning/index.js",
       "default": "./dist/reasoning/index.js"
     },
-    "./capabilities": {
-      "types": "./dist/capabilities/index.d.ts",
-      "import": "./dist/capabilities/index.js",
-      "default": "./dist/capabilities/index.js"
-    },
     "./models": {
       "types": "./dist/models/index.d.ts",
       "import": "./dist/models/index.js",
@@ -75,6 +75,36 @@
       "types": "./dist/mcp/index.d.ts",
       "import": "./dist/mcp/index.js",
       "default": "./dist/mcp/index.js"
+    },
+    "./host": {
+      "types": "./dist/host/index.d.ts",
+      "import": "./dist/host/index.js",
+      "default": "./dist/host/index.js"
+    },
+    "./scope": {
+      "types": "./dist/scope/index.d.ts",
+      "import": "./dist/scope/index.js",
+      "default": "./dist/scope/index.js"
+    },
+    "./signal": {
+      "types": "./dist/signal/index.d.ts",
+      "import": "./dist/signal/index.js",
+      "default": "./dist/signal/index.js"
+    },
+    "./errors": {
+      "types": "./dist/errors/index.d.ts",
+      "import": "./dist/errors/index.js",
+      "default": "./dist/errors/index.js"
+    },
+    "./presets": {
+      "types": "./dist/presets/index.d.ts",
+      "import": "./dist/presets/index.js",
+      "default": "./dist/presets/index.js"
+    },
+    "./safety": {
+      "types": "./dist/safety/index.d.ts",
+      "import": "./dist/safety/index.js",
+      "default": "./dist/safety/index.js"
     }
   },
   "files": [
@@ -87,12 +117,19 @@
     "zod": "^3.25.76 || ^4.1.8"
   },
   "peerDependencies": {
+    "@ai-sdk/amazon-bedrock": "^4.0.0",
     "@ai-sdk/anthropic": "^3.0.0",
+    "@ai-sdk/azure": "^3.0.0",
     "@ai-sdk/google": "^3.0.0",
+    "@ai-sdk/google-vertex": "^4.0.0",
+    "@ai-sdk/groq": "^3.0.0",
     "@ai-sdk/mcp": "^1.0.0",
+    "@ai-sdk/mistral": "^3.0.0",
     "@ai-sdk/openai": "^3.0.0",
     "@ai-sdk/openai-compatible": "^2.0.0",
+    "@ai-sdk/xai": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "@openrouter/ai-sdk-provider": "^1.0.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/resources": "^2.0.0",
     "@opentelemetry/sdk-trace-node": "^2.0.0",
@@ -100,9 +137,15 @@
     "dockerode": "^4.0.9"
   },
   "peerDependenciesMeta": {
+    "@ai-sdk/amazon-bedrock": {
+      "optional": true
+    },
     "@ai-sdk/anthropic": {
       "optional": true
     },
+    "@ai-sdk/azure": {
+      "optional": true
+    },
     "@ai-sdk/openai": {
       "optional": true
     },
@@ -112,12 +155,27 @@
     "@ai-sdk/google": {
       "optional": true
     },
+    "@ai-sdk/google-vertex": {
+      "optional": true
+    },
+    "@ai-sdk/groq": {
+      "optional": true
+    },
     "@ai-sdk/mcp": {
       "optional": true
     },
+    "@ai-sdk/mistral": {
+      "optional": true
+    },
+    "@ai-sdk/xai": {
+      "optional": true
+    },
     "@modelcontextprotocol/sdk": {
       "optional": true
     },
+    "@openrouter/ai-sdk-provider": {
+      "optional": true
+    },
     "dockerode": {
       "optional": true
     },
@@ -135,14 +193,21 @@
     }
   },
   "devDependencies": {
+    "@ai-sdk/amazon-bedrock": "^4.0.77",
     "@ai-sdk/anthropic": "^3.0.35",
+    "@ai-sdk/azure": "^3.0.42",
     "@ai-sdk/google": "^3.0.30",
+    "@ai-sdk/google-vertex": "^4.0.80",
+    "@ai-sdk/groq": "^3.0.29",
     "@ai-sdk/mcp": "^1.0.19",
+    "@ai-sdk/mistral": "^3.0.24",
     "@ai-sdk/openai": "^3.0.25",
     "@ai-sdk/openai-compatible": "^2.0.30",
     "@ai-sdk/provider-utils": "^4.0.15",
+    "@ai-sdk/xai": "^3.0.67",
     "@arizeai/openinference-vercel": "^2.7.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@openrouter/ai-sdk-provider": "^1.0.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.213.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
@@ -179,10 +244,11 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/tool/index.ts src/runtime/index.ts src/tracking/index.ts src/middleware/index.ts src/prompt/index.ts src/skill/index.ts src/sub-agent/index.ts src/storage/index.ts src/context/index.ts src/reasoning/index.ts src/capabilities/index.ts src/models/index.ts src/mcp/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/tool/index.ts src/runtime/index.ts src/tracking/index.ts src/middleware/index.ts src/prompt/index.ts src/skill/index.ts src/sub-agent/index.ts src/storage/index.ts src/context/index.ts src/reasoning/index.ts src/capabilities/index.ts src/models/index.ts src/mcp/index.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/tool/index.ts src/runtime/index.ts src/inference/index.ts src/tracking/index.ts src/middleware/index.ts src/prompt/index.ts src/skill/index.ts src/sub-agent/index.ts src/storage/index.ts src/context/index.ts src/reasoning/index.ts src/models/index.ts src/mcp/index.ts src/host/index.ts src/scope/index.ts src/signal/index.ts src/errors/index.ts src/presets/index.ts src/safety/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/tool/index.ts src/runtime/index.ts src/inference/index.ts src/tracking/index.ts src/middleware/index.ts src/prompt/index.ts src/skill/index.ts src/sub-agent/index.ts src/storage/index.ts src/context/index.ts src/reasoning/index.ts src/models/index.ts src/mcp/index.ts src/host/index.ts src/scope/index.ts src/signal/index.ts src/errors/index.ts src/presets/index.ts src/safety/index.ts --format esm --dts --watch",
     "test": "vitest run",
     "test:watch": "vitest",
+    "lint": "eslint src/",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

package/dist/capabilities/index.d.ts

@@ -1,97 +0,0 @@
-import { C as CapabilitySource, S as SourcePriority, b as SourceResult, P as ProviderCompatibility, R as ResolverOptions, M as ModelEntry, c as ModelCapabilities } from '../resolver-DOfZ-xuk.js';
-export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, d as ModelCapabilityResolver, N as NetworkStatus, O as OutputModality, f as ResolutionResult, g as configureResolver, e as extractModelId, a as extractProvider, h as getDefaultResolver } from '../resolver-DOfZ-xuk.js';
-export { g as getModelId, a as getProviderId } from '../identifiers-BLUxFqV_.js';
-export { g as getNetworkStatus } from '../network-D76DS5ot.js';
-import 'ai';
-
-/**
- * Pattern-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 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 { CacheCapabilitySource, CapabilityCache, type CapabilityOverrides, CapabilitySource, ModelCapabilities, ModelEntry, PatternCapabilitySource, ProviderCompatibility, RemoteCapabilityFetcher, RemoteCapabilitySource, ResolverOptions, SourcePriority, SourceResult, applyCapabilityOverride, findCapabilityOverride, getProviderCompatibility, inferProvider, likelySupportsReasoning };