@rebyteai/agent-sdk 0.2.0

package/src/internal/parse.ts

@@ -0,0 +1,123 @@
+import type { FinalRequestOptions } from './request-options';
+import { Stream } from '../core/streaming';
+import { type OpenAI } from '../client';
+import { isAbortError } from './errors';
+import { formatRequestDetails, loggerFor } from './utils/log';
+import type { AbstractPage } from '../pagination';
+
+export type APIResponseProps = {
+  response: Response;
+  options: FinalRequestOptions;
+  controller: AbortController;
+  requestLogID: string;
+  retryOfRequestLogID: string | undefined;
+  startTime: number;
+};
+
+export async function defaultParseResponse<T>(
+  client: OpenAI,
+  props: APIResponseProps,
+): Promise<WithRequestID<T>> {
+  const { response, requestLogID, retryOfRequestLogID, startTime } = props;
+  const body = await (async () => {
+    if (props.options.stream) {
+      loggerFor(client).debug('response', response.status, response.url, response.headers, response.body);
+
+      // Note: there is an invariant here that isn't represented in the type system
+      // that if you set `stream: true` the response type must also be `Stream<T>`
+
+      if (props.options.__streamClass) {
+        return props.options.__streamClass.fromSSEResponse(
+          response,
+          props.controller,
+          client,
+          props.options.__synthesizeEventData,
+        ) as any;
+      }
+
+      return Stream.fromSSEResponse(
+        response,
+        props.controller,
+        client,
+        props.options.__synthesizeEventData,
+      ) as any;
+    }
+
+    // fetch refuses to read the body when the status code is 204.
+    if (response.status === 204) {
+      return null as T;
+    }
+
+    if (props.options.__binaryResponse) {
+      return response as unknown as T;
+    }
+
+    const contentType = response.headers.get('content-type');
+    const mediaType = contentType?.split(';')[0]?.trim().toLowerCase();
+    const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
+    if (isJSON) {
+      const contentLength = response.headers.get('content-length');
+      if (contentLength === '0') {
+        // if there is no content we can't do anything
+        return undefined as T;
+      }
+
+      const bodyText = await response.text();
+      if (!bodyText) {
+        // Some servers respond with an empty body and a JSON content-type but
+        // without a `content-length: 0` header (e.g. over HTTP/2 or with chunked
+        // transfer encoding). Treat this the same as an explicit `content-length: 0`
+        // instead of letting `JSON.parse` throw an opaque `SyntaxError`.
+        return undefined as T;
+      }
+
+      const json = JSON.parse(bodyText);
+      return addRequestID(json as T, response);
+    }
+
+    const text = await response.text();
+    return text as unknown as T;
+  })().catch((error: unknown) => {
+    throw asAbortError(error, props.controller.signal);
+  });
+  loggerFor(client).debug(
+    `[${requestLogID}] response parsed`,
+    formatRequestDetails({
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      body,
+      durationMs: Date.now() - startTime,
+    }),
+  );
+  return body;
+}
+
+function asAbortError(error: unknown, signal: AbortSignal): unknown {
+  if (!signal.aborted || error !== signal.reason || isAbortError(error)) {
+    return error;
+  }
+
+  const message = 'This operation was aborted';
+  const DOMExceptionConstructor = (globalThis as any).DOMException;
+  return typeof DOMExceptionConstructor === 'function'
+    ? new DOMExceptionConstructor(message, 'AbortError')
+    : Object.assign(new Error(message), { name: 'AbortError' });
+}
+
+export type WithRequestID<T> = T extends Array<any> | Response | AbstractPage<any>
+  ? T
+  : T extends Record<string, any>
+    ? T & { _request_id?: string | null }
+    : T;
+
+export function addRequestID<T>(value: T, response: Response): WithRequestID<T> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return value as WithRequestID<T>;
+  }
+
+  return Object.defineProperty(value, '_request_id', {
+    value: response.headers.get('x-request-id'),
+    enumerable: false,
+  }) as WithRequestID<T>;
+}

package/src/internal/provider.ts

