@nocobase/plugin-ai 2.1.7 → 2.1.8

package/dist/node_modules/openai/src/resources/responses/index.ts

@@ -3,3 +3,5 @@
 export { InputItems, type ResponseItemList, type InputItemListParams } from './input-items';
 export { InputTokens, type InputTokenCountResponse, type InputTokenCountParams } from './input-tokens';
 export { Responses } from './responses';
+export { type ResponsesWSClientOptions } from './ws';
+export { type ResponsesWSReconnectOptions } from './ws-base';

package/dist/node_modules/openai/src/resources/responses/input-items.ts

@@ -29,7 +29,7 @@ export class InputItems extends APIResource {
     return this._client.getAPIList(
       path`/responses/${responseID}/input_items`,
       CursorPage<ResponsesAPI.ResponseItem>,
-      { query, ...options },
+      { query, ...options, __security: { bearerAuth: true } },
     );
   }
 }

package/dist/node_modules/openai/src/resources/responses/input-tokens.ts

@@ -8,7 +8,10 @@ import { RequestOptions } from '../../internal/request-options';
 
 export class InputTokens extends APIResource {
   /**
-   * Get input token counts
+   * Returns input token counts of the request.
+   *
+   * Returns an object with `object` set to `response.input_tokens` and an
+   * `input_tokens` count.
    *
    * @example
    * ```ts
@@ -19,7 +22,11 @@ export class InputTokens extends APIResource {
     body: InputTokenCountParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<InputTokenCountResponse> {
-    return this._client.post('/responses/input_tokens', { body, ...options });
+    return this._client.post('/responses/input_tokens', {
+      body,
+      ...options,
+      __security: { bearerAuth: true },
+    });
   }
 }
 

package/dist/node_modules/openai/src/resources/responses/internal-base.ts

@@ -0,0 +1,113 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as ResponsesAPI from './responses';
+import { OpenAI } from '../../client';
+import { EventEmitter } from '../../core/EventEmitter';
+import { OpenAIError } from '../../core/error';
+
+import type { RawWebSocketData, ReconnectingEvent, UnsentMessage } from '../../internal/ws';
+
+export type ResponsesStreamMessage =
+  | { type: 'connecting' | 'open' | 'closing' }
+  | {
+      type: 'close';
+      code: number;
+      reason: string;
+      unsent: UnsentMessage<ResponsesAPI.ResponsesClientEvent>[];
+    }
+  | { type: 'reconnecting'; reconnect: ReconnectingEvent }
+  | { type: 'reconnected' }
+  | { type: 'message'; message: ResponsesAPI.ResponsesServerEvent }
+  | { type: 'raw'; data: RawWebSocketData }
+  | { type: 'error'; error: WebSocketError };
+
+export class WebSocketError extends OpenAIError {
+  /**
+   * The error data that the API sent back in an error event.
+   */
+  error?: ResponsesAPI.ResponseErrorEvent | undefined;
+
+  constructor(message: string, event: ResponsesAPI.ResponseErrorEvent | null) {
+    super(message);
+
+    this.error = event ?? undefined;
+  }
+}
+
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+type WebSocketEvents = Simplify<
+  {
+    event: (event: ResponsesAPI.ResponsesServerEvent) => void;
+    raw: (data: RawWebSocketData) => void;
+    error: (error: WebSocketError) => void;
+    close: (code: number, reason: string, unsent: UnsentMessage<ResponsesAPI.ResponsesClientEvent>[]) => void;
+    reconnecting: (event: ReconnectingEvent) => void;
+    reconnected: () => void;
+  } & {
+    [EventType in Exclude<NonNullable<ResponsesAPI.ResponsesServerEvent['type']>, 'error'>]: (
+      event: Extract<ResponsesAPI.ResponsesServerEvent, { type?: EventType }>,
+    ) => unknown;
+  }
+>;
+
+export abstract class ResponsesEmitter extends EventEmitter<WebSocketEvents> {
+  /**
+   * Send an event to the API.
+   */
+  abstract send(event: ResponsesAPI.ResponsesClientEvent): void;
+
+  /**
+   * Send raw data over the WebSocket without JSON serialization.
+   */
+  abstract sendRaw(data: RawWebSocketData): void;
+
+  /**
+   * Close the WebSocket connection.
+   */
+  abstract close(props?: { code: number; reason: string }): void;
+
+  protected _onError(event: null, message: string, cause: any): void;
+  protected _onError(event: ResponsesAPI.ResponseErrorEvent, message?: string | undefined): void;
+  protected _onError(
+    event: ResponsesAPI.ResponseErrorEvent | null,
+    message?: string | undefined,
+    cause?: any,
+  ): void {
+    message = message ?? safeJSONStringify(event) ?? 'unknown error';
+
+    if (!this._hasListener('error')) {
+      const error = new WebSocketError(
+        message +
+          `\n\nTo resolve these unhandled rejection errors you should bind an \`error\` callback, e.g. \`ws.on('error', (error) => ...)\` `,
+        event,
+      );
+      // @ts-ignore
+      error.cause = cause;
+      Promise.reject(error);
+      return;
+    }
+
+    const error = new WebSocketError(message, event);
+    // @ts-ignore
+    error.cause = cause;
+
+    this._emit('error', error);
+  }
+}
+
+export function buildURL(client: OpenAI, parameters: Record<string, unknown>): URL {
+  const { ...query } = parameters;
+  const endpoint = '/responses';
+  const url = new URL(client.buildURL(endpoint, query, undefined));
+  url.protocol = url.protocol === 'http:' || url.protocol === 'ws:' ? 'ws:' : 'wss:';
+  return url;
+}
+
+function safeJSONStringify(value: unknown): string | null {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}