Merge pull request #59 from runbasehq/dev

feat: add provider name prefix to model identifiers

Author: fveiraswww

packages/mcp-check/CHANGELOG.md

@@ -1,5 +1,11 @@
 # mcp-testing-library
 
+## 0.4.3
+
+### Patch Changes
+
+- feat: add provider name prefix to model identifiers
+
 ## 0.4.2
 
 ### Patch Changes

packages/mcp-check/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-check",
   "module": "dist/src/index.js",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

packages/mcp-check/src/chunks/types.ts

@@ -1,4 +1,9 @@
-import type { BetaRawContentBlockDeltaEvent, BetaRawContentBlockStartEvent, BetaRawContentBlockStopEvent, BetaRawMessageStreamEvent } from "@anthropic-ai/sdk/resources/beta.js";
+import type {
+  BetaRawContentBlockDeltaEvent,
+  BetaRawContentBlockStartEvent,
+  BetaRawContentBlockStopEvent,
+  BetaRawMessageStreamEvent,
+} from "@anthropic-ai/sdk/resources/beta.js";
 import type OpenAI from "openai";
 
 export interface ToolCall {
@@ -273,7 +278,7 @@ export interface NormalizedChunkAnthropic extends BaseNormalizedChunk {
 }
 
 export interface NormalizedChunkOpenAI extends BaseNormalizedChunk {
-  provider: "openai";
+  provider: "openai" | "openrouter";
   originalChunk: OpenAI.Responses.ResponseStreamEvent;
 }
 
@@ -363,17 +368,27 @@ export interface ChunkHandlerConfig {
   /** Provider-specific handlers for Anthropic */
   anthropic?: {
     /** Handler for Anthropic content block delta chunks */
-    onContentBlockDelta?: (chunk: BetaRawContentBlockDeltaEvent) => void | Promise<void>;
+    onContentBlockDelta?: (
+      chunk: BetaRawContentBlockDeltaEvent,
+    ) => void | Promise<void>;
     /** Handler for Anthropic content block start chunks */
-    onContentBlockStart?: (chunk: BetaRawContentBlockStartEvent) => void | Promise<void>;
+    onContentBlockStart?: (
+      chunk: BetaRawContentBlockStartEvent,
+    ) => void | Promise<void>;
     /** Handler for Anthropic content block stop chunks */
-    onContentBlockStop?: (chunk: BetaRawContentBlockStopEvent) => void | Promise<void>;
+    onContentBlockStop?: (
+      chunk: BetaRawContentBlockStopEvent,
+    ) => void | Promise<void>;
   };
   /** Provider-specific handlers for OpenAI */
   openai?: {
     /** Handler for OpenAI response output item added chunks */
-    onResponseOutputItemAdded?: (chunk: OpenAI.Responses.ResponseOutputItemAddedEvent) => void | Promise<void>;
+    onResponseOutputItemAdded?: (
+      chunk: OpenAI.Responses.ResponseOutputItemAddedEvent,
+    ) => void | Promise<void>;
     /** Handler for OpenAI response output item done chunks */
-    onResponseOutputItemDone?: (chunk: OpenAI.Responses.ResponseOutputItemDoneEvent) => void | Promise<void>;
+    onResponseOutputItemDone?: (
+      chunk: OpenAI.Responses.ResponseOutputItemDoneEvent,
+    ) => void | Promise<void>;
   };
 }

packages/mcp-check/src/providers/anthropic.ts

@@ -112,7 +112,7 @@ export class AnthropicProvider extends Provider {
     this.currentModel = model;
 
     const stream = this.client.beta.messages.stream({
-      model: model as Anthropic.Model,
+      model: model.replace("anthropic/", "") as Anthropic.Model,
       max_tokens: 1000,
       messages: [
         {

packages/mcp-check/src/providers/index.ts

@@ -5,17 +5,18 @@ import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIProvider } from "./openai.js";
 import type { ProviderConfig } from "./types.js";
 import { Provider } from "./provider.js";
+import { type OpenRouterModel } from "./openrouter.js";
 
 /**
  * @fileoverview Provider factory and type exports for MCP AI providers.
- * 
+ *
  * This module provides a factory function to create appropriate provider instances
  * based on model names, and exports type definitions for model names and providers.
  */
 
 /**
  * Type alias for Anthropic Claude model names.
- * 
+ *
  * @example
  * ```typescript
  * const model: AnthropicModel = "claude-3-haiku-20240307";
@@ -25,72 +26,85 @@ export type { AnthropicModel } from "./anthropic.js";
 
 /**
  * Type alias for OpenAI model names.
- * 
+ *
  * @example
  * ```typescript
  * const model: OpenAIModel = "gpt-4";
  * ```
  */
 export type { OpenAIModel } from "./openai.js";
 
+/**
+ * Type alias for OpenRouter model names.
+ *
+ * @example
+ * ```typescript
+ * const model: OpenRouterModel = "meta-llama/llama-3.3-70b-instruct:free";
+ * ```
+ */
+export type { OpenRouterModel } from "./openrouter.js";
+
 /**
  * Union type of all supported model names.
- * 
+ *
  * This type represents all available model identifiers that can be used
  * with the provider system.
- * 
+ *
  * @example
  * ```typescript
  * const models: ModelName[] = ["claude-3-haiku-20240307", "gpt-4"];
  * ```
  */
-export type ModelName = AnthropicModel | OpenAIModel;
+export type ModelName =
+  | `anthropic/${AnthropicModel}`
+  | `openai/${OpenAIModel}`
+  | `openrouter/${OpenRouterModel}`;
 
 /**
  * Array type for model name collections.
- * 
+ *
  * @example
  * ```typescript
- * const models: Models = ["claude-3-sonnet-20240229", "gpt-3.5-turbo"];
+ * const models: Models = ["anthropic/claude-3-sonnet-20240229", "openai/gpt-3.5-turbo"];
  * ```
  */
 export type Models = ModelName[];
 
 /**
  * Factory function to create appropriate provider instances based on model names.
- * 
+ *
  * This function automatically determines the correct provider (Anthropic or OpenAI)
  * based on the model name prefix and creates a configured provider instance.
- * 
+ *
  * @param model - The model name to create a provider for
  * @param mcpServer - The MCP server configuration
  * @param promptText - The prompt text to send to the model
  * @param config - Optional provider configuration (API keys, silent mode, etc.)
  * @returns A configured provider instance for the specified model
- * 
+ *
  * @throws {Error} When the model name is not recognized or supported
- * 
+ *
  * @example
  * ```typescript
  * // Create provider for Anthropic model
  * const anthropicProvider = createProvider(
- *   "claude-3-haiku-20240307",
+ *   "anthropic/claude-3-haiku-20240307",
  *   mcpServer,
  *   "What tools are available?",
  *   { anthropicApiKey: process.env.ANTHROPIC_API_KEY }
  * );
- * 
+ *
  * // Create provider for OpenAI model
  * const openaiProvider = createProvider(
- *   "gpt-4",
+ *   "openai/gpt-4",
  *   mcpServer,
  *   "What tools are available?",
  *   { openaiApiKey: process.env.OPENAI_API_KEY }
  * );
- * 
+ *
  * // Use the providers
- * const anthropicResult = await anthropicProvider.stream("claude-3-haiku-20240307");
- * const openaiResult = await openaiProvider.stream("gpt-4");
+ * const anthropicResult = await anthropicProvider.stream("anthropic/claude-3-haiku-20240307");
+ * const openaiResult = await openaiProvider.stream("openai/gpt-4");
  * ```
  */
 export function createProvider(
@@ -99,15 +113,16 @@ export function createProvider(
   promptText: string,
   config: ProviderConfig = {},
 ): Provider {
-  // Anthropic models
-  if (model.startsWith("claude-")) {
+  if (model.startsWith("anthropic/")) {
     return new AnthropicProvider(mcpServer, promptText, config);
   }
 
-  // OpenAI models
-  if (model.startsWith("gpt-") || model.startsWith("o") || model.startsWith("chatgpt-") || model.startsWith("codex-")) {
+  if (model.startsWith("openai/")) {
     return new OpenAIProvider(mcpServer, promptText, config);
   }
 
+  if (model.startsWith("openrouter/")) {
+  }
+
   throw new Error(`Error: unknown provider for model: ${model}.`);
 }

packages/mcp-check/src/providers/openai.ts

@@ -7,10 +7,10 @@ import type { McpServer } from "../index.js";
 
 /**
  * Type alias for OpenAI model names.
- * 
+ *
  * This type represents all available OpenAI model identifiers
  * that can be used with the OpenAIProvider.
- * 
+ *
  * @example
  * ```typescript
  * const model: OpenAIModel = "gpt-4";
@@ -20,18 +20,18 @@ export type OpenAIModel = ChatModel;
 
 /**
  * Provider for OpenAI models.
- * 
+ *
  * This class handles interactions with OpenAI's models through their
  * official SDK. It supports streaming responses, MCP tool calls,
  * and chunk normalization for the OpenAI API format.
- * 
+ *
  * @example
  * ```typescript
  * const provider = new OpenAIProvider(mcpServer, "What tools are available?", {
  *   openaiApiKey: process.env.OPENAI_API_KEY,
  *   silent: true
  * });
- * 
+ *
  * const result = await provider.stream("gpt-4");
  * console.log("Content:", result.content);
  * console.log("Used tools:", result.usedTools);
@@ -51,11 +51,11 @@ export class OpenAIProvider extends Provider {
 
   /**
    * Creates a new OpenAIProvider instance.
-   * 
+   *
    * @param mcpServer - The MCP server configuration
    * @param promptText - The prompt text to send to the OpenAI model
    * @param config - Optional provider configuration including API key
-   * 
+   *
    * @example
    * ```typescript
    * const provider = new OpenAIProvider(mcpServer, "Hello GPT!", {
@@ -67,24 +67,28 @@ export class OpenAIProvider extends Provider {
    * });
    * ```
    */
-  constructor(mcpServer: McpServer, promptText: string, config: ProviderConfig = {}) {
+  constructor(
+    mcpServer: McpServer,
+    promptText: string,
+    config: ProviderConfig = {},
+  ) {
     super(mcpServer, promptText, config);
     const apiKey = config.openaiApiKey || process.env.OPENAI_API_KEY;
     this.client = apiKey ? new OpenAI({ apiKey }) : null;
   }
 
   /**
    * Streams a response from the specified OpenAI model.
-   * 
+   *
    * This method establishes a streaming connection to the OpenAI API,
    * processes the response chunks, tracks tool usage, and returns the
    * final result with content and tool call information.
-   * 
+   *
    * @param model - The OpenAI model name to use (e.g., "gpt-4", "gpt-3.5-turbo")
    * @returns Promise that resolves to a StreamResult containing the response
-   * 
+   *
    * @throws {Error} When the OpenAI client is not initialized (missing API key)
-   * 
+   *
    * @example
    * ```typescript
    * const result = await provider.stream("gpt-4");
@@ -96,7 +100,7 @@ export class OpenAIProvider extends Provider {
   async stream(model: string): Promise<StreamResult> {
     if (!this.client) {
       throw new Error(
-        "OpenAI client not initialized. Please set OPENAI_API_KEY environment variable or pass openaiApiKey in config."
+        "OpenAI client not initialized. Please set OPENAI_API_KEY environment variable or pass openaiApiKey in config.",
       );
     }
 
@@ -106,7 +110,7 @@ export class OpenAIProvider extends Provider {
     this.currentModel = model;
 
     const response = await this.client.responses.create({
-      model: model as ChatModel,
+      model: model.replace("openai/", "") as ChatModel,
       tools: [
         {
           type: "mcp",
@@ -155,9 +159,13 @@ export class OpenAIProvider extends Provider {
         if (item.type === "mcp_call") {
           const toolName = item.name;
           if (this.toolCalls[toolName] && this.toolCalls[toolName].length > 0) {
-            const lastCall = this.toolCalls[toolName][this.toolCalls[toolName].length - 1];
+            const lastCall =
+              this.toolCalls[toolName][this.toolCalls[toolName].length - 1];
             if (lastCall) {
-              lastCall.result = (item as any).result || { id: `result_${Date.now()}`, status: "completed" };
+              lastCall.result = (item as any).result || {
+                id: `result_${Date.now()}`,
+                status: "completed",
+              };
             }
           }
         }
@@ -166,18 +174,22 @@ export class OpenAIProvider extends Provider {
       await this.processChunk(chunk);
     }
 
-    return { usedTools: this.usedTools, content: this.content, toolCalls: this.toolCalls };
+    return {
+      usedTools: this.usedTools,
+      content: this.content,
+      toolCalls: this.toolCalls,
+    };
   }
 
   /**
    * Normalizes OpenAI-specific chunks into the unified NormalizedChunk format.
-   * 
+   *
    * This method converts OpenAI's streaming response chunks into a standardized
    * format that can be processed by the chunk handling system.
-   * 
+   *
    * @param chunk - The raw chunk from OpenAI's streaming API
    * @returns NormalizedChunk if the chunk can be normalized, null otherwise
-   * 
+   *
    * @example
    * ```typescript
    * const normalized = this.normalizeChunk(openaiChunk);
@@ -287,7 +299,7 @@ export class OpenAIProvider extends Provider {
               type: "model_stream",
               model: this.currentModel,
               text: `Calling tool: ${toolName}\n`,
-            }) + "\n"
+            }) + "\n",
           );
         }
       }
@@ -299,7 +311,7 @@ export class OpenAIProvider extends Provider {
             type: "model_stream",
             model: this.currentModel,
             text: `Tool ${toolName} completed\n`,
-          }) + "\n"
+          }) + "\n",
         );
       }
     }