hyacinth-ai 0.9.6

package/dist/provider/config.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('provider-config');
+export const DEFAULT_PROVIDERS = {
+    providers: {
+        anthropic: {
+            id: 'anthropic',
+            name: 'Anthropic',
+            baseUrl: 'https://api.anthropic.com',
+            defaultModel: 'claude-sonnet-4-20250514',
+            envKey: 'ANTHROPIC_API_KEY',
+        },
+        openai: {
+            id: 'openai',
+            name: 'OpenAI',
+            baseUrl: 'https://api.openai.com/v1',
+            defaultModel: 'gpt-4o',
+            envKey: 'OPENAI_API_KEY',
+        },
+        deepseek: {
+            id: 'deepseek',
+            name: 'DeepSeek',
+            baseUrl: 'https://api.deepseek.com/v1',
+            defaultModel: 'deepseek-v4-flash',
+            envKey: 'DEEPSEEK_API_KEY',
+        },
+        groq: {
+            id: 'groq',
+            name: 'Groq',
+            baseUrl: 'https://api.groq.com/openai/v1',
+            defaultModel: 'llama-3.3-70b-versatile',
+            envKey: 'GROQ_API_KEY',
+        },
+        xai: {
+            id: 'xai',
+            name: 'xAI',
+            baseUrl: 'https://api.x.ai/v1',
+            defaultModel: 'grok-2',
+            envKey: 'XAI_API_KEY',
+        },
+        mistral: {
+            id: 'mistral',
+            name: 'Mistral',
+            baseUrl: 'https://api.mistral.ai/v1',
+            defaultModel: 'mistral-large-latest',
+            envKey: 'MISTRAL_API_KEY',
+        },
+        gemini: {
+            id: 'gemini',
+            name: 'Google Gemini',
+            baseUrl: 'https://generativelanguage.googleapis.com',
+            defaultModel: 'gemini-2.5-flash',
+            envKey: 'GEMINI_API_KEY',
+        },
+        openrouter: {
+            id: 'openrouter',
+            name: 'OpenRouter',
+            baseUrl: 'https://openrouter.ai/api/v1',
+            defaultModel: 'openrouter/auto',
+            envKey: 'OPENROUTER_API_KEY',
+        },
+        moonshot: {
+            id: 'moonshot',
+            name: 'Moonshot',
+            baseUrl: 'https://api.moonshot.cn/v1',
+            defaultModel: 'moonshot-v1-128k',
+            envKey: 'MOONSHOT_API_KEY',
+        },
+        qwen: {
+            id: 'qwen',
+            name: 'Qwen (阿里百炼)',
+            baseUrl: 'https://dashscope.aliyuncs.com/apps/anthropic',
+            defaultModel: 'qwen3-vl-plus',
+            envKey: 'DASHSCOPE_API_KEY',
+        },
+        zhipu: {
+            id: 'zhipu',
+            name: 'Zhipu (智谱)',
+            baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+            defaultModel: 'glm-4.6v',
+            envKey: 'ZHIPU_API_KEY',
+        },
+        minimax: {
+            id: 'minimax',
+            name: 'MiniMax',
+            baseUrl: 'https://api.minimaxi.com/anthropic',
+            defaultModel: 'MiniMax-M3',
+            envKey: 'MINIMAX_API_KEY',
+        },
+        mimo: {
+            id: 'mimo',
+            name: 'MiMo (小米)',
+            baseUrl: 'https://api.xiaomimimo.com/anthropic',
+            defaultModel: 'mimo-v2.5',
+            envKey: 'MIMO_API_KEY',
+        },
+    },
+};
+export class ProviderConfigLoader {
+    configPath;
+    cache = DEFAULT_PROVIDERS;
+    constructor(cwd) {
+        this.configPath = path.join(os.homedir(), '.agent', 'providers.json');
+    }
+    async load() {
+        try {
+            const content = await fs.readFile(this.configPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            this.cache = parsed;
+            logger.info('Provider config loaded', { path: this.configPath });
+            return parsed;
+        }
+        catch {
+            logger.info('Provider config not found, generating default', { path: this.configPath });
+            await this.writeDefault();
+            this.cache = { ...DEFAULT_PROVIDERS };
+            return this.cache;
+        }
+    }
+    getProvider(id) {
+        return this.cache.providers[id] ?? DEFAULT_PROVIDERS.providers[id];
+    }
+    getAll() {
+        return Object.values(this.cache.providers);
+    }
+    async reload() {
+        try {
+            const content = await fs.readFile(this.configPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            this.cache = parsed;
+            logger.info('Provider config reloaded', { path: this.configPath });
+            return parsed;
+        }
+        catch {
+            logger.warn('Provider config reload failed, using cache', { path: this.configPath });
+            return this.cache;
+        }
+    }
+    async writeDefault() {
+        const dir = path.dirname(this.configPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(this.configPath, JSON.stringify(DEFAULT_PROVIDERS, null, 2), 'utf-8');
+        logger.info('Default provider config written', { path: this.configPath });
+    }
+}
+let singleton;
+export function getProviderConfigLoader(cwd) {
+    if (!singleton && cwd) {
+        singleton = new ProviderConfigLoader(cwd);
+    }
+    if (!singleton) {
+        throw new Error('ProviderConfigLoader not initialized. Call getProviderConfigLoader(cwd) first.');
+    }
+    return singleton;
+}
+//# sourceMappingURL=config.js.map

package/dist/provider/deepseek.d.ts

@@ -0,0 +1,25 @@
+import { OpenAICompatibleProvider } from './compatible.js';
+import type { ProviderConfig } from '../types.js';
+/**
+ * DeepSeek Provider — 基于 OpenAI 兼容 API。
+ *
+ * DeepSeek 的 API 使用 OpenAI Chat Completions 兼容格式。
+ * Endpoint: https://api.deepseek.com/v1
+ *
+ * 支持模型：
+ *   - deepseek-v4-flash (V4 快速，1M上下文，推荐)
+ *   - deepseek-v4-pro (V4 Pro，1M上下文)
+ *   - deepseek-chat (即将退役，路由到 V4 Flash)
+ *   - deepseek-reasoner (即将退役，路由到 V4 Flash 思考模式)
+ */
+export declare function createDeepSeekProvider(config?: {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+    maxOutputTokens?: number;
+    /** DeepSeek KVCache 隔离 ID。不同角色应使用不同的 userId。 */
+    userId?: string;
+}): OpenAICompatibleProvider;
+/** 从 ProviderConfig 创建 */
+export declare function createDeepSeekFromConfig(config: ProviderConfig): OpenAICompatibleProvider;
+//# sourceMappingURL=deepseek.d.ts.map

package/dist/provider/deepseek.js

@@ -0,0 +1,37 @@
+import { OpenAICompatibleProvider } from './compatible.js';
+import { getProviderConfigLoader } from './config.js';
+/**
+ * DeepSeek Provider — 基于 OpenAI 兼容 API。
+ *
+ * DeepSeek 的 API 使用 OpenAI Chat Completions 兼容格式。
+ * Endpoint: https://api.deepseek.com/v1
+ *
+ * 支持模型：
+ *   - deepseek-v4-flash (V4 快速，1M上下文，推荐)
+ *   - deepseek-v4-pro (V4 Pro，1M上下文)
+ *   - deepseek-chat (即将退役，路由到 V4 Flash)
+ *   - deepseek-reasoner (即将退役，路由到 V4 Flash 思考模式)
+ */
+export function createDeepSeekProvider(config) {
+    const provCfg = getProviderConfigLoader().getProvider('deepseek');
+    return new OpenAICompatibleProvider({
+        apiKey: config?.apiKey,
+        envKey: 'DEEPSEEK_API_KEY',
+        baseUrl: config?.baseUrl ?? provCfg?.baseUrl ?? 'https://api.deepseek.com/v1',
+        model: (config?.model && config.model.trim()) ? config.model : (provCfg?.defaultModel ?? 'unknown'),
+        providerType: 'deepseek',
+        maxOutputTokens: config?.maxOutputTokens,
+        userId: config?.userId,
+    });
+}
+/** 从 ProviderConfig 创建 */
+export function createDeepSeekFromConfig(config) {
+    return createDeepSeekProvider({
+        apiKey: config.apiKey,
+        model: config.model,
+        baseUrl: config.baseUrl,
+        maxOutputTokens: config.maxOutputTokens,
+        userId: config.userId,
+    });
+}
+//# sourceMappingURL=deepseek.js.map

package/dist/provider/fallback.d.ts

@@ -0,0 +1,51 @@
+/**
+ * FallbackProviderChain — tries a list of providers in order.
+ *
+ * Each provider in the chain gets its own ResilientProvider wrapper for
+ * individual retry + circuit breaker, then the chain tries them
+ * sequentially until one succeeds.
+ *
+ * Example config:
+ *   primary: anthropic/claude-sonnet-4-20250514
+ *   fallback: [openai/gpt-4o, deepseek/deepseek-v4-flash]
+ */
+import type { Provider } from './interface.js';
+import type { Message, StreamEvent, ToolDefinition, ProviderType } from '../types.js';
+import { ResilientProvider } from './resilient.js';
+import type { RetryConfig, CircuitBreakerConfig } from './resilient.js';
+export interface FallbackChainConfig {
+    /** Providers in order: [0]=primary, [1..]=fallbacks */
+    providers: Provider[];
+    /** Retry config applied to each provider in the chain */
+    retry?: Partial<RetryConfig>;
+    /** Circuit breaker config applied to each provider in the chain */
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
+    /** Called when fallback from one provider to the next occurs */
+    onFallback?: (from: Provider, to: Provider, error: Error) => void;
+}
+export declare class FallbackProviderChain implements Provider {
+    private providers;
+    private retryConfig;
+    private cbConfig;
+    private onFallback?;
+    constructor(config: FallbackChainConfig);
+    /** Index of the last successfully used provider in the chain (0 = primary). */
+    private lastSuccessfulIdx;
+    /** Returns true if currently running on a fallback (not the primary). */
+    get isOnFallback(): boolean;
+    /** Get the currently active provider type (may differ from primary on fallback). */
+    getActiveType(): ProviderType;
+    /** Get the currently active model (may differ from primary on fallback). */
+    getActiveModel(): string;
+    getProviderType(): ProviderType;
+    getModel(): string;
+    getCapabilities(): import("./interface.js").ProviderCapabilities;
+    setThinking(enabled: boolean, effort?: string | number): void;
+    setUserId(userId: string): void;
+    /** Return the underlying providers (for inspection) */
+    getChainProviders(): ResilientProvider[];
+    /** Set a fallback callback after construction (e.g. once configCenter is ready). */
+    setOnFallback(cb: (from: Provider, to: Provider, error: Error) => void): void;
+    createStream(messages: Message[], tools?: ToolDefinition[], signal?: AbortSignal): AsyncIterable<StreamEvent>;
+}
+//# sourceMappingURL=fallback.d.ts.map

package/dist/provider/fallback.js

@@ -0,0 +1,113 @@
+/**
+ * FallbackProviderChain — tries a list of providers in order.
+ *
+ * Each provider in the chain gets its own ResilientProvider wrapper for
+ * individual retry + circuit breaker, then the chain tries them
+ * sequentially until one succeeds.
+ *
+ * Example config:
+ *   primary: anthropic/claude-sonnet-4-20250514
+ *   fallback: [openai/gpt-4o, deepseek/deepseek-v4-flash]
+ */
+import { ResilientProvider } from './resilient.js';
+export class FallbackProviderChain {
+    providers;
+    retryConfig;
+    cbConfig;
+    onFallback;
+    constructor(config) {
+        if (config.providers.length === 0) {
+            throw new Error('FallbackProviderChain requires at least one provider');
+        }
+        this.retryConfig = config.retry ?? {};
+        this.cbConfig = config.circuitBreaker ?? {};
+        this.onFallback = config.onFallback;
+        this.providers = config.providers.map((p) => new ResilientProvider(p, this.retryConfig, this.cbConfig));
+    }
+    /** Index of the last successfully used provider in the chain (0 = primary). */
+    lastSuccessfulIdx = 0;
+    /** Returns true if currently running on a fallback (not the primary). */
+    get isOnFallback() {
+        return this.lastSuccessfulIdx > 0;
+    }
+    /** Get the currently active provider type (may differ from primary on fallback). */
+    getActiveType() {
+        return this.providers[this.lastSuccessfulIdx]?.getProviderType() ?? this.providers[0].getProviderType();
+    }
+    /** Get the currently active model (may differ from primary on fallback). */
+    getActiveModel() {
+        return this.providers[this.lastSuccessfulIdx]?.getModel() ?? this.providers[0].getModel();
+    }
+    getProviderType() {
+        return this.providers[this.lastSuccessfulIdx]?.getProviderType()
+            ?? this.providers[0].getProviderType();
+    }
+    getModel() {
+        return this.providers[this.lastSuccessfulIdx]?.getModel()
+            ?? this.providers[0].getModel();
+    }
+    getCapabilities() {
+        return this.providers[this.lastSuccessfulIdx]?.getCapabilities?.()
+            ?? this.providers[0]?.getCapabilities?.()
+            ?? { toolCalling: false, streaming: true, adapterSupport: false, maxContextTokens: 4096, isLocal: false, vision: false };
+    }
+    setThinking(enabled, effort) {
+        for (const p of this.providers) {
+            p.setThinking(enabled, effort);
+        }
+    }
+    setUserId(userId) {
+        for (const p of this.providers) {
+            p.setUserId?.(userId);
+        }
+    }
+    /** Return the underlying providers (for inspection) */
+    getChainProviders() {
+        return this.providers;
+    }
+    /** Set a fallback callback after construction (e.g. once configCenter is ready). */
+    setOnFallback(cb) {
+        this.onFallback = cb;
+    }
+    async *createStream(messages, tools, signal) {
+        const errors = [];
+        for (let i = 0; i < this.providers.length; i++) {
+            const provider = this.providers[i];
+            const label = `${provider.getProviderType()}/${provider.getModel()}`;
+            try {
+                yield* provider.createStream(messages, tools, signal);
+                // Success — track which provider actually worked
+                if (i > 0 && this.lastSuccessfulIdx !== i) {
+                    this.lastSuccessfulIdx = i;
+                }
+                return;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                const msg = err.message;
+                errors.push(`[${label}] ${msg}`);
+                // If last provider failed, throw aggregated error
+                if (i === this.providers.length - 1) {
+                    throw new Error(`All ${this.providers.length} provider(s) failed:\n` +
+                        errors.map((e) => `  ${e}`).join('\n'));
+                }
+                // Strip Anthropic cache_control markers before sending to next provider
+                // (these were applied by composeCore for the primary provider and are
+                // invalid for providers that don't use manual-markers mode)
+                for (const msg of messages) {
+                    const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
+                    for (const block of blocks) {
+                        if ('cache_control' in block) {
+                            delete block.cache_control;
+                        }
+                    }
+                }
+                // Notify callback so the system can adapt (context window, cache strategy, etc.)
+                const nextProvider = this.providers[i + 1];
+                this.onFallback?.(provider, nextProvider, err);
+                continue;
+            }
+        }
+    }
+}
+//# sourceMappingURL=fallback.js.map

package/dist/provider/gemini.d.ts

@@ -0,0 +1,27 @@
+import type { Message, StreamEvent, ProviderType, ToolDefinition } from '../types.js';
+import type { Provider, ProviderCapabilities } from './interface.js';
+export interface GeminiProviderOptions {
+    apiKey?: string;
+    model?: string;
+}
+/**
+ * Gemini Provider — 使用 @google/genai SDK 调用 Google Gemini 模型。
+ */
+export declare class GeminiProvider implements Provider {
+    private client;
+    private model;
+    private maxOutputTokens;
+    constructor(opts?: GeminiProviderOptions);
+    getProviderType(): ProviderType;
+    getModel(): string;
+    getCapabilities(): ProviderCapabilities;
+    createStream(messages: Message[], tools?: ToolDefinition[], signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private splitMessages;
+    private convertTools;
+}
+/** 便捷工厂 */
+export declare function createGeminiProvider(config?: {
+    apiKey?: string;
+    model?: string;
+}): GeminiProvider;
+//# sourceMappingURL=gemini.d.ts.map

package/dist/provider/gemini.js

@@ -0,0 +1,170 @@
+import { GoogleGenAI } from '@google/genai';
+import { getModelInfo } from './catalog.js';
+/**
+ * Gemini Provider — 使用 @google/genai SDK 调用 Google Gemini 模型。
+ */
+export class GeminiProvider {
+    client;
+    model;
+    maxOutputTokens;
+    constructor(opts = {}) {
+        const apiKey = opts.apiKey ??
+            process.env.GEMINI_API_KEY ??
+            process.env.GOOGLE_API_KEY;
+        if (!apiKey) {
+            throw new Error('Gemini API key is required. Set GEMINI_API_KEY or GOOGLE_API_KEY environment variable.');
+        }
+        this.client = new GoogleGenAI({ apiKey });
+        this.model = opts.model ?? 'gemini-2.5-flash';
+        this.maxOutputTokens = getModelInfo('gemini', this.model)?.maxOutputTokens ?? 8192;
+    }
+    getProviderType() {
+        return 'gemini';
+    }
+    getModel() {
+        return this.model;
+    }
+    getCapabilities() {
+        const info = getModelInfo('gemini', this.model);
+        return {
+            toolCalling: true,
+            streaming: true,
+            adapterSupport: false,
+            maxContextTokens: info?.contextWindow ?? 1048576,
+            isLocal: false,
+            vision: info?.capabilities.vision ?? true, // Gemini models all support vision
+        };
+    }
+    async *createStream(messages, tools, signal) {
+        const { systemInstruction, history, userMessage, userParts } = this.splitMessages(messages);
+        const chat = this.client.chats.create({
+            model: this.model,
+            config: {
+                systemInstruction: systemInstruction
+                    ? { role: 'user', parts: [{ text: systemInstruction }] }
+                    : undefined,
+                tools: tools && tools.length > 0 ? this.convertTools(tools) : undefined,
+                maxOutputTokens: this.maxOutputTokens,
+            },
+            history: history.length > 0 ? history : undefined,
+        });
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const stream = await chat.sendMessageStream({
+                message: (userParts && userParts.length > 0 ? userParts : userMessage || 'Hello'),
+                config: { abortSignal: signal },
+            });
+            for await (const chunk of stream) {
+                const candidate = chunk.candidates?.[0];
+                if (!candidate)
+                    continue;
+                const parts = candidate.content?.parts ?? [];
+                for (const part of parts) {
+                    if (part.text) {
+                        yield { type: 'TEXT', content: part.text };
+                    }
+                    if (part.thought) {
+                        yield { type: 'THINKING', content: String(part.thought) };
+                    }
+                }
+            }
+            yield { type: 'STOP', reason: 'end_turn' };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Gemini API error: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    splitMessages(messages) {
+        const systemParts = [];
+        const history = [];
+        let userMessage = '';
+        let userParts;
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
+            if (msg.role === 'system') {
+                for (const b of blocks) {
+                    if (b.type === 'text')
+                        systemParts.push(b.text);
+                }
+                continue;
+            }
+            if (msg.role === 'assistant') {
+                const parts = [];
+                for (const b of blocks) {
+                    if (b.type === 'text')
+                        parts.push({ text: b.text });
+                    else if (b.type === 'tool_use')
+                        parts.push({ text: `[Tool: ${b.name}]` });
+                }
+                if (parts.length > 0) {
+                    history.push({ role: 'model', parts: parts });
+                }
+                continue;
+            }
+            if (msg.role === 'user') {
+                const textParts = [];
+                const imageParts = [];
+                for (const b of blocks) {
+                    if (b.type === 'text')
+                        textParts.push(b.text);
+                    else if (b.type === 'tool_result')
+                        textParts.push(`[Tool result: ${b.content.substring(0, 200)}]`);
+                    else if (b.type === 'image' && b.source.type === 'base64') {
+                        imageParts.push({ inlineData: { mimeType: b.source.media_type, data: b.source.data } });
+                    }
+                    else if (b.type === 'image' && b.source.type === 'url') {
+                        // Gemini 也支持 fileData 引用远程图片
+                        imageParts.push({ inlineData: { mimeType: 'image/unknown', data: b.source.url } });
+                    }
+                }
+                const isLast = i === messages.length - 1;
+                if (isLast && imageParts.length > 0) {
+                    userParts = [
+                        ...(textParts.length > 0 ? [{ text: textParts.join('\n\n') }] : []),
+                        ...imageParts,
+                    ];
+                    userMessage = textParts.join('\n\n'); // fallback
+                }
+                else if (isLast) {
+                    userMessage = textParts.join('\n\n');
+                }
+                else {
+                    const text = textParts.join('\n\n');
+                    if (text || imageParts.length > 0) {
+                        const hParts = [
+                            ...(text ? [{ text }] : []),
+                            ...imageParts,
+                        ];
+                        history.push({ role: 'user', parts: hParts });
+                    }
+                }
+            }
+        }
+        return {
+            systemInstruction: systemParts.length > 0 ? systemParts.join('\n\n') : undefined,
+            history,
+            userMessage: userMessage || 'Hello',
+            userParts,
+        };
+    }
+    convertTools(tools) {
+        return [
+            {
+                functionDeclarations: tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.input_schema,
+                })),
+            },
+        ];
+    }
+}
+/** 便捷工厂 */
+export function createGeminiProvider(config) {
+    return new GeminiProvider(config);
+}
+//# sourceMappingURL=gemini.js.map

package/dist/provider/index.d.ts

@@ -0,0 +1,36 @@
+export type { Provider, ProviderCapabilities } from './interface.js';
+export { AnthropicProvider, createAnthropicProvider } from './anthropic.js';
+export type { AnthropicProviderOptions } from './anthropic.js';
+export { OpenAIProvider, createOpenAIProvider } from './openai.js';
+export type { OpenAIProviderOptions } from './openai.js';
+export { createDeepSeekProvider, createDeepSeekFromConfig } from './deepseek.js';
+export { LocalProvider, createLocalProvider } from './local.js';
+export type { LocalProviderOptions } from './local.js';
+export { LlamaCppProvider, createLlamaCppProvider } from '../local-model/llamacpp-provider.js';
+export type { LlamaCppOptions } from '../local-model/llamacpp-provider.js';
+export { ProviderRouter } from './router.js';
+export type { AssessmentInput, RoutingInfo } from './router.js';
+export { OpenAICompatibleProvider, createGroqProvider, createXAIProvider, createMistralProvider, createOpenRouterProvider, createMoonshotProvider, } from './compatible.js';
+export type { OpenAICompatibleOptions } from './compatible.js';
+export { GeminiProvider, createGeminiProvider } from './gemini.js';
+export type { GeminiProviderOptions } from './gemini.js';
+export { createQwenProvider, createQwenFromConfig } from './qwen.js';
+export { createZhipuProvider, createZhipuFromConfig } from './zhipu.js';
+export { createMiniMaxProvider, createMiniMaxFromConfig } from './minimax.js';
+export { createMiMoProvider, createMiMoFromConfig } from './mimo.js';
+export { ProviderManager } from './manager.js';
+export type { ProviderManagerOptions } from './manager.js';
+export { ResilientProvider, DEFAULT_CB } from './resilient.js';
+export type { CircuitBreakerConfig } from './resilient.js';
+export { FallbackProviderChain } from './fallback.js';
+export type { FallbackChainConfig } from './fallback.js';
+export { withRetry, isRetryableError, isNonRetryableError, DEFAULT_RETRY_CONFIG } from './retry.js';
+export { ModelCatalog, modelCatalog, getModelInfo } from './catalog.js';
+export type { ModelInfo, ModelCapabilities, ModelCost } from './catalog.js';
+export { ModelCatalogLoader, getModelCatalogLoader } from './model-catalog-loader.js';
+export type { ModelCatalogEntry, ModelsCatalogConfig } from './model-catalog-loader.js';
+export { ModelRouter } from './model-router.js';
+export type { ModelRole, ModelSourceConfig, ModelsConfig, LocalModelConfig } from './model-router.js';
+export { ModelChannelRegistry } from './model-channel-registry.js';
+export type { ChannelConfig, ModelChannelsConfig } from './model-channel-registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/provider/index.js

@@ -0,0 +1,42 @@
+// Provider 模块统一导出
+// Anthropic Provider
+export { AnthropicProvider, createAnthropicProvider } from './anthropic.js';
+// OpenAI Provider
+export { OpenAIProvider, createOpenAIProvider } from './openai.js';
+// DeepSeek Provider (OpenAI 兼容)
+export { createDeepSeekProvider, createDeepSeekFromConfig } from './deepseek.js';
+// Local Provider
+export { LocalProvider, createLocalProvider } from './local.js';
+// LlamaCpp Provider
+export { LlamaCppProvider, createLlamaCppProvider } from '../local-model/llamacpp-provider.js';
+// Provider Router
+export { ProviderRouter } from './router.js';
+// OpenAI-Compatible Providers (Groq, xAI, Mistral, OpenRouter, Moonshot)
+export { OpenAICompatibleProvider, createGroqProvider, createXAIProvider, createMistralProvider, createOpenRouterProvider, createMoonshotProvider, } from './compatible.js';
+// Google Gemini
+export { GeminiProvider, createGeminiProvider } from './gemini.js';
+// Qwen (阿里百炼) — Anthropic 兼容
+export { createQwenProvider, createQwenFromConfig } from './qwen.js';
+// Zhipu (智谱) — OpenAI 兼容
+export { createZhipuProvider, createZhipuFromConfig } from './zhipu.js';
+// MiniMax — Anthropic 兼容
+export { createMiniMaxProvider, createMiniMaxFromConfig } from './minimax.js';
+// MiMo (小米) — Anthropic 兼容
+export { createMiMoProvider, createMiMoFromConfig } from './mimo.js';
+// Provider Manager
+export { ProviderManager } from './manager.js';
+// Resilience (retry + circuit breaker)
+export { ResilientProvider, DEFAULT_CB } from './resilient.js';
+// Fallback chain
+export { FallbackProviderChain } from './fallback.js';
+// Retry utilities
+export { withRetry, isRetryableError, isNonRetryableError, DEFAULT_RETRY_CONFIG } from './retry.js';
+// Model Catalog
+export { ModelCatalog, modelCatalog, getModelInfo } from './catalog.js';
+// Model Catalog Loader
+export { ModelCatalogLoader, getModelCatalogLoader } from './model-catalog-loader.js';
+// Model Router
+export { ModelRouter } from './model-router.js';
+// Model Channel Registry
+export { ModelChannelRegistry } from './model-channel-registry.js';
+//# sourceMappingURL=index.js.map