@pwshub/aisdk 0.0.4 → 0.0.5

package/src/config.test.js

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Tests for config module.
+ */
+
+import {
+  describe, it,
+} from 'node:test'
+import assert from 'node:assert'
+import {
+  normalizeConfig, getWireMap,
+} from '../src/config.js'
+
+describe('config', () => {
+  describe('getWireMap', () => {
+    it('should return wire map for openai', () => {
+      const wireMap = getWireMap('openai')
+      assert.ok(wireMap)
+      assert.ok(wireMap.temperature)
+      assert.strictEqual(wireMap.temperature.wireKey, 'temperature')
+    })
+
+    it('should return wire map for anthropic', () => {
+      const wireMap = getWireMap('anthropic')
+      assert.ok(wireMap)
+      assert.ok(wireMap.temperature)
+      assert.strictEqual(wireMap.temperature.wireKey, 'temperature')
+    })
+
+    it('should return wire map for google', () => {
+      const wireMap = getWireMap('google')
+      assert.ok(wireMap)
+      assert.ok(wireMap.temperature)
+      assert.strictEqual(wireMap.temperature.wireKey, 'temperature')
+      assert.strictEqual(wireMap.temperature.scope, 'generationConfig')
+    })
+
+    it('should return wire map for dashscope', () => {
+      const wireMap = getWireMap('dashscope')
+      assert.ok(wireMap)
+      assert.ok(wireMap.temperature)
+      assert.strictEqual(wireMap.temperature.wireKey, 'temperature')
+    })
+
+    it('should return wire map for deepseek', () => {
+      const wireMap = getWireMap('deepseek')
+      assert.ok(wireMap)
+      assert.ok(wireMap.temperature)
+      assert.strictEqual(wireMap.temperature.wireKey, 'temperature')
+    })
+
+    it('should return undefined for unknown provider', () => {
+      const wireMap = getWireMap('unknown')
+      assert.strictEqual(wireMap, undefined)
+    })
+  })
+
+  describe('normalizeConfig', () => {
+    it('should normalize openai config', () => {
+      const config = {
+        temperature: 0.5,
+        maxTokens: 100,
+        topP: 0.9,
+      }
+      const supportedParams = ['temperature', 'maxTokens', 'topP']
+      const result = normalizeConfig(config, 'openai', supportedParams, 'gpt-4o')
+
+      assert.strictEqual(result.temperature, 0.5)
+      assert.strictEqual(result.max_completion_tokens, 100)
+      assert.strictEqual(result.top_p, 0.9)
+    })
+
+    it('should normalize anthropic config', () => {
+      const config = {
+        temperature: 0.5,
+        maxTokens: 100,
+        topK: 50,
+      }
+      const supportedParams = ['temperature', 'maxTokens', 'topK']
+      const result = normalizeConfig(config, 'anthropic', supportedParams, 'claude-sonnet')
+
+      assert.strictEqual(result.temperature, 0.5)
+      assert.strictEqual(result.max_tokens, 100)
+      assert.strictEqual(result.top_k, 50)
+    })
+
+    it('should normalize google config with generationConfig nesting', () => {
+      const config = {
+        temperature: 0.5,
+        maxTokens: 100,
+        topP: 0.9,
+      }
+      const supportedParams = ['temperature', 'maxTokens', 'topP']
+      const result = normalizeConfig(config, 'google', supportedParams, 'gemini-2.0-flash')
+
+      assert.strictEqual(result.temperature, undefined)
+      assert.strictEqual(result.maxTokens, undefined)
+      assert.strictEqual(result.topP, undefined)
+      assert.ok(result.generationConfig)
+      assert.strictEqual(result.generationConfig.temperature, 0.5)
+      assert.strictEqual(result.generationConfig.maxOutputTokens, 100)
+      assert.strictEqual(result.generationConfig.topP, 0.9)
+    })
+
+    it('should skip unsupported params', () => {
+      const config = {
+        temperature: 0.5,
+        topK: 50, // openai doesn't support topK
+      }
+      const supportedParams = ['temperature']
+      const result = normalizeConfig(config, 'openai', supportedParams, 'gpt-4o')
+
+      assert.strictEqual(result.temperature, 0.5)
+      assert.strictEqual(result.top_k, undefined)
+    })
+
+    it('should skip null/undefined values', () => {
+      const config = {
+        temperature: 0.5,
+        maxTokens: null,
+        topP: undefined,
+      }
+      const supportedParams = ['temperature', 'maxTokens', 'topP']
+      const result = normalizeConfig(config, 'openai', supportedParams, 'gpt-4o')
+
+      assert.strictEqual(result.temperature, 0.5)
+      assert.strictEqual(result.max_completion_tokens, undefined)
+      assert.strictEqual(result.top_p, undefined)
+    })
+
+    it('should return empty object when no config provided', () => {
+      const result = normalizeConfig({}, 'openai', ['temperature'], 'gpt-4o')
+      assert.deepStrictEqual(result, {})
+    })
+
+    it('should return empty object when no supported params match', () => {
+      const config = { unknownParam: 123 }
+      const supportedParams = ['temperature']
+      const result = normalizeConfig(config, 'openai', supportedParams, 'gpt-4o')
+      assert.deepStrictEqual(result, {})
+    })
+  })
+})

