@contractspec/lib.ai-providers 2.9.0 → 3.1.1

package/dist/selector.js

@@ -0,0 +1,694 @@
+// @bun
+// src/models.ts
+var DEFAULT_MODELS = {
+  ollama: "llama3.2",
+  openai: "gpt-4o",
+  anthropic: "claude-sonnet-4-20250514",
+  mistral: "mistral-large-latest",
+  gemini: "gemini-2.0-flash"
+};
+var MODELS = [
+  {
+    id: "llama3.2",
+    name: "Llama 3.2",
+    provider: "ollama",
+    contextWindow: 128000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    }
+  },
+  {
+    id: "codellama",
+    name: "Code Llama",
+    provider: "ollama",
+    contextWindow: 16000,
+    capabilities: {
+      vision: false,
+      tools: false,
+      reasoning: false,
+      streaming: true
+    }
+  },
+  {
+    id: "deepseek-coder",
+    name: "DeepSeek Coder",
+    provider: "ollama",
+    contextWindow: 16000,
+    capabilities: {
+      vision: false,
+      tools: false,
+      reasoning: false,
+      streaming: true
+    }
+  },
+  {
+    id: "mistral",
+    name: "Mistral 7B",
+    provider: "ollama",
+    contextWindow: 32000,
+    capabilities: {
+      vision: false,
+      tools: false,
+      reasoning: false,
+      streaming: true
+    }
+  },
+  {
+    id: "gpt-4o",
+    name: "GPT-4o",
+    provider: "openai",
+    contextWindow: 128000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 2.5, output: 10 }
+  },
+  {
+    id: "gpt-4o-mini",
+    name: "GPT-4o Mini",
+    provider: "openai",
+    contextWindow: 128000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 0.15, output: 0.6 }
+  },
+  {
+    id: "o1",
+    name: "o1",
+    provider: "openai",
+    contextWindow: 200000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    },
+    costPerMillion: { input: 15, output: 60 }
+  },
+  {
+    id: "o1-mini",
+    name: "o1 Mini",
+    provider: "openai",
+    contextWindow: 128000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    },
+    costPerMillion: { input: 3, output: 12 }
+  },
+  {
+    id: "claude-sonnet-4-20250514",
+    name: "Claude Sonnet 4",
+    provider: "anthropic",
+    contextWindow: 200000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    },
+    costPerMillion: { input: 3, output: 15 }
+  },
+  {
+    id: "claude-3-5-sonnet-20241022",
+    name: "Claude 3.5 Sonnet",
+    provider: "anthropic",
+    contextWindow: 200000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 3, output: 15 }
+  },
+  {
+    id: "claude-3-5-haiku-20241022",
+    name: "Claude 3.5 Haiku",
+    provider: "anthropic",
+    contextWindow: 200000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 0.8, output: 4 }
+  },
+  {
+    id: "mistral-large-latest",
+    name: "Mistral Large",
+    provider: "mistral",
+    contextWindow: 128000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 2, output: 6 }
+  },
+  {
+    id: "mistral-medium-latest",
+    name: "Mistral Medium",
+    provider: "mistral",
+    contextWindow: 128000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    }
+  },
+  {
+    id: "codestral-latest",
+    name: "Codestral",
+    provider: "mistral",
+    contextWindow: 256000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 0.2, output: 0.6 }
+  },
+  {
+    id: "devstral-small-latest",
+    name: "Devstral Small",
+    provider: "mistral",
+    contextWindow: 128000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    }
+  },
+  {
+    id: "magistral-medium-latest",
+    name: "Magistral Medium",
+    provider: "mistral",
+    contextWindow: 128000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    }
+  },
+  {
+    id: "pixtral-large-latest",
+    name: "Pixtral Large",
+    provider: "mistral",
+    contextWindow: 128000,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    }
+  },
+  {
+    id: "mistral-small-latest",
+    name: "Mistral Small",
+    provider: "mistral",
+    contextWindow: 32000,
+    capabilities: {
+      vision: false,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 0.2, output: 0.6 }
+  },
+  {
+    id: "gemini-2.0-flash",
+    name: "Gemini 2.0 Flash",
+    provider: "gemini",
+    contextWindow: 1e6,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: false,
+      streaming: true
+    },
+    costPerMillion: { input: 0.075, output: 0.3 }
+  },
+  {
+    id: "gemini-2.5-pro-preview-06-05",
+    name: "Gemini 2.5 Pro",
+    provider: "gemini",
+    contextWindow: 1e6,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    },
+    costPerMillion: { input: 1.25, output: 10 }
+  },
+  {
+    id: "gemini-2.5-flash-preview-05-20",
+    name: "Gemini 2.5 Flash",
+    provider: "gemini",
+    contextWindow: 1e6,
+    capabilities: {
+      vision: true,
+      tools: true,
+      reasoning: true,
+      streaming: true
+    },
+    costPerMillion: { input: 0.15, output: 0.6 }
+  }
+];
+function getModelsForProvider(provider) {
+  return MODELS.filter((m) => m.provider === provider);
+}
+function getModelInfo(modelId) {
+  return MODELS.find((m) => m.id === modelId);
+}
+function getRecommendedModels(provider) {
+  const normalizedProvider = provider === "claude" ? "anthropic" : provider === "custom" ? "openai" : provider;
+  return getModelsForProvider(normalizedProvider).map((m) => m.id);
+}
+function getDefaultModel(provider) {
+  return DEFAULT_MODELS[provider];
+}
+
+// src/factory.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createMistral } from "@ai-sdk/mistral";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOllama } from "ollama-ai-provider";
+class BaseProvider {
+  name;
+  model;
+  mode;
+  config;
+  transport;
+  authMethod;
+  apiVersion;
+  customHeaders;
+  cachedModel = null;
+  constructor(config) {
+    this.name = config.provider;
+    this.model = config.model ?? DEFAULT_MODELS[config.provider];
+    this.mode = this.determineMode(config);
+    this.config = config;
+    this.transport = config.transport;
+    this.authMethod = config.authMethod;
+    this.apiVersion = config.apiVersion;
+    this.customHeaders = config.customHeaders;
+  }
+  getModel() {
+    if (!this.cachedModel) {
+      this.cachedModel = this.createModel();
+    }
+    return this.cachedModel;
+  }
+  async listModels() {
+    if (this.name === "ollama") {
+      return this.listOllamaModels();
+    }
+    return getModelsForProvider(this.name);
+  }
+  async validate() {
+    if (this.name === "ollama") {
+      return this.validateOllama();
+    }
+    if (this.mode === "byok" && !this.config.apiKey) {
+      return {
+        valid: false,
+        error: `API key required for ${this.name}`
+      };
+    }
+    if (this.mode === "managed" && !this.config.proxyUrl && !this.config.organizationId) {
+      return {
+        valid: false,
+        error: "Managed mode requires proxyUrl or organizationId"
+      };
+    }
+    return { valid: true };
+  }
+  determineMode(config) {
+    if (config.provider === "ollama")
+      return "local";
+    if (config.apiKey)
+      return "byok";
+    return "managed";
+  }
+  createModel() {
+    const { baseUrl, proxyUrl, apiKey } = this.config;
+    const headers = this.customHeaders;
+    if (this.name === "ollama") {
+      const provider = createOllama({ baseURL: baseUrl, headers });
+      return provider(this.model);
+    }
+    if (this.mode === "managed" && proxyUrl) {
+      const provider = createOpenAI({ baseURL: proxyUrl, apiKey, headers });
+      return provider(this.model);
+    }
+    switch (this.name) {
+      case "openai": {
+        const provider = createOpenAI({ apiKey, headers });
+        return provider(this.model);
+      }
+      case "anthropic": {
+        const provider = createAnthropic({ apiKey, headers });
+        return provider(this.model);
+      }
+      case "mistral": {
+        const provider = createMistral({ apiKey, headers });
+        return provider(this.model);
+      }
+      case "gemini": {
+        const provider = createGoogleGenerativeAI({ apiKey, headers });
+        return provider(this.model);
+      }
+      default:
+        throw new Error(`Unknown provider: ${this.name}`);
+    }
+  }
+  async listOllamaModels() {
+    try {
+      const baseUrl = this.config.baseUrl ?? "http://localhost:11434";
+      const response = await fetch(`${baseUrl}/api/tags`);
+      if (!response.ok) {
+        return getModelsForProvider("ollama");
+      }
+      const data = await response.json();
+      const models = data.models ?? [];
+      return models.map((m) => ({
+        id: m.name,
+        name: m.name,
+        provider: "ollama",
+        contextWindow: 8000,
+        capabilities: {
+          vision: false,
+          tools: false,
+          reasoning: false,
+          streaming: true
+        }
+      }));
+    } catch {
+      return getModelsForProvider("ollama");
+    }
+  }
+  async validateOllama() {
+    try {
+      const baseUrl = this.config.baseUrl ?? "http://localhost:11434";
+      const response = await fetch(`${baseUrl}/api/tags`);
+      if (!response.ok) {
+        return {
+          valid: false,
+          error: `Ollama server returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      const models = data.models ?? [];
+      const hasModel = models.some((m) => m.name === this.model);
+      if (!hasModel) {
+        return {
+          valid: false,
+          error: `Model "${this.model}" not found. Available: ${models.map((m) => m.name).join(", ")}`
+        };
+      }
+      return { valid: true };
+    } catch (error) {
+      const baseUrl = this.config.baseUrl ?? "http://localhost:11434";
+      return {
+        valid: false,
+        error: `Cannot connect to Ollama at ${baseUrl}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+}
+function createProvider(config) {
+  return new BaseProvider(config);
+}
+function createProviderFromEnv() {
+  const provider = process.env.CONTRACTSPEC_AI_PROVIDER ?? "openai";
+  const model = process.env.CONTRACTSPEC_AI_MODEL;
+  let apiKey;
+  switch (provider) {
+    case "openai":
+      apiKey = process.env.OPENAI_API_KEY;
+      break;
+    case "anthropic":
+      apiKey = process.env.ANTHROPIC_API_KEY;
+      break;
+    case "mistral":
+      apiKey = process.env.MISTRAL_API_KEY;
+      break;
+    case "gemini":
+      apiKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+      break;
+    case "ollama":
+      break;
+  }
+  const transport = process.env.CONTRACTSPEC_AI_TRANSPORT;
+  const apiVersion = process.env.CONTRACTSPEC_AI_API_VERSION;
+  return createProvider({
+    provider,
+    model,
+    apiKey,
+    baseUrl: process.env.OLLAMA_BASE_URL,
+    proxyUrl: process.env.CONTRACTSPEC_AI_PROXY_URL,
+    organizationId: process.env.CONTRACTSPEC_ORG_ID,
+    transport,
+    apiVersion
+  });
+}
+function getAvailableProviders() {
+  const providers = [];
+  providers.push({
+    provider: "ollama",
+    available: true,
+    mode: "local",
+    transports: ["rest", "sdk"],
+    authMethods: []
+  });
+  const openaiKey = process.env.OPENAI_API_KEY;
+  providers.push({
+    provider: "openai",
+    available: Boolean(openaiKey) || Boolean(process.env.CONTRACTSPEC_AI_PROXY_URL),
+    mode: openaiKey ? "byok" : "managed",
+    reason: !openaiKey ? "Set OPENAI_API_KEY for BYOK mode" : undefined,
+    transports: ["rest", "sdk"],
+    authMethods: ["api-key"]
+  });
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  providers.push({
+    provider: "anthropic",
+    available: Boolean(anthropicKey) || Boolean(process.env.CONTRACTSPEC_AI_PROXY_URL),
+    mode: anthropicKey ? "byok" : "managed",
+    reason: !anthropicKey ? "Set ANTHROPIC_API_KEY for BYOK mode" : undefined,
+    transports: ["rest", "sdk"],
+    authMethods: ["api-key"]
+  });
+  const mistralKey = process.env.MISTRAL_API_KEY;
+  providers.push({
+    provider: "mistral",
+    available: Boolean(mistralKey) || Boolean(process.env.CONTRACTSPEC_AI_PROXY_URL),
+    mode: mistralKey ? "byok" : "managed",
+    reason: !mistralKey ? "Set MISTRAL_API_KEY for BYOK mode" : undefined,
+    transports: ["rest", "sdk"],
+    authMethods: ["api-key"]
+  });
+  const geminiKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+  providers.push({
+    provider: "gemini",
+    available: Boolean(geminiKey) || Boolean(process.env.CONTRACTSPEC_AI_PROXY_URL),
+    mode: geminiKey ? "byok" : "managed",
+    reason: !geminiKey ? "Set GOOGLE_API_KEY for BYOK mode" : undefined,
+    transports: ["rest", "sdk"],
+    authMethods: ["api-key"]
+  });
+  return providers;
+}
+
+// src/selector.ts
+function createModelSelector(options) {
+  const { store, fallbackModels, defaultConstraints } = options;
+  const catalog = fallbackModels ?? MODELS;
+  return {
+    async select(context) {
+      const merged = mergeConstraints(defaultConstraints, context.constraints);
+      if (context.priorities?.length) {
+        return selectMultiObjective(store, catalog, context.priorities, merged);
+      }
+      const dimension = context.taskDimension ?? "reasoning";
+      return selectByDimension(store, catalog, dimension, merged);
+    },
+    async selectAndCreate(context) {
+      const selection = await this.select(context);
+      const model = createProvider({
+        provider: selection.providerKey,
+        model: selection.modelId
+      }).getModel();
+      return { model, selection };
+    }
+  };
+}
+async function selectByDimension(store, catalog, dimension, constraints) {
+  const { rankings } = await store.listModelRankings({ dimension, limit: 50 });
+  const eligible = filterRankings(rankings, catalog, constraints);
+  const topCandidate = eligible[0];
+  if (topCandidate) {
+    const dimScore = topCandidate.dimensionScores[dimension]?.score ?? topCandidate.compositeScore;
+    return {
+      modelId: topCandidate.modelId,
+      providerKey: topCandidate.providerKey,
+      score: dimScore,
+      reason: `Top-ranked for "${dimension}" (score ${Math.round(dimScore)})`,
+      alternatives: eligible.slice(1, 4).map((r) => ({
+        modelId: r.modelId,
+        providerKey: r.providerKey,
+        score: r.dimensionScores[dimension]?.score ?? r.compositeScore
+      }))
+    };
+  }
+  return fallbackFromCatalog(catalog, constraints, dimension);
+}
+async function selectMultiObjective(store, catalog, priorities, constraints) {
+  const { rankings } = await store.listModelRankings({ limit: 100 });
+  const eligible = filterRankings(rankings, catalog, constraints);
+  if (eligible.length === 0) {
+    const primaryDim = priorities.reduce((a, b) => b.weight > a.weight ? b : a).dimension;
+    return fallbackFromCatalog(catalog, constraints, primaryDim);
+  }
+  const totalWeight = priorities.reduce((sum, p) => sum + p.weight, 0) || 1;
+  const scored = eligible.map((r) => {
+    let weightedScore = 0;
+    for (const p of priorities) {
+      const dimScore = r.dimensionScores[p.dimension]?.score ?? 0;
+      weightedScore += dimScore * (p.weight / totalWeight);
+    }
+    return { ranking: r, weightedScore };
+  });
+  scored.sort((a, b) => b.weightedScore - a.weightedScore);
+  const best = scored[0];
+  if (!best) {
+    const primaryDim = priorities.reduce((a, b) => b.weight > a.weight ? b : a).dimension;
+    return fallbackFromCatalog(catalog, constraints, primaryDim);
+  }
+  const dims = priorities.map((p) => p.dimension).join(", ");
+  return {
+    modelId: best.ranking.modelId,
+    providerKey: best.ranking.providerKey,
+    score: Math.round(best.weightedScore * 100) / 100,
+    reason: `Multi-objective optimum across [${dims}]`,
+    alternatives: scored.slice(1, 4).map((s) => ({
+      modelId: s.ranking.modelId,
+      providerKey: s.ranking.providerKey,
+      score: Math.round(s.weightedScore * 100) / 100
+    }))
+  };
+}
+function filterRankings(rankings, catalog, constraints) {
+  return rankings.filter((r) => {
+    if (constraints.allowedProviders?.length) {
+      if (!constraints.allowedProviders.includes(r.providerKey))
+        return false;
+    }
+    if (constraints.excludeModels?.length) {
+      if (constraints.excludeModels.includes(r.modelId))
+        return false;
+    }
+    const info = getModelInfo(r.modelId) ?? catalog.find((m) => m.id === r.modelId);
+    if (!info)
+      return true;
+    if (constraints.minContextWindow && info.contextWindow < constraints.minContextWindow) {
+      return false;
+    }
+    if (constraints.maxCostPerMillionInput && info.costPerMillion) {
+      if (info.costPerMillion.input > constraints.maxCostPerMillionInput)
+        return false;
+    }
+    if (constraints.maxCostPerMillionOutput && info.costPerMillion) {
+      if (info.costPerMillion.output > constraints.maxCostPerMillionOutput)
+        return false;
+    }
+    if (constraints.requiredCapabilities?.length) {
+      for (const cap of constraints.requiredCapabilities) {
+        if (!info.capabilities[cap])
+          return false;
+      }
+    }
+    return true;
+  });
+}
+function fallbackFromCatalog(catalog, constraints, dimension) {
+  let eligible = catalog.filter((m) => m.costPerMillion != null);
+  const {
+    allowedProviders,
+    excludeModels,
+    minContextWindow,
+    requiredCapabilities
+  } = constraints;
+  if (allowedProviders?.length) {
+    eligible = eligible.filter((m) => allowedProviders.includes(m.provider));
+  }
+  if (excludeModels?.length) {
+    eligible = eligible.filter((m) => !excludeModels.includes(m.id));
+  }
+  if (minContextWindow) {
+    eligible = eligible.filter((m) => m.contextWindow >= minContextWindow);
+  }
+  if (requiredCapabilities?.length) {
+    eligible = eligible.filter((m) => requiredCapabilities.every((cap) => m.capabilities[cap]));
+  }
+  if (eligible.length === 0) {
+    eligible = catalog.slice(0, 5);
+  }
+  eligible.sort((a, b) => {
+    const costA = a.costPerMillion ? (a.costPerMillion.input + a.costPerMillion.output) / 2 : 999;
+    const costB = b.costPerMillion ? (b.costPerMillion.input + b.costPerMillion.output) / 2 : 999;
+    return b.contextWindow / 1e5 - costB - (a.contextWindow / 1e5 - costA);
+  });
+  const best = eligible[0];
+  if (!best) {
+    return {
+      modelId: "unknown",
+      providerKey: "openai",
+      score: 0,
+      reason: `No eligible models found for "${dimension}"`,
+      alternatives: []
+    };
+  }
+  return {
+    modelId: best.id,
+    providerKey: best.provider,
+    score: 0,
+    reason: `Fallback from catalog (no ranking data for "${dimension}")`,
+    alternatives: eligible.slice(1, 4).map((m) => ({
+      modelId: m.id,
+      providerKey: m.provider,
+      score: 0
+    }))
+  };
+}
+function mergeConstraints(defaults, overrides) {
+  if (!defaults)
+    return overrides ?? {};
+  if (!overrides)
+    return defaults;
+  return { ...defaults, ...overrides };
+}
+export {
+  createModelSelector
+};