refactor(functions): rename function helper methods to include tools

Author: RobertCraigie

examples/tool-call-helpers-zod.ts

@@ -73,8 +73,10 @@ async function main() {
       ],
     })
     .on('message', (msg) => console.log('msg', msg))
-    .on('functionCall', (functionCall) => console.log('functionCall', functionCall))
-    .on('functionCallResult', (functionCallResult) => console.log('functionCallResult', functionCallResult))
+    .on('finalFunctionToolCall', (functionCall) => console.log('functionCall', functionCall))
+    .on('finalFunctionToolCallResult', (functionCallResult) =>
+      console.log('functionCallResult', functionCallResult),
+    )
     .on('content', (diff) => process.stdout.write(diff));
 
   const result = await runner.finalChatCompletion();

examples/tool-call-helpers.ts

@@ -82,8 +82,10 @@ async function main() {
       ],
     })
     .on('message', (msg) => console.log('msg', msg))
-    .on('functionCall', (functionCall) => console.log('functionCall', functionCall))
-    .on('functionCallResult', (functionCallResult) => console.log('functionCallResult', functionCallResult))
+    .on('functionToolCall', (functionCall) => console.log('functionCall', functionCall))
+    .on('functionToolCallResult', (functionCallResult) =>
+      console.log('functionCallResult', functionCallResult),
+    )
     .on('content', (diff) => process.stdout.write(diff));
 
   const result = await runner.finalChatCompletion();

src/lib/AbstractChatCompletionRunner.ts

@@ -12,7 +12,7 @@ import {
   type RunnableFunction,
   isRunnableFunctionWithParse,
   type BaseFunctionsArgs,
-  RunnableToolFunction,
+  type RunnableToolFunction,
 } from './RunnableFunction';
 import type { ChatCompletionToolRunnerParams } from './ChatCompletionRunner';
 import type { ChatCompletionStreamingToolRunnerParams } from './ChatCompletionStreamingRunner';
@@ -60,11 +60,11 @@ export class AbstractChatCompletionRunner<
       this._emit('message', message);
       if (isToolMessage(message) && message.content) {
         // Note, this assumes that {role: 'tool', content: …} is always the result of a call of tool of type=function.
-        this._emit('functionCallResult', message.content as string);
+        this._emit('functionToolCallResult', message.content as string);
       } else if (isAssistantMessage(message) && message.tool_calls) {
         for (const tool_call of message.tool_calls) {
           if (tool_call.type === 'function') {
-            this._emit('functionCall', tool_call.function);
+            this._emit('functionToolCall', tool_call.function);
           }
         }
       }
@@ -121,7 +121,7 @@ export class AbstractChatCompletionRunner<
     return this.#getFinalMessage();
   }
 
