modelmix 2.2.4 → 2.3.2

package/demo/node_modules/openai/src/lib/ChatCompletionRunFunctions.test.ts

@@ -1,2328 +0,0 @@
-import OpenAI from 'openai';
-import { OpenAIError, APIConnectionError } from "../error";
-import { PassThrough } from 'stream';
-import {
-  ParsingToolFunction,
-  type ChatCompletionRunner,
-  type ChatCompletionFunctionRunnerParams,
-  ChatCompletionStreamingRunner,
-  type ChatCompletionStreamingFunctionRunnerParams,
-} from "../resources/beta/chat/completions";
-import type { ChatCompletionMessageParam } from "../resources/chat/completions";
-
-import { type RequestInfo, type RequestInit } from "../_shims/index";
-import { Response } from 'node-fetch';
-import { isAssistantMessage } from './chatCompletionUtils';
-
-type Fetch = (req: string | RequestInfo, init?: RequestInit) => Promise<Response>;
-
-/**
- * Creates a mock `fetch` function and a `handleRequest` function for intercepting `fetch` calls.
- *
- * You call `handleRequest` with a callback function that handles the next `fetch` call.
- * It returns a Promise that:
- * - waits for the next call to `fetch`
- * - calls the callback with the `fetch` arguments
- * - resolves `fetch` with the callback output
- */
-function mockFetch(): { fetch: Fetch; handleRequest: (handle: Fetch) => Promise<void> } {
-  const fetchQueue: ((handler: typeof fetch) => void)[] = [];
-  const handlerQueue: Promise<typeof fetch>[] = [];
-
-  const enqueueHandler = () => {
-    handlerQueue.push(
-      new Promise<typeof fetch>((resolve) => {
-        fetchQueue.push((handle: typeof fetch) => {
-          enqueueHandler();
-          resolve(handle);
-        });
-      }),
-    );
-  };
-  enqueueHandler();
-
-  async function fetch(req: string | RequestInfo, init?: RequestInit): Promise<Response> {
-    const handler = await handlerQueue.shift();
-    if (!handler) throw new Error('expected handler to be defined');
-    const signal = init?.signal;
-    if (!signal) return await handler(req, init);
-    return await Promise.race([
-      handler(req, init),
-      new Promise<Response>((resolve, reject) => {
-        if (signal.aborted) {
-          // @ts-ignore does exist in Node
-          reject(new DOMException('The user aborted a request.', 'AbortError'));
-          return;
-        }
-        signal.addEventListener('abort', (e) => {
-          // @ts-ignore does exist in Node
-          reject(new DOMException('The user aborted a request.', 'AbortError'));
-        });
-      }),
-    ]);
-  }
-
-  function handleRequest(handle: typeof fetch): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      fetchQueue.shift()?.(async (req, init) => {
-        try {
-          return await handle(req, init);
-        } catch (err) {
-          reject(err);
-          return err as any;
-        } finally {
-          resolve();
-        }
-      });
-    });
-  }
-
-  return { fetch, handleRequest };
-}
-
-// mockChatCompletionFetch is like mockFetch, but with better a more convenient handleRequest to mock
-// chat completion request/responses.
-function mockChatCompletionFetch() {
-  const { fetch, handleRequest: handleRawRequest } = mockFetch();
-
-  function handleRequest(
-    handler: (body: ChatCompletionFunctionRunnerParams<any[]>) => Promise<OpenAI.Chat.ChatCompletion>,
-  ): Promise<void> {
-    return handleRawRequest(async (req, init) => {
-      const rawBody = init?.body;
-      if (typeof rawBody !== 'string') throw new Error(`expected init.body to be a string`);
-      const body: ChatCompletionFunctionRunnerParams<any[]> = JSON.parse(rawBody);
-      return new Response(JSON.stringify(await handler(body)), {
-        headers: { 'Content-Type': 'application/json' },
-      });
-    });
-  }
-  return { fetch, handleRequest };
-}
-
-// mockStreamingChatCompletionFetch is like mockFetch, but with better a more convenient handleRequest to mock
-// streaming chat completion request/responses.
-function mockStreamingChatCompletionFetch() {
-  const { fetch, handleRequest: handleRawRequest } = mockFetch();
-
-  function handleRequest(
-    handler: (
-      body: ChatCompletionStreamingFunctionRunnerParams<any[]>,
-    ) => AsyncIterable<OpenAI.Chat.ChatCompletionChunk>,
-  ): Promise<void> {
-    return handleRawRequest(async (req, init) => {
-      const rawBody = init?.body;
-      if (typeof rawBody !== 'string') throw new Error(`expected init.body to be a string`);
-      const body: ChatCompletionStreamingFunctionRunnerParams<any[]> = JSON.parse(rawBody);
-      const stream = new PassThrough();
-      (async () => {
-        for await (const chunk of handler(body)) {
-          stream.write(`data: ${JSON.stringify(chunk)}\n\n`);
-        }
-        stream.end(`data: [DONE]\n\n`);
-      })();
-      return new Response(stream, {
-        headers: {
-          'Content-Type': 'text/event-stream',
-          'Transfer-Encoding': 'chunked',
-        },
-      });
-    });
-  }
-  return { fetch, handleRequest };
-}
-
-// contentChoiceDeltas returns an async iterator which mocks a delta stream of a by splitting the
-// argument into chunks separated by whitespace.
-function* contentChoiceDeltas(
-  content: string,
-  {
-    index = 0,
-    role = 'assistant',
-  }: { index?: number; role?: NonNullable<OpenAI.Chat.ChatCompletionChunk.Choice.Delta['role']> } = {},
-): Iterable<OpenAI.Chat.Completions.ChatCompletionChunk.Choice> {
-  const deltas = content.split(/\s+/g);
-  for (let i = 0; i < deltas.length; i++) {
-    yield {
-      index,
-      finish_reason: i === deltas.length - 1 ? 'stop' : null,
-      logprobs: null,
-      delta: {
-        role,
-        content: deltas[i] ? `${deltas[i]}${i === deltas.length - 1 ? '' : ' '}` : null,
-      },
-    };
-  }
-}
-
-// functionCallDeltas returns an async iterator which mocks a delta stream of a functionCall by splitting
-// the argument into chunks separated by whitespace.
-function* functionCallDeltas(
-  args: string,
-  {
-    index = 0,
-    id = '123',
-    name,
-    role = 'assistant',
-  }: {
-    name: string;
-    id?: string;
-    index?: number;
-    role?: NonNullable<OpenAI.Chat.ChatCompletionChunk.Choice.Delta['role']>;
-  },
-): Iterable<OpenAI.Chat.Completions.ChatCompletionChunk.Choice> {
-  const deltas = args.split(/\s+/g);
-  for (let i = 0; i < deltas.length; i++) {
-    yield {
-      index,
-      finish_reason: i === deltas.length - 1 ? 'function_call' : null,
-      delta: {
-        role,
-        tool_calls: [
-          {
-            type: 'function',
-            index: 0,
-            id,
-            function: {
-              arguments: `${deltas[i] || ''}${i === deltas.length - 1 ? '' : ' '}`,
-              ...(i === deltas.length - 1 ? { name } : null),
-            },
-          },
-        ],
-      },
-    };
-  }
-}
-
-class RunnerListener {
-  readonly contents: string[] = [];
-  readonly messages: ChatCompletionMessageParam[] = [];
-  readonly chatCompletions: OpenAI.Chat.ChatCompletion[] = [];
-  readonly functionCalls: OpenAI.Chat.ChatCompletionMessage.FunctionCall[] = [];
-  readonly functionCallResults: string[] = [];
-  finalContent: string | null = null;
-  finalMessage: ChatCompletionMessageParam | undefined;
-  finalChatCompletion: OpenAI.Chat.ChatCompletion | undefined;
-  finalFunctionCall: OpenAI.Chat.ChatCompletionMessage.FunctionCall | undefined;
-  finalFunctionCallResult: string | undefined;
-  totalUsage: OpenAI.CompletionUsage | undefined;
-  error: OpenAIError | undefined;
-  gotConnect = false;
-  gotAbort = false;
-  gotEnd = false;
-
-  onceMessageCallCount = 0;
-
-  constructor(public runner: ChatCompletionRunner) {
-    runner
-      .on('connect', () => (this.gotConnect = true))
-      .on('content', (content) => this.contents.push(content))
-      .on('message', (message) => this.messages.push(message))
-      .on('chatCompletion', (completion) => this.chatCompletions.push(completion))
-      .on('functionCall', (functionCall) => this.functionCalls.push(functionCall))
-      .on('functionCallResult', (result) => this.functionCallResults.push(result))
-      .on('finalContent', (content) => (this.finalContent = content))
-      .on('finalMessage', (message) => (this.finalMessage = message))
-      .on('finalChatCompletion', (completion) => (this.finalChatCompletion = completion))
-      .on('finalFunctionCall', (functionCall) => (this.finalFunctionCall = functionCall))
-      .on('finalFunctionCallResult', (result) => (this.finalFunctionCallResult = result))
-      .on('totalUsage', (usage) => (this.totalUsage = usage))
-      .on('error', (error) => (this.error = error))
-      .on('abort', (error) => ((this.error = error), (this.gotAbort = true)))
-      .on('end', () => (this.gotEnd = true))
-      .once('message', () => this.onceMessageCallCount++);
-  }
-
-  async sanityCheck({ error }: { error?: string } = {}) {
-    expect(this.onceMessageCallCount).toBeLessThanOrEqual(1);
-    expect(this.gotAbort).toEqual(this.runner.aborted);
-    if (this.runner.aborted) expect(this.runner.errored).toBe(true);
-    if (error) {
-      expect(this.error?.message).toEqual(error);
-      expect(this.runner.errored).toBe(true);
-      await expect(this.runner.finalChatCompletion()).rejects.toThrow(error);
-      await expect(this.runner.finalMessage()).rejects.toThrow(error);
-      await expect(this.runner.finalContent()).rejects.toThrow(error);
-      await expect(this.runner.finalFunctionCall()).rejects.toThrow(error);
-      await expect(this.runner.finalFunctionCallResult()).rejects.toThrow(error);
-      await expect(this.runner.totalUsage()).rejects.toThrow(error);
-      await expect(this.runner.done()).rejects.toThrow(error);
-    } else {
-      expect(this.error).toBeUndefined();
-      expect(this.runner.errored).toBe(false);
-    }
-
-    if (!this.gotConnect) {
-      expect(this.contents).toEqual([]);
-      expect(this.messages).toEqual([]);
-      expect(this.chatCompletions).toEqual([]);
-      expect(this.functionCalls).toEqual([]);
-      expect(this.functionCallResults).toEqual([]);
-      expect(this.finalContent).toBeUndefined();
-      expect(this.finalMessage).toBeUndefined();
-      expect(this.finalChatCompletion).toBeUndefined();
-      expect(this.finalFunctionCall).toBeUndefined();
-      expect(this.finalFunctionCallResult).toBeUndefined();
-      expect(this.totalUsage).toBeUndefined();
-      expect(this.gotEnd).toBe(true);
-      return;
-    }
-
-    if (error) return;
-
-    const expectedContents = this.messages
-      .filter(isAssistantMessage)
-      .map((m) => m.content as string)
-      .filter(Boolean);
-    expect(this.contents).toEqual(expectedContents);
-    expect(this.finalMessage).toEqual([...this.messages].reverse().find((x) => x.role === 'assistant'));
-    expect(await this.runner.finalMessage()).toEqual(this.finalMessage);
-    expect(this.finalContent).toEqual(expectedContents[expectedContents.length - 1] ?? null);
-    expect(await this.runner.finalContent()).toEqual(this.finalContent);
-    expect(this.finalChatCompletion).toEqual(this.chatCompletions[this.chatCompletions.length - 1]);
-    expect(await this.runner.finalChatCompletion()).toEqual(this.finalChatCompletion);
-    expect(this.finalFunctionCall).toEqual(this.functionCalls[this.functionCalls.length - 1]);
-    expect(await this.runner.finalFunctionCall()).toEqual(this.finalFunctionCall);
-    expect(this.finalFunctionCallResult).toEqual(
-      this.functionCallResults[this.functionCallResults.length - 1],
-    );
-    expect(await this.runner.finalFunctionCallResult()).toEqual(this.finalFunctionCallResult);
-    expect(this.chatCompletions).toEqual(this.runner.allChatCompletions());
-    expect(this.messages).toEqual(this.runner.messages.slice(-this.messages.length));
-    if (this.chatCompletions.some((c) => c.usage)) {
-      const totalUsage: OpenAI.CompletionUsage = {
-        completion_tokens: 0,
-        prompt_tokens: 0,
-        total_tokens: 0,
-      };
-      for (const { usage } of this.chatCompletions) {
-        if (usage) {
-          totalUsage.completion_tokens += usage.completion_tokens;
-          totalUsage.prompt_tokens += usage.prompt_tokens;
-          totalUsage.total_tokens += usage.total_tokens;
-        }
-      }
-      expect(this.totalUsage).toEqual(totalUsage);
-      expect(await this.runner.totalUsage()).toEqual(totalUsage);
-    }
-
-    expect(this.gotEnd).toBe(true);
-  }
-}
-
-class StreamingRunnerListener {
-  readonly eventChunks: OpenAI.Chat.ChatCompletionChunk[] = [];
-  readonly eventContents: [string, string][] = [];
-  readonly eventMessages: ChatCompletionMessageParam[] = [];
-  readonly eventChatCompletions: OpenAI.Chat.ChatCompletion[] = [];
-  readonly eventFunctionCalls: OpenAI.Chat.ChatCompletionMessage.FunctionCall[] = [];
-  readonly eventFunctionCallResults: string[] = [];
-
-  finalContent: string | null = null;
-  finalMessage: ChatCompletionMessageParam | undefined;
-  finalChatCompletion: OpenAI.Chat.ChatCompletion | undefined;
-  finalFunctionCall: OpenAI.Chat.ChatCompletionMessage.FunctionCall | undefined;
-  finalFunctionCallResult: string | undefined;
-  error: OpenAIError | undefined;
-  gotConnect = false;
-  gotEnd = false;
-
-  constructor(public runner: ChatCompletionStreamingRunner) {
-    runner
-      .on('connect', () => (this.gotConnect = true))
-      .on('chunk', (chunk) => this.eventChunks.push(chunk))
-      .on('content', (delta, snapshot) => this.eventContents.push([delta, snapshot]))
-      .on('message', (message) => this.eventMessages.push(message))
-      .on('chatCompletion', (completion) => this.eventChatCompletions.push(completion))
-      .on('functionCall', (functionCall) => this.eventFunctionCalls.push(functionCall))
-      .on('functionCallResult', (result) => this.eventFunctionCallResults.push(result))
-      .on('finalContent', (content) => (this.finalContent = content))
-      .on('finalMessage', (message) => (this.finalMessage = message))
-      .on('finalChatCompletion', (completion) => (this.finalChatCompletion = completion))
-      .on('finalFunctionCall', (functionCall) => (this.finalFunctionCall = functionCall))
-      .on('finalFunctionCallResult', (result) => (this.finalFunctionCallResult = result))
-      .on('error', (error) => (this.error = error))
-      .on('abort', (abort) => (this.error = abort))
-      .on('end', () => (this.gotEnd = true));
-  }
-
-  async sanityCheck({ error }: { error?: string } = {}) {
-    if (error) {
-      expect(this.error?.message).toEqual(error);
-      expect(this.runner.errored).toBe(true);
-      await expect(this.runner.finalChatCompletion()).rejects.toThrow(error);
-      await expect(this.runner.finalMessage()).rejects.toThrow(error);
-      await expect(this.runner.finalContent()).rejects.toThrow(error);
-      await expect(this.runner.finalFunctionCall()).rejects.toThrow(error);
-      await expect(this.runner.finalFunctionCallResult()).rejects.toThrow(error);
-      await expect(this.runner.done()).rejects.toThrow(error);
-    } else {
-      expect(this.error).toBeUndefined();
-      expect(this.runner.errored).toBe(false);
-    }
-
-    if (!this.gotConnect) {
-      expect(this.eventContents).toEqual([]);
-      expect(this.eventMessages).toEqual([]);
-      expect(this.eventChatCompletions).toEqual([]);
-      expect(this.eventFunctionCalls).toEqual([]);
-      expect(this.eventFunctionCallResults).toEqual([]);
-      expect(this.finalContent).toBeUndefined();
-      expect(this.finalMessage).toBeUndefined();
-      expect(this.finalChatCompletion).toBeUndefined();
-      expect(this.finalFunctionCall).toBeUndefined();
-      expect(this.finalFunctionCallResult).toBeUndefined();
-      expect(this.gotEnd).toBe(true);
-      return;
-    }
-
-    if (error) return;
-
-    if (this.eventContents.length) expect(this.eventChunks.length).toBeGreaterThan(0);
-    expect(this.finalMessage).toEqual([...this.eventMessages].reverse().find((x) => x.role === 'assistant'));
-    expect(await this.runner.finalMessage()).toEqual(this.finalMessage);
-    expect(this.finalContent).toEqual(this.eventContents[this.eventContents.length - 1]?.[1] ?? null);
-    expect(await this.runner.finalContent()).toEqual(this.finalContent);
-    expect(this.finalChatCompletion).toEqual(this.eventChatCompletions[this.eventChatCompletions.length - 1]);
-    expect(await this.runner.finalChatCompletion()).toEqual(this.finalChatCompletion);
-    expect(this.finalFunctionCall).toEqual(this.eventFunctionCalls[this.eventFunctionCalls.length - 1]);
-    expect(await this.runner.finalFunctionCall()).toEqual(this.finalFunctionCall);
-    expect(this.finalFunctionCallResult).toEqual(
-      this.eventFunctionCallResults[this.eventFunctionCallResults.length - 1],
-    );
-    expect(await this.runner.finalFunctionCallResult()).toEqual(this.finalFunctionCallResult);
-    expect(this.eventChatCompletions).toEqual(this.runner.allChatCompletions());
-    expect(this.eventMessages).toEqual(this.runner.messages.slice(-this.eventMessages.length));
-    if (error) {
-      expect(this.error?.message).toEqual(error);
-      expect(this.runner.errored).toBe(true);
-    } else {
-      expect(this.error).toBeUndefined();
-      expect(this.runner.errored).toBe(false);
-    }
-    expect(this.gotEnd).toBe(true);
-  }
-}
-
-function _typeTests() {
-  const openai = new OpenAI();
-
-  openai.beta.chat.completions.runTools({
-    messages: [
-      { role: 'user', content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}' },
-    ],
-    model: 'gpt-3.5-turbo',
-    tools: [
-      {
-        type: 'function',
-        function: {
-          name: 'numProperties',
-          function: (obj: object) => String(Object.keys(obj).length),
-          parameters: { type: 'object' },
-          parse: (str: string): object => {
-            const result = JSON.parse(str);
-            if (!(result instanceof Object) || Array.isArray(result)) {
-              throw new Error('must be an object');
-            }
-            return result;
-          },
-          description: 'gets the number of properties on an object',
-        },
-      },
-      {
-        type: 'function',
-        function: {
-          function: (str: string) => String(str.length),
-          parameters: { type: 'string' },
-          description: 'gets the length of a string',
-        },
-      },
-      {
-        type: 'function',
-        // @ts-expect-error function must accept string if parse is omitted
-        function: {
-          function: (obj: object) => String(Object.keys(obj).length),
-          parameters: { type: 'object' },
-          description: 'gets the number of properties on an object',
-        },
-      },
-    ],
-  });
-  openai.beta.chat.completions.runTools({
-    messages: [
-      { role: 'user', content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}' },
-    ],
-    model: 'gpt-3.5-turbo',
-    tools: [
-      new ParsingToolFunction({
-        name: 'numProperties',
-        // @ts-expect-error parse and function don't match
-        parse: (str: string) => str,
-        function: (obj: object) => String(Object.keys(obj).length),
-        parameters: { type: 'object' },
-        description: 'gets the number of properties on an object',
-      }),
-    ],
-  });
-  openai.beta.chat.completions.runTools({
-    messages: [
-      { role: 'user', content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}' },
-    ],
-    model: 'gpt-3.5-turbo',
-    tools: [
-      new ParsingToolFunction({
-        name: 'numProperties',
-        parse: (str: string): object => {
-          const result = JSON.parse(str);
-          if (!(result instanceof Object) || Array.isArray(result)) {
-            throw new Error('must be an object');
-          }
-          return result;
-        },
-        function: (obj: object) => String(Object.keys(obj).length),
-        parameters: { type: 'object' },
-        description: 'gets the number of properties on an object',
-      }),
-      new ParsingToolFunction({
-        name: 'keys',
-        parse: (str: string): object => {
-          const result = JSON.parse(str);
-          if (!(result instanceof Object)) {
-            throw new Error('must be an Object');
-          }
-          return result;
-        },
-        function: (obj: object) => Object.keys(obj).join(', '),
-        parameters: { type: 'object' },
-        description: 'gets the number of properties on an object',
-      }),
-      new ParsingToolFunction({
-        name: 'len2',
-        // @ts-expect-error parse and function don't match
-        parse: (str: string) => str,
-        function: (obj: object) => String(Object.keys(obj).length),
-        parameters: { type: 'object' },
-        description: 'gets the number of properties on an object',
-      }),
-    ],
-  });
-  openai.beta.chat.completions.runTools({
-    messages: [
-      { role: 'user', content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}' },
-    ],
-    model: 'gpt-3.5-turbo',
-    // @ts-ignore error occurs here in TS 4
-    tools: [
-      {
-        type: 'function',
-        function: {
-          name: 'numProperties',
-          parse: (str: string): object => {
-            const result = JSON.parse(str);
-            if (!(result instanceof Object) || Array.isArray(result)) {
-              throw new Error('must be an object');
-            }
-            return result;
-          },
-          function: (obj: object) => String(Object.keys(obj).length),
-          parameters: { type: 'object' },
-          description: 'gets the number of properties on an object',
-        },
-      },
-      {
-        type: 'function',
-        function: {
-          name: 'keys',
-          parse: (str: string): object => {
-            const result = JSON.parse(str);
-            if (!(result instanceof Object)) {
-              throw new Error('must be an Object');
-            }
-            return result;
-          },
-          function: (obj: object) => Object.keys(obj).join(', '),
-          parameters: { type: 'object' },
-          description: 'gets the number of properties on an object',
-        },
-      },
-      {
-        type: 'function',
-        function: {
-          name: 'len2',
-          parse: (str: string) => str,
-          // @ts-ignore error occurs here in TS 5
-          // function input doesn't match parse output
-          function: (obj: object) => String(Object.keys(obj).length),
-          parameters: { type: 'object' },
-          description: 'gets the number of properties on an object',
-        },
-      },
-    ] as const,
-  });
-}
-
-describe('resource completions', () => {
-  describe('runTools with stream: false', () => {
-    test('successful flow', async () => {
-      const { fetch, handleRequest } = mockChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          {
-            type: 'function',
-            function: {
-              function: function getWeather() {
-                return `it's raining`;
-              },
-              parameters: {},
-              description: 'gets the weather',
-            },
-          },
-        ],
-      });
-      const listener = new RunnerListener(runner);
-
-      await handleRequest(async (request) => {
-        expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-        return {
-          id: '1',
-          choices: [
-            {
-              index: 0,
-              finish_reason: 'function_call',
-              logprobs: null,
-              message: {
-                role: 'assistant',
-                content: null,
-                tool_calls: [
-                  {
-                    type: 'function',
-                    id: '123',
-                    function: {
-                      arguments: '',
-                      name: 'getWeather',
-                    },
-                  },
-                ],
-              },
-            },
-          ],
-          created: Math.floor(Date.now() / 1000),
-          model: 'gpt-3.5-turbo',
-          object: 'chat.completion',
-        };
-      });
-
-      await handleRequest(async (request) => {
-        expect(request.messages).toEqual([
-          { role: 'user', content: 'tell me what the weather is like' },
-          {
-            role: 'assistant',
-            content: null,
-            tool_calls: [
-              {
-                type: 'function',
-                id: '123',
-                function: {
-                  arguments: '',
-                  name: 'getWeather',
-                },
-              },
-            ],
-          },
-          {
-            role: 'tool',
-            content: `it's raining`,
-            tool_call_id: '123',
-          },
-        ]);
-
-        return {
-          id: '2',
-          choices: [
-            {
-              index: 0,
-              finish_reason: 'stop',
-              logprobs: null,
-              message: {
-                role: 'assistant',
-                content: `it's raining`,
-              },
-            },
-          ],
-          created: Math.floor(Date.now() / 1000),
-          model: 'gpt-3.5-turbo',
-          object: 'chat.completion',
-        };
-      });
-
-      await runner.done();
-
-      expect(listener.messages).toEqual([
-        { role: 'user', content: 'tell me what the weather is like' },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '123' },
-        { role: 'assistant', content: "it's raining" },
-      ]);
-      expect(listener.functionCallResults).toEqual([`it's raining`]);
-      await listener.sanityCheck();
-    });
-    test('flow with abort', async () => {
-      const { fetch, handleRequest } = mockChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const controller = new AbortController();
-      const runner = openai.beta.chat.completions.runTools(
-        {
-          messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-          model: 'gpt-3.5-turbo',
-          tools: [
-            {
-              type: 'function',
-              function: {
-                function: function getWeather() {
-                  return `it's raining`;
-                },
-                parameters: {},
-                description: 'gets the weather',
-              },
-            },
-          ],
-        },
-        { signal: controller.signal },
-      );
-      const listener = new RunnerListener(runner);
-
-      await handleRequest(async (request) => {
-        expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-        return {
-          id: '1',
-          choices: [
-            {
-              index: 0,
-              finish_reason: 'function_call',
-              logprobs: null,
-              message: {
-                role: 'assistant',
-                content: null,
-                tool_calls: [
-                  {
-                    type: 'function',
-                    id: '123',
-                    function: {
-                      arguments: '',
-                      name: 'getWeather',
-                    },
-                  },
-                ],
-              },
-            },
-          ],
-          created: Math.floor(Date.now() / 1000),
-          model: 'gpt-3.5-turbo',
-          object: 'chat.completion',
-        };
-      });
-
-      controller.abort();
-
-      await runner.done().catch(() => {});
-
-      expect(listener.messages).toEqual([
-        { role: 'user', content: 'tell me what the weather is like' },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '123' },
-      ]);
-      expect(listener.functionCallResults).toEqual([`it's raining`]);
-      await listener.sanityCheck({ error: 'Request was aborted.' });
-      expect(runner.aborted).toBe(true);
-    });
-    test('successful flow with parse', async () => {
-      const { fetch, handleRequest } = mockChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        messages: [
-          {
-            role: 'user',
-            content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-          },
-        ],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          new ParsingToolFunction({
-            name: 'numProperties',
-            function: (obj: object) => String(Object.keys(obj).length),
-            parameters: { type: 'object' },
-            parse: (str: string): object => {
-              const result = JSON.parse(str);
-              if (!(result instanceof Object) || Array.isArray(result)) {
-                throw new Error('must be an object');
-              }
-              return result;
-            },
-            description: 'gets the number of properties on an object',
-          }),
-        ],
-      });
-      const listener = new RunnerListener(runner);
-
-      await handleRequest(async (request) => {
-        expect(request.messages).toEqual([
-          {
-            role: 'user',
-            content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-          },
-        ]);
-        return {
-          id: '1',
-          choices: [
-            {
-              index: 0,
-              finish_reason: 'function_call',
-              logprobs: null,
-              message: {
-                role: 'assistant',
-                content: null,
-                tool_calls: [
-                  {
-                    type: 'function',
-                    id: '123',
-                    function: {
-                      arguments: '{"a": 1, "b": 2, "c": 3}',
-                      name: 'numProperties',
-                    },
-                  },
-                ],
-              },
-            },
-          ],
-          created: Math.floor(Date.now() / 1000),
-          model: 'gpt-3.5-turbo',
-          object: 'chat.completion',
-          usage: {
-            completion_tokens: 5,
-            prompt_tokens: 20,
-            total_tokens: 25,
-          },
-        };
-      });
-
-      await handleRequest(async (request) => {
-        expect(request.messages).toEqual([
-          {
-            role: 'user',
-            content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-          },
-          {
-            role: 'assistant',
-            content: null,
-            tool_calls: [
-              {
-                type: 'function',
-                id: '123',
-                function: {
-                  arguments: '{"a": 1, "b": 2, "c": 3}',
-                  name: 'numProperties',
-                },
-              },
-            ],
-          },
-          {
-            role: 'tool',
-            content: '3',
-            tool_call_id: '123',
-          },
-        ]);
-        return {
-          id: '2',
-          choices: [
-            {
-              index: 0,
-              finish_reason: 'stop',
-              logprobs: null,
-              message: {
-                role: 'assistant',
-                content: `there are 3 properties in {"a": 1, "b": 2, "c": 3}`,
-              },
-            },
-          ],
-          created: Math.floor(Date.now() / 1000),
-          model: 'gpt-3.5-turbo',
-          object: 'chat.completion',
-          usage: {
-            completion_tokens: 10,
-            prompt_tokens: 25,
-            total_tokens: 35,
-          },
-        };
-      });
-
-      await runner.done();
-
-      expect(listener.messages).toEqual([
-        {
-          role: 'user',
-          content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-        },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: { name: 'numProperties', arguments: '{"a": 1, "b": 2, "c": 3}' },
-            },
-          ],
-        },
-        { role: 'tool', content: '3', tool_call_id: '123' },
-        { role: 'assistant', content: 'there are 3 properties in {"a": 1, "b": 2, "c": 3}' },
-      ]);
-      expect(listener.functionCallResults).toEqual(['3']);
-      await listener.sanityCheck();
-    });
-    test('flow with parse error', async () => {
-      const { fetch, handleRequest } = mockChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        messages: [
-          {
-            role: 'user',
-            content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-          },
-        ],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          new ParsingToolFunction({
-            name: 'numProperties',
-            function: (obj: object) => String(Object.keys(obj).length),
-            parameters: { type: 'object' },
-            parse: (str: string): object => {
-              const result = JSON.parse(str);
-              if (!(result instanceof Object) || Array.isArray(result)) {
-                throw new Error('must be an object');
-              }
-              return result;
-            },
-            description: 'gets the number of properties on an object',
-          }),
-        ],
-      });
-      const listener = new RunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-          ]);
-          return {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      id: '123',
-                      function: {
-                        arguments: '[{"a": 1, "b": 2, "c": 3}]',
-                        name: 'numProperties',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '[{"a": 1, "b": 2, "c": 3}]',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `must be an object`,
-              tool_call_id: '123',
-            },
-          ]);
-          return {
-            id: '2',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      id: '1234',
-                      function: {
-                        arguments: '{"a": 1, "b": 2, "c": 3}',
-                        name: 'numProperties',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '[{"a": 1, "b": 2, "c": 3}]',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `must be an object`,
-              tool_call_id: '123',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '1234',
-                  function: {
-                    arguments: '{"a": 1, "b": 2, "c": 3}',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: '3',
-              tool_call_id: '1234',
-            },
-          ]);
-          return {
-            id: '3',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'stop',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: `there are 3 properties in {"a": 1, "b": 2, "c": 3}`,
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.messages).toEqual([
-        {
-          role: 'user',
-          content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-        },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: { name: 'numProperties', arguments: '[{"a": 1, "b": 2, "c": 3}]' },
-            },
-          ],
-        },
-        { role: 'tool', content: `must be an object`, tool_call_id: '123' },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '1234',
-              function: { name: 'numProperties', arguments: '{"a": 1, "b": 2, "c": 3}' },
-            },
-          ],
-        },
-        { role: 'tool', content: '3', tool_call_id: '1234' },
-        { role: 'assistant', content: 'there are 3 properties in {"a": 1, "b": 2, "c": 3}' },
-      ]);
-      expect(listener.functionCallResults).toEqual([`must be an object`, '3']);
-      await listener.sanityCheck();
-    });
-    test('single function call', async () => {
-      const { fetch, handleRequest } = mockChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-        tool_choice: {
-          type: 'function',
-          function: {
-            name: 'getWeather',
-          },
-        },
-        tools: [
-          {
-            type: 'function',
-            function: {
-              function: function getWeather() {
-                return `it's raining`;
-              },
-              parameters: {},
-              description: 'gets the weather',
-            },
-          },
-        ],
-      });
-      const listener = new RunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          return {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      id: '123',
-                      function: {
-                        arguments: '',
-                        name: 'getWeather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.messages).toEqual([
-        { role: 'user', content: 'tell me what the weather is like' },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '123' },
-      ]);
-      expect(listener.functionCallResults).toEqual([`it's raining`]);
-      await listener.sanityCheck();
-    });
-    test('wrong function name', async () => {
-      const { fetch, handleRequest } = mockChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          {
-            type: 'function',
-            function: {
-              function: function getWeather() {
-                return `it's raining`;
-              },
-              parameters: {},
-              description: 'gets the weather',
-            },
-          },
-        ],
-      });
-      const listener = new RunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          return {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      id: '123',
-                      function: {
-                        arguments: '',
-                        name: 'get_weather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([
-            { role: 'user', content: 'tell me what the weather is like' },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '',
-                    name: 'get_weather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-              tool_call_id: '123',
-            },
-          ]);
-          return {
-            id: '2',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      id: '1234',
-                      function: {
-                        arguments: '',
-                        name: 'getWeather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        handleRequest(async (request) => {
-          expect(request.messages).toEqual([
-            { role: 'user', content: 'tell me what the weather is like' },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '',
-                    name: 'get_weather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-              tool_call_id: '123',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '1234',
-                  function: {
-                    arguments: '',
-                    name: 'getWeather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `it's raining`,
-              tool_call_id: '1234',
-            },
-          ]);
-          return {
-            id: '3',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'stop',
-                logprobs: null,
-                message: {
-                  role: 'assistant',
-                  content: `it's raining`,
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion',
-          };
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.messages).toEqual([
-        { role: 'user', content: 'tell me what the weather is like' },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [{ type: 'function', id: '123', function: { name: 'get_weather', arguments: '' } }],
-        },
-        {
-          role: 'tool',
-          content: `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-          tool_call_id: '123',
-        },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [{ type: 'function', id: '1234', function: { name: 'getWeather', arguments: '' } }],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '1234' },
-        { role: 'assistant', content: "it's raining" },
-      ]);
-      expect(listener.functionCallResults).toEqual([
-        `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-        `it's raining`,
-      ]);
-      await listener.sanityCheck();
-    });
-  });
-
-  describe('runTools with stream: true', () => {
-    test('successful flow', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        stream: true,
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          {
-            type: 'function',
-            function: {
-              function: function getWeather() {
-                return `it's raining`;
-              },
-              parameters: {},
-              description: 'gets the weather',
-            },
-          },
-        ],
-      });
-      const listener = new StreamingRunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          yield {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                delta: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      index: 0,
-                      id: '123',
-                      function: {
-                        arguments: '',
-                        name: 'getWeather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion.chunk',
-          };
-        }),
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            { role: 'user', content: 'tell me what the weather is like' },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '',
-                    name: 'getWeather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `it's raining`,
-              tool_call_id: '123',
-            },
-          ]);
-          for (const choice of contentChoiceDeltas(`it's raining`)) {
-            yield {
-              id: '2',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.eventMessages).toEqual([
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '123' },
-        { role: 'assistant', content: "it's raining" },
-      ]);
-      expect(listener.eventFunctionCallResults).toEqual([`it's raining`]);
-      await listener.sanityCheck();
-    });
-    test('flow with abort', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const controller = new AbortController();
-      const runner = openai.beta.chat.completions.runTools(
-        {
-          stream: true,
-          messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-          model: 'gpt-3.5-turbo',
-          tools: [
-            {
-              type: 'function',
-              function: {
-                function: function getWeather() {
-                  return `it's raining`;
-                },
-                parameters: {},
-                description: 'gets the weather',
-              },
-            },
-          ],
-        },
-        { signal: controller.signal },
-      );
-      runner.on('functionCallResult', () => controller.abort());
-      const listener = new StreamingRunnerListener(runner);
-
-      await handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-        expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-        yield {
-          id: '1',
-          choices: [
-            {
-              index: 0,
-              finish_reason: 'function_call',
-              delta: {
-                role: 'assistant',
-                content: null,
-                tool_calls: [
-                  {
-                    type: 'function',
-                    index: 0,
-                    id: '123',
-                    function: {
-                      arguments: '',
-                      name: 'getWeather',
-                    },
-                  },
-                ],
-              },
-            },
-          ],
-          created: Math.floor(Date.now() / 1000),
-          model: 'gpt-3.5-turbo',
-          object: 'chat.completion.chunk',
-        };
-      });
-
-      await runner.done().catch(() => {});
-
-      expect(listener.eventMessages).toEqual([
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '123' },
-      ]);
-      expect(listener.eventFunctionCallResults).toEqual([`it's raining`]);
-      await listener.sanityCheck({ error: 'Request was aborted.' });
-      expect(runner.aborted).toBe(true);
-    });
-    test('successful flow with parse', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        stream: true,
-        messages: [
-          {
-            role: 'user',
-            content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-          },
-        ],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          new ParsingToolFunction({
-            name: 'numProperties',
-            function: (obj: object) => String(Object.keys(obj).length),
-            parameters: { type: 'object' },
-            parse: (str: string): object => {
-              const result = JSON.parse(str);
-              if (!(result instanceof Object) || Array.isArray(result)) {
-                throw new Error('must be an object');
-              }
-              return result;
-            },
-            description: 'gets the number of properties on an object',
-          }),
-        ],
-      });
-      const listener = new StreamingRunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-          ]);
-          yield {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                delta: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      id: '123',
-                      index: 0,
-                      function: {
-                        arguments: '{"a": 1, "b": 2, "c": 3}',
-                        name: 'numProperties',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion.chunk',
-          };
-        }),
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '{"a": 1, "b": 2, "c": 3}',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: '3',
-              tool_call_id: '123',
-            },
-          ]);
-          for (const choice of contentChoiceDeltas(`there are 3 properties in {"a": 1, "b": 2, "c": 3}`)) {
-            yield {
-              id: '2',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.eventMessages).toEqual([
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: { name: 'numProperties', arguments: '{"a": 1, "b": 2, "c": 3}' },
-            },
-          ],
-        },
-        { role: 'tool', content: '3', tool_call_id: '123' },
-        { role: 'assistant', content: 'there are 3 properties in {"a": 1, "b": 2, "c": 3}' },
-      ]);
-      expect(listener.eventFunctionCallResults).toEqual(['3']);
-      await listener.sanityCheck();
-    });
-    test('flow with parse error', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        stream: true,
-        messages: [
-          {
-            role: 'user',
-            content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-          },
-        ],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          new ParsingToolFunction({
-            name: 'numProperties',
-            function: (obj: object) => String(Object.keys(obj).length),
-            parameters: { type: 'object' },
-            parse: (str: string): object => {
-              const result = JSON.parse(str);
-              if (!(result instanceof Object) || Array.isArray(result)) {
-                throw new Error('must be an object');
-              }
-              return result;
-            },
-            description: 'gets the number of properties on an object',
-          }),
-        ],
-      });
-      const listener = new StreamingRunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-          ]);
-          for (const choice of functionCallDeltas('[{"a": 1, "b": 2, "c": 3}]', {
-            name: 'numProperties',
-            id: '123',
-          })) {
-            yield {
-              id: '1',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '[{"a": 1, "b": 2, "c": 3}]',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `must be an object`,
-              tool_call_id: '123',
-            },
-          ]);
-          for (const choice of functionCallDeltas('{"a": 1, "b": 2, "c": 3}', {
-            name: 'numProperties',
-            id: '1234',
-          })) {
-            yield {
-              id: '2',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            {
-              role: 'user',
-              content: 'can you tell me how many properties are in {"a": 1, "b": 2, "c": 3}',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '[{"a": 1, "b": 2, "c": 3}]',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `must be an object`,
-              tool_call_id: '123',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '1234',
-                  function: {
-                    arguments: '{"a": 1, "b": 2, "c": 3}',
-                    name: 'numProperties',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: '3',
-              tool_call_id: '1234',
-            },
-          ]);
-          for (const choice of contentChoiceDeltas(`there are 3 properties in {"a": 1, "b": 2, "c": 3}`)) {
-            yield {
-              id: '3',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.eventMessages).toEqual([
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: { name: 'numProperties', arguments: '[{"a": 1, "b": 2, "c": 3}]' },
-            },
-          ],
-        },
-        { role: 'tool', content: `must be an object`, tool_call_id: '123' },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '1234',
-              function: { name: 'numProperties', arguments: '{"a": 1, "b": 2, "c": 3}' },
-            },
-          ],
-        },
-        { role: 'tool', content: '3', tool_call_id: '1234' },
-        { role: 'assistant', content: 'there are 3 properties in {"a": 1, "b": 2, "c": 3}' },
-      ]);
-      expect(listener.eventFunctionCallResults).toEqual([`must be an object`, '3']);
-      await listener.sanityCheck();
-    });
-    test('single function call', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        stream: true,
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-        tool_choice: {
-          type: 'function',
-          function: {
-            name: 'getWeather',
-          },
-        },
-        tools: [
-          {
-            type: 'function',
-            function: {
-              function: function getWeather() {
-                return `it's raining`;
-              },
-              parameters: {},
-              description: 'gets the weather',
-            },
-          },
-        ],
-      });
-      const listener = new StreamingRunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          yield {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                delta: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      index: 0,
-                      id: '123',
-                      function: {
-                        arguments: '',
-                        name: 'getWeather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion.chunk',
-          };
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.eventMessages).toEqual([
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', tool_call_id: '123', content: `it's raining` },
-      ]);
-      expect(listener.eventFunctionCallResults).toEqual([`it's raining`]);
-      await listener.sanityCheck();
-    });
-    test('wrong function name', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.runTools({
-        stream: true,
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-        tools: [
-          {
-            type: 'function',
-            function: {
-              function: function getWeather() {
-                return `it's raining`;
-              },
-              parameters: {},
-              description: 'gets the weather',
-            },
-          },
-        ],
-      });
-      const listener = new StreamingRunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          yield {
-            id: '1',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                delta: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      index: 0,
-                      id: '123',
-                      function: {
-                        arguments: '',
-                        name: 'get_weather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion.chunk',
-          };
-        }),
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            { role: 'user', content: 'tell me what the weather is like' },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '',
-                    name: 'get_weather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-              tool_call_id: '123',
-            },
-          ]);
-          yield {
-            id: '2',
-            choices: [
-              {
-                index: 0,
-                finish_reason: 'function_call',
-                logprobs: null,
-                delta: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: [
-                    {
-                      type: 'function',
-                      index: 0,
-                      id: '1234',
-                      function: {
-                        arguments: '',
-                        name: 'getWeather',
-                      },
-                    },
-                  ],
-                },
-              },
-            ],
-            created: Math.floor(Date.now() / 1000),
-            model: 'gpt-3.5-turbo',
-            object: 'chat.completion.chunk',
-          };
-        }),
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([
-            { role: 'user', content: 'tell me what the weather is like' },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '123',
-                  function: {
-                    arguments: '',
-                    name: 'get_weather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-              tool_call_id: '123',
-            },
-            {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  id: '1234',
-                  function: {
-                    arguments: '',
-                    name: 'getWeather',
-                  },
-                },
-              ],
-            },
-            {
-              role: 'tool',
-              content: `it's raining`,
-              tool_call_id: '1234',
-            },
-          ]);
-          for (const choice of contentChoiceDeltas(`it's raining`)) {
-            yield {
-              id: '3',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.eventMessages).toEqual([
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '123',
-              function: {
-                arguments: '',
-                name: 'get_weather',
-              },
-            },
-          ],
-        },
-        {
-          role: 'tool',
-          content: `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-          tool_call_id: '123',
-        },
-        {
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              type: 'function',
-              id: '1234',
-              function: {
-                arguments: '',
-                name: 'getWeather',
-              },
-            },
-          ],
-        },
-        { role: 'tool', content: `it's raining`, tool_call_id: '1234' },
-        { role: 'assistant', content: "it's raining" },
-      ]);
-      expect(listener.eventFunctionCallResults).toEqual([
-        `Invalid tool_call: "get_weather". Available options are: "getWeather". Please try again`,
-        `it's raining`,
-      ]);
-      await listener.sanityCheck();
-    });
-  });
-
-  describe('stream', () => {
-    test('successful flow', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.stream({
-        stream: true,
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-      });
-
-      const listener = new StreamingRunnerListener(runner);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          for (const choice of contentChoiceDeltas(`The weather is great today!`)) {
-            yield {
-              id: '1',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        runner.done(),
-      ]);
-
-      expect(listener.finalMessage).toEqual({ role: 'assistant', content: 'The weather is great today!' });
-      await listener.sanityCheck();
-    });
-    test('toReadableStream and fromReadableStream', async () => {
-      const { fetch, handleRequest } = mockStreamingChatCompletionFetch();
-
-      const openai = new OpenAI({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010', fetch });
-
-      const runner = openai.beta.chat.completions.stream({
-        stream: true,
-        messages: [{ role: 'user', content: 'tell me what the weather is like' }],
-        model: 'gpt-3.5-turbo',
-      });
-
-      const proxied = ChatCompletionStreamingRunner.fromReadableStream(runner.toReadableStream());
-      const listener = new StreamingRunnerListener(proxied);
-
-      await Promise.all([
-        handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {
-          expect(request.messages).toEqual([{ role: 'user', content: 'tell me what the weather is like' }]);
-          for (const choice of contentChoiceDeltas(`The weather is great today!`)) {
-            yield {
-              id: '1',
-              choices: [choice],
-              created: Math.floor(Date.now() / 1000),
-              model: 'gpt-3.5-turbo',
-              object: 'chat.completion.chunk',
-            };
-          }
-        }),
-        proxied.done(),
-      ]);
-
-      expect(listener.finalMessage).toEqual({ role: 'assistant', content: 'The weather is great today!' });
-      await listener.sanityCheck();
-    });
-    test('handles network errors', async () => {
-      const { fetch, handleRequest } = mockFetch();
-
-      const openai = new OpenAI({ apiKey: '...', fetch });
-
-      const stream = openai.beta.chat.completions.stream(
-        {
-          max_tokens: 1024,
-          model: 'gpt-3.5-turbo',
-          messages: [{ role: 'user', content: 'Say hello there!' }],
-        },
-        { maxRetries: 0 },
-      );
-
-      handleRequest(async () => {
-        throw new Error('mock request error');
-      }).catch(() => {});
-
-      async function runStream() {
-        await stream.done();
-      }
-
-      await expect(runStream).rejects.toThrow(APIConnectionError);
-    });
-    test('handles network errors on async iterator', async () => {
-      const { fetch, handleRequest } = mockFetch();
-
-      const openai = new OpenAI({ apiKey: '...', fetch });
-
-      const stream = openai.beta.chat.completions.stream(
-        {
-          max_tokens: 1024,
-          model: 'gpt-3.5-turbo',
-          messages: [{ role: 'user', content: 'Say hello there!' }],
-        },
-        { maxRetries: 0 },
-      );
-
-      handleRequest(async () => {
-        throw new Error('mock request error');
-      }).catch(() => {});
-
-      async function runStream() {
-        for await (const _event of stream) {
-          continue;
-        }
-      }
-
-      await expect(runStream).rejects.toThrow(APIConnectionError);
-    });
-  });
-});