openai 4.8.0 → 4.9.0

package/src/resources/moderations.ts

@@ -1,8 +1,8 @@
 // File generated from our OpenAPI spec by Stainless.
 
-import * as Core from '../core.js';
-import { APIResource } from '../resource.js';
-import * as API from './index.js';
+import * as Core from "../core";
+import { APIResource } from "../resource";
+import * as API from './index';
 
 export class Moderations extends APIResource {
   /**

package/src/shims/node.ts

@@ -0,0 +1,50 @@
+// @ts-ignore
+import * as types from '../_shims/node-types';
+import { setShims } from '../_shims/registry';
+import { getRuntime } from '../_shims/node-runtime';
+setShims(getRuntime());
+
+declare module '../_shims/manual-types' {
+  export namespace manual {
+    // @ts-ignore
+    export type Agent = types.Agent;
+    // @ts-ignore
+    export import fetch = types.fetch;
+    // @ts-ignore
+    export type Request = types.Request;
+    // @ts-ignore
+    export type RequestInfo = types.RequestInfo;
+    // @ts-ignore
+    export type RequestInit = types.RequestInit;
+    // @ts-ignore
+    export type Response = types.Response;
+    // @ts-ignore
+    export type ResponseInit = types.ResponseInit;
+    // @ts-ignore
+    export type ResponseType = types.ResponseType;
+    // @ts-ignore
+    export type BodyInit = types.BodyInit;
+    // @ts-ignore
+    export type Headers = types.Headers;
+    // @ts-ignore
+    export type HeadersInit = types.HeadersInit;
+    // @ts-ignore
+    export type BlobPropertyBag = types.BlobPropertyBag;
+    // @ts-ignore
+    export type FilePropertyBag = types.FilePropertyBag;
+    // @ts-ignore
+    export type FileFromPathOptions = types.FileFromPathOptions;
+    // @ts-ignore
+    export import FormData = types.FormData;
+    // @ts-ignore
+    export import File = types.File;
+    // @ts-ignore
+    export import Blob = types.Blob;
+    // @ts-ignore
+    export type Readable = types.Readable;
+    // @ts-ignore
+    export type FsReadStream = types.FsReadStream;
+    // @ts-ignore
+    export type ReadableStream = types.ReadableStream;
+  }
+}

package/src/shims/web.ts

@@ -0,0 +1,50 @@
+// @ts-ignore
+import * as types from '../_shims/web-types';
+import { setShims } from '../_shims/registry';
+import { getRuntime } from '../_shims/web-runtime';
+setShims(getRuntime({ manuallyImported: true }));
+
+declare module '../_shims/manual-types' {
+  export namespace manual {
+    // @ts-ignore
+    export type Agent = types.Agent;
+    // @ts-ignore
+    export import fetch = types.fetch;
+    // @ts-ignore
+    export type Request = types.Request;
+    // @ts-ignore
+    export type RequestInfo = types.RequestInfo;
+    // @ts-ignore
+    export type RequestInit = types.RequestInit;
+    // @ts-ignore
+    export type Response = types.Response;
+    // @ts-ignore
+    export type ResponseInit = types.ResponseInit;
+    // @ts-ignore
+    export type ResponseType = types.ResponseType;
+    // @ts-ignore
+    export type BodyInit = types.BodyInit;
+    // @ts-ignore
+    export type Headers = types.Headers;
+    // @ts-ignore
+    export type HeadersInit = types.HeadersInit;
+    // @ts-ignore
+    export type BlobPropertyBag = types.BlobPropertyBag;
+    // @ts-ignore
+    export type FilePropertyBag = types.FilePropertyBag;
+    // @ts-ignore
+    export type FileFromPathOptions = types.FileFromPathOptions;
+    // @ts-ignore
+    export import FormData = types.FormData;
+    // @ts-ignore
+    export import File = types.File;
+    // @ts-ignore
+    export import Blob = types.Blob;
+    // @ts-ignore
+    export type Readable = types.Readable;
+    // @ts-ignore
+    export type FsReadStream = types.FsReadStream;
+    // @ts-ignore
+    export type ReadableStream = types.ReadableStream;
+  }
+}

package/src/streaming.ts

@@ -1,4 +1,4 @@
-import type { Response } from './_shims/fetch.js';
+import { type Response } from './_shims/index';
 
 type Bytes = string | ArrayBuffer | Uint8Array | Buffer | null | undefined;
 

package/src/uploads.ts

@@ -1,12 +1,15 @@
-import { type RequestOptions } from './core.js';
-import { type Readable } from './_shims/node-readable.js';
-import { type BodyInit } from './_shims/fetch.js';
-import { FormData, File, type Blob, type FilePropertyBag } from './_shims/form-data.js';
-import { getMultipartRequestOptions } from './_shims/getMultipartRequestOptions.js';
-import { fileFromPath } from './_shims/fileFromPath.js';
-import { type FsReadStream, isFsReadStream } from './_shims/node-readable.js';
-
-export { fileFromPath };
+import { type RequestOptions } from './core';
+import {
+  FormData,
+  File,
+  type Blob,
+  type FilePropertyBag,
+  getMultipartRequestOptions,
+  type FsReadStream,
+  isFsReadStream,
+} from './_shims/index';
+import { MultipartBody } from './_shims/MultipartBody';
+export { fileFromPath } from './_shims/index';
 
 type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | Uint8Array | DataView;
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | Uint8Array | DataView;
@@ -175,13 +178,6 @@ const getStringFromMaybeBuffer = (x: string | Buffer | unknown): string | undefi
 const isAsyncIterableIterator = (value: any): value is AsyncIterableIterator<unknown> =>
   value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
 
-export class MultipartBody {
-  constructor(public body: Readable | BodyInit) {}
-  get [Symbol.toStringTag](): string {
-    return 'MultipartBody';
-  }
-}
-
 export const isMultipartBody = (body: any): body is MultipartBody =>
   body && typeof body === 'object' && body.body && body[Symbol.toStringTag] === 'MultipartBody';
 

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '4.8.0'; // x-release-please-version
+export const VERSION = '4.9.0'; // x-release-please-version

package/streaming.d.ts

@@ -1,10 +1,11 @@
-import type { Response } from 'openai/_shims/fetch';
+                              
+import { type Response } from "./_shims/index.js";
 export declare class Stream<Item> implements AsyncIterable<Item> {
-  controller: AbortController;
-  private response;
-  private decoder;
-  constructor(response: Response, controller: AbortController);
-  private iterMessages;
-  [Symbol.asyncIterator](): AsyncIterator<Item, any, undefined>;
+    controller: AbortController;
+    private response;
+    private decoder;
+    constructor(response: Response, controller: AbortController);
+    private iterMessages;
+    [Symbol.asyncIterator](): AsyncIterator<Item, any, undefined>;
 }
-//# sourceMappingURL=streaming.d.ts.map
+//# sourceMappingURL=streaming.d.ts.map

package/streaming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAUpD,qBAAa,MAAM,CAAC,IAAI,CAAE,YAAW,aAAa,CAAC,IAAI,CAAC;IACtD,UAAU,EAAE,eAAe,CAAC;IAE5B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,OAAO,CAAa;gBAEhB,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe;YAM5C,YAAY;IAqBpB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,CAAC;CA+BrE"}
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAU/C,qBAAa,MAAM,CAAC,IAAI,CAAE,YAAW,aAAa,CAAC,IAAI,CAAC;IACtD,UAAU,EAAE,eAAe,CAAC;IAE5B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,OAAO,CAAa;gBAEhB,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe;YAM5C,YAAY;IAqBpB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,CAAC;CA+BrE"}

package/streaming.js

@@ -1,99 +1,109 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stream = void 0;
 class Stream {
-  constructor(response, controller) {
-    this.response = response;
-    this.controller = controller;
-    this.decoder = new SSEDecoder();
-  }
-  async *iterMessages() {
-    if (!this.response.body) {
-      this.controller.abort();
-      throw new Error(`Attempted to iterate over a response with no body`);
-    }
-    const lineDecoder = new LineDecoder();
-    const iter = readableStreamAsyncIterable(this.response.body);
-    for await (const chunk of iter) {
-      for (const line of lineDecoder.decode(chunk)) {
-        const sse = this.decoder.decode(line);
-        if (sse) yield sse;
-      }
-    }
-    for (const line of lineDecoder.flush()) {
-      const sse = this.decoder.decode(line);
-      if (sse) yield sse;
+    constructor(response, controller) {
+        this.response = response;
+        this.controller = controller;
+        this.decoder = new SSEDecoder();
+    }
+    async *iterMessages() {
+        if (!this.response.body) {
+            this.controller.abort();
+            throw new Error(`Attempted to iterate over a response with no body`);
+        }
+        const lineDecoder = new LineDecoder();
+        const iter = readableStreamAsyncIterable(this.response.body);
+        for await (const chunk of iter) {
+            for (const line of lineDecoder.decode(chunk)) {
+                const sse = this.decoder.decode(line);
+                if (sse)
+                    yield sse;
+            }
+        }
+        for (const line of lineDecoder.flush()) {
+            const sse = this.decoder.decode(line);
+            if (sse)
+                yield sse;
+        }
     }
-  }
-  async *[Symbol.asyncIterator]() {
-    let done = false;
-    try {
-      for await (const sse of this.iterMessages()) {
-        if (done) continue;
-        if (sse.data.startsWith('[DONE]')) {
-          done = true;
-          continue;
-        }
-        if (sse.event === null) {
-          try {
-            yield JSON.parse(sse.data);
-          } catch (e) {
-            console.error(`Could not parse message into JSON:`, sse.data);
-            console.error(`From chunk:`, sse.raw);
+    async *[Symbol.asyncIterator]() {
+        let done = false;
+        try {
+            for await (const sse of this.iterMessages()) {
+                if (done)
+                    continue;
+                if (sse.data.startsWith('[DONE]')) {
+                    done = true;
+                    continue;
+                }
+                if (sse.event === null) {
+                    try {
+                        yield JSON.parse(sse.data);
+                    }
+                    catch (e) {
+                        console.error(`Could not parse message into JSON:`, sse.data);
+                        console.error(`From chunk:`, sse.raw);
+                        throw e;
+                    }
+                }
+            }
+            done = true;
+        }
+        catch (e) {
+            // If the user calls `stream.controller.abort()`, we should exit without throwing.
+            if (e instanceof Error && e.name === 'AbortError')
+                return;
             throw e;
-          }
-        }
-      }
-      done = true;
-    } catch (e) {
-      // If the user calls `stream.controller.abort()`, we should exit without throwing.
-      if (e instanceof Error && e.name === 'AbortError') return;
-      throw e;
-    } finally {
-      // If the user `break`s, abort the ongoing request.
-      if (!done) this.controller.abort();
+        }
+        finally {
+            // If the user `break`s, abort the ongoing request.
+            if (!done)
+                this.controller.abort();
+        }
     }
-  }
 }
 exports.Stream = Stream;
 class SSEDecoder {
-  constructor() {
-    this.event = null;
-    this.data = [];
-    this.chunks = [];
-  }
-  decode(line) {
-    if (line.endsWith('\r')) {
-      line = line.substring(0, line.length - 1);
-    }
-    if (!line) {
-      // empty line and we didn't previously encounter any messages
-      if (!this.event && !this.data.length) return null;
-      const sse = {
-        event: this.event,
-        data: this.data.join('\n'),
-        raw: this.chunks,
-      };
-      this.event = null;
-      this.data = [];
-      this.chunks = [];
-      return sse;
-    }
-    this.chunks.push(line);
-    if (line.startsWith(':')) {
-      return null;
-    }
-    let [fieldname, _, value] = partition(line, ':');
-    if (value.startsWith(' ')) {
-      value = value.substring(1);
-    }
-    if (fieldname === 'event') {
-      this.event = value;
-    } else if (fieldname === 'data') {
-      this.data.push(value);
+    constructor() {
+        this.event = null;
+        this.data = [];
+        this.chunks = [];
+    }
+    decode(line) {
+        if (line.endsWith('\r')) {
+            line = line.substring(0, line.length - 1);
+        }
+        if (!line) {
+            // empty line and we didn't previously encounter any messages
+            if (!this.event && !this.data.length)
+                return null;
+            const sse = {
+                event: this.event,
+                data: this.data.join('\n'),
+                raw: this.chunks,
+            };
+            this.event = null;
+            this.data = [];
+            this.chunks = [];
+            return sse;
+        }
+        this.chunks.push(line);
+        if (line.startsWith(':')) {
+            return null;
+        }
+        let [fieldname, _, value] = partition(line, ':');
+        if (value.startsWith(' ')) {
+            value = value.substring(1);
+        }
+        if (fieldname === 'event') {
+            this.event = value;
+        }
+        else if (fieldname === 'data') {
+            this.data.push(value);
+        }
+        return null;
     }
-    return null;
-  }
 }
 /**
  * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
@@ -102,87 +112,83 @@ class SSEDecoder {
  * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
  */
 class LineDecoder {
-  constructor() {
-    this.buffer = [];
-    this.trailingCR = false;
-  }
-  decode(chunk) {
-    let text = this.decodeText(chunk);
-    if (this.trailingCR) {
-      text = '\r' + text;
-      this.trailingCR = false;
-    }
-    if (text.endsWith('\r')) {
-      this.trailingCR = true;
-      text = text.slice(0, -1);
-    }
-    if (!text) {
-      return [];
-    }
-    const trailingNewline = LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || '');
-    let lines = text.split(LineDecoder.NEWLINE_REGEXP);
-    if (lines.length === 1 && !trailingNewline) {
-      this.buffer.push(lines[0]);
-      return [];
-    }
-    if (this.buffer.length > 0) {
-      lines = [this.buffer.join('') + lines[0], ...lines.slice(1)];
-      this.buffer = [];
-    }
-    if (!trailingNewline) {
-      this.buffer = [lines.pop() || ''];
-    }
-    return lines;
-  }
-  decodeText(bytes) {
-    var _a;
-    if (bytes == null) return '';
-    if (typeof bytes === 'string') return bytes;
-    // Node:
-    if (typeof Buffer !== 'undefined') {
-      if (bytes instanceof Buffer) {
-        return bytes.toString();
-      }
-      if (bytes instanceof Uint8Array) {
-        return Buffer.from(bytes).toString();
-      }
-      throw new Error(
-        `Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`,
-      );
-    }
-    // Browser
-    if (typeof TextDecoder !== 'undefined') {
-      if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
-        (_a = this.textDecoder) !== null && _a !== void 0 ? _a : (this.textDecoder = new TextDecoder('utf8'));
-        return this.textDecoder.decode(bytes);
-      }
-      throw new Error(
-        `Unexpected: received non-Uint8Array/ArrayBuffer (${bytes.constructor.name}) in a web platform. Please report this error.`,
-      );
+    constructor() {
+        this.buffer = [];
+        this.trailingCR = false;
+    }
+    decode(chunk) {
+        let text = this.decodeText(chunk);
+        if (this.trailingCR) {
+            text = '\r' + text;
+            this.trailingCR = false;
+        }
+        if (text.endsWith('\r')) {
+            this.trailingCR = true;
+            text = text.slice(0, -1);
+        }
+        if (!text) {
+            return [];
+        }
+        const trailingNewline = LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || '');
+        let lines = text.split(LineDecoder.NEWLINE_REGEXP);
+        if (lines.length === 1 && !trailingNewline) {
+            this.buffer.push(lines[0]);
+            return [];
+        }
+        if (this.buffer.length > 0) {
+            lines = [this.buffer.join('') + lines[0], ...lines.slice(1)];
+            this.buffer = [];
+        }
+        if (!trailingNewline) {
+            this.buffer = [lines.pop() || ''];
+        }
+        return lines;
+    }
+    decodeText(bytes) {
+        var _a;
+        if (bytes == null)
+            return '';
+        if (typeof bytes === 'string')
+            return bytes;
+        // Node:
+        if (typeof Buffer !== 'undefined') {
+            if (bytes instanceof Buffer) {
+                return bytes.toString();
+            }
+            if (bytes instanceof Uint8Array) {
+                return Buffer.from(bytes).toString();
+            }
+            throw new Error(`Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`);
+        }
+        // Browser
+        if (typeof TextDecoder !== 'undefined') {
+            if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
+                (_a = this.textDecoder) !== null && _a !== void 0 ? _a : (this.textDecoder = new TextDecoder('utf8'));
+                return this.textDecoder.decode(bytes);
+            }
+            throw new Error(`Unexpected: received non-Uint8Array/ArrayBuffer (${bytes.constructor.name}) in a web platform. Please report this error.`);
+        }
+        throw new Error(`Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.`);
     }
