chore: remove deprecated methods

Author: RobertCraigie

README.md

@@ -287,8 +287,6 @@ main();
 
 Like with `.stream()`, we provide a variety of [helpers and events](helpers.md#chat-events).
 
-Note that `runFunctions` was previously available as well, but has been deprecated in favor of `runTools`.
-
 Read more about various examples such as with integrating with [zod](helpers.md#integrate-with-zod),
 [next.js](helpers.md#integrate-with-nextjs), and [proxying a stream to the browser](helpers.md#proxy-streaming-to-a-browser).
 

api.md

@@ -347,7 +347,6 @@ Methods:
 
 Methods:
 
-- <code>client.beta.chat.completions.<a href="./src/resources/beta/chat/completions.ts">runFunctions</a>(body, options?) -> ChatCompletionRunner | ChatCompletionStreamingRunner</code>
 - <code>client.beta.chat.completions.<a href="./src/resources/beta/chat/completions.ts">runTools</a>(body, options?) -> ChatCompletionRunner | ChatCompletionStreamingRunner</code>
 - <code>client.beta.chat.completions.<a href="./src/resources/beta/chat/completions.ts">stream</a>(body, options?) -> ChatCompletionStream</code>
 

helpers.md

@@ -353,8 +353,6 @@ chat completion request, not for the entire call run.
 See an example of automated function calls in action in
 [`examples/function-call-helpers.ts`](examples/function-call-helpers.ts).
 
-Note, `runFunctions` was also previously available, but has been deprecated in favor of `runTools`.
-
 ### Chat Events
 
 #### `.on('connect', () => …)`

src/lib/AbstractChatCompletionRunner.ts

@@ -13,11 +13,8 @@ import {
   type BaseFunctionsArgs,
   RunnableToolFunction,
 } from './RunnableFunction';
-import { ChatCompletionFunctionRunnerParams, ChatCompletionToolRunnerParams } from './ChatCompletionRunner';
-import {
-  ChatCompletionStreamingFunctionRunnerParams,
-  ChatCompletionStreamingToolRunnerParams,
-} from './ChatCompletionStreamingRunner';
+import { ChatCompletionToolRunnerParams } from './ChatCompletionRunner';
+import { ChatCompletionStreamingToolRunnerParams } from './ChatCompletionStreamingRunner';
 import { isAssistantMessage, isFunctionMessage, isToolMessage } from './chatCompletionUtils';
 import { BaseEvents, EventStream } from './EventStream';
 import { ParsedChatCompletion } from '../resources/beta/chat/completions';
@@ -266,91 +263,6 @@ export class AbstractChatCompletionRunner<
     return await this._createChatCompletion(client, params, options);
   }
 
-  protected async _runFunctions<FunctionsArgs extends BaseFunctionsArgs>(
-    client: OpenAI,
-    params:
-      | ChatCompletionFunctionRunnerParams<FunctionsArgs>
-      | ChatCompletionStreamingFunctionRunnerParams<FunctionsArgs>,
-    options?: RunnerOptions,
-  ) {
-    const role = 'function' as const;
-    const { function_call = 'auto', stream, ...restParams } = params;
-    const singleFunctionToCall = typeof function_call !== 'string' && function_call?.name;
-    const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS } = options || {};
-
-    const functionsByName: Record<string, RunnableFunction<any>> = {};
-    for (const f of params.functions) {
-      functionsByName[f.name || f.function.name] = f;
-    }
-
-    const functions: ChatCompletionCreateParams.Function[] = params.functions.map(
-      (f): ChatCompletionCreateParams.Function => ({
-        name: f.name || f.function.name,
-        parameters: f.parameters as Record<string, unknown>,
-        description: f.description,
-      }),
-    );
-
-    for (const message of params.messages) {
-      this._addMessage(message, false);
-    }
-
-    for (let i = 0; i < maxChatCompletions; ++i) {
-      const chatCompletion: ChatCompletion = await this._createChatCompletion(
-        client,
-        {
-          ...restParams,
-          function_call,
-          functions,
-          messages: [...this.messages],
-        },
-        options,
-      );
-      const message = chatCompletion.choices[0]?.message;
-      if (!message) {
-        throw new OpenAIError(`missing message in ChatCompletion response`);
-      }
-      if (!message.function_call) return;
-      const { name, arguments: args } = message.function_call;
-      const fn = functionsByName[name];
-      if (!fn) {
-        const content = `Invalid function_call: ${JSON.stringify(name)}. Available options are: ${functions
-          .map((f) => JSON.stringify(f.name))
-          .join(', ')}. Please try again`;
-
-        this._addMessage({ role, name, content });
-        continue;
-      } else if (singleFunctionToCall && singleFunctionToCall !== name) {
-        const content = `Invalid function_call: ${JSON.stringify(name)}. ${JSON.stringify(
-          singleFunctionToCall,
-        )} requested. Please try again`;
-
-        this._addMessage({ role, name, content });
-        continue;
-      }
-
-      let parsed;
-      try {
-        parsed = isRunnableFunctionWithParse(fn) ? await fn.parse(args) : args;
-      } catch (error) {
-        this._addMessage({
-          role,
-          name,
-          content: error instanceof Error ? error.message : String(error),
-        });
-        continue;
-      }
-
-      // @ts-expect-error it can't rule out `never` type.
-      const rawContent = await fn.function(parsed, this);
-      const content = this.#stringifyFunctionCallResult(rawContent);
-
-      this._addMessage({ role, name, content });
-
-      if (singleFunctionToCall) return;
-    }
-  }
-
   protected async _runTools<FunctionsArgs extends BaseFunctionsArgs>(
     client: OpenAI,
     params:

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'
@@ -34,21 +27,6 @@ export class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletion
   ChatCompletionRunnerEvents,
   ParsedT
 > {
-  /** @deprecated - please use `runTools` instead. */
-  static runFunctions(
-    client: OpenAI,
-    params: ChatCompletionFunctionRunnerParams<any[]>,
-    options?: RunnerOptions,
-  ): ChatCompletionRunner<null> {
-    const runner = new ChatCompletionRunner();
-    const opts = {
-      ...options,
-      headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runFunctions' },
-    };
-    runner._run(() => runner._runFunctions(client, params, opts));
-    return runner;
-  }
-
   static runTools<ParsedT>(
     client: OpenAI,
     params: ChatCompletionToolRunnerParams<any[]>,

src/lib/ChatCompletionStreamingRunner.ts

@@ -3,8 +3,8 @@ import {
   type ChatCompletionCreateParamsStreaming,
 } 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 type { ReadableStream } from '../internal/shim-types';
+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'
@@ -38,21 +31,6 @@ export class ChatCompletionStreamingRunner<ParsedT = null>
     return runner;
   }
 
-  /** @deprecated - please use `runTools` instead. */
-  static runFunctions<T extends (string | object)[]>(
-    client: OpenAI,
-    params: ChatCompletionStreamingFunctionRunnerParams<T>,
-    options?: RunnerOptions,
-  ): ChatCompletionStreamingRunner<null> {
-    const runner = new ChatCompletionStreamingRunner(null);
-    const opts = {
-      ...options,
-      headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runFunctions' },
-    };
-    runner._run(() => runner._runFunctions(client, params, opts));
-    return runner;
-  }
-
   static runTools<T extends (string | object)[], ParsedT = null>(
     client: OpenAI,
     params: ChatCompletionStreamingToolRunnerParams<T>,

src/lib/RunnableFunction.ts

@@ -85,42 +85,13 @@ export function isRunnableFunctionWithParse<Args extends object>(
 
 export type BaseFunctionsArgs = readonly (object | string)[];
 
-export type RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs> =
-  [any[]] extends [FunctionsArgs] ? readonly RunnableFunction<any>[]
-  : {
-      [Index in keyof FunctionsArgs]: Index extends number ? RunnableFunction<FunctionsArgs[Index]>
-      : FunctionsArgs[Index];
-    };
-
 export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs> =
   [any[]] extends [FunctionsArgs] ? readonly RunnableToolFunction<any>[]
   : {
       [Index in keyof FunctionsArgs]: Index extends number ? RunnableToolFunction<FunctionsArgs[Index]>
       : FunctionsArgs[Index];
     };
 
-/**
- * This is helper class for passing a `function` and `parse` where the `function`
- * argument type matches the `parse` return type.
- *
- * @deprecated - please use ParsingToolFunction instead.
- */
-export class ParsingFunction<Args extends object> {
-  function: RunnableFunctionWithParse<Args>['function'];
-  parse: RunnableFunctionWithParse<Args>['parse'];
-  parameters: RunnableFunctionWithParse<Args>['parameters'];
-  description: RunnableFunctionWithParse<Args>['description'];
-  name?: RunnableFunctionWithParse<Args>['name'];
-
-  constructor(input: RunnableFunctionWithParse<Args>) {
-    this.function = input.function;
-    this.parse = input.parse;
-    this.parameters = input.parameters;
-    this.description = input.description;
-    this.name = input.name;
-  }
-}
-
 /**
  * This is helper class for passing a `function` and `parse` where the `function`
  * argument type matches the `parse` return type.

src/resources/beta/chat/completions.ts

@@ -3,7 +3,6 @@
 import { APIResource } from '../../../resource';
 import { ChatCompletionRunner } from '../../../lib/ChatCompletionRunner';
 import { ChatCompletionStreamingRunner } from '../../../lib/ChatCompletionStreamingRunner';
-import { RunnerOptions } from '../../../lib/AbstractChatCompletionRunner';
 import { ChatCompletionToolRunnerParams } from '../../../lib/ChatCompletionRunner';
 import { ChatCompletionStreamingToolRunnerParams } from '../../../lib/ChatCompletionStreamingRunner';
 import { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
@@ -14,28 +13,21 @@ import {
   ChatCompletionMessageToolCall,
 } from '../../chat/completions';
 import { ExtractParsedContentFromParams, parseChatCompletion, validateInputTools } from '../../../lib/parser';
+import { RequestOptions } from '../../../internal/request-options';
+import { type APIPromise } from '../../../api-promise';
+import { RunnerOptions } from '../../../lib/AbstractChatCompletionRunner';
 
-export {
-  ChatCompletionStreamingRunner,
-  type ChatCompletionStreamingFunctionRunnerParams,
-} from '../../../lib/ChatCompletionStreamingRunner';
+export { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
+export { ChatCompletionRunner } from '../../../lib/ChatCompletionRunner';
+export { ChatCompletionStreamingRunner } from '../../../lib/ChatCompletionStreamingRunner';
 export {
   type RunnableFunction,
-  type RunnableFunctions,
   type RunnableFunctionWithParse,
   type RunnableFunctionWithoutParse,
-  ParsingFunction,
   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';
-import { RequestOptions } from '../../../internal/request-options';
-import { type APIPromise } from '../../../index';
 
 export interface ParsedFunction extends ChatCompletionMessageToolCall.Function {
   parsed_arguments?: unknown;