@@ -0,0 +1,89 @@
+import type { FinalRequestOptions } from './request-options';
+import type { FinalizedRequestInit } from './types';
+
+declare const providerBrand: unique symbol;
+
+/** An opaque provider configuration created by {@link createProvider}. */
+export interface Provider {
+  /** Prevents arbitrary objects from being treated as SDK-created providers. */
+  readonly [providerBrand]: true;
+}
+
+/** Request details supplied to a provider immediately before each request attempt. */
+export interface ProviderRequestContext {
+  /** Absolute URL of the request being prepared. */
+  url: string;
+
+  /** Final SDK request options, including the HTTP method and resource path. */
+  options: FinalRequestOptions;
+}
+
+/** Provider configuration instantiated separately for each OpenAI client. */
+export interface ProviderRuntime {
+  /** Provider identifier used to distinguish the client's upstream service. */
+  name: string;
+
+  /** Absolute API root used to resolve the client's resource paths. */
+  baseURL: string;
+
+  /**
+   * Updates a request immediately before each attempt, including retries.
+   *
+   * Providers can refresh credentials or replace request headers in place. A
+   * rejected promise prevents that attempt from being sent.
+   */
+  prepareRequest?(request: FinalizedRequestInit, context: ProviderRequestContext): void | Promise<void>;
+}
+
+/** Factory for the per-client runtime associated with an opaque provider. */
+export interface ProviderDefinition {
+  /** Creates a fresh runtime whenever the provider is attached to a client. */
+  configure(): ProviderRuntime;
+}
+
+/**
+ * A provider factory such as `bedrock(options)` captures configuration in a
+ * definition, while every OpenAI client receives a fresh runtime from
+ * `definition.configure()`. Keeping definitions out of the provider object
+ * makes providers opaque and prevents arbitrary objects from imitating one.
+ * It also leaves provider-specific dependencies outside the core SDK.
+ *
+ * The registry lives on `globalThis` under a global symbol so a provider made
+ * by one copy of the package still works with another copy, including mixed
+ * CommonJS and ESM installations. The WeakMap avoids retaining discarded
+ * provider configurations.
+ */
+const providerDefinitionsKey = Symbol.for('openai.node.providerDefinitions.v1');
+const providerGlobal = globalThis as any;
+const existingProviderDefinitions = providerGlobal[providerDefinitionsKey] as
+  | WeakMap<Provider, ProviderDefinition>
+  | undefined;
+const providerDefinitions = existingProviderDefinitions ?? new WeakMap<Provider, ProviderDefinition>();
+if (!existingProviderDefinitions) {
+  Object.defineProperty(providerGlobal, providerDefinitionsKey, { value: providerDefinitions });
+}
+
+/**
+ * Creates an opaque, immutable provider handle for a runtime definition.
+ *
+ * The definition is registered out of band and can be resolved by another
+ * installed copy of the SDK in the same JavaScript realm.
+ */
+export function createProvider(definition: ProviderDefinition): Provider {
+  const provider = Object.freeze({}) as Provider;
+  providerDefinitions.set(provider, definition);
+  return provider;
+}
+
+/**
+ * Creates a new client-specific runtime from a previously registered provider.
+ *
+ * @throws {Error} If the value was not created with {@link createProvider}.
+ */
+export function configureProvider(provider: Provider): ProviderRuntime {
+  const definition = providerDefinitions.get(provider);
+  if (!definition) {
+    throw new Error('Invalid provider. Providers must be created with createProvider().');
+  }
+  return definition.configure();
+}

package/src/internal/qs/LICENSE.md

