@nfreeness/clawdbot 0.124.22101 → 0.124.22103

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/core/streaming.ts

@@ -1,348 +0,0 @@
-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 { loggerFor } from '../internal/utils/log';
-import type { OpenAI } from '../client';
-
-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;
-  #client: OpenAI | undefined;
-
-  constructor(
-    private iterator: () => AsyncIterator<Item>,
-    controller: AbortController,
-    client?: OpenAI,
-  ) {
-    this.controller = controller;
-    this.#client = client;
-  }
-
-  static fromSSEResponse<Item>(
-    response: Response,
-    controller: AbortController,
-    client?: OpenAI,
-  ): Stream<Item> {
-    let consumed = false;
-    const logger = client ? loggerFor(client) : console;
-
-    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('thread.')) {
-            let data;
-
-            try {
-              data = JSON.parse(sse.data);
-            } catch (e) {
-              logger.error(`Could not parse message into JSON:`, sse.data);
-              logger.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, client);
-  }
-
-  /**
-   * Generates a Stream from a newline-separated ReadableStream
-   * where each item is a JSON value.
-   */
-  static fromReadableStream<Item>(
-    readableStream: ReadableStream,
-    controller: AbortController,
-    client?: OpenAI,
-  ): 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, client);
-  }
-
-  [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, this.#client),
-      new Stream(() => teeIterator(right), this.controller, this.#client),
-    ];
-  }
-
-  /**
-   * 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/extensions/memory-lancedb/node_modules/.ignored_openai/src/core/uploads.ts

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

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/error.ts

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

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/helpers/audio.ts

@@ -1,146 +0,0 @@
-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/extensions/memory-lancedb/node_modules/.ignored_openai/src/helpers/zod.ts

@@ -1,180 +0,0 @@
-import { ResponseFormatJSONSchema } from '../resources/index';
-import * as z3 from 'zod/v3';
-import * as z4 from 'zod/v4';
-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';
-import { toStrictJsonSchema } from '../lib/transform';
-import { JSONSchema } from '../lib/jsonschema';
-
-type InferZodType<T> =
-  T extends z4.ZodType ? z4.infer<T>
-  : T extends z3.ZodType ? z3.infer<T>
-  : never;
-
-function zodV3ToJsonSchema(schema: z3.ZodType, options: { name: string }): Record<string, unknown> {
-  return _zodToJsonSchema(schema, {
-    openaiStrictMode: true,
-    name: options.name,
-    nameStrategy: 'duplicate-ref',
-    $refStrategy: 'extract-to-root',
-    nullableStrategy: 'property',
-  });
-}
-
-function zodV4ToJsonSchema(schema: z4.ZodType): Record<string, unknown> {
-  return toStrictJsonSchema(
-    z4.toJSONSchema(schema, {
-      target: 'draft-7',
-    }) as JSONSchema,
-  ) as Record<string, unknown>;
-}
-
-function isZodV4(zodObject: z3.ZodType | z4.ZodType): zodObject is z4.ZodType {
-  return '_zod' in zodObject;
-}
-
-/**
- * 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 z3.ZodType | z4.ZodType>(
-  zodObject: ZodInput,
-  name: string,
-  props?: Omit<ResponseFormatJSONSchema.JSONSchema, 'schema' | 'strict' | 'name'>,
-): AutoParseableResponseFormat<InferZodType<ZodInput>> {
-  return makeParseableResponseFormat(
-    {
-      type: 'json_schema',
-      json_schema: {
-        ...props,
-        name,
-        strict: true,
-        schema: isZodV4(zodObject) ? zodV4ToJsonSchema(zodObject) : zodV3ToJsonSchema(zodObject, { name }),
-      },
-    },
-    (content) => zodObject.parse(JSON.parse(content)),
-  );
-}
-
-export function zodTextFormat<ZodInput extends z3.ZodType | z4.ZodType>(
-  zodObject: ZodInput,
-  name: string,
-  props?: Omit<ResponseFormatTextJSONSchemaConfig, 'schema' | 'type' | 'strict' | 'name'>,
-): AutoParseableTextFormat<InferZodType<ZodInput>> {
-  return makeParseableTextFormat(
-    {
-      type: 'json_schema',
-      ...props,
-      name,
-      strict: true,
-      schema: isZodV4(zodObject) ? zodV4ToJsonSchema(zodObject) : zodV3ToJsonSchema(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 z3.ZodType | z4.ZodType>(options: {
-  name: string;
-  parameters: Parameters;
-  function?: ((args: InferZodType<Parameters>) => unknown | Promise<unknown>) | undefined;
-  description?: string | undefined;
-}): AutoParseableTool<{
-  arguments: Parameters;
-  name: string;
-  function: (args: InferZodType<Parameters>) => unknown;
-}> {
-  // @ts-expect-error TODO
-  return makeParseableTool<any>(
-    {
-      type: 'function',
-      function: {
-        name: options.name,
-        parameters:
-          isZodV4(options.parameters) ?
-            zodV4ToJsonSchema(options.parameters)
-          : zodV3ToJsonSchema(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 z3.ZodType | z4.ZodType>(options: {
-  name: string;
-  parameters: Parameters;
-  function?: ((args: InferZodType<Parameters>) => unknown | Promise<unknown>) | undefined;
-  description?: string | undefined;
-}): AutoParseableResponseTool<{
-  arguments: Parameters;
-  name: string;
-  function: (args: InferZodType<Parameters>) => unknown;
-}> {
-  return makeParseableResponseTool<any>(
-    {
-      type: 'function',
-      name: options.name,
-      parameters:
-        isZodV4(options.parameters) ?
-          zodV4ToJsonSchema(options.parameters)
-        : zodV3ToJsonSchema(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/extensions/memory-lancedb/node_modules/.ignored_openai/src/index.ts

@@ -1,26 +0,0 @@
-// 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';

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/internal/README.md

@@ -1,3 +0,0 @@
-# `internal`
-
-The modules in this directory are not importable outside this package and will change between releases.