-  #getFinalFunctionCall(): ChatCompletionMessageToolCall.Function | undefined {
+  #getFinalFunctionToolCall(): ChatCompletionMessageToolCall.Function | undefined {
     for (let i = this.messages.length - 1; i >= 0; i--) {
       const message = this.messages[i];
       if (isAssistantMessage(message) && message?.tool_calls?.length) {
@@ -136,12 +136,12 @@ export class AbstractChatCompletionRunner<
    * @returns a promise that resolves with the content of the final FunctionCall, or rejects
    * if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
    */
-  async finalFunctionCall(): Promise<ChatCompletionMessageToolCall.Function | undefined> {
+  async finalFunctionToolCall(): Promise<ChatCompletionMessageToolCall.Function | undefined> {
     await this.done();
-    return this.#getFinalFunctionCall();
+    return this.#getFinalFunctionToolCall();
   }
 
-  #getFinalFunctionCallResult(): string | undefined {
+  #getFinalFunctionToolCallResult(): string | undefined {
     for (let i = this.messages.length - 1; i >= 0; i--) {
       const message = this.messages[i];
       if (
@@ -161,9 +161,9 @@ export class AbstractChatCompletionRunner<
     return;
   }
 
-  async finalFunctionCallResult(): Promise<string | undefined> {
+  async finalFunctionToolCallResult(): Promise<string | undefined> {
     await this.done();
-    return this.#getFinalFunctionCallResult();
+    return this.#getFinalFunctionToolCallResult();
   }
 
   #calculateTotalUsage(): CompletionUsage {
@@ -201,11 +201,11 @@ export class AbstractChatCompletionRunner<
     const finalContent = this.#getFinalContent();
     if (finalContent) this._emit('finalContent', finalContent);
 
-    const finalFunctionCall = this.#getFinalFunctionCall();
-    if (finalFunctionCall) this._emit('finalFunctionCall', finalFunctionCall);
+    const finalFunctionCall = this.#getFinalFunctionToolCall();
+    if (finalFunctionCall) this._emit('finalFunctionToolCall', finalFunctionCall);
 
-    const finalFunctionCallResult = this.#getFinalFunctionCallResult();
-    if (finalFunctionCallResult != null) this._emit('finalFunctionCallResult', finalFunctionCallResult);
+    const finalFunctionCallResult = this.#getFinalFunctionToolCallResult();
+    if (finalFunctionCallResult != null) this._emit('finalFunctionToolCallResult', finalFunctionCallResult);
 
     if (this._chatCompletions.some((c) => c.usage)) {
       this._emit('totalUsage', this.#calculateTotalUsage());
@@ -390,14 +390,14 @@ export class AbstractChatCompletionRunner<
 }
 
 export interface AbstractChatCompletionRunnerEvents extends BaseEvents {
-  functionCall: (functionCall: ChatCompletionMessageToolCall.Function) => void;
+  functionToolCall: (functionCall: ChatCompletionMessageToolCall.Function) => void;
   message: (message: ChatCompletionMessageParam) => void;
   chatCompletion: (completion: ChatCompletion) => void;
   finalContent: (contentSnapshot: string) => void;
   finalMessage: (message: ChatCompletionMessageParam) => void;
   finalChatCompletion: (completion: ChatCompletion) => void;
-  finalFunctionCall: (functionCall: ChatCompletionMessageToolCall.Function) => void;
-  functionCallResult: (content: string) => void;
-  finalFunctionCallResult: (content: string) => void;
+  finalFunctionToolCall: (functionCall: ChatCompletionMessageToolCall.Function) => void;
+  functionToolCallResult: (content: string) => void;
+  finalFunctionToolCallResult: (content: string) => void;
   totalUsage: (usage: CompletionUsage) => void;
 }

src/lib/ChatCompletionRunner.ts

@@ -2,7 +2,7 @@ import {
   type ChatCompletionMessageParam,
   type ChatCompletionCreateParamsNonStreaming,
 } from '../resources/chat/completions';
-import { type RunnableFunctions, type BaseFunctionsArgs, RunnableTools } from './RunnableFunction';
+import { type BaseFunctionsArgs, RunnableTools } from './RunnableFunction';
 import {
   AbstractChatCompletionRunner,
   AbstractChatCompletionRunnerEvents,
@@ -16,13 +16,6 @@ export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunner
   content: (content: string) => void;
 }
 
-export type ChatCompletionFunctionRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
-  ChatCompletionCreateParamsNonStreaming,
-  'functions'
-> & {
-  functions: RunnableFunctions<FunctionsArgs>;
-};
-
 export type ChatCompletionToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
   ChatCompletionCreateParamsNonStreaming,
   'tools'

src/lib/ChatCompletionStreamingRunner.ts

@@ -4,7 +4,7 @@ import {
 } from '../resources/chat/completions';
 import { RunnerOptions, type AbstractChatCompletionRunnerEvents } from './AbstractChatCompletionRunner';
 import { type ReadableStream } from '../internal/shim-types';
-import { RunnableTools, type BaseFunctionsArgs, type RunnableFunctions } from './RunnableFunction';
+import { RunnableTools, type BaseFunctionsArgs } from './RunnableFunction';
 import { ChatCompletionSnapshot, ChatCompletionStream } from './ChatCompletionStream';
 import OpenAI from '../index';
 import { AutoParseableTool } from '../lib/parser';
@@ -14,13 +14,6 @@ export interface ChatCompletionStreamEvents extends AbstractChatCompletionRunner
   chunk: (chunk: ChatCompletionChunk, snapshot: ChatCompletionSnapshot) => void;
 }
 
-export type ChatCompletionStreamingFunctionRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
-  ChatCompletionCreateParamsStreaming,
-  'functions'
-> & {
-  functions: RunnableFunctions<FunctionsArgs>;
-};
-
 export type ChatCompletionStreamingToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
   ChatCompletionCreateParamsStreaming,
   'tools'

src/resources/beta/chat/completions.ts

@@ -15,24 +15,16 @@ import {
 } from '../../chat/completions';
 import { ExtractParsedContentFromParams, parseChatCompletion, validateInputTools } from '../../../lib/parser';
 
+export { ChatCompletionStreamingRunner } from '../../../lib/ChatCompletionStreamingRunner';
 export {
-  ChatCompletionStreamingRunner,
-  type ChatCompletionStreamingFunctionRunnerParams,
-} from '../../../lib/ChatCompletionStreamingRunner';
-export {
-  type RunnableFunction,
-  type RunnableFunctions,
   type RunnableFunctionWithParse,
   type RunnableFunctionWithoutParse,
   ParsingToolFunction,
 } from '../../../lib/RunnableFunction';
 export { type ChatCompletionToolRunnerParams } from '../../../lib/ChatCompletionRunner';
 export { type ChatCompletionStreamingToolRunnerParams } from '../../../lib/ChatCompletionStreamingRunner';
 export { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
-export {
-  ChatCompletionRunner,
-  type ChatCompletionFunctionRunnerParams,
-} from '../../../lib/ChatCompletionRunner';
+export { ChatCompletionRunner } from '../../../lib/ChatCompletionRunner';
 import { RequestOptions } from '../../../internal/request-options';
 import { type APIPromise } from '../../../index';
 

tests/lib/ChatCompletionRunFunctions.test.ts

@@ -151,13 +151,13 @@ class RunnerListener {
       .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('functionToolCall', (functionCall) => this.functionCalls.push(functionCall))
+      .on('functionToolCallResult', (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('finalFunctionToolCall', (functionCall) => (this.finalFunctionCall = functionCall))
+      .on('finalFunctionToolCallResult', (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)))
@@ -175,8 +175,8 @@ class RunnerListener {
       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.finalFunctionToolCall()).rejects.toThrow(error);
+      await expect(this.runner.finalFunctionToolCallResult()).rejects.toThrow(error);
       await expect(this.runner.totalUsage()).rejects.toThrow(error);
       await expect(this.runner.done()).rejects.toThrow(error);
     } else {
@@ -214,11 +214,11 @@ class RunnerListener {
     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(await this.runner.finalFunctionToolCall()).toEqual(this.finalFunctionCall);
     expect(this.finalFunctionCallResult).toEqual(
       this.functionCallResults[this.functionCallResults.length - 1],
     );
-    expect(await this.runner.finalFunctionCallResult()).toEqual(this.finalFunctionCallResult);
+    expect(await this.runner.finalFunctionToolCallResult()).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)) {
@@ -266,13 +266,13 @@ class StreamingRunnerListener {
       .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('functionToolCall', (functionCall) => this.eventFunctionCalls.push(functionCall))
+      .on('functionToolCallResult', (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('finalFunctionToolCall', (functionCall) => (this.finalFunctionCall = functionCall))
+      .on('finalFunctionToolCallResult', (result) => (this.finalFunctionCallResult = result))
       .on('error', (error) => (this.error = error))
       .on('abort', (abort) => (this.error = abort))
       .on('end', () => (this.gotEnd = true));
@@ -285,8 +285,8 @@ class StreamingRunnerListener {
       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.finalFunctionToolCall()).rejects.toThrow(error);
+      await expect(this.runner.finalFunctionToolCallResult()).rejects.toThrow(error);
       await expect(this.runner.done()).rejects.toThrow(error);
     } else {
       expect(this.error).toBeUndefined();
@@ -318,11 +318,11 @@ class StreamingRunnerListener {
     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(await this.runner.finalFunctionToolCall()).toEqual(this.finalFunctionCall);
     expect(this.finalFunctionCallResult).toEqual(
       this.eventFunctionCallResults[this.eventFunctionCallResults.length - 1],
     );
-    expect(await this.runner.finalFunctionCallResult()).toEqual(this.finalFunctionCallResult);
+    expect(await this.runner.finalFunctionToolCallResult()).toEqual(this.finalFunctionCallResult);
     expect(this.eventChatCompletions).toEqual(this.runner.allChatCompletions());
     expect(this.eventMessages).toEqual(this.runner.messages.slice(-this.eventMessages.length));
     if (error) {
@@ -1603,7 +1603,7 @@ describe('resource completions', () => {
         },
         { signal: controller.signal },
       );
-      runner.on('functionCallResult', () => controller.abort());
+      runner.on('functionToolCallResult', () => controller.abort());
       const listener = new StreamingRunnerListener(runner);
 
       await handleRequest(async function* (request): AsyncIterable<OpenAI.Chat.ChatCompletionChunk> {