@nfreeness/clawdbot 0.124.22101 → 0.124.22103

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/lib/responses/EventTypes.ts

@@ -1,74 +0,0 @@
-import {
-  ResponseAudioDeltaEvent,
-  ResponseAudioDoneEvent,
-  ResponseAudioTranscriptDeltaEvent,
-  ResponseAudioTranscriptDoneEvent,
-  ResponseCodeInterpreterCallCodeDeltaEvent,
-  ResponseCodeInterpreterCallCodeDoneEvent,
-  ResponseCodeInterpreterCallCompletedEvent,
-  ResponseCodeInterpreterCallInProgressEvent,
-  ResponseCodeInterpreterCallInterpretingEvent,
-  ResponseCompletedEvent,
-  ResponseContentPartAddedEvent,
-  ResponseContentPartDoneEvent,
-  ResponseCreatedEvent,
-  ResponseErrorEvent,
-  ResponseFailedEvent,
-  ResponseFileSearchCallCompletedEvent,
-  ResponseFileSearchCallInProgressEvent,
-  ResponseFileSearchCallSearchingEvent,
-  ResponseFunctionCallArgumentsDeltaEvent as RawResponseFunctionCallArgumentsDeltaEvent,
-  ResponseFunctionCallArgumentsDoneEvent,
-  ResponseInProgressEvent,
-  ResponseOutputItemAddedEvent,
-  ResponseOutputItemDoneEvent,
-  ResponseRefusalDeltaEvent,
-  ResponseRefusalDoneEvent,
-  ResponseTextDeltaEvent as RawResponseTextDeltaEvent,
-  ResponseTextDoneEvent,
-  ResponseIncompleteEvent,
-  ResponseWebSearchCallCompletedEvent,
-  ResponseWebSearchCallInProgressEvent,
-  ResponseWebSearchCallSearchingEvent,
-} from '../../resources/responses/responses';
-
-export type ResponseFunctionCallArgumentsDeltaEvent = RawResponseFunctionCallArgumentsDeltaEvent & {
-  snapshot: string;
-};
-
-export type ResponseTextDeltaEvent = RawResponseTextDeltaEvent & {
-  snapshot: string;
-};
-
-export type ParsedResponseStreamEvent =
-  | ResponseAudioDeltaEvent
-  | ResponseAudioDoneEvent
-  | ResponseAudioTranscriptDeltaEvent
-  | ResponseAudioTranscriptDoneEvent
-  | ResponseCodeInterpreterCallCodeDeltaEvent
-  | ResponseCodeInterpreterCallCodeDoneEvent
-  | ResponseCodeInterpreterCallCompletedEvent
-  | ResponseCodeInterpreterCallInProgressEvent
-  | ResponseCodeInterpreterCallInterpretingEvent
-  | ResponseCompletedEvent
-  | ResponseContentPartAddedEvent
-  | ResponseContentPartDoneEvent
-  | ResponseCreatedEvent
-  | ResponseErrorEvent
-  | ResponseFileSearchCallCompletedEvent
-  | ResponseFileSearchCallInProgressEvent
-  | ResponseFileSearchCallSearchingEvent
-  | ResponseFunctionCallArgumentsDeltaEvent
-  | ResponseFunctionCallArgumentsDoneEvent
-  | ResponseInProgressEvent
-  | ResponseFailedEvent
-  | ResponseIncompleteEvent
-  | ResponseOutputItemAddedEvent
-  | ResponseOutputItemDoneEvent
-  | ResponseRefusalDeltaEvent
-  | ResponseRefusalDoneEvent
-  | ResponseTextDeltaEvent
-  | ResponseTextDoneEvent
-  | ResponseWebSearchCallCompletedEvent
-  | ResponseWebSearchCallInProgressEvent
-  | ResponseWebSearchCallSearchingEvent;

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/lib/responses/ResponseStream.ts