-    throw new Error(
-      `Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.`,
-    );
-  }
-  flush() {
-    if (!this.buffer.length && !this.trailingCR) {
-      return [];
+    flush() {
+        if (!this.buffer.length && !this.trailingCR) {
+            return [];
+        }
+        const lines = [this.buffer.join('')];
+        this.buffer = [];
+        this.trailingCR = false;
+        return lines;
     }
-    const lines = [this.buffer.join('')];
-    this.buffer = [];
-    this.trailingCR = false;
-    return lines;
-  }
 }
 // prettier-ignore
 LineDecoder.NEWLINE_CHARS = new Set(['\n', '\r', '\x0b', '\x0c', '\x1c', '\x1d', '\x1e', '\x85', '\u2028', '\u2029']);
 LineDecoder.NEWLINE_REGEXP = /\r\n|[\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029]/g;
 function partition(str, delimiter) {
-  const index = str.indexOf(delimiter);
-  if (index !== -1) {
-    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
-  }
-  return [str, '', ''];
+    const index = str.indexOf(delimiter);
+    if (index !== -1) {
+        return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+    }
+    return [str, '', ''];
 }
 /**
  * Most browsers don't yet have async iterable support for ReadableStream,
@@ -191,28 +197,31 @@ function partition(str, delimiter) {
  * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
  */
 function readableStreamAsyncIterable(stream) {
-  if (stream[Symbol.asyncIterator]) return stream;
-  const reader = stream.getReader();
-  return {
-    async next() {
-      try {
-        const result = await reader.read();
-        if (result === null || result === void 0 ? void 0 : result.done) reader.releaseLock(); // release lock when stream becomes closed
-        return result;
-      } catch (e) {
-        reader.releaseLock(); // release lock when stream becomes errored
-        throw e;
-      }
-    },
-    async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
-      await cancelPromise;
-      return { done: true, value: undefined };
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-  };
+    if (stream[Symbol.asyncIterator])
+        return stream;
+    const reader = stream.getReader();
+    return {
+        async next() {
+            try {
+                const result = await reader.read();
+                if (result === null || result === void 0 ? void 0 : result.done)
+                    reader.releaseLock(); // release lock when stream becomes closed
+                return result;
+            }
+            catch (e) {
+                reader.releaseLock(); // release lock when stream becomes errored
+                throw e;
+            }
+        },
+        async return() {
+            const cancelPromise = reader.cancel();
+            reader.releaseLock();
+            await cancelPromise;
+            return { done: true, value: undefined };
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
 }
-//# sourceMappingURL=streaming.js.map
+//# sourceMappingURL=streaming.js.map