@yadimon/prio-llm-router 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1058 @@
+'use strict';
+
+var anthropic = require('@ai-sdk/anthropic');
+var cohere = require('@ai-sdk/cohere');
+var deepseek = require('@ai-sdk/deepseek');
+var google = require('@ai-sdk/google');
+var groq = require('@ai-sdk/groq');
+var mistral = require('@ai-sdk/mistral');
+var openai = require('@ai-sdk/openai');
+var openaiCompatible = require('@ai-sdk/openai-compatible');
+var perplexity = require('@ai-sdk/perplexity');
+var togetherai = require('@ai-sdk/togetherai');
+var xai = require('@ai-sdk/xai');
+var ai = require('ai');
+var aiSdkProvider = require('@openrouter/ai-sdk-provider');
+
+// src/errors.ts
+var PrioLlmRouterError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var RouterConfigurationError = class extends PrioLlmRouterError {
+};
+var AllModelsFailedError = class extends PrioLlmRouterError {
+  attempts;
+  constructor(attempts, cause) {
+    super(buildFailureMessage(attempts), { cause });
+    this.attempts = attempts;
+  }
+};
+function serializeError(error) {
+  if (error instanceof Error) {
+    const maybeError = error;
+    const serialized = {
+      name: error.name,
+      message: error.message
+    };
+    if (maybeError.code !== void 0) {
+      serialized.code = maybeError.code;
+    }
+    const statusCode = maybeError.statusCode ?? maybeError.status;
+    if (statusCode !== void 0) {
+      serialized.statusCode = statusCode;
+    }
+    return serialized;
+  }
+  if (typeof error === "string") {
+    return {
+      name: "Error",
+      message: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: "Unknown router error"
+  };
+}
+function isAbortError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.name === "AbortError" || error.name === "TimeoutError";
+}
+function buildFailureMessage(attempts) {
+  const summary = attempts.map((attempt) => {
+    const errorMessage = attempt.error?.message ?? "Unknown error";
+    return `${attempt.targetName} (${attempt.providerName}/${attempt.model}): ${errorMessage}`;
+  }).join("; ");
+  return summary ? `All configured model attempts failed. ${summary}` : "All configured model attempts failed.";
+}
+function createDefaultTextGenerationExecutor(options) {
+  return new AiSdkTextGenerationExecutor(options?.defaultProviderMaxRetries ?? 0);
+}
+var AiSdkTextGenerationExecutor = class {
+  constructor(defaultProviderMaxRetries) {
+    this.defaultProviderMaxRetries = defaultProviderMaxRetries;
+  }
+  providerCache = /* @__PURE__ */ new Map();
+  async execute({
+    provider,
+    model,
+    request
+  }) {
+    const languageModel = this.getLanguageModel(provider, model.model);
+    const call = buildBaseTextCallOptions({
+      languageModel,
+      request,
+      defaultProviderMaxRetries: this.defaultProviderMaxRetries
+    });
+    const result = await ai.generateText(call);
+    const output = {
+      text: result.text,
+      finishReason: result.finishReason ?? null,
+      raw: result
+    };
+    const usage = normalizeUsage(result.usage);
+    if (usage) {
+      output.usage = usage;
+    }
+    const warnings = normalizeWarnings(result.warnings);
+    if (warnings) {
+      output.warnings = warnings;
+    }
+    return output;
+  }
+  async stream({
+    provider,
+    model,
+    request
+  }) {
+    await Promise.resolve();
+    const languageModel = this.getLanguageModel(provider, model.model);
+    const call = buildBaseTextCallOptions({
+      languageModel,
+      request,
+      defaultProviderMaxRetries: this.defaultProviderMaxRetries
+    });
+    const result = ai.streamText(call);
+    return {
+      textStream: result.textStream,
+      consumeStream: async () => {
+        await result.consumeStream();
+      },
+      finishReason: Promise.resolve(result.finishReason).then(
+        (value) => value ?? null
+      ),
+      usage: Promise.resolve(result.totalUsage).then(
+        (value) => normalizeUsage(value)
+      ),
+      warnings: Promise.resolve(result.warnings).then(
+        (value) => normalizeWarnings(value)
+      ),
+      raw: result
+    };
+  }
+  getLanguageModel(provider, modelId) {
+    const handle = this.providerCache.get(provider.name) ?? createProviderHandle(provider);
+    if (!this.providerCache.has(provider.name)) {
+      this.providerCache.set(provider.name, handle);
+    }
+    return resolveLanguageModel(handle, modelId, provider.name);
+  }
+};
+function buildBaseTextCallOptions({
+  languageModel,
+  request,
+  defaultProviderMaxRetries
+}) {
+  const call = {
+    model: languageModel,
+    system: request.system,
+    temperature: request.temperature,
+    topP: request.topP,
+    maxRetries: request.providerMaxRetries ?? defaultProviderMaxRetries,
+    abortSignal: request.abortSignal
+  };
+  if (request.maxOutputTokens !== void 0) {
+    call.maxOutputTokens = request.maxOutputTokens;
+  }
+  if (request.stopSequences !== void 0) {
+    call.stopSequences = request.stopSequences;
+  }
+  if ("prompt" in request) {
+    call.prompt = request.prompt;
+  } else {
+    call.messages = request.messages;
+  }
+  return call;
+}
+function createProviderHandle(provider) {
+  const apiKey = provider.auth.apiKey.trim();
+  if (!apiKey) {
+    throw new RouterConfigurationError(
+      `Provider "${provider.name}" is missing an API key.`
+    );
+  }
+  switch (provider.type) {
+    case "anthropic": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return anthropic.createAnthropic(options);
+    }
+    case "cohere": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return cohere.createCohere(options);
+    }
+    case "deepseek": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return deepseek.createDeepSeek(options);
+    }
+    case "google": {
+      const options = {
+        apiKey
+      };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return google.createGoogleGenerativeAI(options);
+    }
+    case "groq": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return groq.createGroq(options);
+    }
+    case "mistral": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return mistral.createMistral(options);
+    }
+    case "openai": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return openai.createOpenAI(options);
+    }
+    case "openai-compatible": {
+      const options = {
+        name: provider.providerLabel ?? provider.name,
+        apiKey,
+        baseURL: provider.baseURL
+      };
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      if (provider.queryParams) {
+        options.queryParams = provider.queryParams;
+      }
+      return openaiCompatible.createOpenAICompatible(options);
+    }
+    case "openrouter": {
+      const options = {
+        apiKey
+      };
+      const headers = buildOpenRouterHeaders(provider);
+      if (headers) {
+        options.headers = headers;
+      }
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      return aiSdkProvider.createOpenRouter(options);
+    }
+    case "perplexity": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return perplexity.createPerplexity(options);
+    }
+    case "togetherai": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return togetherai.createTogetherAI(options);
+    }
+    case "xai": {
+      const options = { apiKey };
+      if (provider.baseURL) {
+        options.baseURL = provider.baseURL;
+      }
+      if (provider.headers) {
+        options.headers = provider.headers;
+      }
+      return xai.createXai(options);
+    }
+    default: {
+      const exhaustiveCheck = provider;
+      throw new RouterConfigurationError(
+        `Unsupported provider type: ${JSON.stringify(exhaustiveCheck)}`
+      );
+    }
+  }
+}
+function buildOpenRouterHeaders(provider) {
+  const headers = { ...provider.headers };
+  if (provider.appUrl) {
+    headers["HTTP-Referer"] = provider.appUrl;
+  }
+  if (provider.appName) {
+    headers["X-Title"] = provider.appName;
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function resolveLanguageModel(providerHandle, modelId, providerName) {
+  if (typeof providerHandle === "function") {
+    return providerHandle(modelId);
+  }
+  const dynamicHandle = providerHandle;
+  const candidates = ["languageModel", "chatModel", "chat"];
+  for (const candidate of candidates) {
+    const factory = dynamicHandle[candidate];
+    if (typeof factory === "function") {
+      return factory(modelId);
+    }
+  }
+  throw new RouterConfigurationError(
+    `Provider "${providerName}" does not expose a supported language model factory.`
+  );
+}
+function normalizeUsage(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
+  }
+  const numericUsage = usage;
+  const normalized = {};
+  const keys = [
+    "inputTokens",
+    "outputTokens",
+    "totalTokens",
+    "reasoningTokens",
+    "cachedInputTokens"
+  ];
+  for (const key of keys) {
+    const value = numericUsage[key];
+    if (typeof value === "number") {
+      normalized[key] = value;
+    }
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeWarnings(warnings) {
+  return Array.isArray(warnings) ? warnings : void 0;
+}
+
+// src/source-builders.ts
+function createLlmConnection(provider) {
+  assertConnectionProviderName(provider);
+  return {
+    provider
+  };
+}
+function createLlmSource(connection, config) {
+  assertSourceConfig(config);
+  const normalizedConfig = config.access === "free" ? config : {
+    ...config,
+    access: "standard"
+  };
+  return {
+    connection,
+    config: normalizedConfig
+  };
+}
+function assertConnectionProviderName(provider) {
+  if (!provider.name.trim()) {
+    throw new RouterConfigurationError(
+      "Connection provider names must be non-empty."
+    );
+  }
+}
+function assertSourceConfig(config) {
+  if (!config.name.trim()) {
+    throw new RouterConfigurationError("Source names must be non-empty.");
+  }
+  if (!config.model.trim()) {
+    throw new RouterConfigurationError("Source models must be non-empty.");
+  }
+}
+
+// src/prio-llm-router.ts
+var PrioLlmRouter = class {
+  providersByName = /* @__PURE__ */ new Map();
+  modelsByName = /* @__PURE__ */ new Map();
+  defaultChain;
+  executor;
+  hooks;
+  constructor(options) {
+    const normalized = resolveRouterConfig(options);
+    if (normalized.providers.length === 0) {
+      throw new RouterConfigurationError(
+        "At least one provider configuration is required."
+      );
+    }
+    if (normalized.models.length === 0) {
+      throw new RouterConfigurationError(
+        "At least one model configuration is required."
+      );
+    }
+    this.defaultChain = normalized.defaultChain;
+    this.hooks = options.hooks;
+    this.executor = options.executor ?? (options.defaultProviderMaxRetries === void 0 ? createDefaultTextGenerationExecutor() : createDefaultTextGenerationExecutor({
+      defaultProviderMaxRetries: options.defaultProviderMaxRetries
+    }));
+    for (const provider of normalized.providers) {
+      this.assertUniqueName(
+        this.providersByName,
+        provider.name,
+        "provider configuration"
+      );
+      this.validateProvider(provider);
+      this.providersByName.set(provider.name, provider);
+    }
+    normalized.models.forEach((model, index) => {
+      this.assertUniqueName(this.modelsByName, model.name, "model configuration");
+      if (!this.providersByName.has(model.provider)) {
+        throw new RouterConfigurationError(
+          `Model "${model.name}" references unknown provider "${model.provider}".`
+        );
+      }
+      this.modelsByName.set(model.name, {
+        ...model,
+        __index: index
+      });
+    });
+    if (this.defaultChain) {
+      this.resolveNamedChain(this.defaultChain);
+    }
+  }
+  listProviders() {
+    return [...this.providersByName.values()];
+  }
+  listModels() {
+    return [...this.modelsByName.values()].sort(compareModels).map((model) => this.toResolvedTarget(model));
+  }
+  async generateText(request) {
+    const chain = this.resolveExecutionChain(request.chain);
+    const attempts = [];
+    let lastError;
+    for (const [index, model] of chain.entries()) {
+      const provider = this.providersByName.get(model.provider);
+      if (!provider) {
+        throw new RouterConfigurationError(
+          `Provider "${model.provider}" was not found for target "${model.name}".`
+        );
+      }
+      const pendingAttempt = {
+        attemptIndex: index,
+        targetName: model.name,
+        providerName: provider.name,
+        providerType: provider.type,
+        model: model.model,
+        startedAt: /* @__PURE__ */ new Date()
+      };
+      if (model.tier !== void 0) {
+        pendingAttempt.tier = model.tier;
+      }
+      this.hooks?.onAttemptStart?.(pendingAttempt);
+      try {
+        const result = await this.executor.execute({
+          provider,
+          model,
+          request
+        });
+        const finishedAt = /* @__PURE__ */ new Date();
+        const attemptRecord = {
+          ...pendingAttempt,
+          finishedAt,
+          durationMs: finishedAt.getTime() - pendingAttempt.startedAt.getTime(),
+          success: true
+        };
+        attempts.push(attemptRecord);
+        this.hooks?.onAttemptSuccess?.(attemptRecord);
+        const response = {
+          text: result.text,
+          target: this.toResolvedTarget(model),
+          attempts,
+          finishReason: result.finishReason,
+          raw: result.raw
+        };
+        if (result.usage) {
+          response.usage = result.usage;
+        }
+        if (result.warnings) {
+          response.warnings = result.warnings;
+        }
+        return response;
+      } catch (error) {
+        if (isAbortError(error)) {
+          throw error;
+        }
+        const finishedAt = /* @__PURE__ */ new Date();
+        const attemptRecord = {
+          ...pendingAttempt,
+          finishedAt,
+          durationMs: finishedAt.getTime() - pendingAttempt.startedAt.getTime(),
+          success: false,
+          error: serializeError(error)
+        };
+        attempts.push(attemptRecord);
+        this.hooks?.onAttemptFailure?.(attemptRecord);
+        lastError = error;
+      }
+    }
+    throw new AllModelsFailedError(attempts, lastError);
+  }
+  async streamText(request) {
+    const chain = this.resolveExecutionChain(request.chain);
+    const attempts = [];
+    let lastError;
+    for (const [index, model] of chain.entries()) {
+      const provider = this.providersByName.get(model.provider);
+      if (!provider) {
+        throw new RouterConfigurationError(
+          `Provider "${model.provider}" was not found for target "${model.name}".`
+        );
+      }
+      const pendingAttempt = createPendingAttempt(index, provider, model);
+      this.hooks?.onAttemptStart?.(pendingAttempt);
+      const { controller, cleanup, parentAborted } = createLinkedAbortController(
+        request.abortSignal
+      );
+      try {
+        const streamResult = await this.executor.stream({
+          provider,
+          model,
+          request: {
+            ...request,
+            abortSignal: controller.signal
+          }
+        });
+        const iterator = streamResult.textStream[Symbol.asyncIterator]();
+        const firstChunk = await this.waitForFirstChunk({
+          iterator,
+          timeoutMs: request.firstChunkTimeoutMs,
+          abortController: controller,
+          parentAborted
+        });
+        if (firstChunk.done) {
+          throw createEmptyFirstChunkError(model.name);
+        }
+        return this.createStreamingResult({
+          pendingAttempt,
+          attempts,
+          model,
+          iterator,
+          streamResult,
+          firstChunk: firstChunk.value,
+          cleanupAbortLink: cleanup
+        });
+      } catch (error) {
+        cleanup();
+        if (isAbortError(error) && parentAborted()) {
+          throw error;
+        }
+        const attemptRecord = createFailedAttemptRecord(pendingAttempt, error);
+        attempts.push(attemptRecord);
+        this.hooks?.onAttemptFailure?.(attemptRecord);
+        lastError = error;
+      }
+    }
+    throw new AllModelsFailedError(attempts, lastError);
+  }
+  createStreamingResult(options) {
+    const {
+      pendingAttempt,
+      attempts,
+      model,
+      iterator,
+      streamResult,
+      firstChunk,
+      cleanupAbortLink
+    } = options;
+    let started = false;
+    const textParts = [firstChunk];
+    let resolveFinal;
+    let rejectFinal;
+    let finalized = false;
+    const final = new Promise((resolve, reject) => {
+      resolveFinal = resolve;
+      rejectFinal = reject;
+    });
+    const finalizeSuccess = async () => {
+      if (finalized) {
+        return;
+      }
+      finalized = true;
+      const finishedAt = /* @__PURE__ */ new Date();
+      const attemptRecord = {
+        ...pendingAttempt,
+        finishedAt,
+        durationMs: finishedAt.getTime() - pendingAttempt.startedAt.getTime(),
+        success: true
+      };
+      attempts.push(attemptRecord);
+      this.hooks?.onAttemptSuccess?.(attemptRecord);
+      const result = {
+        text: textParts.join(""),
+        target: this.toResolvedTarget(model),
+        attempts: [...attempts],
+        finishReason: await streamResult.finishReason,
+        raw: streamResult.raw
+      };
+      const usage = await streamResult.usage;
+      if (usage) {
+        result.usage = usage;
+      }
+      const warnings = await streamResult.warnings;
+      if (warnings) {
+        result.warnings = warnings;
+      }
+      cleanupAbortLink();
+      resolveFinal(result);
+    };
+    const finalizeFailure = (error) => {
+      if (finalized) {
+        return;
+      }
+      finalized = true;
+      const attemptRecord = createFailedAttemptRecord(pendingAttempt, error);
+      attempts.push(attemptRecord);
+      this.hooks?.onAttemptFailure?.(attemptRecord);
+      cleanupAbortLink();
+      rejectFinal(error);
+    };
+    const wrappedStream = {
+      [Symbol.asyncIterator]: () => {
+        if (started) {
+          throw new RouterConfigurationError(
+            "This stream can only be consumed once."
+          );
+        }
+        started = true;
+        return createRouterTextStreamIterator({
+          firstChunk,
+          iterator,
+          onChunk: (chunk) => {
+            textParts.push(chunk);
+          },
+          onSuccess: finalizeSuccess,
+          onFailure: finalizeFailure
+        });
+      }
+    };
+    return {
+      target: this.toResolvedTarget(model),
+      selectedAttempt: pendingAttempt,
+      attempts: [...attempts],
+      textStream: wrappedStream,
+      final,
+      consumeStream: async () => {
+        if (!started) {
+          for await (const _ of wrappedStream) {
+          }
+        }
+        return final;
+      }
+    };
+  }
+  async waitForFirstChunk(options) {
+    const { iterator, timeoutMs, abortController, parentAborted } = options;
+    const nextPromise = iterator.next();
+    if (timeoutMs === void 0) {
+      return nextPromise;
+    }
+    const timeoutError = createFirstChunkTimeoutError(timeoutMs);
+    const timedRace = await Promise.race([
+      nextPromise.then(
+        (value) => ({ kind: "value", value }),
+        (error) => ({ kind: "error", error })
+      ),
+      delay(timeoutMs).then(() => ({ kind: "timeout" }))
+    ]);
+    if (timedRace.kind === "value") {
+      return timedRace.value;
+    }
+    if (timedRace.kind === "timeout") {
+      abortController.abort(timeoutError);
+      void nextPromise.catch(() => void 0);
+      throw timeoutError;
+    }
+    if (isAbortError(timedRace.error) && parentAborted()) {
+      throw timedRace.error;
+    }
+    throw timedRace.error;
+  }
+  resolveExecutionChain(chain) {
+    if (chain?.length) {
+      return this.resolveNamedChain(chain);
+    }
+    if (this.defaultChain?.length) {
+      return this.resolveNamedChain(this.defaultChain);
+    }
+    const implicitChain = [...this.modelsByName.values()].filter((model) => this.isModelEnabled(model)).sort(compareModels);
+    if (implicitChain.length === 0) {
+      throw new RouterConfigurationError(
+        "No enabled model targets are available for execution."
+      );
+    }
+    return implicitChain;
+  }
+  resolveNamedChain(chain) {
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const targetName of chain) {
+      if (seen.has(targetName)) {
+        continue;
+      }
+      seen.add(targetName);
+      const model = this.modelsByName.get(targetName);
+      if (!model) {
+        throw new RouterConfigurationError(
+          `Model target "${targetName}" is not configured.`
+        );
+      }
+      if (!this.isModelEnabled(model)) {
+        throw new RouterConfigurationError(
+          `Model target "${targetName}" is disabled or its provider is disabled.`
+        );
+      }
+      resolved.push(model);
+    }
+    if (resolved.length === 0) {
+      throw new RouterConfigurationError(
+        "The resolved execution chain is empty."
+      );
+    }
+    return resolved;
+  }
+  isModelEnabled(model) {
+    if (model.enabled === false) {
+      return false;
+    }
+    const provider = this.providersByName.get(model.provider);
+    return provider?.enabled !== false;
+  }
+  toResolvedTarget(model) {
+    const provider = this.providersByName.get(model.provider);
+    if (!provider) {
+      throw new RouterConfigurationError(
+        `Model "${model.name}" references missing provider "${model.provider}".`
+      );
+    }
+    const resolvedTarget = {
+      name: model.name,
+      providerName: provider.name,
+      providerType: provider.type,
+      model: model.model
+    };
+    if (model.priority !== void 0) {
+      resolvedTarget.priority = model.priority;
+    }
+    if (model.tier !== void 0) {
+      resolvedTarget.tier = model.tier;
+    }
+    if (model.metadata !== void 0) {
+      resolvedTarget.metadata = model.metadata;
+    }
+    return resolvedTarget;
+  }
+  validateProvider(provider) {
+    if (!provider.name.trim()) {
+      throw new RouterConfigurationError(
+        "Provider configuration names must be non-empty."
+      );
+    }
+    if (!provider.auth.apiKey.trim()) {
+      throw new RouterConfigurationError(
+        `Provider "${provider.name}" requires a non-empty API key.`
+      );
+    }
+  }
+  assertUniqueName(registry, name, label) {
+    if (!name.trim()) {
+      throw new RouterConfigurationError(`${label} names must be non-empty.`);
+    }
+    if (registry.has(name)) {
+      throw new RouterConfigurationError(
+        `Duplicate ${label} name "${name}" detected.`
+      );
+    }
+  }
+};
+function createLlmRouter(options) {
+  return new PrioLlmRouter(options);
+}
+function resolveRouterConfig(options) {
+  if ("sources" in options) {
+    return compileSources(options.sources, options.defaultChain);
+  }
+  const normalized = {
+    providers: options.providers,
+    models: options.models
+  };
+  if (options.defaultChain !== void 0) {
+    normalized.defaultChain = options.defaultChain;
+  }
+  return normalized;
+}
+function compareModels(left, right) {
+  const leftPriority = left.priority ?? Number.MAX_SAFE_INTEGER;
+  const rightPriority = right.priority ?? Number.MAX_SAFE_INTEGER;
+  if (leftPriority !== rightPriority) {
+    return leftPriority - rightPriority;
+  }
+  return left.__index - right.__index;
+}
+function compileSources(sources, defaultChain) {
+  const providersByName = /* @__PURE__ */ new Map();
+  const models = [];
+  for (const source of sources) {
+    const provider = source.connection.provider;
+    const providerName = provider.name.trim();
+    const modelId = source.config.model.trim();
+    const access = source.config.access ?? "standard";
+    if (!providerName) {
+      throw new RouterConfigurationError(
+        "Connection provider names must be non-empty."
+      );
+    }
+    if (!source.config.name.trim()) {
+      throw new RouterConfigurationError("Source names must be non-empty.");
+    }
+    if (!modelId) {
+      throw new RouterConfigurationError("Source models must be non-empty.");
+    }
+    const existingProvider = providersByName.get(providerName);
+    if (existingProvider) {
+      assertMatchingSourceProvider(existingProvider, provider);
+    } else {
+      providersByName.set(providerName, provider);
+    }
+    if (access === "free") {
+      assertGuaranteedFreeSource(provider, source.config.model);
+    }
+    if (access === "free" && source.config.tier === "paid") {
+      throw new RouterConfigurationError(
+        `Free source "${source.config.name}" cannot be marked as paid.`
+      );
+    }
+    const compiledModel = {
+      name: source.config.name,
+      provider: providerName,
+      model: modelId
+    };
+    if (source.config.enabled !== void 0) {
+      compiledModel.enabled = source.config.enabled;
+    }
+    if (source.config.priority !== void 0) {
+      compiledModel.priority = source.config.priority;
+    }
+    const tier = source.config.tier ?? (access === "free" ? "free" : void 0);
+    if (tier !== void 0) {
+      compiledModel.tier = tier;
+    }
+    if (source.config.metadata !== void 0) {
+      compiledModel.metadata = source.config.metadata;
+    }
+    models.push(compiledModel);
+  }
+  const normalized = {
+    providers: [...providersByName.values()],
+    models
+  };
+  if (defaultChain !== void 0) {
+    normalized.defaultChain = defaultChain;
+  }
+  return normalized;
+}
+function assertMatchingSourceProvider(existingProvider, nextProvider) {
+  if (JSON.stringify(existingProvider) === JSON.stringify(nextProvider)) {
+    return;
+  }
+  throw new RouterConfigurationError(
+    `Connection provider "${existingProvider.name}" is configured more than once with different settings.`
+  );
+}
+function assertGuaranteedFreeSource(provider, model) {
+  if (provider.type !== "openrouter") {
+    throw new RouterConfigurationError(
+      `Provider "${provider.name}" does not support strict free sources. Only OpenRouter with explicit ":free" model variants is supported today.`
+    );
+  }
+  const normalizedModel = model.trim();
+  if (normalizedModel === "openrouter/free") {
+    throw new RouterConfigurationError(
+      `Free source "${provider.name}" cannot use "openrouter/free". Use an explicit ":free" model id instead.`
+    );
+  }
+  if (!normalizedModel.endsWith(":free")) {
+    throw new RouterConfigurationError(
+      `Free OpenRouter sources must use an explicit ":free" model id. Received "${normalizedModel}".`
+    );
+  }
+}
+function createPendingAttempt(attemptIndex, provider, model) {
+  const pendingAttempt = {
+    attemptIndex,
+    targetName: model.name,
+    providerName: provider.name,
+    providerType: provider.type,
+    model: model.model,
+    startedAt: /* @__PURE__ */ new Date()
+  };
+  if (model.tier !== void 0) {
+    pendingAttempt.tier = model.tier;
+  }
+  return pendingAttempt;
+}
+function createFailedAttemptRecord(pendingAttempt, error) {
+  const finishedAt = /* @__PURE__ */ new Date();
+  return {
+    ...pendingAttempt,
+    finishedAt,
+    durationMs: finishedAt.getTime() - pendingAttempt.startedAt.getTime(),
+    success: false,
+    error: serializeError(error)
+  };
+}
+function createRouterTextStreamIterator(options) {
+  const { firstChunk, iterator, onChunk, onSuccess, onFailure } = options;
+  let firstYielded = false;
+  let finished = false;
+  return {
+    async next() {
+      if (finished) {
+        return {
+          done: true,
+          value: void 0
+        };
+      }
+      if (!firstYielded) {
+        firstYielded = true;
+        return {
+          done: false,
+          value: firstChunk
+        };
+      }
+      try {
+        const next = await iterator.next();
+        if (next.done) {
+          finished = true;
+          await onSuccess();
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        onChunk(next.value);
+        return {
+          done: false,
+          value: next.value
+        };
+      } catch (error) {
+        finished = true;
+        onFailure(error);
+        throw error;
+      }
+    },
+    async return() {
+      finished = true;
+      onFailure(createStreamClosedEarlyError());
+      if (typeof iterator.return === "function") {
+        await iterator.return();
+      }
+      return {
+        done: true,
+        value: void 0
+      };
+    },
+    async throw(error) {
+      finished = true;
+      onFailure(error);
+      if (typeof iterator.throw === "function") {
+        return iterator.throw(error);
+      }
+      throw error;
+    }
+  };
+}
+function createLinkedAbortController(parentSignal) {
+  const controller = new AbortController();
+  let abortedByParent = false;
+  const abortFromParent = () => {
+    abortedByParent = true;
+    controller.abort(parentSignal?.reason);
+  };
+  if (parentSignal?.aborted) {
+    abortFromParent();
+  } else {
+    parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+  }
+  return {
+    controller,
+    cleanup: () => {
+      parentSignal?.removeEventListener("abort", abortFromParent);
+    },
+    parentAborted: () => abortedByParent
+  };
+}
+function createFirstChunkTimeoutError(timeoutMs) {
+  const error = new Error(
+    `The first stream chunk did not arrive within ${timeoutMs}ms.`
+  );
+  error.name = "FirstChunkTimeoutError";
+  return error;
+}
+function createEmptyFirstChunkError(targetName) {
+  const error = new Error(
+    `Stream for target "${targetName}" completed before the first text chunk.`
+  );
+  error.name = "EmptyStreamError";
+  return error;
+}
+function createStreamClosedEarlyError() {
+  const error = new Error("The stream was closed before completion.");
+  error.name = "StreamClosedError";
+  return error;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+exports.AllModelsFailedError = AllModelsFailedError;
+exports.PrioLlmRouter = PrioLlmRouter;
+exports.PrioLlmRouterError = PrioLlmRouterError;
+exports.RouterConfigurationError = RouterConfigurationError;
+exports.createDefaultTextGenerationExecutor = createDefaultTextGenerationExecutor;
+exports.createLlmConnection = createLlmConnection;
+exports.createLlmRouter = createLlmRouter;
+exports.createLlmSource = createLlmSource;
+exports.isAbortError = isAbortError;
+exports.serializeError = serializeError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map