add more examples

Author: 404Wolf

examples/tool-helpers-advanced-streaming.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env -S npm run tsn -T
+
+import OpenAI from 'openai';
+import { betaZodTool } from 'openai/helpers/beta/zod';
+import { z } from 'zod';
+
+const client = new OpenAI();
+
+async function main() {
+  const runner = client.chat.completions.toolRunner({
+    messages: [
+      {
+        role: 'user',
+        content: `I'm planning a trip to San Francisco and I need some information. Can you help me with the weather, current time, and currency exchange rates (from EUR)? Please use parallel tool use`,
+      },
+    ],
+    tools: [
+      betaZodTool({
+        name: 'getWeather',
+        description: 'Get the weather at a specific location',
+        inputSchema: z.object({
+          location: z.string().describe('The city and state, e.g. San Francisco, CA'),
+        }),
+        run: ({ location }) => {
+          return `The weather is sunny with a temperature of 20°C in ${location}.`;
+        },
+      }),
+      betaZodTool({
+        name: 'getTime',
+        description: 'Get the current time in a specific timezone',
+        inputSchema: z.object({
+          timezone: z.string().describe('The timezone, e.g. America/Los_Angeles'),
+        }),
+        run: ({ timezone }) => {
+          return `The current time in ${timezone} is 3:00 PM.`;
+        },
+      }),
+      betaZodTool({
+        name: 'getCurrencyExchangeRate',
+        description: 'Get the exchange rate between two currencies',
+        inputSchema: z.object({
+          from_currency: z.string().describe('The currency to convert from, e.g. USD'),
+          to_currency: z.string().describe('The currency to convert to, e.g. EUR'),
+        }),
+        run: ({ from_currency, to_currency }) => {
+          return `The exchange rate from ${from_currency} to ${to_currency} is 0.85.`;
+        },
+      }),
+    ],
+    model: 'gpt-4o',
+    max_tokens: 1024,
+    // This limits the conversation to at most 10 back and forth between the API.
+    max_iterations: 10,
+    stream: true,
+  });
+
+  console.log(`\n🚀 Running tools...\n`);
+
+  let prevMessageStarted = '';
+  let prevToolStarted = '';
+  let prevWasToolCall = false;
+
+  for await (const messageStream of runner) {
+    for await (const event of messageStream) {
+      const hadToolCalls = !!event.choices?.[0]?.delta?.tool_calls;
+
+      if (hadToolCalls) {
+        if (!prevMessageStarted) {
+          console.log(`┌─ Message ${event.id} `.padEnd(process.stdout.columns, '─'));
+          prevMessageStarted = event.id;
+        }
+
+        prevWasToolCall = true;
+        const toolCalls = event.choices[0]!.delta.tool_calls!;
+
+        for (const toolCall of toolCalls) {
+          if (toolCall.function?.name && prevToolStarted !== toolCall.function.name) {
+            process.stdout.write(`\n${toolCall.function.name}: `);
+            prevToolStarted = toolCall.function.name;
+          } else if (toolCall.function?.arguments) {
+            process.stdout.write(toolCall.function.arguments);
+          }
+        }
+      } else if (event.choices?.[0]?.delta?.content) {
+        if (prevWasToolCall) {
+          console.log();
+          console.log();
+          console.log(`└─`.padEnd(process.stdout.columns, '─'));
+          console.log();
+          prevWasToolCall = false;
+        }
+
+        if (prevMessageStarted !== event.id) {
+          console.log(`┌─ Message ${event.id} `.padEnd(process.stdout.columns, '─'));
+          console.log();
+          prevMessageStarted = event.id;
+        }
+
+        process.stdout.write(event.choices[0].delta.content);
+      }
+    }
+  }
+
+  console.log();
+  console.log();
+  console.log(`└─`.padEnd(process.stdout.columns, '─'));
+}
+
+main();

