parallel-web 0.4.0 → 0.5.0

package/src/client.ts

@@ -26,12 +26,50 @@ import {
   ExtractResponse,
   ExtractResult,
   FetchPolicy,
+  FullContentSettings,
   SearchParams,
   SearchResult,
   UsageItem,
   WebSearchResult,
 } from './resources/top-level';
 import { APIPromise } from './core/api-promise';
+import {
+  AdvancedMonitorSettings,
+  CreateMonitorRequest,
+  Monitor,
+  MonitorCompletionEvent,
+  MonitorCreateParams,
+  MonitorErrorEvent,
+  MonitorEventStreamEvent,
+  MonitorEventStreamResponseSettings,
+  MonitorEventStreamSettings,
+  MonitorEventsParams,
+  MonitorListParams,
+  MonitorResource,
+  MonitorSnapshotEvent,
+  MonitorSnapshotOutput,
+  MonitorSnapshotResponseSettings,
+  MonitorSnapshotSettings,
+  MonitorUpdateParams,
+  MonitorWebhook,
+  PaginatedMonitorEvents,
+  PaginatedMonitorResponse,
+  UpdateMonitorEventStreamSettings,
+  UpdateMonitorRequest,
+} from './resources/monitor';
+import {
+  TaskGroup,
+  TaskGroupAddRunsParams,
+  TaskGroupCreateParams,
+  TaskGroupEventsParams,
+  TaskGroupEventsResponse,
+  TaskGroupGetRunsParams,
+  TaskGroupGetRunsResponse,
+  TaskGroupRetrieveRunParams,
+  TaskGroupRunResponse,
+  TaskGroupStatus,
+  TaskGroupStatusEvent,
+} from './resources/task-group';
 import {
   AutoSchema,
   Citation,
@@ -41,13 +79,17 @@ import {
   McpServer,
   McpToolCall,
   RunInput,
+  TaskAdvancedSettings,
   TaskRun,
   TaskRunCreateParams,
   TaskRunEvent,
   TaskRunEventsResponse,
   TaskRunJsonOutput,
+  TaskRunProgressMessageEvent,
+  TaskRunProgressStatsEvent,
   TaskRunResult,
   TaskRunResultParams,
+  TaskRunSourceStats,
   TaskRunTextOutput,
   TaskSpec,
   TextSchema,
@@ -204,6 +246,18 @@ export class Parallel {
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
     this.#encoder = Opts.FallbackEncoder;
 
+    const customHeadersEnv = readEnv('PARALLEL_CUSTOM_HEADERS');
+    if (customHeadersEnv) {
+      const parsed: Record<string, string> = {};
+      for (const line of customHeadersEnv.split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon >= 0) {
+          parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+        }
+      }
+      options.defaultHeaders = { ...parsed, ...options.defaultHeaders };
+    }
+
     this._options = options;
 
     this.apiKey = apiKey;
@@ -238,8 +292,10 @@ export class Parallel {
   /**
    * Extracts relevant content from specific web URLs.
    *
-   * The legacy Extract API reference is available
-   * [here](https://docs.parallel.ai/api-reference/legacy/extract-beta/extract).
+   * The legacy Extract API reference (`/v1beta/extract` endpoint) is available
+   * [here](https://docs.parallel.ai/api-reference/legacy/extract-beta/extract), and
+   * migration guide is
+   * [here](https://docs.parallel.ai/extract/extract-migration-guide).
    *
    * @example
    * ```ts
@@ -258,8 +314,10 @@ export class Parallel {
   /**
    * Searches the web.
    *
-   * The legacy Search API reference is available
-   * [here](https://docs.parallel.ai/api-reference/legacy/search-beta/search).
+   * The legacy Search API reference (`/v1beta/search` endpoint) is available
+   * [here](https://docs.parallel.ai/api-reference/legacy/search-beta/search), and
+   * migration guide is
+   * [here](https://docs.parallel.ai/search/search-migration-guide).
    *
    * @example
    * ```ts
@@ -284,9 +342,6 @@ export class Parallel {
     return buildHeaders([{ 'x-api-key': this.apiKey }]);
   }
 
-  /**
-   * Basic re-implementation of `qs.stringify` for primitive types.
-   */
   protected stringifyQuery(query: object | Record<string, unknown>): string {
     return stringifyQuery(query);
   }
@@ -796,16 +851,37 @@ export class Parallel {
    * - Output metadata: citations, excerpts, reasoning, and confidence per field
    *
    * Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-   *  - Submit hundreds or thousands of Tasks as a single group
+   * - Submit hundreds or thousands of Tasks as a single group
    * - Observe group progress and receive results as they complete
    * - Real-time updates via Server-Sent Events (SSE)
    * - Add tasks to an existing group while it is running
    * - Group-level retry and error aggregation
    */
   taskRun: API.TaskRun = new API.TaskRun(this);
+  /**
+   * The Task API executes web research and extraction tasks. Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+   * - Output metadata: citations, excerpts, reasoning, and confidence per field
+   *
+   * Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+   * - Submit hundreds or thousands of Tasks as a single group
+   * - Observe group progress and receive results as they complete
+   * - Real-time updates via Server-Sent Events (SSE)
+   * - Add tasks to an existing group while it is running
+   * - Group-level retry and error aggregation
+   */
+  taskGroup: API.TaskGroup = new API.TaskGroup(this);
+  /**
+   * The Monitor API watches the web for material changes on a fixed frequency. Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+   * - `event_stream` monitors track a search query and emit an event for each new material change.
+   * - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+   *
+   * Results can be polled via the events endpoint or delivered via webhooks.
+   */
+  monitor: API.MonitorResource = new API.MonitorResource(this);
   beta: API.Beta = new API.Beta(this);
 }
 
+Parallel.MonitorResource = MonitorResource;
 Parallel.Beta = Beta;
 
 export declare namespace Parallel {
@@ -819,6 +895,7 @@ export declare namespace Parallel {
     type ExtractResponse as ExtractResponse,
     type ExtractResult as ExtractResult,
     type FetchPolicy as FetchPolicy,
+    type FullContentSettings as FullContentSettings,
     type SearchResult as SearchResult,
     type UsageItem as UsageItem,
     type WebSearchResult as WebSearchResult,
@@ -836,9 +913,13 @@ export declare namespace Parallel {
     type McpServer as McpServer,
     type McpToolCall as McpToolCall,
     type RunInput as RunInput,
+    type TaskAdvancedSettings as TaskAdvancedSettings,
     type TaskRunEvent as TaskRunEvent,
     type TaskRunJsonOutput as TaskRunJsonOutput,
+    type TaskRunProgressMessageEvent as TaskRunProgressMessageEvent,
+    type TaskRunProgressStatsEvent as TaskRunProgressStatsEvent,
     type TaskRunResult as TaskRunResult,
+    type TaskRunSourceStats as TaskRunSourceStats,
     type TaskRunTextOutput as TaskRunTextOutput,
     type TaskSpec as TaskSpec,
     type TextSchema as TextSchema,
@@ -848,6 +929,45 @@ export declare namespace Parallel {
     type TaskRunResultParams as TaskRunResultParams,
   };
 
+  export {
+    type TaskGroup as TaskGroup,
+    type TaskGroupRunResponse as TaskGroupRunResponse,
+    type TaskGroupStatus as TaskGroupStatus,
+    type TaskGroupStatusEvent as TaskGroupStatusEvent,
+    type TaskGroupEventsResponse as TaskGroupEventsResponse,
+    type TaskGroupGetRunsResponse as TaskGroupGetRunsResponse,
+    type TaskGroupCreateParams as TaskGroupCreateParams,
+    type TaskGroupAddRunsParams as TaskGroupAddRunsParams,
+    type TaskGroupEventsParams as TaskGroupEventsParams,
+    type TaskGroupGetRunsParams as TaskGroupGetRunsParams,
+    type TaskGroupRetrieveRunParams as TaskGroupRetrieveRunParams,
+  };
+
+  export {
+    MonitorResource as MonitorResource,
+    type AdvancedMonitorSettings as AdvancedMonitorSettings,
+    type CreateMonitorRequest as CreateMonitorRequest,
+    type Monitor as Monitor,
+    type MonitorCompletionEvent as MonitorCompletionEvent,
+    type MonitorErrorEvent as MonitorErrorEvent,
+    type MonitorEventStreamEvent as MonitorEventStreamEvent,
+    type MonitorEventStreamResponseSettings as MonitorEventStreamResponseSettings,
+    type MonitorEventStreamSettings as MonitorEventStreamSettings,
+    type MonitorSnapshotEvent as MonitorSnapshotEvent,
+    type MonitorSnapshotOutput as MonitorSnapshotOutput,
+    type MonitorSnapshotResponseSettings as MonitorSnapshotResponseSettings,
+    type MonitorSnapshotSettings as MonitorSnapshotSettings,
+    type MonitorWebhook as MonitorWebhook,
+    type PaginatedMonitorEvents as PaginatedMonitorEvents,
+    type PaginatedMonitorResponse as PaginatedMonitorResponse,
+    type UpdateMonitorEventStreamSettings as UpdateMonitorEventStreamSettings,
+    type UpdateMonitorRequest as UpdateMonitorRequest,
+    type MonitorCreateParams as MonitorCreateParams,
+    type MonitorUpdateParams as MonitorUpdateParams,
+    type MonitorListParams as MonitorListParams,
+    type MonitorEventsParams as MonitorEventsParams,
+  };
+
   export { Beta as Beta };
 
   export type ErrorObject = API.ErrorObject;

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 = (v: PropertyKey) => String(v);
+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,385 @@
+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 (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)) !== void undefined && !find_flag) {
+    // Where object last appeared in the ref tree
+    const pos = tmp_sc.get(object);
+    step += 1;
+    if (typeof pos !== 'undefined') {
+      if (pos === step) {
+        throw new RangeError('Cyclic object value');
+      } else {
+        find_flag = true; // Break while
+      }
+    }
+    if (typeof 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, function (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 (typeof 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 : void undefined }];
+  } else if (isArray(filter)) {
+    obj_keys = filter;
+  } else {
+    const keys = Object.keys(obj);
+    obj_keys = sort ? keys.sort(sort) : 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 (let j = 0; j < obj_keys.length; ++j) {
+    const key = obj_keys[j];
+    const value =
+      // @ts-ignore
+      typeof key === 'object' && typeof 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;
+    const key_prefix =
+      isArray(obj) ?
+        typeof generateArrayPrefix === 'function' ?
+          generateArrayPrefix(adjusted_prefix, encoded_key)
+        : adjusted_prefix
+      : adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']');
+
+    sideChannel.set(object, step);
+    const valueSideChannel = new WeakMap();
+    valueSideChannel.set(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 (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
+    throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
+  }
+
+  if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {
+    throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');
+  }
+
+  if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
+    throw new TypeError('Encoder has to be a function.');
+  }
+
+  const charset = opts.charset || defaults.charset;
+  if (typeof 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 (typeof 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');
+  }
+
+  const allowDots =
+    typeof opts.allowDots === 'undefined' ?
+      !!opts.encodeDotInKeys === true ?
+        true
+      : defaults.allowDots
+    : !!opts.allowDots;
+
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
+    // @ts-ignore
+    allowDots: allowDots,
+    allowEmptyArrays:
+      typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+    arrayFormat: arrayFormat,
+    charset: charset,
+    charsetSentinel:
+      typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
+    commaRoundTrip: !!opts.commaRoundTrip,
+    delimiter: typeof 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: filter,
+    format: format,
+    formatter: 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 (let i = 0; i < obj_keys.length; ++i) {
+    const key = obj_keys[i]!;
+
+    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) {
+    if (options.charset === 'iso-8859-1') {
+      // encodeURIComponent('&#10003;'), the "numeric entity" representation of a checkmark
+      prefix += 'utf8=%26%2310003%3B&';
+    } else {
+      // encodeURIComponent('✓')
+      prefix += 'utf8=%E2%9C%93&';
+    }
+  }
+
+  return joined.length > 0 ? prefix + joined : '';
+}