@astro-minimax/ai 0.7.4 → 0.8.0

package/dist/provider-manager/config.js

@@ -1,134 +0,0 @@
-export const DEFAULT_WORKERS_BINDING_NAME = 'minimaxAI';
-const DEFAULT_WEIGHT = 100;
-const DEFAULT_TIMEOUT = 30000;
-const DEFAULT_MODEL = 'gpt-4o-mini';
-function hasOpenAIConfig(env) {
-    return !!(env.AI_BASE_URL && env.AI_API_KEY);
-}
-function hasWorkersAIBinding(env) {
-    const bindingName = env.AI_BINDING_NAME || DEFAULT_WORKERS_BINDING_NAME;
-    return !!env[bindingName];
-}
-function createOpenAIConfigFromEnv(env) {
-    if (!hasOpenAIConfig(env))
-        return null;
-    return {
-        id: 'openai-default',
-        type: 'openai',
-        weight: DEFAULT_WEIGHT - 10, // Lower priority than Workers AI (fallback)
-        baseURL: env.AI_BASE_URL,
-        apiKey: env.AI_API_KEY,
-        model: env.AI_MODEL || DEFAULT_MODEL,
-        keywordModel: env.AI_KEYWORD_MODEL,
-        evidenceModel: env.AI_EVIDENCE_MODEL,
-        timeout: DEFAULT_TIMEOUT,
-        enabled: true,
-    };
-}
-function createWorkersAIConfigFromEnv(env) {
-    const bindingName = env.AI_BINDING_NAME || DEFAULT_WORKERS_BINDING_NAME;
-    if (!env[bindingName])
-        return null;
-    return {
-        id: 'workers-ai-default',
-        type: 'workers',
-        weight: DEFAULT_WEIGHT,
-        bindingName,
-        model: env.AI_WORKERS_MODEL || '@cf/zai-org/glm-4.7-flash',
-        keywordModel: env.AI_WORKERS_MODEL || undefined,
-        evidenceModel: env.AI_WORKERS_MODEL || undefined,
-        timeout: DEFAULT_TIMEOUT,
-        enabled: true,
-    };
-}
-function parseAIProvidersJSON(jsonString) {
-    try {
-        const configs = JSON.parse(jsonString);
-        if (!Array.isArray(configs))
-            return null;
-        return configs.map((config, index) => {
-            const weight = config.weight ?? DEFAULT_WEIGHT;
-            const timeout = config.timeout ?? DEFAULT_TIMEOUT;
-            const enabled = config.enabled ?? true;
-            if (config.type === 'openai') {
-                return {
-                    ...config,
-                    weight,
-                    timeout,
-                    enabled,
-                    id: config.id || `openai-${index}`,
-                };
-            }
-            if (config.type === 'workers') {
-                return {
-                    ...config,
-                    weight,
-                    timeout,
-                    enabled,
-                    id: config.id || `workers-${index}`,
-                    bindingName: config.bindingName || DEFAULT_WORKERS_BINDING_NAME,
-                };
-            }
-            return null;
-        }).filter((c) => c !== null);
-    }
-    catch {
-        return null;
-    }
-}
-export function parseProviderConfigs(env) {
-    // Priority 1: AI_PROVIDERS JSON string
-    if (env.AI_PROVIDERS) {
-        const configs = parseAIProvidersJSON(env.AI_PROVIDERS);
-        if (configs && configs.length > 0) {
-            return configs;
-        }
-    }
-    // Priority 2: Legacy environment variables
-    const configs = [];
-    const openaiConfig = createOpenAIConfigFromEnv(env);
-    if (openaiConfig) {
-        configs.push(openaiConfig);
-    }
-    const workersConfig = createWorkersAIConfigFromEnv(env);
-    if (workersConfig) {
-        configs.push(workersConfig);
-    }
-    return configs;
-}
-export function validateProviderConfig(config) {
-    if (!config.id) {
-        return 'Provider config missing id';
-    }
-    if (!config.model) {
-        return `Provider ${config.id} missing model`;
-    }
-    if (config.type === 'openai') {
-        const openaiConfig = config;
-        if (!openaiConfig.baseURL) {
-            return `OpenAI provider ${config.id} missing baseURL`;
-        }
-        if (!openaiConfig.apiKey) {
-            return `OpenAI provider ${config.id} missing apiKey`;
-        }
-    }
-    if (config.type === 'workers') {
-        const workersConfig = config;
-        if (!workersConfig.bindingName) {
-            return `Workers AI provider ${config.id} missing bindingName`;
-        }
-    }
-    return null;
-}
-export function getAvailableProvidersCount(env) {
-    const configs = parseProviderConfigs(env);
-    return configs.filter(c => c.enabled !== false).length;
-}
-export function hasAnyProviderConfigured(env) {
-    if (env.AI_PROVIDERS) {
-        const configs = parseAIProvidersJSON(env.AI_PROVIDERS);
-        if (configs && configs.length > 0)
-            return true;
-    }
-    return hasOpenAIConfig(env) || hasWorkersAIBinding(env);
-}

