feat: add support for chat-style tools in callModel

- Add CallModelTools type to accept ToolDefinitionJson[] (chat format)
- Automatically convert chat-style tools to responses format
- Add tests for chat-style tools and combined usage

Author: mattapperson

src/funcs/callModel.ts

@@ -12,6 +12,14 @@ export type CallModelInput =
   | models.OpenResponsesInput
   | models.Message[];
 
+/**
+ * Tool type that accepts chat-style, responses-style, or enhanced tools
+ */
+export type CallModelTools =
+  | EnhancedTool[]
+  | models.ToolDefinitionJson[]
+  | models.OpenResponsesRequest["tools"];
+
 /**
  * Check if input is chat-style messages (Message[])
  */
@@ -25,6 +33,33 @@ function isChatStyleMessages(input: CallModelInput): input is models.Message[] {
   return first && 'role' in first && !('type' in first);
 }
 
+/**
+ * Check if tools are chat-style (ToolDefinitionJson[])
+ */
+function isChatStyleTools(tools: CallModelTools): tools is models.ToolDefinitionJson[] {
+  if (!Array.isArray(tools)) return false;
+  if (tools.length === 0) return false;
+
+  const first = tools[0] as any;
+  // Chat-style tools have nested 'function' property with 'name' inside
+  // Enhanced tools have 'function' with 'inputSchema'
+  // Responses-style tools have 'name' at top level
+  return first && 'function' in first && first.function && 'name' in first.function && !('inputSchema' in first.function);
+}
+
+/**
+ * Convert chat-style tools to responses-style
+ */
+function convertChatToResponsesTools(tools: models.ToolDefinitionJson[]): models.OpenResponsesRequest["tools"] {
+  return tools.map((tool): models.OpenResponsesRequestToolFunction => ({
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description ?? null,
+    strict: tool.function.strict ?? null,
+    parameters: tool.function.parameters ?? null,
+  }));
+}
+
 /**
  * Convert chat-style messages to responses-style input
  */
@@ -140,7 +175,7 @@ export function callModel(
   client: OpenRouterCore,
   request: Omit<models.OpenResponsesRequest, "stream" | "tools" | "input"> & {
     input?: CallModelInput;
-    tools?: EnhancedTool[] | models.OpenResponsesRequest["tools"];
+    tools?: CallModelTools;
     maxToolRounds?: MaxToolRounds;
   },
   options?: RequestOptions,
@@ -157,16 +192,27 @@ export function callModel(
     input: convertedInput,
   };
 
-  // Separate enhanced tools from API tools
+  // Determine tool type and convert as needed
   let isEnhancedTools = false;
-  if (tools && tools.length > 0) {
+  let isChatTools = false;
+
+  if (tools && Array.isArray(tools) && tools.length > 0) {
     const firstTool = tools[0] as any;
     isEnhancedTools = "function" in firstTool && firstTool.function && "inputSchema" in firstTool.function;
+    isChatTools = !isEnhancedTools && isChatStyleTools(tools);
   }
+
   const enhancedTools = isEnhancedTools ? (tools as EnhancedTool[]) : undefined;
 
-  // Convert enhanced tools to API format if provided, otherwise use tools as-is
-  const apiTools = enhancedTools ? convertEnhancedToolsToAPIFormat(enhancedTools) : (tools as models.OpenResponsesRequest["tools"]);
+  // Convert tools to API format based on their type
+  let apiTools: models.OpenResponsesRequest["tools"];
+  if (enhancedTools) {
+    apiTools = convertEnhancedToolsToAPIFormat(enhancedTools);
+  } else if (isChatTools) {
+    apiTools = convertChatToResponsesTools(tools as models.ToolDefinitionJson[]);
+  } else {
+    apiTools = tools as models.OpenResponsesRequest["tools"];
+  }
 
   // Build the request with converted tools
   const finalRequest: models.OpenResponsesRequest = {

src/sdk/sdk.ts

@@ -96,7 +96,7 @@ export class OpenRouter extends ClientSDK {
   callModel(
     request: Omit<models.OpenResponsesRequest, "stream" | "tools" | "input"> & {
       input?: import("../funcs/callModel.js").CallModelInput;
-      tools?: EnhancedTool[] | models.OpenResponsesRequest["tools"];
+      tools?: import("../funcs/callModel.js").CallModelTools;
       maxToolRounds?: MaxToolRounds;
     },
     options?: RequestOptions,

tests/e2e/callModel.test.ts

@@ -89,6 +89,81 @@ describe("callModel E2E Tests", () => {
       expect(text).toBeDefined();
       expect(typeof text).toBe("string");
     });
+
+    it("should accept chat-style tools (ToolDefinitionJson)", async () => {
+      const response = client.callModel({
+        model: "meta-llama/llama-3.1-8b-instruct",
+        input: [
+          {
+            role: "user",
+            content: "What's the weather in Paris? Use the get_weather tool.",
+          },
+        ],
+        tools: [
+          {
+            type: "function" as const,
+            function: {
+              name: "get_weather",
+              description: "Get weather for a location",
+              parameters: {
+                type: "object",
+                properties: {
+                  location: {
+                    type: "string",
+                    description: "City name",
+                  },
+                },
+                required: ["location"],
+              },
+            },
+          },
+        ],
+      });
+
+      const toolCalls = await response.getToolCalls();
+
+      // Model should call the tool
+      expect(toolCalls.length).toBeGreaterThan(0);
+      expect(toolCalls[0].name).toBe("get_weather");
+      expect(toolCalls[0].arguments).toBeDefined();
+    }, 30000);
+
+    it("should work with chat-style messages and chat-style tools together", async () => {
+      const response = client.callModel({
+        model: "meta-llama/llama-3.1-8b-instruct",
+        input: [
+          {
+            role: "system",
+            content: "You are a helpful assistant. Use tools when needed.",
+          },
+          {
+            role: "user",
+            content: "Get the weather in Tokyo using the weather tool.",
+          },
+        ] as Message[],
+        tools: [
+          {
+            type: "function" as const,
+            function: {
+              name: "get_weather",
+              description: "Get current weather",
+              parameters: {
+                type: "object",
+                properties: {
+                  city: { type: "string" },
+                },
+                required: ["city"],
+              },
+            },
+          },
+        ],
+      });
+
+      const toolCalls = await response.getToolCalls();
+
+      expect(toolCalls.length).toBeGreaterThan(0);
+      expect(toolCalls[0].name).toBe("get_weather");
+    }, 30000);
   });
 
   describe("response.text - Text extraction", () => {