@oai2lmapi/opencode-provider 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,5 +1,150 @@
-// src/provider.ts
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+// src/index.ts
+import {
+  createOpenAICompatible
+} from "@ai-sdk/openai-compatible";
+
+// src/config.ts
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, isAbsolute } from "node:path";
+function getDataDir() {
+  const xdgDataHome = process.env["XDG_DATA_HOME"];
+  if (xdgDataHome && isAbsolute(xdgDataHome)) {
+    return join(xdgDataHome, "opencode");
+  }
+  return join(homedir(), ".local", "share", "opencode");
+}
+function getConfigDir() {
+  const xdgConfigHome = process.env["XDG_CONFIG_HOME"];
+  if (xdgConfigHome && isAbsolute(xdgConfigHome)) {
+    return join(xdgConfigHome, "opencode");
+  }
+  return join(homedir(), ".config", "opencode");
+}
+var CONFIG_FILENAME = "oai2lm.json";
+function readJsonFile(filepath) {
+  try {
+    if (!existsSync(filepath)) {
+      return void 0;
+    }
+    const content = readFileSync(filepath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      console.warn(
+        `Failed to parse JSON in config file ${filepath}: ${error.message}`
+      );
+    } else {
+      console.warn(`Failed to read config file ${filepath}:`, error);
+    }
+    return void 0;
+  }
+}
+function loadConfig() {
+  const dataDir = getDataDir();
+  const configDir = getConfigDir();
+  const dataPath = join(dataDir, CONFIG_FILENAME);
+  const dataConfig = readJsonFile(dataPath);
+  const configPath = join(configDir, CONFIG_FILENAME);
+  const configDirConfig = readJsonFile(configPath);
+  if (dataConfig && configDirConfig) {
+    return {
+      ...configDirConfig,
+      ...dataConfig,
+      headers: {
+        ...configDirConfig.headers,
+        ...dataConfig.headers
+      },
+      modelOverrides: {
+        ...configDirConfig.modelOverrides,
+        ...dataConfig.modelOverrides
+      }
+    };
+  }
+  return dataConfig || configDirConfig;
+}
+function resolveApiKey(config) {
+  if (config.apiKey) {
+    const envMatch = config.apiKey.match(/^\{env:(\w+)\}$/);
+    if (envMatch) {
+      return process.env[envMatch[1]];
+    }
+    const fileMatch = config.apiKey.match(/^\{file:(.+)\}$/);
+    if (fileMatch) {
+      try {
+        let filePath = fileMatch[1];
+        if (filePath.startsWith("~")) {
+          filePath = join(homedir(), filePath.slice(1));
+        }
+        return readFileSync(filePath, "utf-8").trim();
+      } catch {
+        return void 0;
+      }
+    }
+    return config.apiKey;
+  }
+  return process.env["OAI2LM_API_KEY"];
+}
+
+// src/discover.ts
+async function discoverModels(baseURL, apiKey, headers) {
+  const url = `${baseURL}/models`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      ...headers
+    }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch models from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const models = data.data || [];
+  return models.map((model) => ({
+    id: model.id,
+    name: model.name,
+    object: model.object,
+    created: model.created,
+    owned_by: model.owned_by,
+    metadata: extractMetadataFromModel(model)
+  }));
+}
+function extractMetadataFromModel(model) {
+  const metadata = {};
+  if (model.context_length) {
+    metadata.maxInputTokens = model.context_length;
+  }
+  if (model.max_tokens) {
+    metadata.maxOutputTokens = model.max_tokens;
+  }
+  if (model.max_input_tokens) {
+    metadata.maxInputTokens = model.max_input_tokens;
+  }
+  if (model.max_output_tokens) {
+    metadata.maxOutputTokens = model.max_output_tokens;
+  }
+  if (typeof model.function_call === "boolean") {
+    metadata.supportsToolCalling = model.function_call;
+  } else if (typeof model.supports_function_calling === "boolean") {
+    metadata.supportsToolCalling = model.supports_function_calling;
+  } else if (typeof model.supports_tools === "boolean") {
+    metadata.supportsToolCalling = model.supports_tools;
+  }
+  if (typeof model.vision === "boolean") {
+    metadata.supportsImageInput = model.vision;
+  } else if (typeof model.supports_vision === "boolean") {
+    metadata.supportsImageInput = model.supports_vision;
+  } else if (model.modalities?.includes("vision")) {
+    metadata.supportsImageInput = true;
+  } else if (model.modalities?.includes("image")) {
+    metadata.supportsImageInput = true;
+  }
+  return metadata;
+}
 
 // ../model-metadata/dist/esm/index.mjs
 var DEFAULT_MODEL_METADATA = {
@@ -9,10 +154,10 @@ var DEFAULT_MODEL_METADATA = {
   supportsImageInput: false,
   modelType: "llm"
 };
-var md = (maxInputTokens, maxOutputTokens, supportsToolCalling2, supportsImageInput, modelType = "llm") => ({
+var md = (maxInputTokens, maxOutputTokens, supportsToolCalling, supportsImageInput, modelType = "llm") => ({
   maxInputTokens,
   maxOutputTokens,
-  supportsToolCalling: supportsToolCalling2,
+  supportsToolCalling,
   supportsImageInput,
   modelType
 });
@@ -536,360 +681,156 @@ function getModelMetadata(modelId) {
 function getModelMetadataFromPatterns(modelId) {
   return getModelMetadata(modelId);
 }
+
+// src/metadata.ts
+function getModelMetadataFromPatterns2(modelId) {
+  return getModelMetadataFromPatterns(modelId);
+}
 function mergeMetadata(apiMetadata, patternMetadata) {
+  if (!apiMetadata) {
+    return patternMetadata;
+  }
   return {
-    maxInputTokens: apiMetadata?.maxInputTokens ?? patternMetadata.maxInputTokens,
-    maxOutputTokens: apiMetadata?.maxOutputTokens ?? patternMetadata.maxOutputTokens,
-    supportsToolCalling: apiMetadata?.supportsToolCalling ?? patternMetadata.supportsToolCalling,
-    supportsImageInput: apiMetadata?.supportsImageInput ?? patternMetadata.supportsImageInput,
-    modelType: apiMetadata?.modelType ?? patternMetadata.modelType
+    maxInputTokens: apiMetadata.maxInputTokens ?? patternMetadata.maxInputTokens,
+    maxOutputTokens: apiMetadata.maxOutputTokens ?? patternMetadata.maxOutputTokens,
+    supportsToolCalling: apiMetadata.supportsToolCalling ?? patternMetadata.supportsToolCalling,
+    supportsImageInput: apiMetadata.supportsImageInput ?? patternMetadata.supportsImageInput,
+    modelType: patternMetadata.modelType
   };
 }
 
-// src/modelMetadata.ts
-var getModelMetadataFromPatterns2 = getModelMetadataFromPatterns;
-var mergeMetadata2 = mergeMetadata;
-
-// src/modelDiscovery.ts
-var ModelDiscovery = class {
-  // 5 minutes
-  constructor(baseURL, apiKey, headers, fetchFn = fetch) {
-    this.baseURL = baseURL;
-    this.apiKey = apiKey;
-    this.headers = headers;
-    this.fetchFn = fetchFn;
+// src/index.ts
+var modelCache = /* @__PURE__ */ new WeakMap();
+function findModelOverride(modelId, overrides) {
+  if (!overrides) return void 0;
+  if (overrides[modelId]) {
+    return overrides[modelId];
   }
-  modelsCache = /* @__PURE__ */ new Map();
-  lastFetchTime = 0;
-  cacheDuration = 5 * 60 * 1e3;
-  /**
-   * Fetch models from API /models endpoint
-   */
-  async fetchModels() {
-    const now = Date.now();
-    if (this.modelsCache.size > 0 && now - this.lastFetchTime < this.cacheDuration) {
-      return Array.from(this.modelsCache.values());
-    }
-    try {
-      const url = `${this.baseURL}/models`;
-      const response = await this.fetchFn(url, {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          ...this.headers
-        }
-      });
-      if (!response.ok) {
-        console.warn(`Failed to fetch models from ${url}: ${response.status} ${response.statusText}`);
-        return [];
+  for (const [pattern, override] of Object.entries(overrides)) {
+    if (pattern.includes("*") || pattern.includes("?")) {
+      const regex = new RegExp(
+        "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+      );
+      {
       }
-      const data = await response.json();
-      const models = data.data || [];
-      for (const model of models) {
-        const patternMetadata = getModelMetadataFromPatterns2(model.id);
-        const apiMetadata = this.extractMetadataFromModel(model);
-        model.metadata = mergeMetadata2(apiMetadata, patternMetadata);
-        this.modelsCache.set(model.id, model);
+      if (regex.test(modelId)) {
+        return override;
       }
-      this.lastFetchTime = now;
-      return models;
-    } catch (error) {
-      console.error("Error fetching models:", error);
-      return [];
-    }
-  }
-  /**
-   * Get metadata for a specific model
-   */
-  async getModelMetadata(modelId) {
-    const cached = this.modelsCache.get(modelId);
-    if (cached?.metadata) {
-      return cached.metadata;
-    }
-    await this.fetchModels();
-    const model = this.modelsCache.get(modelId);
-    if (model?.metadata) {
-      return model.metadata;
-    }
-    return getModelMetadataFromPatterns2(modelId);
-  }
-  /**
-   * Extract metadata from model object returned by API
-   */
-  extractMetadataFromModel(model) {
-    const metadata = {};
-    if (model.context_length) {
-      metadata.maxInputTokens = model.context_length;
-    }
-    if (model.max_tokens) {
-      metadata.maxOutputTokens = model.max_tokens;
-    }
-    if (model.max_input_tokens) {
-      metadata.maxInputTokens = model.max_input_tokens;
-    }
-    if (model.max_output_tokens) {
-      metadata.maxOutputTokens = model.max_output_tokens;
-    }
-    if (typeof model.function_call === "boolean") {
-      metadata.supportsToolCalling = model.function_call;
-    } else if (typeof model.supports_function_calling === "boolean") {
-      metadata.supportsToolCalling = model.supports_function_calling;
-    } else if (typeof model.supports_tools === "boolean") {
-      metadata.supportsToolCalling = model.supports_tools;
-    }
-    if (typeof model.vision === "boolean") {
-      metadata.supportsImageInput = model.vision;
-    } else if (typeof model.supports_vision === "boolean") {
-      metadata.supportsImageInput = model.supports_vision;
-    } else if (model.modalities?.includes("vision")) {
-      metadata.supportsImageInput = true;
-    } else if (model.modalities?.includes("image")) {
-      metadata.supportsImageInput = true;
-    }
-    return metadata;
-  }
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.modelsCache.clear();
-    this.lastFetchTime = 0;
-  }
-};
-
-// src/utils.ts
-function wildcardToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const regex = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${regex}$`, "i");
-}
-function matchesWildcard(modelId, pattern) {
-  const regex = wildcardToRegex(pattern);
-  return regex.test(modelId);
-}
-function findBestMatch(modelId, patterns) {
-  const matches = patterns.filter((p) => matchesWildcard(modelId, p));
-  if (matches.length === 0) {
-    return void 0;
-  }
-  matches.sort((a, b) => {
-    const aHasWildcard = a.includes("*") || a.includes("?");
-    const bHasWildcard = b.includes("*") || b.includes("?");
-    if (!aHasWildcard && bHasWildcard) return -1;
-    if (aHasWildcard && !bHasWildcard) return 1;
-    return b.length - a.length;
-  });
-  return matches[0];
-}
-
-// src/config.ts
-import { readFileSync, existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, isAbsolute } from "node:path";
-function getDataDir() {
-  const xdgDataHome = process.env["XDG_DATA_HOME"];
-  if (xdgDataHome && isAbsolute(xdgDataHome)) {
-    return join(xdgDataHome, "opencode");
-  }
-  return join(homedir(), ".local", "share", "opencode");
-}
-function getConfigDir() {
-  const xdgConfigHome = process.env["XDG_CONFIG_HOME"];
-  if (xdgConfigHome && isAbsolute(xdgConfigHome)) {
-    return join(xdgConfigHome, "opencode");
-  }
-  return join(homedir(), ".config", "opencode");
-}
-var CONFIG_FILENAME = "oai2lm.json";
-function readJsonFile(filepath) {
-  try {
-    if (!existsSync(filepath)) {
-      return void 0;
-    }
-    const content = readFileSync(filepath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      const message = error.message;
-      console.warn(`Failed to parse JSON in config file ${filepath}: ${message}`);
-    } else {
-      console.warn(`Failed to read config file ${filepath}:`, error);
-    }
-    return void 0;
-  }
-}
-function loadConfig() {
-  const paths = [
-    join(getDataDir(), CONFIG_FILENAME),
-    join(getConfigDir(), CONFIG_FILENAME)
-  ];
-  for (const configPath of paths) {
-    const config = readJsonFile(configPath);
-    if (config) {
-      return config;
     }
   }
   return void 0;
 }
-function resolveApiKey(explicitKey, config) {
-  if (typeof explicitKey === "string" && explicitKey.trim().length > 0) {
-    return explicitKey.trim();
-  }
-  const envKey = process.env["OAI2LM_API_KEY"];
-  if (typeof envKey === "string" && envKey.trim() !== "") {
-    return envKey.trim();
-  }
-  return config?.apiKey;
-}
-function resolveBaseURL(explicitURL, config) {
-  if (typeof explicitURL === "string" && explicitURL.trim().length > 0) {
-    return explicitURL.trim();
-  }
-  const envURL = process.env["OAI2LM_BASE_URL"];
-  if (typeof envURL === "string" && envURL.trim().length > 0) {
-    return envURL.trim();
-  }
-  if (typeof config?.baseURL === "string" && config.baseURL.trim().length > 0) {
-    return config.baseURL.trim();
-  }
-  return "https://api.openai.com/v1";
-}
-function createSettingsFromConfig(overrides) {
-  const config = loadConfig();
-  const apiKey = resolveApiKey(overrides?.apiKey, config);
-  if (!apiKey) {
-    const dataPath = join(getDataDir(), CONFIG_FILENAME);
-    const configPath = join(getConfigDir(), CONFIG_FILENAME);
-    throw new Error(
-      "API key not found. Please set OAI2LM_API_KEY environment variable, or add apiKey to " + dataPath + " or " + configPath + ", or pass apiKey in settings."
-    );
-  }
-  const baseURL = resolveBaseURL(overrides?.baseURL, config);
-  const modelOverrides = {
-    ...config?.modelOverrides ?? {},
-    ...overrides?.modelOverrides ?? {}
-  };
+function mergeWithConfig(options, config) {
+  if (!config) return options;
   return {
-    apiKey,
-    baseURL,
-    name: overrides?.name ?? config?.name ?? "oai2lm",
+    // Options take precedence over config
+    baseURL: options.baseURL || config.baseURL || "",
+    apiKey: options.apiKey || resolveApiKey(config),
+    name: options.name || config.name,
     headers: {
-      ...config?.headers ?? {},
-      ...overrides?.headers ?? {}
+      ...config.headers,
+      ...options.headers
+    },
+    modelFilter: options.modelFilter || config.modelFilter,
+    modelOverrides: {
+      ...config.modelOverrides,
+      ...options.modelOverrides
     },
-    autoDiscoverModels: overrides?.autoDiscoverModels ?? config?.autoDiscoverModels ?? true,
-    modelOverrides: Object.keys(modelOverrides).length > 0 ? modelOverrides : void 0,
-    fetch: overrides?.fetch
+    useConfigFile: options.useConfigFile
   };
 }
-function getConfigFilePath() {
-  return join(getDataDir(), CONFIG_FILENAME);
-}
-
-// src/provider.ts
-function createOAI2LMProvider(settings) {
-  const providerName = settings.name || "oai2lm";
-  const modelOverrides = settings.modelOverrides || {};
-  const fetchFn = settings.fetch || fetch;
+function createOai2lm(options) {
+  const config = options.useConfigFile !== false ? loadConfig() : void 0;
+  const mergedOptions = mergeWithConfig(options, config);
+  if (!mergedOptions.baseURL) {
+    throw new Error(
+      "baseURL is required. Provide it in options or in oai2lm.json config file."
+    );
+  }
   const baseProvider = createOpenAICompatible({
-    baseURL: settings.baseURL,
-    name: providerName,
-    apiKey: settings.apiKey,
-    headers: settings.headers,
-    fetch: fetchFn
+    baseURL: mergedOptions.baseURL.replace(/\/+$/, ""),
+    name: mergedOptions.name || "oai2lm",
+    apiKey: mergedOptions.apiKey,
+    headers: mergedOptions.headers
   });
-  const modelDiscovery = new ModelDiscovery(
-    settings.baseURL,
-    settings.apiKey,
-    settings.headers || {},
-    fetchFn
-  );
-  async function discoverModels() {
-    return modelDiscovery.fetchModels();
-  }
-  async function getModelMetadata2(modelId) {
-    return modelDiscovery.getModelMetadata(modelId);
-  }
-  function clearModelCache() {
-    modelDiscovery.clearCache();
-  }
-  function getModelOverride(modelId) {
-    const patterns = Object.keys(modelOverrides);
-    const bestMatch = findBestMatch(modelId, patterns);
-    return bestMatch ? modelOverrides[bestMatch] : void 0;
-  }
-  if (settings.autoDiscoverModels !== false) {
-    discoverModels().catch((err) => {
-      console.warn("Failed to auto-discover models:", err);
+  const cacheKey = {};
+  async function discoverAndCache() {
+    const apiKey = mergedOptions.apiKey || "";
+    const models = await discoverModels(
+      mergedOptions.baseURL,
+      apiKey,
+      mergedOptions.headers
+    );
+    let filteredModels = models;
+    if (mergedOptions.modelFilter) {
+      const filterRegex = new RegExp(mergedOptions.modelFilter);
+      filteredModels = models.filter((m) => filterRegex.test(m.id));
+    }
+    const metadataMap = /* @__PURE__ */ new Map();
+    for (const model of filteredModels) {
+      const patternMetadata = getModelMetadataFromPatterns2(model.id);
+      const metadata = mergeMetadata(model.metadata, patternMetadata);
+      const override = findModelOverride(
+        model.id,
+        mergedOptions.modelOverrides
+      );
+      if (override) {
+        if (override.maxInputTokens !== void 0) {
+          metadata.maxInputTokens = override.maxInputTokens;
+        }
+        if (override.maxOutputTokens !== void 0) {
+          metadata.maxOutputTokens = override.maxOutputTokens;
+        }
+        if (override.supportsToolCalling !== void 0) {
+          metadata.supportsToolCalling = override.supportsToolCalling;
+        }
+        if (override.supportsImageInput !== void 0) {
+          metadata.supportsImageInput = override.supportsImageInput;
+        }
+      }
+      metadataMap.set(model.id, metadata);
+    }
+    modelCache.set(cacheKey, {
+      models: filteredModels,
+      metadata: metadataMap,
+      lastRefresh: Date.now()
     });
   }
+  async function getCache() {
+    let cache = modelCache.get(cacheKey);
+    if (!cache) {
+      await discoverAndCache();
+      cache = modelCache.get(cacheKey);
+    }
+    return cache;
+  }
   const provider = function(modelId) {
-    return baseProvider.languageModel(modelId);
+    return baseProvider(modelId);
   };
-  provider.languageModel = baseProvider.languageModel.bind(baseProvider);
-  provider.chatModel = baseProvider.chatModel.bind(baseProvider);
-  provider.completionModel = baseProvider.completionModel.bind(baseProvider);
-  provider.textEmbeddingModel = baseProvider.textEmbeddingModel.bind(baseProvider);
-  provider.imageModel = baseProvider.imageModel.bind(baseProvider);
-  provider.discoverModels = discoverModels;
-  provider.getModelMetadata = getModelMetadata2;
-  provider.clearModelCache = clearModelCache;
-  provider.getModelOverride = getModelOverride;
-  Object.defineProperty(provider, "providerName", {
-    value: providerName,
-    writable: false,
-    enumerable: true
-  });
-  return provider;
-}
-function createOAI2LMProviderFromConfig(overrides) {
-  const settings = createSettingsFromConfig(overrides);
-  return createOAI2LMProvider(settings);
-}
-
-// src/index.ts
-function isPluginInput(arg) {
-  if (typeof arg !== "object" || arg === null) {
-    return false;
-  }
-  if (!Object.prototype.hasOwnProperty.call(arg, "client")) {
-    return false;
-  }
-  const client = arg.client;
-  if (typeof client !== "object" || client === null) {
-    return false;
-  }
-  return true;
-}
-var EMPTY_HOOKS = Object.freeze({});
-function guardPluginCall(fn) {
-  return (...args) => {
-    if (args.length > 0 && isPluginInput(args[0])) {
-      return EMPTY_HOOKS;
-    }
-    return fn(...args);
+  provider.languageModel = (modelId) => baseProvider.languageModel(modelId);
+  provider.chatModel = (modelId) => baseProvider.chatModel(modelId);
+  provider.completionModel = (modelId) => baseProvider.completionModel(modelId);
+  provider.textEmbeddingModel = (modelId) => baseProvider.textEmbeddingModel(modelId);
+  provider.imageModel = (modelId) => baseProvider.imageModel(modelId);
+  provider.listModels = async () => {
+    const cache = await getCache();
+    return cache.models;
+  };
+  provider.getModelMetadata = async (modelId) => {
+    const cache = await getCache();
+    return cache.metadata.get(modelId);
   };
+  provider.refreshModels = async () => {
+    await discoverAndCache();
+  };
+  return provider;
 }
-var createOAI2LMProvider2 = guardPluginCall(createOAI2LMProvider);
-var createOAI2LMProviderFromConfig2 = guardPluginCall(createOAI2LMProviderFromConfig);
-var loadConfig2 = guardPluginCall(loadConfig);
-var createSettingsFromConfig2 = guardPluginCall(createSettingsFromConfig);
-var getConfigFilePath2 = guardPluginCall(getConfigFilePath);
-var getDataDir2 = guardPluginCall(getDataDir);
-var getConfigDir2 = guardPluginCall(getConfigDir);
-var resolveApiKey2 = guardPluginCall(resolveApiKey);
-var resolveBaseURL2 = guardPluginCall(resolveBaseURL);
-var getModelMetadataFromPatterns3 = guardPluginCall(getModelMetadataFromPatterns2);
+var index_default = createOai2lm;
 export {
-  createOAI2LMProvider2 as createOAI2LMProvider,
-  createOAI2LMProviderFromConfig2 as createOAI2LMProviderFromConfig,
-  createSettingsFromConfig2 as createSettingsFromConfig,
-  getConfigDir2 as getConfigDir,
-  getConfigFilePath2 as getConfigFilePath,
-  getDataDir2 as getDataDir,
-  getModelMetadataFromPatterns3 as getModelMetadataFromPatterns,
-  loadConfig2 as loadConfig,
-  resolveApiKey2 as resolveApiKey,
-  resolveBaseURL2 as resolveBaseURL
+  createOai2lm,
+  index_default as default,
+  discoverModels,
+  loadConfig,
+  resolveApiKey
 };
 //# sourceMappingURL=index.js.map