ailib-router 0.0.2

package/README.md

@@ -0,0 +1,60 @@
+# AI Multi Provider Library
+
+TypeScript Node.js library to send one message and receive one response using multiple AI providers.
+
+## Supported providers (v1)
+
+- OpenAI (ChatGPT)
+- Google Gemini
+- Anthropic Claude
+- Ollama Cloud
+- Ollama Local
+
+## Features
+
+- AUTO mode with configurable provider order and fallback
+- MANUAL mode to choose provider and model
+- In MANUAL mode, if selected model is rate-limited, it retries with other models in the same provider
+- In AUTO mode, if provider/model reaches rate limit, it moves to next available provider/model
+- Normalized error handling across all providers
+
+## Install
+
+npm install
+
+## Build
+
+npm run build
+
+## Test
+
+npm test
+
+## Quick use
+
+import { createAIClient } from "ailib-router";
+
+const client = createAIClient();
+const result = await client.sendMessage({
+  mode: "auto",
+  message: "Explain clean architecture in 5 lines"
+});
+
+console.log(result.provider, result.model, result.content);
+
+## Manual mode
+
+const result = await client.sendMessage({
+  mode: "manual",
+  provider: "gemini",
+  model: "gemini-2.0-flash",
+  message: "Write a short poem"
+});
+
+## NestJS example
+
+Use AIClient inside a service provider and call sendMessage in your service methods.
+
+## Environment
+
+Copy values from .env.example into your real .env file and set valid keys and model names.

package/dist/client.d.ts

@@ -0,0 +1,9 @@
+import type { AIMessageRequest, AIMessageResponse, LibraryConfig, ProviderId } from "./types.js";
+export declare class AIClient {
+    private readonly config;
+    private readonly router;
+    constructor(config?: LibraryConfig);
+    sendMessage(request: AIMessageRequest): Promise<AIMessageResponse>;
+    providers(): ProviderId[];
+}
+export declare function createAIClient(config?: LibraryConfig): AIClient;

package/dist/client.js