package/dist/provider-manager/index.js

@@ -1,6 +0,0 @@
-export { ProviderManager, getProviderManager, resetProviderManager } from './manager.js';
-export { BaseProviderAdapter } from './base.js';
-export { OpenAIAdapter } from './openai.js';
-export { WorkersAIAdapter } from './workers.js';
-export { MockAdapter } from './mock.js';
-export { parseProviderConfigs, validateProviderConfig, hasAnyProviderConfigured, DEFAULT_WORKERS_BINDING_NAME } from './config.js';

package/dist/provider-manager/manager.js

@@ -1,121 +0,0 @@
-import { parseProviderConfigs, validateProviderConfig } from './config.js';
-import { OpenAIAdapter } from './openai.js';
-import { WorkersAIAdapter } from './workers.js';
-import { MockAdapter } from './mock.js';
-export class ProviderManager {
-    providers = [];
-    mockAdapter;
-    options;
-    constructor(env, options) {
-        this.options = {
-            unhealthyThreshold: options?.unhealthyThreshold ?? 3,
-            healthRecoveryTTL: options?.healthRecoveryTTL ?? 60000,
-            enableMockFallback: options?.enableMockFallback ?? true,
-            onProviderSwitch: options?.onProviderSwitch,
-            onStreamError: options?.onStreamError,
-            onHealthChange: options?.onHealthChange,
-        };
-        this.mockAdapter = new MockAdapter();
-        this.initializeProviders(env);
-    }
-    initializeProviders(env) {
-        const configs = parseProviderConfigs(env);
-        for (const config of configs) {
-            if (config.enabled === false)
-                continue;
-            const validationError = validateProviderConfig(config);
-            if (validationError) {
-                console.warn(`[ProviderManager] Skipping invalid config: ${validationError}`);
-                continue;
-            }
-            try {
-                const adapter = this.createAdapter(config, env);
-                if (adapter) {
-                    this.providers.push(adapter);
-                }
-            }
-            catch (error) {
-                console.warn(`[ProviderManager] Failed to create adapter for ${config.id}:`, error);
-            }
-        }
-        this.providers.sort((a, b) => b.weight - a.weight);
-    }
-    createAdapter(config, env) {
-        switch (config.type) {
-            case 'openai':
-                return new OpenAIAdapter(config);
-            case 'workers':
-                return new WorkersAIAdapter(config, env);
-            default:
-                return null;
-        }
-    }
-    async getAvailableProvider() {
-        for (const provider of this.providers) {
-            if (await provider.isAvailable()) {
-                return provider;
-            }
-        }
-        return null;
-    }
-    async streamText(options) {
-        let lastProviderId = null;
-        let lastError = null;
-        for (const provider of this.providers) {
-            const isAvailable = await provider.isAvailable();
-            if (!isAvailable)
-                continue;
-            try {
-                const result = await provider.streamText(options);
-                provider.recordSuccess();
-                if (lastProviderId && lastProviderId !== provider.id) {
-                    this.options.onProviderSwitch?.(lastProviderId, provider.id, 'fallback success');
-                }
-                return result;
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                lastProviderId = provider.id;
-                provider.recordFailure(lastError);
-                this.options.onStreamError?.(provider.id, lastError);
-                if (!provider.getHealth().healthy) {
-                    this.options.onHealthChange?.(provider.id, false);
-                }
-            }
-        }
-        if (this.options.enableMockFallback) {
-            this.options.onProviderSwitch?.(lastProviderId, 'mock', 'all providers failed');
-            return this.mockAdapter.streamText(options);
-        }
-        throw lastError || new Error('No providers available');
-    }
-    getProviderStatus() {
-        return this.providers.map(provider => ({
-            id: provider.id,
-            type: provider.type,
-            weight: provider.weight,
-            enabled: true,
-            health: provider.getHealth(),
-            model: provider.model,
-        }));
-    }
-    hasProviders() {
-        return this.providers.length > 0;
-    }
-    getProviderCount() {
-        return this.providers.length;
-    }
-    async getAvailableAdapter() {
-        return this.getAvailableProvider();
-    }
-}
-let managerInstance = null;
-export function getProviderManager(env, options) {
-    if (!managerInstance) {
-        managerInstance = new ProviderManager(env, options);
-    }
-    return managerInstance;
-}
-export function resetProviderManager() {
-    managerInstance = null;
-}