examples/tool-helpers-advanced.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env -S npm run tsn -T
+
+import OpenAI from 'openai';
+import { betaZodTool } from 'openai/helpers/beta/zod';
+import { z } from 'zod';
+
+const client = new OpenAI();
+
+async function main() {
+  const message = await client.chat.completions.toolRunner({
+    messages: [
+      {
+        role: 'user',
+        content: `What is the weather in SF?`,
+      },
+    ],
+    tools: [
+      betaZodTool({
+        name: 'getWeather',
+        description: 'Get the weather at a specific location',
+        inputSchema: z.object({
+          location: z.string().describe('The city and state, e.g. San Francisco, CA'),
+        }),
+        run: ({ location }) => {
+          return `The weather is foggy with a temperature of 20°C in ${location}.`;
+        },
+      }),
+    ],
+    model: 'gpt-4o',
+    max_tokens: 1024,
+    // the maximum number of iterations to run the tool
+    max_iterations: 10,
+  });
+
+  console.log('Final response:', message.content);
+}
+
+main();

examples/tool-helpers-json-schema.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env -S npm run tsn -T
+
+import OpenAI from 'openai';
+import { betaTool } from 'openai/helpers/beta/json-schema';
+
+const client = new OpenAI();
+
+async function main() {
+  const message = await client.chat.completions.toolRunner({
+    messages: [
+      {
+        role: 'user',
+        content: `What is the weather in SF?`,
+      },
+    ],
+    tools: [
+      betaTool({
+        name: 'getWeather',
+        description: 'Get the weather at a specific location',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            location: {
+              type: 'string',
+              description: 'The city and state, e.g. San Francisco, CA',
+            },
+          },
+          required: ['location'],
+        },
+        run: ({ location }) => {
+          return `The weather is foggy with a temperature of 20°C in ${location}.`;
+        },
+      }),
+    ],
+    model: 'gpt-4o',
+    max_tokens: 1024,
+    // the maximum number of iterations to run the tool
+    max_iterations: 10,
+  });
+
+  console.log('Final response:', message.content);
+}
+
+main();

package.json

@@ -27,6 +27,7 @@
     "fix": "./scripts/format"
   },
   "dependencies": {
+    "json-schema-to-ts": "3.1.1",
     "nock": "^14.0.10"
   },
   "devDependencies": {

src/helpers/beta/betaZodTool.ts

@@ -0,0 +1,35 @@
+import type { FromSchema, JSONSchema } from 'json-schema-to-ts';
+import type { BetaRunnableTool, Promisable } from '../../lib/beta/BetaRunnableTool';
+import type { FunctionTool } from '../../resources/beta';
+import { OpenAIError } from '../../error';
+
+type NoInfer<T> = T extends infer R ? R : never;
+
+/**
+ * Creates a Tool with a provided JSON schema that can be passed
+ * to the `.toolRunner()` method. The schema is used to automatically validate
+ * the input arguments for the tool.
+ */
+export function betaTool<const Schema extends Exclude<JSONSchema, boolean> & { type: 'object' }>(options: {
+  name: string;
+  inputSchema: Schema;
+  description: string;
+  run: (args: NoInfer<FromSchema<Schema>>) => Promisable<string | Array<FunctionTool>>;
+}): BetaRunnableTool<NoInfer<FromSchema<Schema>>> {
+  if (options.inputSchema.type !== 'object') {
+    throw new OpenAIError(
+      `JSON schema for tool "${options.name}" must be an object, but got ${options.inputSchema.type}`,
+    );
+  }
+
+  return {
+    type: 'function',
+    function: {
+      name: options.name,
+      parameters: options.inputSchema,
+      description: options.description,
+    },
+    run: options.run,
+    parse: (content: unknown) => content as FromSchema<Schema>,
+  } as any; // For some reason this causes infinite inference so we cast to any to not crash lsp
+}

src/helpers/beta/json-schema.ts

@@ -12,8 +12,6 @@ import type {
   ChatCompletionToolMessageParam,
 } from '../../resources/chat/completions';
 import type { BetaRunnableTool } from './BetaRunnableTool';
-// BetaMessage, BetaMessageParam, BetaToolUnion, MessageCreateParams
-// import { BetaMessageStream } from '../BetaMessageStream';
 
 /**
  * Just Promise.withResolvers(), which is not available in all environments.

src/lib/beta-parser.ts

@@ -120,7 +120,7 @@ function betaMessageToStreamEvents(message: ChatCompletion): ChatCompletionChunk
   const messageContent = message.choices[0]!.message;
 
   // Check if it's a text message
-  if (messageContent.content && typeof messageContent.content === 'string') {
+  if (messageContent.content) {
     // Initial chunk with role only (no content in first chunk for text messages)
     events.push({
       choices: message.choices.map(