@@ -0,0 +1,29 @@
+import { AIRouter } from "./router.js";
+import { ClaudeAdapter } from "./providers/claude.js";
+import { GeminiAdapter } from "./providers/gemini.js";
+import { OllamaAdapter } from "./providers/ollama.js";
+import { OpenAIAdapter } from "./providers/openai.js";
+import { loadConfig } from "./config.js";
+export class AIClient {
+    config;
+    router;
+    constructor(config = loadConfig()) {
+        this.config = config;
+        this.router = new AIRouter(this.config, {
+            openai: new OpenAIAdapter(this.config.providers.openai),
+            gemini: new GeminiAdapter(this.config.providers.gemini),
+            claude: new ClaudeAdapter(this.config.providers.claude),
+            ollamaCloud: new OllamaAdapter("ollamaCloud", this.config.providers.ollamaCloud),
+            ollamaLocal: new OllamaAdapter("ollamaLocal", this.config.providers.ollamaLocal),
+        });
+    }
+    async sendMessage(request) {
+        return this.router.sendMessage(request);
+    }
+    providers() {
+        return this.config.providerOrder;
+    }
+}
+export function createAIClient(config) {
+    return new AIClient(config);
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { LibraryConfig } from "./types.js";
+export declare function loadConfig(env?: NodeJS.ProcessEnv): LibraryConfig;

package/dist/config.js

@@ -0,0 +1,85 @@
+import { AIError } from "./errors.js";
+const DEFAULT_PROVIDER_ORDER = [
+    "gemini",
+    "openai",
+    "claude",
+    "ollamaCloud",
+    "ollamaLocal",
+];
+export function loadConfig(env = process.env) {
+    const timeoutMs = Number(env.AI_REQUEST_TIMEOUT_MS ?? "30000");
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new AIError({
+            message: "AI_REQUEST_TIMEOUT_MS must be a positive number",
+            code: "configuration",
+        });
+    }
+    const providerOrder = parseProviderOrder(env.AI_PROVIDER_ORDER);
+    const providers = {
+        openai: {
+            enabled: Boolean(env.OPENAI_API_KEY),
+            apiKey: env.OPENAI_API_KEY,
+            baseUrl: env.OPENAI_BASE_URL ?? "https://api.openai.com",
+            models: parseList(env.OPENAI_MODELS, ["gpt-4.1-mini", "gpt-4o-mini"]),
+        },
+        gemini: {
+            enabled: Boolean(env.GEMINI_API_KEY),
+            apiKey: env.GEMINI_API_KEY,
+            baseUrl: env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com",
+            models: parseList(env.GEMINI_MODELS, [
+                "gemini-2.0-flash",
+                "gemini-1.5-flash",
+            ]),
+        },
+        claude: {
+            enabled: Boolean(env.ANTHROPIC_API_KEY),
+            apiKey: env.ANTHROPIC_API_KEY,
+            baseUrl: env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
+            models: parseList(env.ANTHROPIC_MODELS, [
+                "claude-3-5-sonnet-latest",
+                "claude-3-5-haiku-latest",
+            ]),
+        },
+        ollamaCloud: {
+            enabled: Boolean(env.OLLAMA_CLOUD_BASE_URL),
+            apiKey: env.OLLAMA_CLOUD_API_KEY,
+            baseUrl: env.OLLAMA_CLOUD_BASE_URL ?? "",
+            models: parseList(env.OLLAMA_CLOUD_MODELS, []),
+        },
+        ollamaLocal: {
+            enabled: Boolean(env.OLLAMA_LOCAL_BASE_URL),
+            baseUrl: env.OLLAMA_LOCAL_BASE_URL ?? "http://localhost:11434",
+            models: parseList(env.OLLAMA_LOCAL_MODELS, ["llama3.2"]),
+        },
+    };
+    return {
+        timeoutMs,
+        providerOrder,
+        providers,
+    };
+}
+function parseProviderOrder(raw) {
+    if (!raw) {
+        return DEFAULT_PROVIDER_ORDER;
+    }
+    const mapped = parseList(raw, []).map((value) => value);
+    for (const provider of mapped) {
+        if (!DEFAULT_PROVIDER_ORDER.includes(provider)) {
+            throw new AIError({
+                message: `Unknown provider in AI_PROVIDER_ORDER: ${provider}`,
+                code: "configuration",
+            });
+        }
+    }
+    return mapped;
+}
+function parseList(raw, fallback) {
+    if (!raw) {
+        return fallback;
+    }
+    const values = raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    return values.length > 0 ? values : fallback;
+}

package/dist/errors.d.ts

@@ -0,0 +1,33 @@
+import type { AttemptRecord, ProviderId } from "./types.js";
+export type AIErrorCode = "rate_limit" | "auth" | "timeout" | "invalid_request" | "provider_unavailable" | "network" | "configuration" | "all_models_exhausted" | "all_providers_exhausted" | "unknown";
+export declare class AIError extends Error {
+    readonly code: AIErrorCode;
+    readonly provider?: ProviderId;
+    readonly model?: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    constructor(params: {
+        message: string;
+        code: AIErrorCode;
+        provider?: ProviderId;
+        model?: string;
+        status?: number;
+        retryable?: boolean;
+        cause?: unknown;
+    });
+}
+export declare class AllModelsExhaustedError extends AIError {
+    readonly attempts: AttemptRecord[];
+    constructor(provider: ProviderId, attempts: AttemptRecord[]);
+}
+export declare class AllProvidersExhaustedError extends AIError {
+    readonly attempts: AttemptRecord[];
+    constructor(attempts: AttemptRecord[]);
+}
+export declare function toAIError(input: {
+    provider: ProviderId;
+    model?: string;
+    status?: number;
+    message: string;
+    cause?: unknown;
+}): AIError;

