@nocobase/plugin-ai 1.9.0-beta.8 → 2.0.0-alpha.10

package/dist/node_modules/@langchain/deepseek/node_modules/openai/src/core/streaming.ts

@@ -0,0 +1,338 @@
+import { OpenAIError } from './error';
+import { type ReadableStream } from '../internal/shim-types';
+import { makeReadableStream } from '../internal/shims';
+import { findDoubleNewlineIndex, LineDecoder } from '../internal/decoders/line';
+import { ReadableStreamToAsyncIterable } from '../internal/shims';
+import { isAbortError } from '../internal/errors';
+import { encodeUTF8 } from '../internal/utils/bytes';
+
+import { APIError } from './error';
+
+type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+export type ServerSentEvent = {
+  event: string | null;
+  data: string;
+  raw: string[];
+};
+
+export class Stream<Item> implements AsyncIterable<Item> {
+  controller: AbortController;
+
+  constructor(
+    private iterator: () => AsyncIterator<Item>,
+    controller: AbortController,
+  ) {
+    this.controller = controller;
+  }
+
+  static fromSSEResponse<Item>(response: Response, controller: AbortController): Stream<Item> {
+    let consumed = false;
+
+    async function* iterator(): AsyncIterator<Item, any, undefined> {
+      if (consumed) {
+        throw new OpenAIError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const sse of _iterSSEMessages(response, controller)) {
+          if (done) continue;
+
+          if (sse.data.startsWith('[DONE]')) {
+            done = true;
+            continue;
+          }
+
+          if (
+            sse.event === null ||
+            sse.event.startsWith('response.') ||
+            sse.event.startsWith('transcript.')
+          ) {
+            let data;
+
+            try {
+              data = JSON.parse(sse.data);
+            } catch (e) {
+              console.error(`Could not parse message into JSON:`, sse.data);
+              console.error(`From chunk:`, sse.raw);
+              throw e;
+            }
+
+            if (data && data.error) {
+              throw new APIError(undefined, data.error, undefined, response.headers);
+            }
+
+            yield data;
+          } else {
+            let data;
+            try {
+              data = JSON.parse(sse.data);
+            } catch (e) {
+              console.error(`Could not parse message into JSON:`, sse.data);
+              console.error(`From chunk:`, sse.raw);
+              throw e;
+            }
+            // TODO: Is this where the error should be thrown?
+            if (sse.event == 'error') {
+              throw new APIError(undefined, data.error, data.message, undefined);
+            }
+            yield { event: sse.event, data: data } as any;
+          }
+        }
+        done = true;
+      } catch (e) {
+        // If the user calls `stream.controller.abort()`, we should exit without throwing.
+        if (isAbortError(e)) return;
+        throw e;
+      } finally {
+        // If the user `break`s, abort the ongoing request.
+        if (!done) controller.abort();
+      }
+    }
+
+    return new Stream(iterator, controller);
+  }
+
+  /**
+   * Generates a Stream from a newline-separated ReadableStream
+   * where each item is a JSON value.
+   */
+  static fromReadableStream<Item>(readableStream: ReadableStream, controller: AbortController): Stream<Item> {
+    let consumed = false;
+
+    async function* iterLines(): AsyncGenerator<string, void, unknown> {
+      const lineDecoder = new LineDecoder();
+
+      const iter = ReadableStreamToAsyncIterable<Bytes>(readableStream);
+      for await (const chunk of iter) {
+        for (const line of lineDecoder.decode(chunk)) {
+          yield line;
+        }
+      }
+
+      for (const line of lineDecoder.flush()) {
+        yield line;
+      }
+    }
+
+    async function* iterator(): AsyncIterator<Item, any, undefined> {
+      if (consumed) {
+        throw new OpenAIError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const line of iterLines()) {
+          if (done) continue;
+          if (line) yield JSON.parse(line);
+        }
+        done = true;
+      } catch (e) {
+        // If the user calls `stream.controller.abort()`, we should exit without throwing.
+        if (isAbortError(e)) return;
+        throw e;
+      } finally {
+        // If the user `break`s, abort the ongoing request.
+        if (!done) controller.abort();
+      }
+    }
+
+    return new Stream(iterator, controller);
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<Item> {
+    return this.iterator();
+  }
+
+  /**
+   * Splits the stream into two streams which can be
+   * independently read from at different speeds.
+   */
+  tee(): [Stream<Item>, Stream<Item>] {
+    const left: Array<Promise<IteratorResult<Item>>> = [];
+    const right: Array<Promise<IteratorResult<Item>>> = [];
+    const iterator = this.iterator();
+
+    const teeIterator = (queue: Array<Promise<IteratorResult<Item>>>): AsyncIterator<Item> => {
+      return {
+        next: () => {
+          if (queue.length === 0) {
+            const result = iterator.next();
+            left.push(result);
+            right.push(result);
+          }
+          return queue.shift()!;
+        },
+      };
+    };
+
+    return [
+      new Stream(() => teeIterator(left), this.controller),
+      new Stream(() => teeIterator(right), this.controller),
+    ];
+  }
+
+  /**
+   * Converts this stream to a newline-separated ReadableStream of
+   * JSON stringified values in the stream
+   * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+   */
+  toReadableStream(): ReadableStream {
+    const self = this;
+    let iter: AsyncIterator<Item>;
+
+    return makeReadableStream({
+      async start() {
+        iter = self[Symbol.asyncIterator]();
+      },
+      async pull(ctrl: any) {
+        try {
+          const { value, done } = await iter.next();
+          if (done) return ctrl.close();
+
+          const bytes = encodeUTF8(JSON.stringify(value) + '\n');
+
+          ctrl.enqueue(bytes);
+        } catch (err) {
+          ctrl.error(err);
+        }
+      },
+      async cancel() {
+        await iter.return?.();
+      },
+    });
+  }
+}
+
+export async function* _iterSSEMessages(
+  response: Response,
+  controller: AbortController,
+): AsyncGenerator<ServerSentEvent, void, unknown> {
+  if (!response.body) {
+    controller.abort();
+    if (
+      typeof (globalThis as any).navigator !== 'undefined' &&
+      (globalThis as any).navigator.product === 'ReactNative'
+    ) {
+      throw new OpenAIError(
+        `The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`,
+      );
+    }
+    throw new OpenAIError(`Attempted to iterate over a response with no body`);
+  }
+
+  const sseDecoder = new SSEDecoder();
+  const lineDecoder = new LineDecoder();
+
+  const iter = ReadableStreamToAsyncIterable<Bytes>(response.body);
+  for await (const sseChunk of iterSSEChunks(iter)) {
+    for (const line of lineDecoder.decode(sseChunk)) {
+      const sse = sseDecoder.decode(line);
+      if (sse) yield sse;
+    }
+  }
+
+  for (const line of lineDecoder.flush()) {
+    const sse = sseDecoder.decode(line);
+    if (sse) yield sse;
+  }
+}
+
+/**
+ * Given an async iterable iterator, iterates over it and yields full
+ * SSE chunks, i.e. yields when a double new-line is encountered.
+ */
+async function* iterSSEChunks(iterator: AsyncIterableIterator<Bytes>): AsyncGenerator<Uint8Array> {
+  let data = new Uint8Array();
+
+  for await (const chunk of iterator) {
+    if (chunk == null) {
+      continue;
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    let newData = new Uint8Array(data.length + binaryChunk.length);
+    newData.set(data);
+    newData.set(binaryChunk, data.length);
+    data = newData;
+
+    let patternIndex;
+    while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
+      yield data.slice(0, patternIndex);
+      data = data.slice(patternIndex);
+    }
+  }
+
+  if (data.length > 0) {
+    yield data;
+  }
+}
+
+class SSEDecoder {
+  private data: string[];
+  private event: string | null;
+  private chunks: string[];
+
+  constructor() {
+    this.event = null;
+    this.data = [];
+    this.chunks = [];
+  }
+
+  decode(line: string) {
+    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: ServerSentEvent = {
+        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;
+  }
+}
+
+function partition(str: string, delimiter: string): [string, string, string] {
+  const index = str.indexOf(delimiter);
+  if (index !== -1) {
+    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+  }
+
+  return [str, '', ''];
+}

package/dist/node_modules/@langchain/deepseek/node_modules/openai/src/core/uploads.ts

@@ -0,0 +1,2 @@
+export { type Uploadable } from '../internal/uploads';
+export { toFile, type ToFileInput } from '../internal/to-file';

package/dist/node_modules/@langchain/deepseek/node_modules/openai/src/error.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/error instead */
+export * from './core/error';

package/dist/node_modules/@langchain/deepseek/node_modules/openai/src/helpers/audio.ts

@@ -0,0 +1,146 @@
+import { spawn } from 'node:child_process';
+import { Readable } from 'node:stream';
+import { platform, versions } from 'node:process';
+import { checkFileSupport } from '../internal/uploads';
+
+const DEFAULT_SAMPLE_RATE = 24000;
+const DEFAULT_CHANNELS = 1;
+
+const isNode = Boolean(versions?.node);
+
+const recordingProviders: Record<NodeJS.Platform, string> = {
+  win32: 'dshow',
+  darwin: 'avfoundation',
+  linux: 'alsa',
+  aix: 'alsa',
+  android: 'alsa',
+  freebsd: 'alsa',
+  haiku: 'alsa',
+  sunos: 'alsa',
+  netbsd: 'alsa',
+  openbsd: 'alsa',
+  cygwin: 'dshow',
+};
+
+function isResponse(stream: NodeJS.ReadableStream | Response | File): stream is Response {
+  return typeof (stream as any).body !== 'undefined';
+}
+
+function isFile(stream: NodeJS.ReadableStream | Response | File): stream is File {
+  checkFileSupport();
+  return stream instanceof File;
+}
+
+async function nodejsPlayAudio(stream: NodeJS.ReadableStream | Response | File): Promise<void> {
+  return new Promise((resolve, reject) => {
+    try {
+      const ffplay = spawn('ffplay', ['-autoexit', '-nodisp', '-i', 'pipe:0']);
+
+      if (isResponse(stream)) {
+        (stream.body! as any).pipe(ffplay.stdin);
+      } else if (isFile(stream)) {
+        Readable.from(stream.stream()).pipe(ffplay.stdin);
+      } else {
+        stream.pipe(ffplay.stdin);
+      }
+
+      ffplay.on('close', (code: number) => {
+        if (code !== 0) {
+          reject(new Error(`ffplay process exited with code ${code}`));
+        }
+        resolve();
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+export async function playAudio(input: NodeJS.ReadableStream | Response | File): Promise<void> {
+  if (isNode) {
+    return nodejsPlayAudio(input);
+  }
+
+  throw new Error(
+    'Play audio is not supported in the browser yet. Check out https://npm.im/wavtools as an alternative.',
+  );
+}
+
+type RecordAudioOptions = {
+  signal?: AbortSignal;
+  device?: number;
+  timeout?: number;
+};
+
+function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {}): Promise<File> {
+  checkFileSupport();
+  return new Promise((resolve, reject) => {
+    const data: any[] = [];
+    const provider = recordingProviders[platform];
+    try {
+      const ffmpeg = spawn(
+        'ffmpeg',
+        [
+          '-f',
+          provider,
+          '-i',
+          `:${device ?? 0}`, // default audio input device; adjust as needed
+          '-ar',
+          DEFAULT_SAMPLE_RATE.toString(),
+          '-ac',
+          DEFAULT_CHANNELS.toString(),
+          '-f',
+          'wav',
+          'pipe:1',
+        ],
+        {
+          stdio: ['ignore', 'pipe', 'pipe'],
+        },
+      );
+
+      ffmpeg.stdout.on('data', (chunk) => {
+        data.push(chunk);
+      });
+
+      ffmpeg.on('error', (error) => {
+        console.error(error);
+        reject(error);
+      });
+
+      ffmpeg.on('close', (code) => {
+        returnData();
+      });
+
+      function returnData() {
+        const audioBuffer = Buffer.concat(data);
+        const audioFile = new File([audioBuffer], 'audio.wav', { type: 'audio/wav' });
+        resolve(audioFile);
+      }
+
+      if (typeof timeout === 'number' && timeout > 0) {
+        const internalSignal = AbortSignal.timeout(timeout);
+        internalSignal.addEventListener('abort', () => {
+          ffmpeg.kill('SIGTERM');
+        });
+      }
+
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          ffmpeg.kill('SIGTERM');
+        });
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+export async function recordAudio(options: RecordAudioOptions = {}) {
+  if (isNode) {
+    return nodejsRecordAudio(options);
+  }
+
+  throw new Error(
+    'Record audio is not supported in the browser. Check out https://npm.im/wavtools as an alternative.',
+  );
+}

package/dist/node_modules/@langchain/deepseek/node_modules/openai/src/helpers/zod.ts

@@ -0,0 +1,154 @@
+import { ResponseFormatJSONSchema } from '../resources/index';
+import type { infer as zodInfer, ZodType } from 'zod';
+import {
+  AutoParseableResponseFormat,
+  AutoParseableTextFormat,
+  AutoParseableTool,
+  makeParseableResponseFormat,
+  makeParseableTextFormat,
+  makeParseableTool,
+} from '../lib/parser';
+import { zodToJsonSchema as _zodToJsonSchema } from '../_vendor/zod-to-json-schema';
+import { AutoParseableResponseTool, makeParseableResponseTool } from '../lib/ResponsesParser';
+import { type ResponseFormatTextJSONSchemaConfig } from '../resources/responses/responses';
+
+function zodToJsonSchema(schema: ZodType, options: { name: string }): Record<string, unknown> {
+  return _zodToJsonSchema(schema, {
+    openaiStrictMode: true,
+    name: options.name,
+    nameStrategy: 'duplicate-ref',
+    $refStrategy: 'extract-to-root',
+    nullableStrategy: 'property',
+  });
+}
+
+/**
+ * Creates a chat completion `JSONSchema` response format object from
+ * the given Zod schema.
+ *
+ * If this is passed to the `.parse()`, `.stream()` or `.runTools()`
+ * chat completion methods then the response message will contain a
+ * `.parsed` property that is the result of parsing the content with
+ * the given Zod object.
+ *
+ * ```ts
+ * const completion = await client.chat.completions.parse({
+ *    model: 'gpt-4o-2024-08-06',
+ *    messages: [
+ *      { role: 'system', content: 'You are a helpful math tutor.' },
+ *      { role: 'user', content: 'solve 8x + 31 = 2' },
+ *    ],
+ *    response_format: zodResponseFormat(
+ *      z.object({
+ *        steps: z.array(z.object({
+ *          explanation: z.string(),
+ *          answer: z.string(),
+ *        })),
+ *        final_answer: z.string(),
+ *      }),
+ *      'math_answer',
+ *    ),
+ *  });
+ *  const message = completion.choices[0]?.message;
+ *  if (message?.parsed) {
+ *    console.log(message.parsed);
+ *    console.log(message.parsed.final_answer);
+ * }
+ * ```
+ *
+ * This can be passed directly to the `.create()` method but will not
+ * result in any automatic parsing, you'll have to parse the response yourself.
+ */
+export function zodResponseFormat<ZodInput extends ZodType>(
+  zodObject: ZodInput,
+  name: string,
+  props?: Omit<ResponseFormatJSONSchema.JSONSchema, 'schema' | 'strict' | 'name'>,
+): AutoParseableResponseFormat<zodInfer<ZodInput>> {
+  return makeParseableResponseFormat(
+    {
+      type: 'json_schema',
+      json_schema: {
+        ...props,
+        name,
+        strict: true,
+        schema: zodToJsonSchema(zodObject, { name }),
+      },
+    },
+    (content) => zodObject.parse(JSON.parse(content)),
+  );
+}
+
+export function zodTextFormat<ZodInput extends ZodType>(
+  zodObject: ZodInput,
+  name: string,
+  props?: Omit<ResponseFormatTextJSONSchemaConfig, 'schema' | 'type' | 'strict' | 'name'>,
+): AutoParseableTextFormat<zodInfer<ZodInput>> {
+  return makeParseableTextFormat(
+    {
+      type: 'json_schema',
+      ...props,
+      name,
+      strict: true,
+      schema: zodToJsonSchema(zodObject, { name }),
+    },
+    (content) => zodObject.parse(JSON.parse(content)),
+  );
+}
+
+/**
+ * Creates a chat completion `function` tool that can be invoked
+ * automatically by the chat completion `.runTools()` method or automatically
+ * parsed by `.parse()` / `.stream()`.
+ */
+export function zodFunction<Parameters extends ZodType>(options: {
+  name: string;
+  parameters: Parameters;
+  function?: ((args: zodInfer<Parameters>) => unknown | Promise<unknown>) | undefined;
+  description?: string | undefined;
+}): AutoParseableTool<{
+  arguments: Parameters;
+  name: string;
+  function: (args: zodInfer<Parameters>) => unknown;
+}> {
+  // @ts-expect-error TODO
+  return makeParseableTool<any>(
+    {
+      type: 'function',
+      function: {
+        name: options.name,
+        parameters: zodToJsonSchema(options.parameters, { name: options.name }),
+        strict: true,
+        ...(options.description ? { description: options.description } : undefined),
+      },
+    },
+    {
+      callback: options.function,
+      parser: (args) => options.parameters.parse(JSON.parse(args)),
+    },
+  );
+}
+
+export function zodResponsesFunction<Parameters extends ZodType>(options: {
+  name: string;
+  parameters: Parameters;
+  function?: ((args: zodInfer<Parameters>) => unknown | Promise<unknown>) | undefined;
+  description?: string | undefined;
+}): AutoParseableResponseTool<{
+  arguments: Parameters;
+  name: string;
+  function: (args: zodInfer<Parameters>) => unknown;
+}> {
+  return makeParseableResponseTool<any>(
+    {
+      type: 'function',
+      name: options.name,
+      parameters: zodToJsonSchema(options.parameters, { name: options.name }),
+      strict: true,
+      ...(options.description ? { description: options.description } : undefined),
+    },
+    {
+      callback: options.function,
+      parser: (args) => options.parameters.parse(JSON.parse(args)),
+    },
+  );
+}

package/dist/node_modules/@langchain/deepseek/node_modules/openai/src/index.ts

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { OpenAI as default } from './client';
+
+export { type Uploadable, toFile } from './core/uploads';
+export { APIPromise } from './core/api-promise';
+export { OpenAI, type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
+export {
+  OpenAIError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+  InvalidWebhookSignatureError,
+} from './core/error';
+
+export { AzureOpenAI } from './azure';