enhancements

Author: mattapperson

src/index.ts

@@ -42,7 +42,7 @@ export type {
 } from "./models/claude-message.js";
 
 // Tool creation helpers
-export { tool, createTool, createGeneratorTool, createManualTool } from "./lib/tool.js";
+export { tool } from "./lib/tool.js";
 
 // Tool types
 export type {

src/lib/anthropic-compat.ts

@@ -5,7 +5,7 @@ import {
   OpenResponsesEasyInputMessageRoleUser,
 } from '../models/openresponseseasyinputmessage.js';
 import { OpenResponsesFunctionCallOutputType } from '../models/openresponsesfunctioncalloutput.js';
-import { OpenResponsesInputMessageItemRoleUser } from '../models/openresponsesinputmessageitem.js';
+import { OpenResponsesInputMessageItemRoleUser, OpenResponsesInputMessageItemRoleDeveloper } from '../models/openresponsesinputmessageitem.js';
 import { convertToClaudeMessage } from './stream-transformers.js';
 
 /**
@@ -150,12 +150,7 @@ export function fromClaudeMessages(
         toolOutput = textParts.join('');
 
         // Map images to image_generation_call items
-        for (let i = 0; i < imageParts.length; i++) {
-          const imagePart = imageParts[i];
-          if (!imagePart) {
-            continue;
-          }
-
+        imageParts.forEach((imagePart, i) => {
           let imageUrl: string;
 
           if (imagePart.source.type === 'url') {
@@ -173,7 +168,7 @@ export function fromClaudeMessages(
             result: imageUrl,
             status: 'completed',
           });
-        }
+        });
       }
 
       // Add the function call output for the text portion (if any)
@@ -222,13 +217,14 @@ export function fromClaudeMessages(
           role:
             role === 'user'
               ? OpenResponsesInputMessageItemRoleUser.User
-              : OpenResponsesInputMessageItemRoleUser.User, // Map assistant to user as well since OpenRouter doesn't have assistant for this type
+              : OpenResponsesInputMessageItemRoleDeveloper.Developer,
           content: contentItems,
         });
       } else {
         // Use simple string format for text-only messages
         const textContent = contentItems
-          .map((item) => (item as models.ResponseInputText).text)
+          .filter((item): item is models.ResponseInputText => item.type === 'input_text')
+          .map((item) => item.text)
           .join('');
 
         if (textContent.length > 0) {

src/lib/chat-compat.ts

@@ -41,6 +41,10 @@ function mapChatRole(
       return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
     case "developer":
       return OpenResponsesEasyInputMessageRoleDeveloper.Developer;
+    default: {
+      const exhaustiveCheck: never = role;
+      throw new Error(`Unhandled role type: ${exhaustiveCheck}`);
+    }
   }
 }
 

src/lib/tool.ts

@@ -260,89 +260,3 @@ export function tool<
     function: fn,
   };
 }
-
-/**
- * @deprecated Use `tool()` instead. This function is kept for backwards compatibility.
- */
-export const createTool = tool;
-
-/**
- * Creates a generator tool with streaming capabilities.
- *
- * @deprecated Use `tool()` with `eventSchema` instead. This function is kept for backwards compatibility.
- *
- * @example
- * ```typescript
- * // Instead of createGeneratorTool, use tool with eventSchema:
- * const progressTool = tool({
- *   name: "process_data",
- *   inputSchema: z.object({ data: z.string() }),
- *   eventSchema: z.object({ progress: z.number() }),
- *   outputSchema: z.object({ result: z.string() }),
- *   execute: async function* (params) {
- *     yield { progress: 50 }; // typed as event
- *     yield { result: "done" }; // typed as output
- *   },
- * });
- * ```
- */
-export function createGeneratorTool<
-  TInput extends ZodObject<ZodRawShape>,
-  TEvent extends ZodType,
-  TOutput extends ZodType,
->(config: {
-  name: string;
-  description?: string;
-  inputSchema: TInput;
-  eventSchema: TEvent;
-  outputSchema: TOutput;
-  execute: (
-    params: z.infer<TInput>,
-    context?: TurnContext
-  ) => AsyncGenerator<z.infer<TEvent> | z.infer<TOutput>>;
-}): ToolWithGenerator<TInput, TEvent, TOutput> {
-  return tool(config);
-}
-
-/**
- * Creates a manual tool without an execute function.
- *
- * @deprecated Use `tool()` with `execute: false` instead. This function is kept for backwards compatibility.
- *
- * @example
- * ```typescript
- * // Instead of createManualTool, use tool with execute: false:
- * const manualTool = tool({
- *   name: "external_api",
- *   inputSchema: z.object({ query: z.string() }),
- *   execute: false,
- * });
- * ```
- */
-export function createManualTool<
-  TInput extends ZodObject<ZodRawShape>,
-  TOutput extends ZodType = ZodType<unknown>,
->(config: {
-  name: string;
-  description?: string;
-  inputSchema: TInput;
-  outputSchema?: TOutput;
-}): ManualTool<TInput, TOutput> {
-  const fn: ManualTool<TInput, TOutput>["function"] = {
-    name: config.name,
-    inputSchema: config.inputSchema,
-  };
-
-  if (config.description !== undefined) {
-    fn.description = config.description;
-  }
-
-  if (config.outputSchema !== undefined) {
-    fn.outputSchema = config.outputSchema;
-  }
-
-  return {
-    type: ToolType.Function,
-    function: fn,
-  };
-}

tests/unit/create-tool.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { z } from 'zod/v4';
-import { tool, createTool, createGeneratorTool, createManualTool } from '../../src/lib/tool.js';
+import { tool } from '../../src/lib/tool.js';
 import { ToolType } from '../../src/lib/tool-types.js';
 
 describe('tool', () => {
@@ -182,43 +182,4 @@ describe('tool', () => {
       expect(manualTool.function).not.toHaveProperty('execute');
     });
   });
-
-  describe('deprecated functions - backwards compatibility', () => {
-    it('createTool should still work', () => {
-      const testTool = createTool({
-        name: 'test_tool',
-        inputSchema: z.object({ input: z.string() }),
-        execute: async (params) => ({ result: params.input }),
-      });
-
-      expect(testTool.type).toBe(ToolType.Function);
-      expect(testTool.function.name).toBe('test_tool');
-    });
-
-    it('createGeneratorTool should still work', () => {
-      const generatorTool = createGeneratorTool({
-        name: 'generator_tool',
-        inputSchema: z.object({ query: z.string() }),
-        eventSchema: z.object({ progress: z.number() }),
-        outputSchema: z.object({ result: z.string() }),
-        execute: async function* () {
-          yield { progress: 50 };
-          yield { result: 'done' };
-        },
-      });
-
-      expect(generatorTool.type).toBe(ToolType.Function);
-      expect(generatorTool.function.name).toBe('generator_tool');
-    });
-
-    it('createManualTool should still work', () => {
-      const manualTool = createManualTool({
-        name: 'manual_tool',
-        inputSchema: z.object({ query: z.string() }),
-      });
-
-      expect(manualTool.type).toBe(ToolType.Function);
-      expect(manualTool.function.name).toBe('manual_tool');
-    });
-  });
 });