package/dist/errors.js

@@ -0,0 +1,111 @@
+export class AIError extends Error {
+    code;
+    provider;
+    model;
+    status;
+    retryable;
+    constructor(params) {
+        super(params.message);
+        this.name = "AIError";
+        this.code = params.code;
+        this.provider = params.provider;
+        this.model = params.model;
+        this.status = params.status;
+        this.retryable = params.retryable ?? false;
+        if (params.cause !== undefined) {
+            this.cause = params.cause;
+        }
+    }
+}
+export class AllModelsExhaustedError extends AIError {
+    attempts;
+    constructor(provider, attempts) {
+        const details = formatAttempts(attempts);
+        super({
+            message: details
+                ? `All models are exhausted for provider ${provider}. Attempts: ${details}`
+                : `All models are exhausted for provider ${provider}`,
+            code: "all_models_exhausted",
+            provider,
+            retryable: false,
+        });
+        this.name = "AllModelsExhaustedError";
+        this.attempts = attempts;
+    }
+}
+export class AllProvidersExhaustedError extends AIError {
+    attempts;
+    constructor(attempts) {
+        const details = formatAttempts(attempts);
+        super({
+            message: details
+                ? `All providers are exhausted or unavailable. Attempts: ${details}`
+                : "All providers are exhausted or unavailable",
+            code: "all_providers_exhausted",
+            retryable: false,
+        });
+        this.name = "AllProvidersExhaustedError";
+        this.attempts = attempts;
+    }
+}
+function formatAttempts(attempts) {
+    return attempts
+        .map((attempt) => `${attempt.provider}/${attempt.model ?? "n/a"}:${attempt.code}:${attempt.message}`)
+        .join(" | ");
+}
+export function toAIError(input) {
+    const { provider, model, status, message, cause } = input;
+    if (status === 401 || status === 403) {
+        return new AIError({
+            message,
+            code: "auth",
+            provider,
+            model,
+            status,
+            retryable: false,
+            cause,
+        });
+    }
+    if (status === 429) {
+        return new AIError({
+            message,
+            code: "rate_limit",
+            provider,
+            model,
+            status,
+            retryable: true,
+            cause,
+        });
+    }
+    if (status === 400 || status === 404 || status === 422) {
+        return new AIError({
+            message,
+            code: "invalid_request",
+            provider,
+            model,
+            status,
+            retryable: false,
+            cause,
+        });
+    }
+    if (status !== undefined && status >= 500) {
+        return new AIError({
+            message,
+            code: "provider_unavailable",
+            provider,
+            model,
+            status,
+            retryable: true,
+            cause,
+        });
+    }
+    return new AIError({
+        message,
+        code: "unknown",
+        provider,
+        model,
+        status,
+        retryable: false,
+        cause,
+    });
+}

package/dist/http.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderId } from "./types.js";
+export declare function postJson(params: {
+    provider: ProviderId;
+    model?: string;
+    url: string;
+    headers: Record<string, string>;
+    body: unknown;
+    timeoutMs: number;
+}): Promise<unknown>;

package/dist/http.js