@@ -0,0 +1,13 @@
+BSD 3-Clause License
+
+Copyright (c) 2014, Nathan LaFreniere and other [contributors](https://github.com/puruvj/neoqs/graphs/contributors) All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/src/internal/qs/README.md

@@ -0,0 +1,3 @@
+# qs
+
+This is a vendored version of [neoqs](https://github.com/PuruVJ/neoqs) which is a TypeScript rewrite of [qs](https://github.com/ljharb/qs), a query string library.

package/src/internal/qs/formats.ts

@@ -0,0 +1,10 @@
+import type { Format } from './types';
+
+export const default_format: Format = 'RFC3986';
+export const default_formatter: (value: PropertyKey) => string = String;
+export const formatters: Record<Format, (str: PropertyKey) => string> = {
+  RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
+  RFC3986: default_formatter,
+};
+export const RFC1738 = 'RFC1738';
+export const RFC3986 = 'RFC3986';

package/src/internal/qs/index.ts

@@ -0,0 +1,13 @@
+import { default_format, formatters, RFC1738, RFC3986 } from './formats';
+
+const formats = {
+  formatters,
+  RFC1738,
+  RFC3986,
+  default: default_format,
+};
+
+export { stringify } from './stringify';
+export { formats };
+
+export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from './types';

package/src/internal/qs/stringify.ts

@@ -0,0 +1,386 @@
+import { encode, is_buffer, maybe_map, has } from './utils';
+import { default_format, default_formatter, formatters } from './formats';
+import type { NonNullableProperties, StringifyOptions } from './types';
+import { isArray } from '../utils/values';
+
+const array_prefix_generators = {
+  brackets(prefix: PropertyKey) {
+    return String(prefix) + '[]';
+  },
+  comma: 'comma',
+  indices(prefix: PropertyKey, key: string) {
+    return String(prefix) + '[' + key + ']';
+  },
+  repeat(prefix: PropertyKey) {
+    return String(prefix);
+  },
+};
+
+const push_to_array = function push_to_array(arr: any[], value_or_array: any) {
+  Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]);
+};
+
+let toISOString;
+
+const defaults = {
+  addQueryPrefix: false,
+  allowDots: false,
+  allowEmptyArrays: false,
+  arrayFormat: 'indices',
+  charset: 'utf-8',
+  charsetSentinel: false,
+  delimiter: '&',
+  encode: true,
+  encodeDotInKeys: false,
+  encoder: encode,
+  encodeValuesOnly: false,
+  format: default_format,
+  formatter: default_formatter,
+  /** @deprecated */
+  indices: false,
+  serializeDate(date) {
+    return (toISOString ??= Function.prototype.call.bind(Date.prototype.toISOString))(date);
+  },
+  skipNulls: false,
+  strictNullHandling: false,
+} as NonNullableProperties<StringifyOptions & { formatter: (typeof formatters)['RFC1738'] }>;
+
+function is_non_nullish_primitive(v: unknown): v is string | number | boolean | symbol | bigint {
+  return (
+    typeof v === 'string' ||
+    typeof v === 'number' ||
+    typeof v === 'boolean' ||
+    typeof v === 'symbol' ||
+    typeof v === 'bigint'
+  );
+}
+
+const sentinel = {};
+
+function inner_stringify(
+  object: any,
+  prefix: PropertyKey,
+  generateArrayPrefix: StringifyOptions['arrayFormat'] | ((prefix: string, key: string) => string),
+  commaRoundTrip: boolean,
+  allowEmptyArrays: boolean,
+  strictNullHandling: boolean,
+  skipNulls: boolean,
+  encodeDotInKeys: boolean,
+  encoder: StringifyOptions['encoder'],
+  filter: StringifyOptions['filter'],
+  sort: StringifyOptions['sort'],
+  allowDots: StringifyOptions['allowDots'],
+  serializeDate: StringifyOptions['serializeDate'],
+  format: StringifyOptions['format'],
+  formatter: StringifyOptions['formatter'],
+  encodeValuesOnly: boolean,
+  charset: StringifyOptions['charset'],
+  sideChannel: WeakMap<any, any>,
+) {
+  let obj = object;
+
+  let tmp_sc = sideChannel;
+  let step = 0;
+  let find_flag = false;
+  while ((tmp_sc = tmp_sc.get(sentinel)) !== undefined && !find_flag) {
+    // Where object last appeared in the ref tree
+    const pos = tmp_sc.get(object);
+    step += 1;
+    if (pos !== undefined) {
+      if (pos === step) {
+        throw new RangeError('Cyclic object value');
+      } else {
+        find_flag = true; // Break while
+      }
+    }
+    if (tmp_sc.get(sentinel) === undefined) {
+      step = 0;
+    }
+  }
+
+  if (typeof filter === 'function') {
+    obj = filter(prefix, obj);
+  } else if (obj instanceof Date) {
+    obj = serializeDate?.(obj);
+  } else if (generateArrayPrefix === 'comma' && isArray(obj)) {
+    obj = maybe_map(obj, (value) => {
+      if (value instanceof Date) {
+        return serializeDate?.(value);
+      }
+      return value;
+    });
+  }
+
+  if (obj === null) {
+    if (strictNullHandling) {
+      return encoder && !encodeValuesOnly
+        ? // @ts-expect-error
+          encoder(prefix, defaults.encoder, charset, 'key', format)
+        : prefix;
+    }
+
+    obj = '';
+  }
+
+  if (is_non_nullish_primitive(obj) || is_buffer(obj)) {
+    if (encoder) {
+      const key_value = encodeValuesOnly
+        ? prefix
+        : // @ts-expect-error
+          encoder(prefix, defaults.encoder, charset, 'key', format);
+      return [
+        formatter?.(key_value) +
+          '=' +
+          // @ts-expect-error
+          formatter?.(encoder(obj, defaults.encoder, charset, 'value', format)),
+      ];
+    }
+    return [formatter?.(prefix) + '=' + formatter?.(String(obj))];
+  }
+
+  const values: string[] = [];
+
+  if (obj === undefined) {
+    return values;
+  }
+
+  let obj_keys;
+  if (generateArrayPrefix === 'comma' && isArray(obj)) {
+    // we need to join elements in
+    if (encodeValuesOnly && encoder) {
+      // @ts-expect-error values only
+      obj = maybe_map(obj, encoder);
+    }
+    obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : undefined }];
+  } else if (isArray(filter)) {
+    obj_keys = filter;
+  } else {
+    const keys = Object.keys(obj);
+    if (sort) {
+      keys.sort(sort);
+    }
+    obj_keys = keys;
+  }
+
+  const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
+
+  const adjusted_prefix =
+    commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+
+  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+    return adjusted_prefix + '[]';
+  }
+
+  for (const key of obj_keys) {
+    const value =
+      // @ts-ignore
+      typeof key === 'object' && key.value !== undefined ? key.value : obj[key as any];
+
+    if (skipNulls && value === null) {
+      continue;
+    }
+
+    // @ts-ignore
+    const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
+    let key_prefix: string;
+    if (isArray(obj)) {
+      key_prefix =
+        typeof generateArrayPrefix === 'function'
+          ? generateArrayPrefix(adjusted_prefix, encoded_key)
+          : adjusted_prefix;
+    } else {
+      key_prefix = adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']');
+    }
+
+    sideChannel.set(object, step);
+    const valueSideChannel = new WeakMap([[sentinel, sideChannel]]);
+    push_to_array(
+      values,
+      inner_stringify(
+        value,
+        key_prefix,
+        generateArrayPrefix,
+        commaRoundTrip,
+        allowEmptyArrays,
+        strictNullHandling,
+        skipNulls,
+        encodeDotInKeys,
+        // @ts-ignore
+        generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,
+        filter,
+        sort,
+        allowDots,
+        serializeDate,
+        format,
+        formatter,
+        encodeValuesOnly,
+        charset,
+        valueSideChannel,
+      ),
+    );
+  }
+
+  return values;
+}
+
+function normalize_stringify_options(
+  opts: StringifyOptions = defaults,
+): NonNullableProperties<Omit<StringifyOptions, 'indices'>> & { indices?: boolean } {
+  if (opts.allowEmptyArrays !== undefined && typeof opts.allowEmptyArrays !== 'boolean') {
+    throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
+  }
+
+  if (opts.encodeDotInKeys !== undefined && typeof opts.encodeDotInKeys !== 'boolean') {
+    throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');
+  }
+
+  if (opts.encoder !== null && opts.encoder !== undefined && typeof opts.encoder !== 'function') {
+    throw new TypeError('Encoder has to be a function.');
+  }
+
+  const charset = opts.charset || defaults.charset;
+  if (opts.charset !== undefined && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
+    throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
+  }
+
+  let format = default_format;
+  if (opts.format !== undefined) {
+    if (!has(formatters, opts.format)) {
+      throw new TypeError('Unknown format option provided.');
+    }
+    format = opts.format;
+  }
+  const formatter = formatters[format];
+
+  let filter = defaults.filter;
+  if (typeof opts.filter === 'function' || isArray(opts.filter)) {
+    filter = opts.filter;
+  }
+
+  let arrayFormat: StringifyOptions['arrayFormat'];
+  if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) {
+    arrayFormat = opts.arrayFormat;
+  } else if ('indices' in opts) {
+    arrayFormat = opts.indices ? 'indices' : 'repeat';
+  } else {
+    arrayFormat = defaults.arrayFormat;
+  }
+
+  if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
+    throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
+  }
+
+  let allowDots: boolean;
+  if (opts.allowDots === undefined) {
+    allowDots = !!opts.encodeDotInKeys === true ? true : defaults.allowDots;
+  } else {
+    allowDots = !!opts.allowDots;
+  }
+
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
+    // @ts-ignore
+    allowDots,
+    allowEmptyArrays:
+      typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+    arrayFormat,
+    charset,
+    charsetSentinel:
+      typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
+    commaRoundTrip: !!opts.commaRoundTrip,
+    delimiter: opts.delimiter === undefined ? defaults.delimiter : opts.delimiter,
+    encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
+    encodeDotInKeys:
+      typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+    encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
+    encodeValuesOnly:
+      typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+    filter,
+    format,
+    formatter,
+    serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
+    skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
+    // @ts-ignore
+    sort: typeof opts.sort === 'function' ? opts.sort : null,
+    strictNullHandling:
+      typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
+  };
+}
+
+export function stringify(object: any, opts: StringifyOptions = {}) {
+  let obj = object;
+  const options = normalize_stringify_options(opts);
+
+  let obj_keys: PropertyKey[] | undefined;
+  let filter;
+
+  if (typeof options.filter === 'function') {
+    filter = options.filter;
+    obj = filter('', obj);
+  } else if (isArray(options.filter)) {
+    filter = options.filter;
+    obj_keys = filter;
+  }
+
+  const keys: string[] = [];
+
+  if (typeof obj !== 'object' || obj === null) {
+    return '';
+  }
+
+  const generateArrayPrefix = array_prefix_generators[options.arrayFormat];
+  const commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;
+
+  if (!obj_keys) {
+    obj_keys = Object.keys(obj);
+  }
+
+  if (options.sort) {
+    obj_keys.sort(options.sort);
+  }
+
+  const sideChannel = new WeakMap();
+  for (const key of obj_keys) {
+    if (options.skipNulls && obj[key] === null) {
+      continue;
+    }
+    push_to_array(
+      keys,
+      inner_stringify(
+        obj[key],
+        key,
+        // @ts-expect-error
+        generateArrayPrefix,
+        commaRoundTrip,
+        options.allowEmptyArrays,
+        options.strictNullHandling,
+        options.skipNulls,
+        options.encodeDotInKeys,
+        options.encode ? options.encoder : null,
+        options.filter,
+        options.sort,
+        options.allowDots,
+        options.serializeDate,
+        options.format,
+        options.formatter,
+        options.encodeValuesOnly,
+        options.charset,
+        sideChannel,
+      ),
+    );
+  }
+
+  const joined = keys.join(options.delimiter);
+  let prefix = options.addQueryPrefix === true ? '?' : '';
+
+  if (options.charsetSentinel) {
+    prefix +=
+      options.charset === 'iso-8859-1'
+        ? // encodeURIComponent('&#10003;'), the "numeric entity" representation of a checkmark
+          'utf8=%26%2310003%3B&'
+        : // encodeURIComponent('✓')
+          'utf8=%E2%9C%93&';
+  }
+
+  return joined.length > 0 ? prefix + joined : '';
+}