@oai2lmapi/opencode-provider 0.3.1 → 0.3.2-prerelease.20260122071726.e4f214e

package/dist/index.js

@@ -85,6 +85,25 @@ function resolveApiKey(config) {
   }
   return process.env["OAI2LM_API_KEY"];
 }
+function findModelOverride(modelId, overrides) {
+  if (!overrides) {
+    return void 0;
+  }
+  if (overrides[modelId]) {
+    return overrides[modelId];
+  }
+  for (const [pattern, override] of Object.entries(overrides)) {
+    if (pattern.includes("*") || pattern.includes("?")) {
+      const regex = new RegExp(
+        "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+      );
+      if (regex.test(modelId)) {
+        return override;
+      }
+    }
+  }
+  return void 0;
+}
 
 // src/discover.ts
 async function discoverModels(baseURL, apiKey, headers) {
@@ -941,104 +960,183 @@ ${result}
 }
 
 // src/plugin.ts
-function generateModelsConfig(models, providerName = "custom-provider") {
+function generateModelsConfig(models, providerName = "custom-provider", config, modelOverrides) {
   const modelsConfig = {};
   for (const model of models) {
-    const metadata = getModelMetadataFromPatterns2(model.id);
-    const merged = mergeMetadata(model.metadata, metadata);
-    modelsConfig[model.id] = {
+    const patternMetadata = getModelMetadataFromPatterns2(model.id);
+    const metadata = mergeMetadata(model.metadata, patternMetadata);
+    const override = findModelOverride(model.id, 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;
+      }
+    }
+    const modelConfig = {
       name: model.name || model.id,
-      tool_call: merged.supportsToolCalling ?? true,
-      attachment: merged.supportsImageInput ?? false,
+      tool_call: metadata.supportsToolCalling ?? true,
+      attachment: metadata.supportsImageInput ?? false,
       limit: {
-        context: merged.maxInputTokens || 128e3,
-        output: merged.maxOutputTokens || 16384
+        context: metadata.maxInputTokens || 128e3,
+        output: metadata.maxOutputTokens || 16384
       }
     };
+    if (override) {
+      const options = {};
+      if (override.usePromptBasedToolCalling !== void 0) {
+        options.usePromptBasedToolCalling = override.usePromptBasedToolCalling;
+      }
+      if (override.trimXmlToolParameterWhitespace !== void 0) {
+        options.trimXmlToolParameterWhitespace = override.trimXmlToolParameterWhitespace;
+      }
+      if (override.thinkingLevel !== void 0) {
+        options.thinkingLevel = override.thinkingLevel;
+      }
+      if (override.temperature !== void 0) {
+        options.temperature = override.temperature;
+      }
+      if (override.suppressChainOfThought !== void 0) {
+        options.suppressChainOfThought = override.suppressChainOfThought;
+      }
+      if (Object.keys(options).length > 0) {
+        modelConfig.options = options;
+      }
+    }
+    modelsConfig[model.id] = modelConfig;
+  }
+  const providerOptions = {};
+  if (config?.baseURL) {
+    providerOptions.baseURL = config.baseURL;
+  } else {
+    providerOptions.baseURL = "YOUR_API_BASE_URL";
   }
-  const config = {
+  if (config?.apiKey) {
+    if (config.apiKey.startsWith("{env:")) {
+      providerOptions.apiKey = config.apiKey;
+    } else {
+      providerOptions.apiKey = "{env:YOUR_API_KEY_ENV}";
+    }
+  } else {
+    providerOptions.apiKey = "{env:YOUR_API_KEY_ENV}";
+  }
+  if (config?.headers && Object.keys(config.headers).length > 0) {
+    providerOptions.headers = config.headers;
+  }
+  const outputConfig = {
     provider: {
       [providerName]: {
-        name: providerName,
+        name: config?.displayName || providerName,
         npm: "@oai2lmapi/opencode-provider",
-        options: {
-          baseURL: "YOUR_API_BASE_URL",
-          apiKey: "{env:YOUR_API_KEY_ENV}"
-        },
+        options: providerOptions,
         models: modelsConfig
       }
     }
   };
-  return JSON.stringify(config, null, 2);
+  return JSON.stringify(outputConfig, null, 2);
 }
-function formatModelsForDisplay(models, providerName) {
+function formatModelsForDisplay(models, providerName, config) {
   const lines = [
     `# Discovered ${models.length} models`,
-    "",
-    "## Quick Setup",
-    "",
-    "Add the following to your opencode.json:",
-    "",
-    "```json",
-    generateModelsConfig(models, providerName),
-    "```",
-    "",
-    "## Model Details",
     ""
   ];
+  if (config?.baseURL) {
+    lines.push(`**API Endpoint**: ${config.baseURL}`);
+    lines.push("");
+  }
+  lines.push("## Quick Setup");
+  lines.push("");
+  lines.push("Add the following to your opencode.json:");
+  lines.push("");
+  lines.push("```json");
+  lines.push(
+    generateModelsConfig(models, providerName, config, config?.modelOverrides)
+  );
+  lines.push("```");
+  lines.push("");
+  lines.push("## Model Details");
+  lines.push("");
   for (const model of models) {
-    const metadata = getModelMetadataFromPatterns2(model.id);
-    const merged = mergeMetadata(model.metadata, metadata);
+    const patternMetadata = getModelMetadataFromPatterns2(model.id);
+    const metadata = mergeMetadata(model.metadata, patternMetadata);
+    const override = findModelOverride(model.id, config?.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;
+      }
+    }
     lines.push(`### ${model.id}`);
     if (model.name && model.name !== model.id) {
       lines.push(`- Name: ${model.name}`);
     }
-    lines.push(`- Context: ${merged.maxInputTokens || "unknown"} tokens`);
-    lines.push(`- Output: ${merged.maxOutputTokens || "unknown"} tokens`);
-    lines.push(`- Tool Calling: ${merged.supportsToolCalling ? "Yes" : "No"}`);
-    lines.push(`- Vision: ${merged.supportsImageInput ? "Yes" : "No"}`);
+    lines.push(`- Context: ${metadata.maxInputTokens || "unknown"} tokens`);
+    lines.push(`- Output: ${metadata.maxOutputTokens || "unknown"} tokens`);
+    lines.push(`- Tool Calling: ${metadata.supportsToolCalling ? "Yes" : "No"}`);
+    lines.push(`- Vision: ${metadata.supportsImageInput ? "Yes" : "No"}`);
+    if (override?.usePromptBasedToolCalling) {
+      lines.push(`- Uses Prompt-Based Tool Calling: Yes`);
+    }
     lines.push("");
   }
   return lines.join("\n");
 }
 async function oai2lmPlugin(_input) {
+  const savedConfig = loadConfig();
   return {
     tool: {
       oai2lm_discover: {
         description: `Discover available models from an OpenAI-compatible API and generate opencode.json configuration.
 
 This tool will:
-1. Connect to the specified API endpoint
+1. Connect to the specified API endpoint (or use oai2lm.json config)
 2. Fetch all available models
 3. Enrich them with metadata (token limits, capabilities)
-4. Generate ready-to-use opencode.json configuration
+4. Apply any model overrides from oai2lm.json
+5. Generate ready-to-use opencode.json configuration
 
-Use this when you want to add a new OpenAI-compatible provider to OpenCode.`,
+Configuration from oai2lm.json (~/.local/share/opencode/oai2lm.json) is automatically loaded.
+You only need to provide arguments if you want to override the config file settings.`,
         parameters: {
           type: "object",
           properties: {
             baseURL: {
               type: "string",
-              description: "Base URL of the OpenAI-compatible API (e.g., https://api.example.com/v1). If not provided, will try to load from oai2lm.json config."
+              description: "Base URL of the OpenAI-compatible API (e.g., https://api.example.com/v1). If not provided, uses oai2lm.json config."
             },
             apiKey: {
               type: "string",
-              description: "API key for authentication. If not provided, will try to load from config or environment."
+              description: "API key for authentication. If not provided, uses oai2lm.json config or environment."
             },
             providerName: {
               type: "string",
-              description: "Name for the provider in opencode.json (e.g., 'my-api'). Defaults to 'custom-provider'."
+              description: "Name for the provider in opencode.json (e.g., 'my-api'). Defaults to config name or 'custom-provider'."
             },
             filter: {
               type: "string",
-              description: "Optional regex pattern to filter models (e.g., 'gpt|claude')"
+              description: "Optional regex pattern to filter models (e.g., 'gpt|claude')."
             }
           },
           required: []
         },
         execute: async (args) => {
           try {
-            const config = loadConfig();
+            const config = loadConfig() || savedConfig;
             const baseURL = args.baseURL || config?.baseURL || "";
             const apiKey = args.apiKey || (config ? resolveApiKey(config) : "") || "";
             const providerName = args.providerName || config?.name || "custom-provider";
@@ -1046,12 +1144,18 @@ Use this when you want to add a new OpenAI-compatible provider to OpenCode.`,
             if (!baseURL) {
               return `Error: No baseURL provided. Either:
 1. Pass it as an argument: oai2lm_discover(baseURL: "https://api.example.com/v1")
-2. Or create an oai2lm.json config file with baseURL
+2. Or create an oai2lm.json config file at ~/.local/share/opencode/oai2lm.json
 
 Example oai2lm.json:
 {
   "baseURL": "https://api.example.com/v1",
-  "apiKey": "your-api-key"
+  "apiKey": "{env:MY_API_KEY}",
+  "name": "my-api",
+  "modelOverrides": {
+    "gpt-4*": {
+      "supportsImageInput": true
+    }
+  }
 }`;
             }
             let models = await discoverModels(baseURL, apiKey, config?.headers);
@@ -1062,7 +1166,7 @@ Example oai2lm.json:
             if (models.length === 0) {
               return `No models found at ${baseURL}/models. Check your API key and endpoint.`;
             }
-            return formatModelsForDisplay(models, providerName);
+            return formatModelsForDisplay(models, providerName, config);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             return `Error discovering models: ${message}`;
@@ -1073,48 +1177,416 @@ Example oai2lm.json:
   };
 }
 
-// src/index.ts
-var modelCache = /* @__PURE__ */ new WeakMap();
-function findModelOverride(modelId, overrides) {
-  if (!overrides) {
-    return void 0;
+// src/enhancedModel.ts
+var idCounter = 0;
+function generateId() {
+  return `id_${Date.now()}_${++idCounter}`;
+}
+var EnhancedLanguageModel = class {
+  specificationVersion = "v2";
+  modelId;
+  baseModel;
+  override;
+  constructor(baseModel, modelId, override) {
+    this.baseModel = baseModel;
+    this.modelId = modelId;
+    this.override = override;
   }
-  if (overrides[modelId]) {
-    return overrides[modelId];
+  get provider() {
+    return this.baseModel.provider;
   }
-  for (const [pattern, override] of Object.entries(overrides)) {
-    if (pattern.includes("*") || pattern.includes("?")) {
-      const regex = new RegExp(
-        "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+  get supportedUrls() {
+    return this.baseModel.supportedUrls;
+  }
+  /**
+   * Generate text (non-streaming)
+   */
+  async doGenerate(options) {
+    let modifiedOptions = { ...options };
+    modifiedOptions = this.applyModelOverrides(modifiedOptions);
+    const toolNames = [];
+    if (this.override?.usePromptBasedToolCalling && options.tools && options.tools.length > 0) {
+      const result2 = this.applyPromptBasedToolCalling(modifiedOptions);
+      modifiedOptions = result2.options;
+      toolNames.push(...result2.toolNames);
+    }
+    let result = await this.baseModel.doGenerate(modifiedOptions);
+    if (this.override?.suppressChainOfThought) {
+      result = this.suppressReasoningContent(result);
+    }
+    if (this.override?.usePromptBasedToolCalling && toolNames.length > 0) {
+      return this.processResultForToolCalls(result, toolNames);
+    }
+    return result;
+  }
+  /**
+   * Stream text
+   */
+  async doStream(options) {
+    let modifiedOptions = { ...options };
+    modifiedOptions = this.applyModelOverrides(modifiedOptions);
+    const toolNames = [];
+    if (this.override?.usePromptBasedToolCalling && options.tools && options.tools.length > 0) {
+      const result2 = this.applyPromptBasedToolCalling(modifiedOptions);
+      modifiedOptions = result2.options;
+      toolNames.push(...result2.toolNames);
+    }
+    let result = await this.baseModel.doStream(modifiedOptions);
+    if (this.override?.suppressChainOfThought) {
+      result = this.suppressReasoningInStream(result);
+    }
+    if (this.override?.usePromptBasedToolCalling && toolNames.length > 0) {
+      return this.processStreamForToolCalls(result, toolNames);
+    }
+    return result;
+  }
+  /**
+   * Apply model-level overrides to call options.
+   * Handles temperature and thinkingLevel configuration.
+   */
+  applyModelOverrides(options) {
+    let modifiedOptions = { ...options };
+    if (this.override?.temperature !== void 0 && modifiedOptions.temperature === void 0) {
+      modifiedOptions.temperature = this.override.temperature;
+    }
+    if (this.override?.thinkingLevel !== void 0) {
+      modifiedOptions = this.applyThinkingLevel(
+        modifiedOptions,
+        this.override.thinkingLevel
       );
-      {
+    }
+    return modifiedOptions;
+  }
+  /**
+   * Apply thinking level configuration via provider options.
+   * Supports various providers that use different parameter names.
+   */
+  applyThinkingLevel(options, thinkingLevel) {
+    const budget = this.thinkingLevelToBudget(thinkingLevel);
+    if (budget === 0) {
+      return options;
+    }
+    const providerOptions = {
+      ...options.providerOptions,
+      // OpenAI-compatible (o1, o3 models)
+      openai: {
+        ...options.providerOptions?.openai,
+        reasoning_effort: thinkingLevel === "auto" ? "medium" : thinkingLevel === "high" ? "high" : thinkingLevel === "low" ? "low" : "medium"
+      },
+      // Anthropic (Claude 3.5+ with extended thinking)
+      anthropic: {
+        ...options.providerOptions?.anthropic,
+        thinking: {
+          type: "enabled",
+          budget_tokens: budget
+        }
+      },
+      // DeepSeek (reasoning models)
+      deepseek: {
+        ...options.providerOptions?.deepseek,
+        reasoning_effort: thinkingLevel === "auto" ? "medium" : thinkingLevel === "high" ? "high" : thinkingLevel === "low" ? "low" : "medium"
       }
-      if (regex.test(modelId)) {
-        return override;
+    };
+    return {
+      ...options,
+      providerOptions
+    };
+  }
+  /**
+   * Convert thinking level to token budget.
+   */
+  thinkingLevelToBudget(level) {
+    if (typeof level === "number") {
+      return level;
+    }
+    switch (level) {
+      case "none":
+        return 0;
+      case "low":
+        return 4096;
+      case "medium":
+        return 16384;
+      case "high":
+        return 65536;
+      case "auto":
+        return 16384;
+      // Default to medium
+      default:
+        return 0;
+    }
+  }
+  /**
+   * Suppress reasoning content from non-streaming result.
+   */
+  suppressReasoningContent(result) {
+    const content = result.content;
+    const filteredContent = content.filter((c) => c.type !== "reasoning");
+    return {
+      ...result,
+      content: filteredContent
+    };
+  }
+  /**
+   * Suppress reasoning content from streaming result.
+   */
+  suppressReasoningInStream(result) {
+    const originalStream = result.stream;
+    const transformedStream = new ReadableStream({
+      async start(controller) {
+        const reader = originalStream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            const partType = value.type;
+            if (partType === "reasoning-start" || partType === "reasoning-delta" || partType === "reasoning-end") {
+              continue;
+            }
+            controller.enqueue(value);
+          }
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    });
+    return {
+      ...result,
+      stream: transformedStream
+    };
+  }
+  /**
+   * Apply prompt-based tool calling by converting tools to system prompt
+   */
+  applyPromptBasedToolCalling(options) {
+    if (!options.tools || options.tools.length === 0) {
+      return { options, toolNames: [] };
+    }
+    const functionTools = options.tools.filter(
+      (tool) => tool.type === "function"
+    );
+    if (functionTools.length === 0) {
+      return { options, toolNames: [] };
+    }
+    const toolDefinitions = functionTools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      // V2 uses inputSchema instead of parameters
+      parameters: tool.inputSchema
+    }));
+    const toolNames = toolDefinitions.map((t) => t.name);
+    const toolPrompt = generateXmlToolPrompt(toolDefinitions);
+    const modifiedPrompt = options.prompt.map((msg) => {
+      if (msg.role === "system") {
+        const content = msg.content;
+        return {
+          ...msg,
+          content: content + "\n\n" + toolPrompt
+        };
       }
+      return msg;
+    });
+    const hasSystemMessage = modifiedPrompt.some((m) => m.role === "system");
+    if (!hasSystemMessage) {
+      modifiedPrompt.unshift({
+        role: "system",
+        content: toolPrompt
+      });
     }
+    return {
+      options: {
+        ...options,
+        prompt: modifiedPrompt,
+        tools: void 0,
+        toolChoice: void 0
+      },
+      toolNames
+    };
   }
-  return void 0;
+  /**
+   * Process non-streaming result for XML tool calls
+   */
+  processResultForToolCalls(result, toolNames) {
+    const content = result.content;
+    const textContentIndex = content.findIndex((c) => c.type === "text");
+    if (textContentIndex === -1 || !content[textContentIndex].text) {
+      return result;
+    }
+    const text = content[textContentIndex].text;
+    const xmlToolCalls = parseXmlToolCalls(text, toolNames, {
+      trimParameterWhitespace: this.override?.trimXmlToolParameterWhitespace ?? false
+    });
+    if (xmlToolCalls.length === 0) {
+      return result;
+    }
+    const cleanedText = this.removeXmlToolCallsFromText(text, toolNames);
+    const newContent = [];
+    if (cleanedText.trim()) {
+      newContent.push({
+        type: "text",
+        text: cleanedText
+      });
+    }
+    for (const tc of xmlToolCalls) {
+      newContent.push({
+        type: "tool-call",
+        toolCallId: tc.id,
+        toolName: tc.name,
+        input: JSON.stringify(tc.arguments)
+      });
+    }
+    for (const c of content) {
+      if (c.type !== "text") {
+        newContent.push(c);
+      }
+    }
+    return {
+      ...result,
+      content: newContent,
+      finishReason: "tool-calls"
+    };
+  }
+  /**
+   * Process streaming result for XML tool calls
+   *
+   * This wraps the stream to accumulate text and parse tool calls at the end.
+   */
+  processStreamForToolCalls(result, toolNames) {
+    const originalStream = result.stream;
+    const override = this.override;
+    const self = this;
+    const transformedStream = new ReadableStream({
+      async start(controller) {
+        let accumulatedText = "";
+        const bufferedParts = [];
+        try {
+          const reader = originalStream.getReader();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            const part = value;
+            if (part.type === "text-delta") {
+              accumulatedText += part.delta;
+            }
+            bufferedParts.push(part);
+          }
+          const xmlToolCalls = parseXmlToolCalls(accumulatedText, toolNames, {
+            trimParameterWhitespace: override?.trimXmlToolParameterWhitespace ?? false
+          });
+          if (xmlToolCalls.length > 0) {
+            const cleanedText = self.removeXmlToolCallsFromText(
+              accumulatedText,
+              toolNames
+            );
+            if (cleanedText.trim()) {
+              controller.enqueue({
+                type: "text-delta",
+                id: generateId(),
+                delta: cleanedText
+              });
+            }
+            for (const tc of xmlToolCalls) {
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: tc.id,
+                toolName: tc.name,
+                input: JSON.stringify(tc.arguments)
+              });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason: "tool-calls",
+              usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+            });
+          } else {
+            for (const part of bufferedParts) {
+              controller.enqueue(part);
+            }
+          }
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    });
+    return {
+      ...result,
+      stream: transformedStream
+    };
+  }
+  /**
+   * Remove XML tool call blocks from text
+   */
+  removeXmlToolCallsFromText(text, toolNames) {
+    let result = text;
+    for (const toolName of toolNames) {
+      const regex = new RegExp(
+        `<${this.escapeRegex(toolName)}>[\\s\\S]*?<\\/${this.escapeRegex(toolName)}>`,
+        "g"
+      );
+      result = result.replace(regex, "");
+    }
+    return result.trim();
+  }
+  /**
+   * Escape special regex characters
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+};
+function createEnhancedModel(baseModel, modelId, override) {
+  if (override?.usePromptBasedToolCalling || override?.temperature !== void 0 || override?.thinkingLevel !== void 0 || override?.suppressChainOfThought !== void 0) {
+    return new EnhancedLanguageModel(baseModel, modelId, override);
+  }
+  return baseModel;
 }
+
+// src/index.ts
+var modelCache = /* @__PURE__ */ new WeakMap();
 function mergeWithConfig(options, config) {
-  if (!config) {
-    return options;
+  const baseModelOverrides = config?.modelOverrides ?? {};
+  const optionModelOverrides = options.modelOverrides ?? {};
+  const modelLevelOverrides = {};
+  if (options.models) {
+    for (const [modelId, modelConfig] of Object.entries(options.models)) {
+      if (modelConfig.options) {
+        modelLevelOverrides[modelId] = modelConfig.options;
+      }
+    }
+  }
+  const mergedModelOverrides = {
+    ...baseModelOverrides,
+    ...optionModelOverrides
+  };
+  for (const [modelId, override] of Object.entries(modelLevelOverrides)) {
+    mergedModelOverrides[modelId] = {
+      ...mergedModelOverrides[modelId],
+      ...override
+    };
+  }
+  let apiKey = options.apiKey;
+  if (!apiKey && config) {
+    apiKey = resolveApiKey(config);
   }
   return {
     // Options take precedence over config
-    baseURL: options.baseURL || config.baseURL || "",
-    apiKey: options.apiKey || resolveApiKey(config),
-    name: options.name || config.name,
+    baseURL: options.baseURL || config?.baseURL || "",
+    apiKey,
+    name: options.name || config?.name,
     headers: {
-      ...config.headers,
+      ...config?.headers,
       ...options.headers
     },
-    modelFilter: options.modelFilter || config.modelFilter,
-    modelOverrides: {
-      ...config.modelOverrides,
-      ...options.modelOverrides
-    },
-    useConfigFile: options.useConfigFile
+    modelFilter: options.modelFilter || config?.modelFilter,
+    modelOverrides: mergedModelOverrides,
+    useConfigFile: options.useConfigFile,
+    models: options.models
   };
 }
 function createOai2lm(options) {
@@ -1125,8 +1597,9 @@ function createOai2lm(options) {
       "baseURL is required. Provide it in options or in oai2lm.json config file."
     );
   }
+  const baseURL = mergedOptions.baseURL;
   const baseProvider = createOpenAICompatible({
-    baseURL: mergedOptions.baseURL.replace(/\/+$/, ""),
+    baseURL: baseURL.replace(/\/+$/, ""),
     name: mergedOptions.name || "oai2lm",
     apiKey: mergedOptions.apiKey,
     headers: mergedOptions.headers
@@ -1135,7 +1608,7 @@ function createOai2lm(options) {
   async function discoverAndCache() {
     const apiKey = mergedOptions.apiKey || "";
     const models = await discoverModels(
-      mergedOptions.baseURL,
+      baseURL,
       apiKey,
       mergedOptions.headers
     );
@@ -1182,11 +1655,24 @@ function createOai2lm(options) {
     }
     return cache;
   }
+  function getOverride(modelId) {
+    return findModelOverride(modelId, mergedOptions.modelOverrides);
+  }
   const provider = function(modelId) {
-    return baseProvider(modelId);
+    const baseModel = baseProvider(modelId);
+    const override = getOverride(modelId);
+    return createEnhancedModel(baseModel, modelId, override);
+  };
+  provider.languageModel = (modelId) => {
+    const baseModel = baseProvider.languageModel(modelId);
+    const override = getOverride(modelId);
+    return createEnhancedModel(baseModel, modelId, override);
+  };
+  provider.chatModel = (modelId) => {
+    const baseModel = baseProvider.chatModel(modelId);
+    const override = getOverride(modelId);
+    return createEnhancedModel(baseModel, modelId, override);
   };
-  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);
@@ -1205,6 +1691,8 @@ function createOai2lm(options) {
 }
 var index_default = createOai2lm;
 export {
+  EnhancedLanguageModel,
+  createEnhancedModel,
   createOai2lm,
   index_default as default,
   discoverModels,