@@ -0,0 +1,91 @@
+import { AIError, toAIError } from "./errors.js";
+export async function postJson(params) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const response = await fetch(params.url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...params.headers,
+            },
+            body: JSON.stringify(params.body),
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        const parsed = safeJsonParse(text);
+        if (!response.ok) {
+            const message = extractErrorMessage(parsed) ?? response.statusText;
+            throw toAIError({
+                provider: params.provider,
+                model: params.model,
+                status: response.status,
+                message,
+            });
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof AIError) {
+            throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new AIError({
+                message: "Request timeout",
+                code: "timeout",
+                provider: params.provider,
+                model: params.model,
+                retryable: true,
+                cause: error,
+            });
+        }
+        const networkMessage = error instanceof Error && error.message
+            ? `Network or unexpected error: ${error.message}`
+            : "Network or unexpected error";
+        throw new AIError({
+            message: networkMessage,
+            code: "network",
+            provider: params.provider,
+            model: params.model,
+            retryable: true,
+            cause: error,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function safeJsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function extractErrorMessage(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    if ("error" in value) {
+        const errorField = value.error;
+        if (typeof errorField === "string") {
+            return errorField;
+        }
+        if (errorField &&
+            typeof errorField === "object" &&
+            "message" in errorField) {
+            const message = errorField.message;
+            if (typeof message === "string") {
+                return message;
+            }
+        }
+    }
+    if ("message" in value) {
+        const message = value.message;
+        if (typeof message === "string") {
+            return message;
+        }
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./config.js";
+export * from "./client.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./config.js";
+export * from "./client.js";

package/dist/providers/claude.d.ts

@@ -0,0 +1,13 @@
+import type { AIMessageResponse, ProviderAdapter, ProviderConfig } from "../types.js";
+export declare class ClaudeAdapter implements ProviderAdapter {
+    private readonly config;
+    readonly id: "claude";
+    constructor(config: ProviderConfig);
+    isConfigured(): boolean;
+    models(): string[];
+    sendMessage(input: {
+        message: string;
+        model: string;
+        timeoutMs: number;
+    }): Promise<AIMessageResponse>;
+}

package/dist/providers/claude.js

@@ -0,0 +1,56 @@
+import { AIError } from "../errors.js";
+import { postJson } from "../http.js";
+export class ClaudeAdapter {
+    config;
+    id = "claude";
+    constructor(config) {
+        this.config = config;
+    }
+    isConfigured() {
+        return (this.config.enabled &&
+            Boolean(this.config.apiKey) &&
+            Boolean(this.config.baseUrl));
+    }
+    models() {
+        return this.config.models;
+    }
+    async sendMessage(input) {
+        if (!this.config.apiKey) {
+            throw new AIError({
+                message: "Missing ANTHROPIC_API_KEY",
+                code: "configuration",
+                provider: this.id,
+            });
+        }
+        const data = (await postJson({
+            provider: this.id,
+            model: input.model,
+            timeoutMs: input.timeoutMs,
+            url: `${this.config.baseUrl}/v1/messages`,
+            headers: {
+                "x-api-key": this.config.apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: {
+                model: input.model,
+                max_tokens: 1024,
+                messages: [{ role: "user", content: input.message }],
+            },
+        }));
+        const content = data.content?.find((entry) => entry.type === "text")?.text;
+        if (!content) {
+            throw new AIError({
+                message: "Claude response does not include text content",
+                code: "provider_unavailable",
+                provider: this.id,
+                model: input.model,
+                retryable: true,
+            });
+        }
+        return {
+            provider: this.id,
+            model: input.model,
+            content,
+        };
+    }
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,13 @@
+import type { AIMessageResponse, ProviderAdapter, ProviderConfig } from "../types.js";
+export declare class GeminiAdapter implements ProviderAdapter {
+    private readonly config;
+    readonly id: "gemini";
+    constructor(config: ProviderConfig);
+    isConfigured(): boolean;
+    models(): string[];
+    sendMessage(input: {
+        message: string;
+        model: string;
+        timeoutMs: number;
+    }): Promise<AIMessageResponse>;
+}

package/dist/providers/gemini.js

@@ -0,0 +1,52 @@
+import { AIError } from "../errors.js";
+import { postJson } from "../http.js";
+export class GeminiAdapter {
+    config;
+    id = "gemini";
+    constructor(config) {
+        this.config = config;
+    }
+    isConfigured() {
+        return (this.config.enabled &&
+            Boolean(this.config.apiKey) &&
+            Boolean(this.config.baseUrl));
+    }
+    models() {
+        return this.config.models;
+    }
+    async sendMessage(input) {
+        if (!this.config.apiKey) {
+            throw new AIError({
+                message: "Missing GEMINI_API_KEY",
+                code: "configuration",
+                provider: this.id,
+            });
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const data = (await postJson({
+            provider: this.id,
+            model: input.model,
+            timeoutMs: input.timeoutMs,
+            url: `${baseUrl}/v1beta/models/${encodeURIComponent(input.model)}:generateContent?key=${this.config.apiKey}`,
+            headers: {},
+            body: {
+                contents: [{ role: "user", parts: [{ text: input.message }] }],
+            },
+        }));
+        const content = data.candidates?.[0]?.content?.parts?.[0]?.text;
+        if (!content) {
+            throw new AIError({
+                message: "Gemini response does not include message content",
+                code: "provider_unavailable",
+                provider: this.id,
+                model: input.model,
+                retryable: true,
+            });
+        }
+        return {
+            provider: this.id,
+            model: input.model,
+            content,
+        };
+    }
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,13 @@
+import type { AIMessageResponse, ProviderAdapter, ProviderConfig, ProviderId } from "../types.js";
+export declare class OllamaAdapter implements ProviderAdapter {
+    private readonly config;
+    readonly id: ProviderId;
+    constructor(id: "ollamaCloud" | "ollamaLocal", config: ProviderConfig);
+    isConfigured(): boolean;
+    models(): string[];
+    sendMessage(input: {
+        message: string;
+        model: string;
+        timeoutMs: number;
+    }): Promise<AIMessageResponse>;
+}

package/dist/providers/ollama.js

@@ -0,0 +1,56 @@
+import { AIError } from "../errors.js";
+import { postJson } from "../http.js";
+export class OllamaAdapter {
+    config;
+    id;
+    constructor(id, config) {
+        this.config = config;
+        this.id = id;
+    }
+    isConfigured() {
+        return this.config.enabled && Boolean(this.config.baseUrl);
+    }
+    models() {
+        return this.config.models;
+    }
+    async sendMessage(input) {
+        const headers = {};
+        if (this.config.apiKey) {
+            headers.Authorization = `Bearer ${this.config.apiKey}`;
+        }
+        const data = (await postJson({
+            provider: this.id,
+            model: input.model,
+            timeoutMs: input.timeoutMs,
+            url: buildOllamaChatUrl(this.config.baseUrl),
+            headers,
+            body: {
+                model: input.model,
+                messages: [{ role: "user", content: input.message }],
+                stream: false,
+            },
+        }));
+        const content = data.message?.content;
+        if (!content) {
+            throw new AIError({
+                message: "Ollama response does not include message content",
+                code: "provider_unavailable",
+                provider: this.id,
+                model: input.model,
+                retryable: true,
+            });
+        }
+        return {
+            provider: this.id,
+            model: input.model,
+            content,
+        };
+    }
+}
+function buildOllamaChatUrl(baseUrl) {
+    const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+    if (normalizedBaseUrl.endsWith("/api")) {
+        return `${normalizedBaseUrl}/chat`;
+    }
+    return `${normalizedBaseUrl}/api/chat`;
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,13 @@
+import type { AIMessageResponse, ProviderAdapter, ProviderConfig } from "../types.js";
+export declare class OpenAIAdapter implements ProviderAdapter {
+    private readonly config;
+    readonly id: "openai";
+    constructor(config: ProviderConfig);
+    isConfigured(): boolean;
+    models(): string[];
+    sendMessage(input: {
+        message: string;
+        model: string;
+        timeoutMs: number;
+    }): Promise<AIMessageResponse>;
+}

package/dist/providers/openai.js

@@ -0,0 +1,54 @@
+import { AIError } from "../errors.js";
+import { postJson } from "../http.js";
+export class OpenAIAdapter {
+    config;
+    id = "openai";
+    constructor(config) {
+        this.config = config;
+    }
+    isConfigured() {
+        return (this.config.enabled &&
+            Boolean(this.config.apiKey) &&
+            Boolean(this.config.baseUrl));
+    }
+    models() {
+        return this.config.models;
+    }
+    async sendMessage(input) {
+        if (!this.config.apiKey) {
+            throw new AIError({
+                message: "Missing OPENAI_API_KEY",
+                code: "configuration",
+                provider: this.id,
+            });
+        }
+        const data = (await postJson({
+            provider: this.id,
+            model: input.model,
+            timeoutMs: input.timeoutMs,
+            url: `${this.config.baseUrl}/v1/chat/completions`,
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+            },
+            body: {
+                model: input.model,
+                messages: [{ role: "user", content: input.message }],
+            },
+        }));
+        const content = data.choices?.[0]?.message?.content;
+        if (!content) {
+            throw new AIError({
+                message: "OpenAI response does not include message content",
+                code: "provider_unavailable",
+                provider: this.id,
+                model: input.model,
+                retryable: true,
+            });
+        }
+        return {
+            provider: this.id,
+            model: input.model,
+            content,
+        };
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,10 @@
+import type { AIMessageRequest, AIMessageResponse, LibraryConfig, ProviderAdapter, ProviderId } from "./types.js";
+export declare class AIRouter {
+    private readonly config;
+    private readonly adapters;
+    constructor(config: LibraryConfig, adapters: Record<ProviderId, ProviderAdapter>);
+    sendMessage(request: AIMessageRequest): Promise<AIMessageResponse>;
+    private sendManual;
+    private sendAuto;
+    private getModelOrder;
+}

package/dist/router.js

@@ -0,0 +1,145 @@
+import { AIError, AllModelsExhaustedError, AllProvidersExhaustedError, } from "./errors.js";
+export class AIRouter {
+    config;
+    adapters;
+    constructor(config, adapters) {
+        this.config = config;
+        this.adapters = adapters;
+    }
+    async sendMessage(request) {
+        const mode = request.mode ?? "auto";
+        if (!request.message?.trim()) {
+            throw new AIError({
+                message: "message is required",
+                code: "invalid_request",
+            });
+        }
+        if (mode === "manual") {
+            console.info("[aiLib] mode=manual");
+            return this.sendManual(request);
+        }
+        console.info("[aiLib] mode=auto");
+        return this.sendAuto(request);
+    }
+    async sendManual(request) {
+        if (!request.provider) {
+            throw new AIError({
+                message: "provider is required in manual mode",
+                code: "invalid_request",
+            });
+        }
+        const providerId = request.provider;
+        const adapter = this.adapters[providerId];
+        const attempts = [];
+        if (!adapter || !adapter.isConfigured()) {
+            throw new AIError({
+                message: `Provider ${providerId} is not configured`,
+                code: "configuration",
+                provider: providerId,
+            });
+        }
+        const candidateModels = this.getModelOrder(adapter.models(), request.model);
+        for (const model of candidateModels) {
+            try {
+                console.info(`[aiLib] trying provider=${providerId} model=${model} (manual)`);
+                const response = await adapter.sendMessage({
+                    message: request.message,
+                    model,
+                    timeoutMs: request.timeoutMs ?? this.config.timeoutMs,
+                });
+                console.info(`[aiLib] using provider=${response.provider} model=${response.model}`);
+                return response;
+            }
+            catch (error) {
+                const aiError = normalizeError(error, providerId, model);
+                attempts.push({
+                    provider: providerId,
+                    model,
+                    code: aiError.code,
+                    message: aiError.message,
+                });
+                if (aiError.code === "rate_limit") {
+                    console.warn(`[aiLib] rate limit on provider=${providerId} model=${model}, trying next model: ${aiError.message}`);
+                    continue;
+                }
+                console.warn(`[aiLib] provider=${providerId} model=${model} failed with code=${aiError.code}: ${aiError.message}`);
+                throw aiError;
+            }
+        }
+        throw new AllModelsExhaustedError(providerId, attempts);
+    }
+    async sendAuto(request) {
+        const attempts = [];
+        for (const providerId of this.config.providerOrder) {
+            const adapter = this.adapters[providerId];
+            if (!adapter || !adapter.isConfigured()) {
+                console.info(`[aiLib] skipping provider=${providerId} (not configured)`);
+                continue;
+            }
+            for (const model of adapter.models()) {
+                try {
+                    console.info(`[aiLib] trying provider=${providerId} model=${model} (auto)`);
+                    const response = await adapter.sendMessage({
+                        message: request.message,
+                        model,
+                        timeoutMs: request.timeoutMs ?? this.config.timeoutMs,
+                    });
+                    console.info(`[aiLib] using provider=${response.provider} model=${response.model}`);
+                    return response;
+                }
+                catch (error) {
+                    const aiError = normalizeError(error, providerId, model);
+                    attempts.push({
+                        provider: providerId,
+                        model,
+                        code: aiError.code,
+                        message: aiError.message,
+                    });
+                    if (aiError.code === "rate_limit" || aiError.retryable) {
+                        console.warn(`[aiLib] fallback from provider=${providerId} model=${model} due to code=${aiError.code}: ${aiError.message}`);
+                        continue;
+                    }
+                    console.warn(`[aiLib] stopping provider=${providerId} due to non-retryable code=${aiError.code}: ${aiError.message}`);
+                    break;
+                }
+            }
+        }
+        if (attempts.length > 0) {
+            const attemptSummary = attempts
+                .map((attempt) => `${attempt.provider}/${attempt.model ?? "n/a"}:${attempt.code}:${attempt.message}`)
+                .join(" | ");
+            console.error(`[aiLib] all providers exhausted. attempts=${attemptSummary}`);
+        }
+        throw new AllProvidersExhaustedError(attempts);
+    }
+    getModelOrder(models, selected) {
+        if (!selected) {
+            return models;
+        }
+        const unique = [selected, ...models.filter((model) => model !== selected)];
+        return unique;
+    }
+}
+function normalizeError(error, provider, model) {
+    if (error instanceof AIError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new AIError({
+            message: error.message,
+            code: "unknown",
+            provider,
+            model,
+            retryable: false,
+            cause: error,
+        });
+    }
+    return new AIError({
+        message: "Unknown error",
+        code: "unknown",
+        provider,
+        model,
+        retryable: false,
+        cause: error,
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+export type ProviderId = "openai" | "gemini" | "claude" | "ollamaCloud" | "ollamaLocal";
+export type RoutingMode = "auto" | "manual";
+export interface AIMessageRequest {
+    message: string;
+    mode?: RoutingMode;
+    provider?: ProviderId;
+    model?: string;
+    timeoutMs?: number;
+}
+export interface AIMessageResponse {
+    provider: ProviderId;
+    model: string;
+    content: string;
+}
+export interface AttemptRecord {
+    provider: ProviderId;
+    model?: string;
+    code: string;
+    message: string;
+}
+export interface ProviderConfig {
+    enabled: boolean;
+    baseUrl: string;
+    apiKey?: string;
+    models: string[];
+}
+export interface LibraryConfig {
+    providerOrder: ProviderId[];
+    timeoutMs: number;
+    providers: Record<ProviderId, ProviderConfig>;
+}
+export interface ProviderAdapter {
+    id: ProviderId;
+    isConfigured(): boolean;
+    models(): string[];
+    sendMessage(input: {
+        message: string;
+        model: string;
+        timeoutMs: number;
+    }): Promise<AIMessageResponse>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "ailib-router",
+  "version": "0.0.2",
+  "description": "Multi-provider AI chat library with auto/manual routing and fallback",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pigos4/Ai-Lib.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "keywords": [
+    "ai",
+    "openai",
+    "gemini",
+    "claude",
+    "ollama",
+    "router"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  }
+}