package/dist/provider-manager/mock.js

@@ -1,56 +0,0 @@
-import { BaseProviderAdapter } from './base.js';
-import { getMockResponse } from '../providers/mock.js';
-const MOCK_WEIGHT = 0;
-const CHAR_DELAY_MS = 15;
-export class MockAdapter extends BaseProviderAdapter {
-    id = 'mock';
-    type = 'mock';
-    weight = MOCK_WEIGHT;
-    model = 'mock';
-    keywordModel = 'mock';
-    evidenceModel = 'mock';
-    timeout = 0;
-    constructor() {
-        super({ unhealthyThreshold: 999 });
-    }
-    async isAvailable() {
-        return true;
-    }
-    async streamText(options) {
-        const { userQuestion = '', lang = 'zh' } = options;
-        const text = getMockResponse(userQuestion, lang);
-        const partId = `mock-${Date.now()}`;
-        const encoder = new TextEncoder();
-        const stream = new ReadableStream({
-            async start(controller) {
-                const write = (event) => controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-                write({ type: 'text-start', id: partId });
-                for (let i = 0; i < text.length;) {
-                    const chunkSize = Math.random() < 0.3 ? 3 : Math.random() < 0.5 ? 2 : 1;
-                    const chunk = text.slice(i, i + chunkSize);
-                    i += chunkSize;
-                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'text-delta', id: partId, delta: chunk })}\n\n`));
-                    await new Promise(r => setTimeout(r, CHAR_DELAY_MS + Math.random() * 20));
-                }
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'text-end', id: partId })}\n\n`));
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'finish', finishReason: 'stop' })}\n\n`));
-                controller.close();
-            },
-        });
-        const response = new Response(stream, {
-            headers: {
-                'Content-Type': 'text/event-stream; charset=utf-8',
-                'Cache-Control': 'no-cache, no-store',
-                'Access-Control-Allow-Origin': '*',
-            },
-        });
-        return {
-            toUIMessageStreamResponse: () => response,
-            providerId: this.id,
-            isMock: true,
-        };
-    }
-    getProvider() {
-        throw new Error('Mock provider does not support chatModel interface');
-    }
-}

package/dist/provider-manager/openai.js

@@ -1,112 +0,0 @@
-import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-import { streamText, convertToModelMessages } from 'ai';
-import { BaseProviderAdapter } from './base.js';
-let proxyInitialized = false;
-async function setupGlobalProxy() {
-    if (proxyInitialized)
-        return;
-    // Check if running in a Node.js-like environment with proxy configured
-    // In Cloudflare Edge Runtime with nodejs_compat, process exists but undici APIs don't work
-    if (typeof process === 'undefined' || !process.env) {
-        return;
-    }
-    const proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY ||
-        process.env.http_proxy || process.env.HTTP_PROXY;
-    if (!proxyUrl) {
-        return;
-    }
-    try {
-        // Dynamic import - will fail or return stubs in Cloudflare Edge Runtime
-        const undici = await import('undici');
-        // Verify the APIs actually exist (they won't in Edge Runtime polyfills)
-        if (typeof undici.setGlobalDispatcher !== 'function' ||
-            typeof undici.ProxyAgent !== 'function') {
-            console.log('[OpenAIAdapter] undici APIs not available, skipping proxy setup (likely Edge Runtime)');
-            return;
-        }
-        undici.setGlobalDispatcher(new undici.ProxyAgent(proxyUrl));
-        console.log('[OpenAIAdapter] Global proxy dispatcher set:', proxyUrl);
-        proxyInitialized = true;
-    }
-    catch (e) {
-        // Expected in Cloudflare Edge Runtime - undici import may fail or APIs may not exist
-        console.log('[OpenAIAdapter] Proxy setup skipped:', e instanceof Error ? e.message : String(e));
-    }
-}
-let proxySetupPromise = null;
-function ensureProxySetup() {
-    if (!proxySetupPromise) {
-        proxySetupPromise = setupGlobalProxy();
-    }
-    return proxySetupPromise;
-}
-export class OpenAIAdapter extends BaseProviderAdapter {
-    id;
-    type = 'openai';
-    weight;
-    model;
-    keywordModel;
-    evidenceModel;
-    timeout;
-    provider;
-    config;
-    constructor(config) {
-        super({
-            unhealthyThreshold: config.maxRetries ? config.maxRetries + 2 : 3,
-        });
-        this.id = config.id;
-        this.weight = config.weight ?? 100;
-        this.model = config.model;
-        this.keywordModel = config.keywordModel ?? config.model;
-        this.evidenceModel = config.evidenceModel ?? this.keywordModel;
-        this.timeout = config.timeout ?? 30000;
-        this.config = config;
-        this.provider = createOpenAICompatible({
-            name: `openai-${config.id}`,
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
-            includeUsage: true,
-        });
-        ensureProxySetup().catch(() => { });
-    }
-    async streamText(options) {
-        await ensureProxySetup();
-        const { system, messages, temperature = 0.7, maxOutputTokens, topP, abortSignal, onError } = options;
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => abortController.abort(), this.timeout);
-        if (abortSignal) {
-            abortSignal.addEventListener('abort', () => abortController.abort());
-        }
-        try {
-            const result = streamText({
-                model: this.provider.chatModel(this.model),
-                system,
-                messages: await convertToModelMessages(messages),
-                temperature,
-                maxOutputTokens,
-                topP,
-                abortSignal: abortController.signal,
-                onError: ({ error }) => {
-                    onError?.(error instanceof Error ? error : new Error(String(error)));
-                },
-            });
-            const streamResult = {
-                toUIMessageStreamResponse: (responseOptions) => result.toUIMessageStreamResponse(responseOptions),
-                providerId: this.id,
-                isMock: false,
-            };
-            clearTimeout(timeoutId);
-            return streamResult;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            throw error;
-        }
-    }
-    getConfig() {
-        return { ...this.config };
-    }
-    getProvider() {
-        return this.provider;
-    }
-}

package/dist/provider-manager/types.js

@@ -1,6 +0,0 @@
-/**
- * Type definitions for the AI Provider Manager.
- *
- * Supports multiple provider types with priority-based fallback.
- */
-export {};

package/dist/provider-manager/workers.js

@@ -1,74 +0,0 @@
-import { createWorkersAI } from 'workers-ai-provider';
-import { streamText, convertToModelMessages } from 'ai';
-import { BaseProviderAdapter } from './base.js';
-export class WorkersAIAdapter extends BaseProviderAdapter {
-    id;
-    type = 'workers';
-    weight;
-    model;
-    keywordModel;
-    evidenceModel;
-    timeout;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    provider;
-    config;
-    constructor(config, env) {
-        super({
-            unhealthyThreshold: config.maxRetries ? config.maxRetries + 2 : 3,
-        });
-        this.id = config.id;
-        this.weight = config.weight ?? 90;
-        this.model = config.model;
-        this.keywordModel = config.keywordModel ?? config.model;
-        this.evidenceModel = config.evidenceModel ?? this.keywordModel;
-        this.timeout = config.timeout ?? 30000;
-        this.config = config;
-        const binding = env[config.bindingName];
-        if (!binding) {
-            throw new Error(`Workers AI binding '${config.bindingName}' not found in environment`);
-        }
-        this.provider = createWorkersAI({ binding: binding });
-    }
-    async streamText(options) {
-        const { system, messages, temperature = 0.7, maxOutputTokens, topP, abortSignal, onError } = options;
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => abortController.abort(), this.timeout);
-        if (abortSignal) {
-            abortSignal.addEventListener('abort', () => abortController.abort());
-        }
-        try {
-            const model = this.provider(this.model, { safePrompt: true });
-            const result = streamText({
-                model,
-                system,
-                messages: await convertToModelMessages(messages),
-                temperature,
-                maxOutputTokens,
-                topP,
-                abortSignal: abortController.signal,
-                onError: ({ error }) => {
-                    onError?.(error instanceof Error ? error : new Error(String(error)));
-                },
-            });
-            const streamResult = {
-                toUIMessageStreamResponse: (responseOptions) => result.toUIMessageStreamResponse(responseOptions),
-                providerId: this.id,
-                isMock: false,
-            };
-            clearTimeout(timeoutId);
-            return streamResult;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            throw error;
-        }
-    }
-    getConfig() {
-        return { ...this.config };
-    }
-    getProvider() {
-        return {
-            chatModel: (modelId) => this.provider(modelId, { safePrompt: true }),
-        };
-    }
-}