package/src/errors.js

@@ -35,7 +35,7 @@ export class ProviderError extends Error {
    * @param {object} meta
    * @param {number} meta.status        - HTTP status code
    * @param {string} meta.provider      - Provider ID
-   * @param {string} meta.model         - Model ID that was called
+   * @param {string} meta.model         - Model name that was called
    * @param {string} [meta.raw]         - Raw response body from provider
    */
   constructor(message, {

package/src/index.js

@@ -6,7 +6,7 @@
  *
  * const ai = createAi()
  * const result = await ai.ask({
- *   model: 'claude-sonnet-4-20250514',
+ *   model: 'anthropic/claude-sonnet-4-20250514',
  *   apikey: 'your-api-key',
  *   prompt: 'What is the capital of Vietnam?',
  *   temperature: 0.5,
@@ -16,18 +16,18 @@
  *
  * @example With fallbacks
  * const result = await ai.ask({
- *   model: 'gpt-4o',
+ *   model: 'openai/gpt-4o',
  *   apikey: 'your-openai-key',
  *   prompt: '...',
- *   fallbacks: ['gpt-4o-mini', 'claude-haiku-4-5-20251001'],
+ *   fallbacks: ['openai/gpt-4o-mini', 'anthropic/claude-haiku-4-5-20251001'],
  * })
- * if (result.model !== 'gpt-4o') {
+ * if (result.model !== 'openai/gpt-4o') {
  *   console.warn('Fell back to', result.model)
  * }
  *
  * @example Google provider-specific options
  * const result = await ai.ask({
- *   model: 'gemini-2.0-flash',
+ *   model: 'google/gemini-2.0-flash',
  *   apikey: 'your-google-key',
  *   prompt: '...',
  *   providerOptions: {
@@ -40,7 +40,7 @@
  *
  * @example Using messages array for multi-turn conversations
  * const result = await ai.ask({
- *   model: 'claude-sonnet-4-20250514',
+ *   model: 'anthropic/claude-sonnet-4-20250514',
  *   apikey: 'your-api-key',
  *   messages: [
  *     { role: 'user', content: 'What is the capital of Vietnam?' },
@@ -73,12 +73,12 @@ export {
 
 /**
  * @typedef {Object} AskParams
- * @property {string} model                       - Model ID (must be registered via setModels())
+ * @property {string} model                       - Model name or 'provider/name' format (e.g., 'gpt-4o', 'ollama/llama3.2')
  * @property {string} apikey                      - API key for the provider
  * @property {string} [prompt]                    - The user message (alternative to messages)
  * @property {string} [system]                    - Optional system prompt (used with prompt)
  * @property {import('./providers.js').Message[]} [messages] - Array of messages with role and content (alternative to prompt)
- * @property {string[]} [fallbacks]               - Ordered list of fallback model IDs
+ * @property {string[]} [fallbacks]               - Ordered list of fallback models (same format as model)
  * @property {Record<string, unknown>} [providerOptions] - Provider-specific options merged into body
  * @property {number} [temperature]
  * @property {number} [maxTokens]

package/src/models.js

@@ -342,4 +342,60 @@ export const DEFAULT_MODELS = [
     max_out: 65536,
     enable: true,
   },
+  // Mistral models
+  {
+    id: 'mistral-large-latest',
+    name: 'mistral-large-latest',
+    provider: 'mistral',
+    input_price: 0.5,
+    output_price: 1.5,
+    cache_price: 0,
+    max_in: 128000,
+    max_out: 128000,
+    enable: true,
+  },
+  {
+    id: 'mistral-medium-latest',
+    name: 'mistral-medium-latest',
+    provider: 'mistral',
+    input_price: 0.4,
+    output_price: 2,
+    cache_price: 0,
+    max_in: 64000,
+    max_out: 64000,
+    enable: true,
+  },
+  {
+    id: 'mistral-small-latest',
+    name: 'mistral-small-latest',
+    provider: 'mistral',
+    input_price: 0.15,
+    output_price: 0.6,
+    cache_price: 0,
+    max_in: 128000,
+    max_out: 128000,
+    enable: true,
+  },
+  {
+    id: 'magistral-medium-latest',
+    name: 'magistral-medium-latest',
+    provider: 'mistral',
+    input_price: 2,
+    output_price: 5,
+    cache_price: 0,
+    max_in: 64000,
+    max_out: 64000,
+    enable: true,
+  },
+  {
+    id: 'magistral-small-latest',
+    name: 'magistral-small-latest',
+    provider: 'mistral',
+    input_price: 0.5,
+    output_price: 1.5,
+    cache_price: 0,
+    max_in: 64000,
+    max_out: 64000,
+    enable: true,
+  },
 ]

package/src/providers.js

@@ -10,7 +10,7 @@
  */
 
 /**
- * @typedef {'openai'|'anthropic'|'google'|'dashscope'|'deepseek'} ProviderId
+ * @typedef {'openai'|'anthropic'|'google'|'dashscope'|'deepseek'|'mistral'|'ollama'} ProviderId
  */
 
 /**
@@ -298,9 +298,79 @@ const deepseek = {
   }),
 }
 
+/** @type {ProviderAdapter} */
+const mistral = {
+  headers: (apikey) => ({
+    Authorization: `Bearer ${apikey}`,
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+  }),
+  url: () => 'https://api.mistral.ai/v1/chat/completions',
+  buildBody: (modelName, messages, config, providerOptions) => ({
+    model: modelName,
+    messages,
+    ...config,
+    ...providerOptions,
+  }),
+  extractText: (data) => {
+    const content = data.choices?.[0]?.message?.content
+    if (!content) {
+      throw new Error('Mistral response missing content')
+    }
+    return content
+  },
+  extractUsage: (data) => ({
+    inputTokens: data.usage?.prompt_tokens ?? 0,
+    outputTokens: data.usage?.completion_tokens ?? 0,
+    cacheTokens: 0,
+    reasoningTokens: 0,
+  }),
+}
+
+/** @type {ProviderAdapter} */
+const ollama = {
+  headers: (apikey) => ({
+    'Content-Type': 'application/json',
+    ...(apikey && { Authorization: `Bearer ${apikey}` }),
+  }),
+  // Default to localhost, but can be overridden via gatewayUrl
+  url: () => 'http://localhost:11434/api/chat',
+  buildBody: (modelName, messages, config, providerOptions) => {
+    // Ollama uses snake_case options
+    const options = {}
+    if (config.temperature !== undefined) options.temperature = config.temperature
+    if (config.top_p !== undefined) options.top_p = config.top_p
+    if (config.top_k !== undefined) options.top_k = config.top_k
+    if (config.num_predict !== undefined) options.num_predict = config.num_predict
+    if (config.seed !== undefined) options.seed = config.seed
+    if (config.stop !== undefined) options.stop = config.stop
+    
+    return {
+      model: modelName,
+      messages,
+      stream: false,
+      ...providerOptions,
+      ...(Object.keys(options).length > 0 && { options }),
+    }
+  },
+  extractText: (data) => {
+    const content = data.message?.content
+    if (!content) {
+      throw new Error('Ollama response missing content')
+    }
+    return content
+  },
+  extractUsage: (data) => ({
+    inputTokens: data.prompt_eval_count ?? 0,
+    outputTokens: data.eval_count ?? 0,
+    cacheTokens: 0,
+    reasoningTokens: 0,
+  }),
+}
+
 /** @type {Record<string, ProviderAdapter>} */
 const ADAPTERS = {
-  openai, anthropic, google, dashscope, deepseek,
+  openai, anthropic, google, dashscope, deepseek, mistral, ollama,
 }
 
 /**

package/src/registry.js

@@ -4,7 +4,8 @@
  * Default models are loaded automatically from ./models.js at import time.
  * Users can modify the registry via addModels() and setModels().
  *
- * This module provides O(1) lookups at runtime via a Map indexed by model ID.
+ * This module provides O(1) lookups at runtime via a Map.
+ * Models can be looked up by name, or by provider/name format.
  *
  * `supportedParams` is optional per record. When absent, the provider's
  * default param set is used.
@@ -43,10 +44,12 @@ export const PROVIDER_DEFAULT_PARAMS = {
   google: ['temperature', 'maxTokens', 'topP', 'topK', 'seed', 'stop'],
   dashscope: ['temperature', 'maxTokens', 'topP', 'topK', 'stop'],
   deepseek: ['temperature', 'maxTokens', 'topP', 'frequencyPenalty', 'presencePenalty', 'stop'],
+  mistral: ['temperature', 'maxTokens', 'topP', 'randomSeed', 'stop'],
+  ollama: ['temperature', 'maxTokens', 'topP', 'topK', 'seed', 'stop'],
 }
 
 /** @type {ProviderId[]} */
-const VALID_PROVIDERS = ['openai', 'anthropic', 'google', 'dashscope', 'deepseek']
+const VALID_PROVIDERS = ['openai', 'anthropic', 'google', 'dashscope', 'deepseek', 'mistral', 'ollama']
 
 /** @type {Map<string, ModelRecord>} */
 let REGISTRY = new Map()
@@ -72,34 +75,29 @@ initRegistry()
 const validateModelRecord = (model, index) => {
   const errors = []
 
-  // Check required string fields
-  if (!model.id || typeof model.id !== 'string') {
-    errors.push('"id" must be a non-empty string')
-  }
-
+  // Only name and provider are required
   if (!model.name || typeof model.name !== 'string') {
     errors.push('"name" must be a non-empty string')
   }
 
-  // Check provider is valid
   if (!model.provider || typeof model.provider !== 'string') {
     errors.push('"provider" must be a string')
   } else if (!VALID_PROVIDERS.includes(model.provider)) {
     errors.push(`"provider" must be one of: ${VALID_PROVIDERS.join(', ')}. Got: "${model.provider}"`)
   }
 
-  // Check required number fields (must be non-negative)
+  // Check optional number fields if present (must be non-negative)
   const numberFields = ['input_price', 'output_price', 'cache_price', 'max_in', 'max_out']
   for (const field of numberFields) {
-    if (typeof model[field] !== 'number') {
+    if (model[field] !== undefined && typeof model[field] !== 'number') {
       errors.push(`"${field}" must be a number`)
-    } else if (model[field] < 0) {
+    } else if (model[field] !== undefined && model[field] < 0) {
       errors.push(`"${field}" must be non-negative, got: ${model[field]}`)
     }
   }
 
-  // Check enable is boolean
-  if (typeof model.enable !== 'boolean') {
+  // Check optional enable if present
+  if (model.enable !== undefined && typeof model.enable !== 'boolean') {
     errors.push('"enable" must be a boolean')
   }
 
@@ -122,30 +120,69 @@ const validateModelRecord = (model, index) => {
 }
 
 /**
- * Looks up a model by ID, validates it is enabled, and resolves its
- * effective supported params (record-level override or provider default).
+ * Normalizes a model record by setting defaults for missing fields.
+ * Generates id from provider and name if not provided.
  *
- * @param {string} modelId
+ * @param {Object} model - The model record to normalize
+ * @returns {ModelRecord} Normalized model record
+ */
+const normalizeModelRecord = (model) => {
+  return {
+    id: model.id || `${model.provider}_${model.name}`,
+    name: model.name,
+    provider: model.provider,
+    input_price: model.input_price ?? 0,
+    output_price: model.output_price ?? 0,
+    cache_price: model.cache_price ?? 0,
+    max_in: model.max_in ?? 32000,
+    max_out: model.max_out ?? 8000,
+    enable: model.enable ?? true,
+    ...(model.supportedParams !== undefined && { supportedParams: model.supportedParams }),
+  }
+}
+
+/**
+ * Looks up a model by provider/name format.
+ * Validates it is enabled, and resolves its effective supported params.
+ *
+ * @param {string} modelId - Model in 'provider/name' format (e.g., 'openai/gpt-4o', 'ollama/llama3.2')
  * @returns {{ record: ModelRecord, supportedParams: string[] }}
  * @throws {Error} When the model is not found or is disabled
  */
 export const getModel = (modelId) => {
-  const record = REGISTRY.get(modelId)
-
-  if (!record) {
-    const available = [...REGISTRY.keys()].join(', ')
-    throw new Error(`Unknown model "${modelId}". Available: ${available}`)
+  // Require provider/name format
+  if (!modelId.includes('/')) {
+    const available = [...REGISTRY.values()].map(m => `${m.provider}/${m.name}`).join(', ')
+    throw new Error(`Model must be in 'provider/name' format. Got: "${modelId}". Available: ${available}`)
   }
-
-  if (!record.enable) {
-    throw new Error(`Model "${modelId}" is currently disabled.`)
+  
+  const parts = modelId.split('/')
+  if (parts.length !== 2) {
+    const available = [...REGISTRY.values()].map(m => `${m.provider}/${m.name}`).join(', ')
+    throw new Error(`Model must be in 'provider/name' format. Got: "${modelId}". Available: ${available}`)
   }
-
-  const supportedParams = record.supportedParams ?? PROVIDER_DEFAULT_PARAMS[record.provider]
-
-  return {
-    record, supportedParams,
+  
+  const [provider, name] = parts
+  
+  // Search for model by name and provider
+  for (const m of REGISTRY.values()) {
+    if (m.name === name && m.provider === provider) {
+      const record = m
+      
+      if (!record.enable) {
+        throw new Error(`Model "${record.provider}/${record.name}" is currently disabled.`)
+      }
+
+      const supportedParams = record.supportedParams ?? PROVIDER_DEFAULT_PARAMS[record.provider]
+
+      return {
+        record, supportedParams,
+      }
+    }
   }
+  
+  const available = [...REGISTRY.values()].map(m => `${m.provider}/${m.name}`).join(', ')
+  throw new Error(`Unknown model "${modelId}". Available: ${available}`)
 }
 
 /**
@@ -168,14 +205,15 @@ export const addModels = (models) => {
     throw new Error(`addModels expects an array. Got: ${typeof models}`)
   }
 
-  // Validate each model record
+  // Validate and normalize each model record
   models.forEach((model, index) => {
     validateModelRecord(model, index)
   })
 
-  // Add models to the registry
+  // Add normalized models to the registry
   models.forEach((model) => {
-    REGISTRY.set(model.id, model)
+    const normalized = normalizeModelRecord(model)
+    REGISTRY.set(normalized.id, normalized)
   })
 }
 
@@ -191,10 +229,13 @@ export const setModels = (models) => {
     throw new Error(`setModels expects an array. Got: ${typeof models}`)
   }
 
-  // Validate each model record strictly
+  // Validate and normalize each model record
   models.forEach((model, index) => {
     validateModelRecord(model, index)
   })
 
-  REGISTRY = new Map(models.map((model) => [model.id, model]))
+  REGISTRY = new Map(models.map((model) => {
+    const normalized = normalizeModelRecord(model)
+    return [normalized.id, normalized]
+  }))
 }