openai 6.46.0 → 6.47.0

package/src/lib/RunnableFunction.ts

@@ -4,15 +4,17 @@ import { JSONSchema } from './jsonschema';
 
 type PromiseOrValue<T> = T | Promise<T>;
 
-export type RunnableFunctionWithParse<Args extends object> = {
+export type RunnableFunctionWithParse<Args extends object, ToolContext = unknown> = {
   /**
    * @param args the return value from `parse`.
    * @param runner the runner evaluating this callback.
+   * @param toolContext the context passed to `.runTools()`.
    * @returns a string to send back to OpenAI.
    */
   function: (
     args: Args,
     runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
+    toolContext: ToolContext,
   ) => PromiseOrValue<unknown>;
   /**
    * @param input the raw args from the OpenAI function call.
@@ -34,14 +36,17 @@ export type RunnableFunctionWithParse<Args extends object> = {
   strict?: boolean | undefined;
 };
 
-export type RunnableFunctionWithoutParse = {
+export type RunnableFunctionWithoutParse<ToolContext = unknown> = {
   /**
    * @param args the raw args from the OpenAI function call.
+   * @param runner the runner evaluating this callback.
+   * @param toolContext the context passed to `.runTools()`.
    * @returns a string to send back to OpenAI
    */
   function: (
     args: string,
     runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
+    toolContext: ToolContext,
   ) => PromiseOrValue<unknown>;
   /**
    * The parameters the function accepts, describes as a JSON Schema object.
@@ -58,56 +63,80 @@ export type RunnableFunctionWithoutParse = {
   strict?: boolean | undefined;
 };
 
-export type RunnableFunction<Args extends object | string> =
-  Args extends string ? RunnableFunctionWithoutParse
-  : Args extends object ? RunnableFunctionWithParse<Args>
-  : never;
+export type RunnableFunction<Args extends object | string, ToolContext = unknown> = Args extends string ?
+  RunnableFunctionWithoutParse<ToolContext>
+: Args extends object ? RunnableFunctionWithParse<Args, ToolContext>
+: never;
 
-export type RunnableToolFunction<Args extends object | string> =
-  Args extends string ? RunnableToolFunctionWithoutParse
-  : Args extends object ? RunnableToolFunctionWithParse<Args>
-  : never;
+export type RunnableToolFunction<Args extends object | string, ToolContext = unknown> = Args extends string ?
+  RunnableToolFunctionWithoutParse<ToolContext>
+: Args extends object ? RunnableToolFunctionWithParse<Args, ToolContext>
+: never;
 
-export type RunnableToolFunctionWithoutParse = {
+export type RunnableToolFunctionWithoutParse<ToolContext = unknown> = {
+  type: 'function';
+  function: RunnableFunctionWithoutParse<ToolContext>;
+};
+export type RunnableToolFunctionWithParse<Args extends object, ToolContext = unknown> = {
   type: 'function';
-  function: RunnableFunctionWithoutParse;
+  function: RunnableFunctionWithParse<Args, ToolContext>;
 };
-export type RunnableToolFunctionWithParse<Args extends object> = {
+
+/**
+ * A broad tool shape for contextually typing callbacks when the argument type is inferred.
+ */
+export type RunnableToolFunctionWithContext<ToolContext> = {
   type: 'function';
-  function: RunnableFunctionWithParse<Args>;
+  function: {
+    function: (
+      args: any,
+      runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
+      toolContext: ToolContext,
+    ) => PromiseOrValue<unknown>;
+    parse?: (input: string) => PromiseOrValue<any>;
+    parameters: JSONSchema;
+    description: string;
+    name?: string | undefined;
+    strict?: boolean | undefined;
+  };
 };
 
-export function isRunnableFunctionWithParse<Args extends object>(
+export function isRunnableFunctionWithParse<Args extends object, ToolContext = unknown>(
   fn: any,
-): fn is RunnableFunctionWithParse<Args> {
+): fn is RunnableFunctionWithParse<Args, ToolContext> {
   return typeof (fn as any).parse === 'function';
 }
 
 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 RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [
+  any[],
+] extends [FunctionsArgs] ?
+  readonly RunnableFunction<any, ToolContext>[]
+: {
+    [Index in keyof FunctionsArgs]: Index extends number ? RunnableFunction<FunctionsArgs[Index], ToolContext>
+    : 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];
-    };
+export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [any[]] extends (
+  [FunctionsArgs]
+) ?
+  readonly RunnableToolFunction<any, ToolContext>[]
+: {
+    [Index in keyof FunctionsArgs]: Index extends number ?
+      RunnableToolFunction<FunctionsArgs[Index], ToolContext>
+    : FunctionsArgs[Index];
+  };
 
 /**
  * This is helper class for passing a `function` and `parse` where the `function`
  * argument type matches the `parse` return type.
  */
-export class ParsingToolFunction<Args extends object> {
+export class ParsingToolFunction<Args extends object, ToolContext = unknown> {
   type: 'function';
-  function: RunnableFunctionWithParse<Args>;
+  function: RunnableFunctionWithParse<Args, ToolContext>;
 
-  constructor(input: RunnableFunctionWithParse<Args>) {
+  constructor(input: RunnableFunctionWithParse<Args, ToolContext>) {
     this.type = 'function';
     this.function = input;
   }

package/src/lib/parser.ts

@@ -7,8 +7,10 @@ import {
   ChatCompletionMessage,
   ChatCompletionMessageFunctionToolCall,
   ChatCompletionStreamingToolRunnerParams,
+  ChatCompletionStreamingToolRunnerParamsWithContext,
   ChatCompletionStreamParams,
   ChatCompletionToolRunnerParams,
+  ChatCompletionToolRunnerParamsWithContext,
   ParsedChatCompletion,
   ParsedChoice,
   ParsedFunctionToolCall,
@@ -19,7 +21,9 @@ import { ResponseFormatJSONSchema } from '../resources/shared';
 type AnyChatCompletionCreateParams =
   | ChatCompletionCreateParams
   | ChatCompletionToolRunnerParams<any>
+  | ChatCompletionToolRunnerParamsWithContext<any, any>
   | ChatCompletionStreamingToolRunnerParams<any>
+  | ChatCompletionStreamingToolRunnerParamsWithContext<any, any>
   | ChatCompletionStreamParams;
 
 type Unpacked<T> = T extends (infer U)[] ? U : T;

package/src/lib/responses/ResponseStream.ts

@@ -7,6 +7,7 @@ import {
   type ResponseStreamEvent,
 } from '../../resources/responses/responses';
 import { RequestOptions } from '../../internal/request-options';
+import { type ReadableStream } from '../../internal/shim-types';
 import { APIUserAbortError, OpenAIError } from '../../error';
 import OpenAI from '../../index';
 import { type BaseEvents, EventStream } from '../EventStream';
@@ -27,7 +28,9 @@ export type ResponseStreamByIdParams = {
    */
   response_id: string;
   /**
-   * If provided, the stream will start after the event with the given sequence number.
+   * If provided, events with a sequence number less than or equal to this value
+   * will not be emitted. The helper still replays them internally to build a
+   * complete snapshot for later events and `finalResponse()`.
    */
   starting_after?: number;
   /**
@@ -90,6 +93,12 @@ export class ResponseStream<ParsedT = null>
     return runner;
   }
 
+  static fromReadableStream(stream: ReadableStream): ResponseStream<null> {
+    const runner = new ResponseStream(null);
+    runner._run(() => runner._fromReadableStream(stream));
+    return runner;
+  }
+
   #beginRequest() {
     if (this.ended) return;
     this.#currentResponseSnapshot = undefined;
@@ -175,6 +184,8 @@ export class ResponseStream<ParsedT = null>
     let stream: Stream<ResponseStreamEvent> | undefined;
     let starting_after: number | null = null;
     if ('response_id' in params) {
+      // Keep the full replay so that `accumulateResponse()` sees `response.created` and can build
+      // complete snapshots before locally filtering events at `starting_after`.
       stream = await client.responses.retrieve(
         params.response_id,
         { stream: true },
@@ -198,6 +209,23 @@ export class ResponseStream<ParsedT = null>
     return this.#endRequest();
   }
 
+  protected async _fromReadableStream(
+    readableStream: ReadableStream,
+    options?: RequestOptions,
+  ): Promise<ParsedResponse<ParsedT>> {
+    this._listenForAbort(options?.signal);
+    this.#beginRequest();
+    this._connected();
+    const stream = Stream.fromReadableStream<ResponseStreamEvent>(readableStream, this.controller);
+    for await (const event of stream) {
+      this.#addEvent(event, null);
+    }
+    if (stream.controller.signal?.aborted) {
+      throw new APIUserAbortError();
+    }
+    return this.#endRequest();
+  }
+
   [Symbol.asyncIterator](this: ResponseStream<ParsedT>): AsyncIterator<ResponseStreamEvent> {
     const pushQueue: ResponseStreamEvent[] = [];
     const readQueue: {

package/src/resources/admin/organization/projects/api-keys.ts

@@ -121,6 +121,11 @@ export interface ProjectAPIKey {
 
   owner: ProjectAPIKey.Owner;
 
+  /**
+   * Whether the API key's owner currently has effective access to the project.
+   */
+  owner_project_access: 'active' | 'inactive';
+
   /**
    * The redacted value of the API key
    */
@@ -218,7 +223,16 @@ export interface APIKeyRetrieveParams {
   project_id: string;
 }
 
-export interface APIKeyListParams extends ConversationCursorPageParams {}
+export interface APIKeyListParams extends ConversationCursorPageParams {
+  /**
+   * Filter API keys by whether the owner currently has effective access to the
+   * project. Use `active` for owners with access, `inactive` for owners without
+   * access, or `any` for all enabled project API keys. If omitted, the endpoint
+   * applies its existing membership-based visibility rules, which may exclude some
+   * enabled keys.
+   */
+  owner_project_access?: 'active' | 'inactive' | 'any';
+}
 
 export interface APIKeyDeleteParams {
   /**

package/src/resources/beta/responses/responses.ts

@@ -9006,8 +9006,9 @@ export interface BetaResponseReasoningItem {
   content?: Array<BetaResponseReasoningItem.Content>;
 
   /**
-   * The encrypted content of the reasoning item - populated when a response is
-   * generated with `reasoning.encrypted_content` in the `include` parameter.
+   * The encrypted content of the reasoning item. This is populated by default for
+   * reasoning items returned by `POST /v1/responses` and WebSocket `response.create`
+   * requests.
    */
   encrypted_content?: string | null;
 

package/src/resources/chat/completions/completions.ts

@@ -15,8 +15,15 @@ import { path } from '../../../internal/utils/path';
 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 {
+  ChatCompletionToolRunnerParamsWithContext,
+  ChatCompletionToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionRunner';
+import {
+  ChatCompletionStreamingToolRunnerParamsWithContext,
+  ChatCompletionStreamingToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionStreamingRunner';
+import { type RunnableToolFunctionWithContext } from '../../../lib/RunnableFunction';
 import { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
 import { ExtractParsedContentFromParams, parseChatCompletion, validateInputTools } from '../../../lib/parser';
 
@@ -188,17 +195,55 @@ export class Completions extends APIResource {
    * [the docs](https://github.com/openai/openai-node#automated-function-calls)
    */
   runTools<
-    Params extends ChatCompletionToolRunnerParams<any>,
+    ToolContext,
+    Params extends Omit<
+      ChatCompletionToolRunnerParamsWithContext<any, ToolContext>,
+      'toolContext' | 'tools'
+    > = Omit<ChatCompletionToolRunnerParamsWithContext<any, ToolContext>, 'toolContext' | 'tools'>,
+    ParsedT = ExtractParsedContentFromParams<
+      Params & ChatCompletionToolRunnerParamsWithContext<any, ToolContext>
+    >,
+  >(
+    body: Params & {
+      toolContext: ToolContext;
+      tools: readonly RunnableToolFunctionWithContext<ToolContext>[];
+    },
+    options?: RunnerOptions,
+  ): ChatCompletionRunner<ParsedT>;
+
+  runTools<
+    ToolContext,
+    Params extends Omit<
+      ChatCompletionStreamingToolRunnerParamsWithContext<any, ToolContext>,
+      'toolContext' | 'tools'
+    > = Omit<ChatCompletionStreamingToolRunnerParamsWithContext<any, ToolContext>, 'toolContext' | 'tools'>,
+    ParsedT = ExtractParsedContentFromParams<
+      Params & ChatCompletionStreamingToolRunnerParamsWithContext<any, ToolContext>
+    >,
+  >(
+    body: Params & {
+      toolContext: ToolContext;
+      tools: readonly RunnableToolFunctionWithContext<ToolContext>[];
+    },
+    options?: RunnerOptions,
+  ): ChatCompletionStreamingRunner<ParsedT>;
+
+  runTools<
+    Params extends ChatCompletionToolRunnerParamsWithoutContext<any>,
     ParsedT = ExtractParsedContentFromParams<Params>,
   >(body: Params, options?: RunnerOptions): ChatCompletionRunner<ParsedT>;
 
   runTools<
-    Params extends ChatCompletionStreamingToolRunnerParams<any>,
+    Params extends ChatCompletionStreamingToolRunnerParamsWithoutContext<any>,
     ParsedT = ExtractParsedContentFromParams<Params>,
   >(body: Params, options?: RunnerOptions): ChatCompletionStreamingRunner<ParsedT>;
 
   runTools<
-    Params extends ChatCompletionToolRunnerParams<any> | ChatCompletionStreamingToolRunnerParams<any>,
+    Params extends
+      | ChatCompletionToolRunnerParamsWithoutContext<any>
+      | ChatCompletionToolRunnerParamsWithContext<any, any>
+      | ChatCompletionStreamingToolRunnerParamsWithoutContext<any>
+      | ChatCompletionStreamingToolRunnerParamsWithContext<any, any>,
     ParsedT = ExtractParsedContentFromParams<Params>,
   >(
     body: Params,
@@ -207,12 +252,16 @@ export class Completions extends APIResource {
     if (body.stream) {
       return ChatCompletionStreamingRunner.runTools(
         this._client,
-        body as ChatCompletionStreamingToolRunnerParams<any>,
+        body as ChatCompletionStreamingToolRunnerParamsWithContext<any, any>,
         options,
       );
     }
 
-    return ChatCompletionRunner.runTools(this._client, body as ChatCompletionToolRunnerParams<any>, options);
+    return ChatCompletionRunner.runTools(
+      this._client,
+      body as ChatCompletionToolRunnerParamsWithContext<any, any>,
+      options,
+    );
   }
 
   /**
@@ -255,8 +304,16 @@ export {
   type RunnableFunctionWithoutParse,
   ParsingToolFunction,
 } from '../../../lib/RunnableFunction';
-export { type ChatCompletionToolRunnerParams } from '../../../lib/ChatCompletionRunner';
-export { type ChatCompletionStreamingToolRunnerParams } from '../../../lib/ChatCompletionStreamingRunner';
+export {
+  type ChatCompletionToolRunnerParams,
+  type ChatCompletionToolRunnerParamsWithContext,
+  type ChatCompletionToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionRunner';
+export {
+  type ChatCompletionStreamingToolRunnerParams,
+  type ChatCompletionStreamingToolRunnerParamsWithContext,
+  type ChatCompletionStreamingToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionStreamingRunner';
 export { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
 export { ChatCompletionRunner } from '../../../lib/ChatCompletionRunner';
 

package/src/resources/responses/responses.ts

@@ -6498,8 +6498,9 @@ export interface ResponseReasoningItem {
   content?: Array<ResponseReasoningItem.Content>;
 
   /**
-   * The encrypted content of the reasoning item - populated when a response is
-   * generated with `reasoning.encrypted_content` in the `include` parameter.
+   * The encrypted content of the reasoning item. This is populated by default for
+   * reasoning items returned by `POST /v1/responses` and WebSocket `response.create`
+   * requests.
    */
   encrypted_content?: string | null;
 

package/src/resources/webhooks/api.md

@@ -17,7 +17,6 @@ Types:
 - <code><a href="./src/resources/webhooks.ts">ResponseCompletedWebhookEvent</a></code>
 - <code><a href="./src/resources/webhooks.ts">ResponseFailedWebhookEvent</a></code>
 - <code><a href="./src/resources/webhooks.ts">ResponseIncompleteWebhookEvent</a></code>
-- <code><a href="./src/resources/webhooks.ts">SafetyIdentifierBlockedWebhookEvent</a></code>
 - <code><a href="./src/resources/webhooks.ts">UnwrapWebhookEvent</a></code>
 
 Methods:

package/src/resources/webhooks/webhooks.ts

@@ -791,68 +791,6 @@ export namespace ResponseIncompleteWebhookEvent {
   }
 }
 
-/**
- * Sent when a request associated with a safety identifier has been blocked.
- */
-export interface SafetyIdentifierBlockedWebhookEvent {
-  /**
-   * The unique ID of the event.
-   */
-  id: string;
-
-  /**
-   * The Unix timestamp (in seconds) of when the request was blocked.
-   */
-  created_at: number;
-
-  /**
-   * Event data payload.
-   */
-  data: SafetyIdentifierBlockedWebhookEvent.Data;
-
-  /**
-   * The type of the event. Always `safety_identifier.blocked`.
-   */
-  type: 'safety_identifier.blocked';
-
-  /**
-   * The object of the event. Always `event`.
-   */
-  object?: 'event';
-}
-
-export namespace SafetyIdentifierBlockedWebhookEvent {
-  /**
-   * Event data payload.
-   */
-  export interface Data {
-    /**
-     * The safety category that triggered the block, such as `bio` or `cyber`.
-     */
-    safety_category: string;
-
-    /**
-     * The stable safety identifier associated with the blocked request.
-     */
-    safety_identifier: string;
-
-    /**
-     * The model used for the blocked request, if available.
-     */
-    model?: string;
-
-    /**
-     * The project associated with the blocked request, if available.
-     */
-    project_id?: string;
-
-    /**
-     * The OpenAI request ID for the blocked request, if available.
-     */
-    request_id?: string;
-  }
-}
-
 /**
  * Sent when a batch API request has been cancelled.
  */
@@ -871,8 +809,7 @@ export type UnwrapWebhookEvent =
   | ResponseCancelledWebhookEvent
   | ResponseCompletedWebhookEvent
   | ResponseFailedWebhookEvent
-  | ResponseIncompleteWebhookEvent
-  | SafetyIdentifierBlockedWebhookEvent;
+  | ResponseIncompleteWebhookEvent;
 
 export declare namespace Webhooks {
   export {
@@ -891,7 +828,6 @@ export declare namespace Webhooks {
     type ResponseCompletedWebhookEvent as ResponseCompletedWebhookEvent,
     type ResponseFailedWebhookEvent as ResponseFailedWebhookEvent,
     type ResponseIncompleteWebhookEvent as ResponseIncompleteWebhookEvent,
-    type SafetyIdentifierBlockedWebhookEvent as SafetyIdentifierBlockedWebhookEvent,
     type UnwrapWebhookEvent as UnwrapWebhookEvent,
   };
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '6.46.0'; // x-release-please-version
+export const VERSION = '6.47.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "6.46.0";
+export declare const VERSION = "6.47.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "6.46.0";
+export declare const VERSION = "6.47.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '6.46.0'; // x-release-please-version
+exports.VERSION = '6.47.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '6.46.0'; // x-release-please-version
+export const VERSION = '6.47.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map