@@ -1,368 +0,0 @@
-import {
-  ResponseTextConfig,
-  type ParsedResponse,
-  type Response,
-  type ResponseCreateParamsBase,
-  type ResponseCreateParamsStreaming,
-  type ResponseStreamEvent,
-} from '../../resources/responses/responses';
-import { RequestOptions } from '../../internal/request-options';
-import { APIUserAbortError, OpenAIError } from '../../error';
-import OpenAI from '../../index';
-import { type BaseEvents, EventStream } from '../EventStream';
-import { type ResponseFunctionCallArgumentsDeltaEvent, type ResponseTextDeltaEvent } from './EventTypes';
-import { maybeParseResponse, ParseableToolsParams } from '../ResponsesParser';
-import { Stream } from '../../streaming';
-
-export type ResponseStreamParams = ResponseCreateAndStreamParams | ResponseStreamByIdParams;
-
-export type ResponseCreateAndStreamParams = Omit<ResponseCreateParamsBase, 'stream'> & {
-  stream?: true;
-};
-
-export type ResponseStreamByIdParams = {
-  /**
-   * The ID of the response to stream.
-   */
-  response_id: string;
-  /**
-   * If provided, the stream will start after the event with the given sequence number.
-   */
-  starting_after?: number;
-  /**
-   * Configuration options for a text response from the model. Can be plain text or
-   * structured JSON data. Learn more:
-   *
-   * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-   * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
-   */
-  text?: ResponseTextConfig;
-
-  /**
-   * An array of tools the model may call while generating a response. When continuing a stream, provide
-   * the same tools as the original request.
-   */
-  tools?: ParseableToolsParams;
-};
-
-type ResponseEvents = BaseEvents &
-  Omit<
-    {
-      [K in ResponseStreamEvent['type']]: (event: Extract<ResponseStreamEvent, { type: K }>) => void;
-    },
-    'response.output_text.delta' | 'response.function_call_arguments.delta'
-  > & {
-    event: (event: ResponseStreamEvent) => void;
-    'response.output_text.delta': (event: ResponseTextDeltaEvent) => void;
-    'response.function_call_arguments.delta': (event: ResponseFunctionCallArgumentsDeltaEvent) => void;
-  };
-
-export type ResponseStreamingParams = Omit<ResponseCreateParamsBase, 'stream'> & {
-  stream?: true;
-};
-
-export class ResponseStream<ParsedT = null>
-  extends EventStream<ResponseEvents>
-  implements AsyncIterable<ResponseStreamEvent>
-{
-  #params: ResponseStreamingParams | null;
-  #currentResponseSnapshot: Response | undefined;
-  #finalResponse: ParsedResponse<ParsedT> | undefined;
-
-  constructor(params: ResponseStreamingParams | null) {
-    super();
-    this.#params = params;
-  }
-
-  static createResponse<ParsedT>(
-    client: OpenAI,
-    params: ResponseStreamParams,
-    options?: RequestOptions,
-  ): ResponseStream<ParsedT> {
-    const runner = new ResponseStream<ParsedT>(params as ResponseCreateParamsStreaming);
-    runner._run(() =>
-      runner._createOrRetrieveResponse(client, params, {
-        ...options,
-        headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
-      }),
-    );
-    return runner;
-  }
-
-  #beginRequest() {
-    if (this.ended) return;
-    this.#currentResponseSnapshot = undefined;
-  }
-
-  #addEvent(this: ResponseStream<ParsedT>, event: ResponseStreamEvent, starting_after: number | null) {
-    if (this.ended) return;
-
-    const maybeEmit = (name: string, event: ResponseStreamEvent & { snapshot?: string }) => {
-      if (starting_after == null || event.sequence_number > starting_after) {
-        this._emit(name as any, event);
-      }
-    };
-
-    const response = this.#accumulateResponse(event);
-    maybeEmit('event', event);
-
-    switch (event.type) {
-      case 'response.output_text.delta': {
-        const output = response.output[event.output_index];
-        if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
-        }
-        if (output.type === 'message') {
-          const content = output.content[event.content_index];
-          if (!content) {
-            throw new OpenAIError(`missing content at index ${event.content_index}`);
-          }
-          if (content.type !== 'output_text') {
-            throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`);
-          }
-
-          maybeEmit('response.output_text.delta', {
-            ...event,
-            snapshot: content.text,
-          });
-        }
-        break;
-      }
-      case 'response.function_call_arguments.delta': {
-        const output = response.output[event.output_index];
-        if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
-        }
-        if (output.type === 'function_call') {
-          maybeEmit('response.function_call_arguments.delta', {
-            ...event,
-            snapshot: output.arguments,
-          });
-        }
-        break;
-      }
-      default:
-        maybeEmit(event.type, event);
-        break;
-    }
-  }
-
-  #endRequest(): ParsedResponse<ParsedT> {
-    if (this.ended) {
-      throw new OpenAIError(`stream has ended, this shouldn't happen`);
-    }
-    const snapshot = this.#currentResponseSnapshot;
-    if (!snapshot) {
-      throw new OpenAIError(`request ended without sending any events`);
-    }
-    this.#currentResponseSnapshot = undefined;
-    const parsedResponse = finalizeResponse<ParsedT>(snapshot, this.#params);
-    this.#finalResponse = parsedResponse;
-
-    return parsedResponse;
-  }
-
-  protected async _createOrRetrieveResponse(
-    client: OpenAI,
-    params: ResponseStreamParams,
-    options?: RequestOptions,
-  ): Promise<ParsedResponse<ParsedT>> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
-    this.#beginRequest();
-
-    let stream: Stream<ResponseStreamEvent> | undefined;
-    let starting_after: number | null = null;
-    if ('response_id' in params) {
-      stream = await client.responses.retrieve(
-        params.response_id,
-        { stream: true },
-        { ...options, signal: this.controller.signal, stream: true },
-      );
-      starting_after = params.starting_after ?? null;
-    } else {
-      stream = await client.responses.create(
-        { ...params, stream: true },
-        { ...options, signal: this.controller.signal },
-      );
-    }
-
-    this._connected();
-    for await (const event of stream) {
-      this.#addEvent(event, starting_after);
-    }
-    if (stream.controller.signal?.aborted) {
-      throw new APIUserAbortError();
-    }
-    return this.#endRequest();
-  }
-
-  #accumulateResponse(event: ResponseStreamEvent): Response {
-    let snapshot = this.#currentResponseSnapshot;
-    if (!snapshot) {
-      if (event.type !== 'response.created') {
-        throw new OpenAIError(
-          `When snapshot hasn't been set yet, expected 'response.created' event, got ${event.type}`,
-        );
-      }
-      snapshot = this.#currentResponseSnapshot = event.response;
-      return snapshot;
-    }
-
-    switch (event.type) {
-      case 'response.output_item.added': {
-        snapshot.output.push(event.item);
-        break;
-      }
-      case 'response.content_part.added': {
-        const output = snapshot.output[event.output_index];
-        if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
-        }
-        const type = output.type;
-        const part = event.part;
-        if (type === 'message' && part.type !== 'reasoning_text') {
-          output.content.push(part);
-        } else if (type === 'reasoning' && part.type === 'reasoning_text') {
-          if (!output.content) {
-            output.content = [];
-          }
-          output.content.push(part);
-        }
-        break;
-      }
-      case 'response.output_text.delta': {
-        const output = snapshot.output[event.output_index];
-        if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
-        }
-        if (output.type === 'message') {
-          const content = output.content[event.content_index];
-          if (!content) {
-            throw new OpenAIError(`missing content at index ${event.content_index}`);
-          }
-          if (content.type !== 'output_text') {
-            throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`);
-          }
-          content.text += event.delta;
-        }
-        break;
-      }
-      case 'response.function_call_arguments.delta': {
-        const output = snapshot.output[event.output_index];
-        if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
-        }
-        if (output.type === 'function_call') {
-          output.arguments += event.delta;
-        }
-        break;
-      }
-      case 'response.reasoning_text.delta': {
-        const output = snapshot.output[event.output_index];
-        if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
-        }
-        if (output.type === 'reasoning') {
-          const content = output.content?.[event.content_index];
-          if (!content) {
-            throw new OpenAIError(`missing content at index ${event.content_index}`);
-          }
-          if (content.type !== 'reasoning_text') {
-            throw new OpenAIError(`expected content to be 'reasoning_text', got ${content.type}`);
-          }
-          content.text += event.delta;
-        }
-        break;
-      }
-      case 'response.completed': {
-        this.#currentResponseSnapshot = event.response;
-        break;
-      }
-    }
-
-    return snapshot;
-  }
-
-  [Symbol.asyncIterator](this: ResponseStream<ParsedT>): AsyncIterator<ResponseStreamEvent> {
-    const pushQueue: ResponseStreamEvent[] = [];
-    const readQueue: {
-      resolve: (event: ResponseStreamEvent | undefined) => void;
-      reject: (err: unknown) => void;
-    }[] = [];
-    let done = false;
-
-    this.on('event', (event) => {
-      const reader = readQueue.shift();
-      if (reader) {
-        reader.resolve(event);
-      } else {
-        pushQueue.push(event);
-      }
-    });
-
-    this.on('end', () => {
-      done = true;
-      for (const reader of readQueue) {
-        reader.resolve(undefined);
-      }
-      readQueue.length = 0;
-    });
-
-    this.on('abort', (err) => {
-      done = true;
-      for (const reader of readQueue) {
-        reader.reject(err);
-      }
-      readQueue.length = 0;
-    });
-
-    this.on('error', (err) => {
-      done = true;
-      for (const reader of readQueue) {
-        reader.reject(err);
-      }
-      readQueue.length = 0;
-    });
-
-    return {
-      next: async (): Promise<IteratorResult<ResponseStreamEvent>> => {
-        if (!pushQueue.length) {
-          if (done) {
-            return { value: undefined, done: true };
-          }
-          return new Promise<ResponseStreamEvent | undefined>((resolve, reject) =>
-            readQueue.push({ resolve, reject }),
-          ).then((event) => (event ? { value: event, done: false } : { value: undefined, done: true }));
-        }
-        const event = pushQueue.shift()!;
-        return { value: event, done: false };
-      },
-      return: async () => {
-        this.abort();
-        return { value: undefined, done: true };
-      },
-    };
-  }
-
-  /**
-   * @returns a promise that resolves with the final Response, or rejects
-   * if an error occurred or the stream ended prematurely without producing a REsponse.
-   */
-  async finalResponse(): Promise<ParsedResponse<ParsedT>> {
-    await this.done();
-    const response = this.#finalResponse;
-    if (!response) throw new OpenAIError('stream ended without producing a ChatCompletion');
-    return response;
-  }
-}
-
-function finalizeResponse<ParsedT>(
-  snapshot: Response,
-  params: ResponseStreamingParams | null,
-): ParsedResponse<ParsedT> {
-  return maybeParseResponse(snapshot, params);
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/lib/transform.ts

@@ -1,193 +0,0 @@
-import type { JSONSchema, JSONSchemaDefinition } from './jsonschema';
-
-export function toStrictJsonSchema(schema: JSONSchema): JSONSchema {
-  if (schema.type !== 'object') {
-    throw new Error(
-      `Root schema must have type: 'object' but got type: ${schema.type ? `'${schema.type}'` : 'undefined'}`,
-    );
-  }
-
-  const schemaCopy = structuredClone(schema);
-  return ensureStrictJsonSchema(schemaCopy, [], schemaCopy);
-}
-
-function isNullable(schema: JSONSchemaDefinition): boolean {
-  if (typeof schema === 'boolean') {
-    return false;
-  }
-  if (schema.type === 'null') {
-    return true;
-  }
-  for (const oneOfVariant of schema.oneOf ?? []) {
-    if (isNullable(oneOfVariant)) {
-      return true;
-    }
-  }
-  for (const allOfVariant of schema.anyOf ?? []) {
-    if (isNullable(allOfVariant)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Mutates the given JSON schema to ensure it conforms to the `strict` standard
- * that the API expects.
- */
-function ensureStrictJsonSchema(
-  jsonSchema: JSONSchemaDefinition,
-  path: string[],
-  root: JSONSchema,
-): JSONSchema {
-  if (typeof jsonSchema === 'boolean') {
-    throw new TypeError(`Expected object schema but got boolean; path=${path.join('/')}`);
-  }
-
-  if (!isObject(jsonSchema)) {
-    throw new TypeError(`Expected ${JSON.stringify(jsonSchema)} to be an object; path=${path.join('/')}`);
-  }
-
-  // Handle $defs (non-standard but sometimes used)
-  const defs = (jsonSchema as any).$defs;
-  if (isObject(defs)) {
-    for (const [defName, defSchema] of Object.entries(defs)) {
-      ensureStrictJsonSchema(defSchema as JSONSchema, [...path, '$defs', defName], root);
-    }
-  }
-
-  // Handle definitions (draft-04 style, deprecated in draft-07 but still used)
-  const definitions = (jsonSchema as any).definitions;
-  if (isObject(definitions)) {
-    for (const [definitionName, definitionSchema] of Object.entries(definitions)) {
-      ensureStrictJsonSchema(definitionSchema as JSONSchema, [...path, 'definitions', definitionName], root);
-    }
-  }
-
-  // Add additionalProperties: false to object types
-  const typ = jsonSchema.type;
-  if (typ === 'object' && !('additionalProperties' in jsonSchema)) {
-    jsonSchema.additionalProperties = false;
-  }
-
-  const required = jsonSchema.required ?? [];
-
-  // Handle object properties
-  const properties = jsonSchema.properties;
-  if (isObject(properties)) {
-    for (const [key, value] of Object.entries(properties)) {
-      if (!isNullable(value) && !required.includes(key)) {
-        throw new Error(
-          `Zod field at \`${[...path, 'properties', key].join(
-            '/',
-          )}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`,
-        );
-      }
-    }
-    jsonSchema.required = Object.keys(properties);
-    jsonSchema.properties = Object.fromEntries(
-      Object.entries(properties).map(([key, propSchema]) => [
-        key,
-        ensureStrictJsonSchema(propSchema, [...path, 'properties', key], root),
-      ]),
-    );
-  }
-
-  // Handle arrays
-  const items = jsonSchema.items;
-  if (isObject(items)) {
-    jsonSchema.items = ensureStrictJsonSchema(items, [...path, 'items'], root);
-  }
-
-  // Handle unions (anyOf)
-  const anyOf = jsonSchema.anyOf;
-  if (Array.isArray(anyOf)) {
-    jsonSchema.anyOf = anyOf.map((variant, i) =>
-      ensureStrictJsonSchema(variant, [...path, 'anyOf', String(i)], root),
-    );
-  }
-
-  // Handle intersections (allOf)
-  const allOf = jsonSchema.allOf;
-  if (Array.isArray(allOf)) {
-    if (allOf.length === 1) {
-      const resolved = ensureStrictJsonSchema(allOf[0]!, [...path, 'allOf', '0'], root);
-      Object.assign(jsonSchema, resolved);
-      delete jsonSchema.allOf;
-    } else {
-      jsonSchema.allOf = allOf.map((entry, i) =>
-        ensureStrictJsonSchema(entry, [...path, 'allOf', String(i)], root),
-      );
-    }
-  }
-
-  // Strip `null` defaults as there's no meaningful distinction
-  if (jsonSchema.default === null) {
-    delete jsonSchema.default;
-  }
-
-  // Handle $ref with additional properties
-  const ref = (jsonSchema as any).$ref;
-  if (ref && hasMoreThanNKeys(jsonSchema, 1)) {
-    if (typeof ref !== 'string') {
-      throw new TypeError(`Received non-string $ref - ${ref}; path=${path.join('/')}`);
-    }
-
-    const resolved = resolveRef(root, ref);
-    if (typeof resolved === 'boolean') {
-      throw new Error(`Expected \`$ref: ${ref}\` to resolve to an object schema but got boolean`);
-    }
-    if (!isObject(resolved)) {
-      throw new Error(
-        `Expected \`$ref: ${ref}\` to resolve to an object but got ${JSON.stringify(resolved)}`,
-      );
-    }
-
-    // Properties from the json schema take priority over the ones on the `$ref`
-    Object.assign(jsonSchema, { ...resolved, ...jsonSchema });
-    delete (jsonSchema as any).$ref;
-
-    // Since the schema expanded from `$ref` might not have `additionalProperties: false` applied,
-    // we call `ensureStrictJsonSchema` again to fix the inlined schema and ensure it's valid.
-    return ensureStrictJsonSchema(jsonSchema, path, root);
-  }
-
-  return jsonSchema;
-}
-
-function resolveRef(root: JSONSchema, ref: string): JSONSchemaDefinition {
-  if (!ref.startsWith('#/')) {
-    throw new Error(`Unexpected $ref format ${JSON.stringify(ref)}; Does not start with #/`);
-  }
-
-  const pathParts = ref.slice(2).split('/');
-  let resolved: any = root;
-
-  for (const key of pathParts) {
-    if (!isObject(resolved)) {
-      throw new Error(`encountered non-object entry while resolving ${ref} - ${JSON.stringify(resolved)}`);
-    }
-    const value = resolved[key];
-    if (value === undefined) {
-      throw new Error(`Key ${key} not found while resolving ${ref}`);
-    }
-    resolved = value;
-  }
-
-  return resolved;
-}
-
-function isObject<T>(obj: T | Array<any>): obj is Extract<T, Record<string, any>> {
-  return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
-}
-
-function hasMoreThanNKeys(obj: Record<string, any>, n: number): boolean {
-  let i = 0;
-  for (const _ in obj) {
-    i++;
-    if (i > n) {
-      return true;
-    }
-  }
-  return false;
-}

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

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

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/realtime/index.ts

@@ -1 +0,0 @@
-export { OpenAIRealtimeError } from './internal-base';