pi2dsh 0.13.0 → 0.13.2

package/dist/compat/pi-ai.d.mts

@@ -1,6 +1,14 @@
 
-import { a as TextContent, c as ToolResultMessage, i as Message, l as Usage, n as AssistantMessage, o as ThinkingContent, r as ImageContent, s as ToolCallContent, t as AgentMessage, u as UserMessage } from "../pi-types-KazmR2O5.mjs";
-import { Static, TSchema, Type } from "typebox";
+/// <reference types="node" />
+import { a as TextContent, c as ToolResultMessage, i as Message$1, l as Usage$1, n as AssistantMessage, o as ThinkingContent, r as ImageContent, s as ToolCallContent, t as AgentMessage, u as UserMessage } from "../pi-types-KazmR2O5.mjs";
+import { URL as URL$1, URLSearchParams as URLSearchParams$1 } from "node:url";
+import { EventEmitter } from "node:events";
+import { Static as Static$1, TSchema, TSchema as TSchema$1, Type } from "typebox";
+import { Duplex, Readable, Writable } from "node:stream";
+import { Blob as Blob$1, File as File$1 } from "node:buffer";
+import { ConnectionOptions, TLSSocket } from "node:tls";
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from "node:net";
+import { SessionOptions } from "node:http2";
 //#region src/compat/vendor/pi-ai-overflow.d.ts
 /**
  * Check if an assistant message represents a context overflow error.
@@ -106,7 +114,7 @@ declare function createProvider(input: any): {
 };
 //#endregion
 //#region src/compat/vendor/pi-ai-event-stream.d.ts
-declare class EventStream {
+declare class EventStream$1 {
   queue: never[];
   waiting: never[];
   done: boolean;
@@ -120,7 +128,7 @@ declare class EventStream {
   [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
   result(): Promise<unknown>;
 }
-declare class AssistantMessageEventStream extends EventStream {
+declare class AssistantMessageEventStream extends EventStream$1 {
   constructor();
 }
 //#endregion
@@ -136,6 +144,2274 @@ declare function lazyApi(load: any, capabilities: any): {
   streamSimple: (model: any, context: any, options: any) => AssistantMessageEventStream;
 };
 //#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/utility.d.ts
+type AutocompletePrimitiveBaseType$1<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+type Autocomplete$1<T> = T | (AutocompletePrimitiveBaseType$1<T> & Record<never, never>);
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/header.d.ts
+/**
+ * The header type declaration of `undici`.
+ */
+type IncomingHttpHeaders$1 = Record<string, string | string[] | undefined>;
+type HeaderNames$1 = Autocomplete$1<'Accept' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'Alt-Svc' | 'Alt-Used' | 'Authorization' | 'Cache-Control' | 'Clear-Site-Data' | 'Connection' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'Device-Memory' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Last-Modified' | 'Link' | 'Location' | 'Max-Forwards' | 'Origin' | 'Permissions-Policy' | 'Priority' | 'Proxy-Authenticate' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'Referrer-Policy' | 'Retry-After' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-Purpose' | 'Sec-WebSocket-Accept' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'SourceMap' | 'Strict-Transport-Security' | 'TE' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Upgrade-Insecure-Requests' | 'User-Agent' | 'Vary' | 'Via' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options'>;
+type IANARegisteredMimeType$1 = Autocomplete$1<'audio/aac' | 'video/x-msvideo' | 'image/avif' | 'video/av1' | 'application/octet-stream' | 'image/bmp' | 'text/css' | 'text/csv' | 'application/vnd.ms-fontobject' | 'application/epub+zip' | 'image/gif' | 'application/gzip' | 'text/html' | 'image/x-icon' | 'text/calendar' | 'image/jpeg' | 'text/javascript' | 'application/json' | 'application/ld+json' | 'audio/x-midi' | 'audio/mpeg' | 'video/mp4' | 'video/mpeg' | 'audio/ogg' | 'video/ogg' | 'application/ogg' | 'audio/opus' | 'font/otf' | 'application/pdf' | 'image/png' | 'application/rtf' | 'image/svg+xml' | 'image/tiff' | 'video/mp2t' | 'font/ttf' | 'text/plain' | 'application/wasm' | 'video/webm' | 'audio/webm' | 'image/webp' | 'font/woff' | 'font/woff2' | 'application/xhtml+xml' | 'application/xml' | 'application/zip' | 'video/3gpp' | 'video/3gpp2' | 'model/gltf+json' | 'model/gltf-binary'>;
+type KnownHeaderValues$1 = {
+  'content-type': IANARegisteredMimeType$1;
+};
+type HeaderRecord$1 = { [K in HeaderNames$1 | Lowercase<HeaderNames$1>]?: Lowercase<K> extends keyof KnownHeaderValues$1 ? KnownHeaderValues$1[Lowercase<K>] : string; };
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/readable.d.ts
+declare class BodyReadable$1 extends Readable {
+  constructor(opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  });
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text(): Promise<string>;
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json(): Promise<unknown>;
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob(): Promise<Blob$1>;
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>;
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData(): Promise<never>;
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean;
+  /**
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined;
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump(opts?: {
+    limit: number;
+    signal?: AbortSignal;
+  }): Promise<void>;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/fetch.d.ts
+type BodyInit$1 = ArrayBuffer | AsyncIterable<Uint8Array> | Blob$1 | FormData$2 | Iterable<Uint8Array> | NodeJS.ArrayBufferView | URLSearchParams$1 | null | string;
+interface SpecIterator$1<T, TReturn = any, TNext = undefined> {
+  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+}
+interface SpecIterableIterator$1<T> extends SpecIterator$1<T> {
+  [Symbol.iterator](): SpecIterableIterator$1<T>;
+}
+interface SpecIterable$1<T> {
+  [Symbol.iterator](): SpecIterator$1<T>;
+}
+type HeadersInit$1 = [string, string][] | HeaderRecord$1 | Headers$2;
+declare class Headers$2 implements SpecIterable$1<[string, string]> {
+  constructor(init?: HeadersInit$1);
+  readonly append: (name: string, value: string) => void;
+  readonly delete: (name: string) => void;
+  readonly get: (name: string) => string | null;
+  readonly has: (name: string) => boolean;
+  readonly set: (name: string, value: string) => void;
+  readonly getSetCookie: () => string[];
+  readonly forEach: (callbackfn: (value: string, key: string, iterable: Headers$2) => void, thisArg?: unknown) => void;
+  readonly keys: () => SpecIterableIterator$1<string>;
+  readonly values: () => SpecIterableIterator$1<string>;
+  readonly entries: () => SpecIterableIterator$1<[string, string]>;
+  readonly [Symbol.iterator]: () => SpecIterableIterator$1<[string, string]>;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/formdata.d.ts
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue$1 = string | File$1;
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+declare class FormData$2 {
+  /**
+   * Appends a new value onto an existing key inside a FormData object,
+   * or adds the key if it does not already exist.
+   *
+   * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   */
+  append(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Set a new value for an existing key inside FormData,
+   * or add the new field if it does not already exist.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   *
+   */
+  set(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Returns the first value associated with a given key from within a `FormData` object.
+   * If you expect multiple values and want all of them, use the `getAll()` method instead.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+   */
+  get(name: string): FormDataEntryValue$1 | null;
+  /**
+   * Returns all the values associated with a given key from within a `FormData` object.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+   */
+  getAll(name: string): FormDataEntryValue$1[];
+  /**
+   * Returns a boolean stating whether a `FormData` object contains a certain key.
+   *
+   * @param name A string representing the name of the key you want to test for.
+   *
+   * @return A boolean value.
+   */
+  has(name: string): boolean;
+  /**
+   * Deletes a key and its value(s) from a `FormData` object.
+   *
+   * @param name The name of the key you want to delete.
+   */
+  delete(name: string): void;
+  /**
+   * Executes given callback function for each field of the FormData instance
+   */
+  forEach: (callbackfn: (value: FormDataEntryValue$1, key: string, iterable: FormData$2) => void, thisArg?: unknown) => void;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
+   */
+  keys: () => SpecIterableIterator$1<string>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+   * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  values: () => SpecIterableIterator$1<FormDataEntryValue$1>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  entries: () => SpecIterableIterator$1<[string, FormDataEntryValue$1]>;
+  /**
+   * An alias for FormData#entries()
+   */
+  [Symbol.iterator]: () => SpecIterableIterator$1<[string, FormDataEntryValue$1]>;
+  readonly [Symbol.toStringTag]: string;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/connector.d.ts
+declare function buildConnector$1(options?: buildConnector$1.BuildOptions): buildConnector$1.connector;
+declare namespace buildConnector$1 {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+    allowH2?: boolean;
+    maxCachedSessions?: number | null;
+    socketPath?: string | null;
+    timeout?: number | null;
+    port?: number;
+    keepAlive?: boolean | null;
+    keepAliveInitialDelay?: number | null;
+  };
+  export interface Options {
+    hostname: string;
+    host?: string;
+    protocol: string;
+    port: string;
+    servername?: string;
+    localAddress?: string | null;
+    httpSocket?: Socket;
+  }
+  export type Callback = (...args: CallbackArgs) => void;
+  type CallbackArgs = [null, Socket | TLSSocket] | [Error, null];
+  export interface connector {
+    (options: buildConnector$1.Options, callback: buildConnector$1.Callback): void;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/client-stats.d.ts
+declare class ClientStats$1 {
+  constructor(pool: Client$1);
+  /** If socket has open connection. */
+  connected: boolean;
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number;
+  /** Number of currently active requests of this client. */
+  running: number;
+  /** Number of active, pending, or queued requests of this client. */
+  size: number;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/client.d.ts
+type ClientConnectOptions$1 = Omit<Dispatcher$1.ConnectOptions, 'origin'>;
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
+declare class Client$1 extends Dispatcher$1 {
+  constructor(url: string | URL$1, options?: Client$1.Options);
+  /** Property to get and set the pipelining factor. */
+  pipelining: number;
+  /** `true` after `client.close()` has been called. */
+  closed: boolean;
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean;
+  /** Aggregate stats for a Client. */
+  readonly stats: ClientStats$1;
+  // Override dispatcher APIs.
+  override connect(options: ClientConnectOptions$1): Promise<Dispatcher$1.ConnectData>;
+  override connect(options: ClientConnectOptions$1, callback: (err: Error | null, data: Dispatcher$1.ConnectData) => void): void;
+}
+declare namespace Client$1 {
+  export interface OptionsInterceptors {
+    Client: readonly Dispatcher$1.DispatchInterceptor[];
+  }
+  export interface Options {
+    /** TODO */
+    interceptors?: OptionsInterceptors;
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+    socketTimeout?: never;
+    /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+    requestTimeout?: never;
+    /** TODO */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+    idleTimeout?: never;
+    /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+    keepAlive?: never;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+    maxKeepAliveTimeout?: never;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** TODO */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** @deprecated use the connect option instead */
+    tls?: never;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** TODO */
+    maxCachedSessions?: number;
+    /** TODO */
+    connect?: Partial<buildConnector$1.BuildOptions> | buildConnector$1.connector;
+    /** TODO */
+    maxRequestsPerClient?: number;
+    /** TODO */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+     * @default false
+     */
+    allowH2?: boolean;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+     */
+    maxConcurrentStreams?: number;
+  }
+  export interface SocketInfo {
+    localAddress?: string;
+    localPort?: number;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    timeout?: number;
+    bytesWritten?: number;
+    bytesRead?: number;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/errors.d.ts
+declare namespace Errors$1 {
+  export class UndiciError extends Error {
+    name: string;
+    code: string;
+  }
+  /** Connect timeout error. */
+  export class ConnectTimeoutError extends UndiciError {
+    name: 'ConnectTimeoutError';
+    code: 'UND_ERR_CONNECT_TIMEOUT';
+  }
+  /** A header exceeds the `headersTimeout` option. */
+  export class HeadersTimeoutError extends UndiciError {
+    name: 'HeadersTimeoutError';
+    code: 'UND_ERR_HEADERS_TIMEOUT';
+  }
+  /** Headers overflow error. */
+  export class HeadersOverflowError extends UndiciError {
+    name: 'HeadersOverflowError';
+    code: 'UND_ERR_HEADERS_OVERFLOW';
+  }
+  /** A body exceeds the `bodyTimeout` option. */
+  export class BodyTimeoutError extends UndiciError {
+    name: 'BodyTimeoutError';
+    code: 'UND_ERR_BODY_TIMEOUT';
+  }
+  export class ResponseError extends UndiciError {
+    constructor(message: string, code: number, options: {
+      headers?: IncomingHttpHeaders$1 | string[] | null;
+      body?: null | Record<string, any> | string;
+    });
+    name: 'ResponseError';
+    code: 'UND_ERR_RESPONSE';
+    statusCode: number;
+    body: null | Record<string, any> | string;
+    headers: IncomingHttpHeaders$1 | string[] | null;
+  }
+  /** Passed an invalid argument. */
+  export class InvalidArgumentError extends UndiciError {
+    name: 'InvalidArgumentError';
+    code: 'UND_ERR_INVALID_ARG';
+  }
+  /** Returned an invalid value. */
+  export class InvalidReturnValueError extends UndiciError {
+    name: 'InvalidReturnValueError';
+    code: 'UND_ERR_INVALID_RETURN_VALUE';
+  }
+  /** The request has been aborted by the user. */
+  export class RequestAbortedError extends UndiciError {
+    name: 'AbortError';
+    code: 'UND_ERR_ABORTED';
+  }
+  /** Expected error with reason. */
+  export class InformationalError extends UndiciError {
+    name: 'InformationalError';
+    code: 'UND_ERR_INFO';
+  }
+  /** Request body length does not match content-length header. */
+  export class RequestContentLengthMismatchError extends UndiciError {
+    name: 'RequestContentLengthMismatchError';
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Response body length does not match content-length header. */
+  export class ResponseContentLengthMismatchError extends UndiciError {
+    name: 'ResponseContentLengthMismatchError';
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Trying to use a destroyed client. */
+  export class ClientDestroyedError extends UndiciError {
+    name: 'ClientDestroyedError';
+    code: 'UND_ERR_DESTROYED';
+  }
+  /** Trying to use a closed client. */
+  export class ClientClosedError extends UndiciError {
+    name: 'ClientClosedError';
+    code: 'UND_ERR_CLOSED';
+  }
+  /** There is an error with the socket. */
+  export class SocketError extends UndiciError {
+    name: 'SocketError';
+    code: 'UND_ERR_SOCKET';
+    socket: Client$1.SocketInfo | null;
+  }
+  /** Encountered unsupported functionality. */
+  export class NotSupportedError extends UndiciError {
+    name: 'NotSupportedError';
+    code: 'UND_ERR_NOT_SUPPORTED';
+  }
+  /** No upstream has been added to the BalancedPool. */
+  export class BalancedPoolMissingUpstreamError extends UndiciError {
+    name: 'MissingUpstreamError';
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+  }
+  export class HTTPParserError extends UndiciError {
+    name: 'HTTPParserError';
+    code: string;
+  }
+  /** The response exceed the length allowed. */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+  }
+  export class RequestRetryError extends UndiciError {
+    constructor(message: string, statusCode: number, headers?: IncomingHttpHeaders$1 | string[] | null, body?: null | Record<string, any> | string);
+    name: 'RequestRetryError';
+    code: 'UND_ERR_REQ_RETRY';
+    statusCode: number;
+    data: {
+      count: number;
+    };
+    headers: Record<string, string | string[]>;
+  }
+  export class SecureProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'SecureProxyConnectionError';
+    code: 'UND_ERR_PRX_TLS';
+  }
+  class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError';
+    code: 'UND_ERR_MAX_ORIGINS_REACHED';
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/dispatcher.d.ts
+type AbortSignal$1 = unknown;
+type UndiciHeaders$1 = Record<string, string | string[]> | IncomingHttpHeaders$1 | string[] | Iterable<[string, string | string[] | undefined]> | null;
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher$1 extends EventEmitter {
+  /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+  dispatch(options: Dispatcher$1.DispatchOptions, handler: Dispatcher$1.DispatchHandler): boolean;
+  /** Starts two-way communications with the requested resource. */
+  connect<TOpaque = null>(options: Dispatcher$1.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher$1.ConnectData<TOpaque>) => void): void;
+  connect<TOpaque = null>(options: Dispatcher$1.ConnectOptions<TOpaque>): Promise<Dispatcher$1.ConnectData<TOpaque>>;
+  /** Compose a chain of dispatchers */
+  compose(dispatchers: Dispatcher$1.DispatcherComposeInterceptor[]): Dispatcher$1.ComposedDispatcher;
+  compose(...dispatchers: Dispatcher$1.DispatcherComposeInterceptor[]): Dispatcher$1.ComposedDispatcher;
+  /** Performs an HTTP request. */
+  request<TOpaque = null>(options: Dispatcher$1.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher$1.ResponseData<TOpaque>) => void): void;
+  request<TOpaque = null>(options: Dispatcher$1.RequestOptions<TOpaque>): Promise<Dispatcher$1.ResponseData<TOpaque>>;
+  /** For easy use with `stream.pipeline`. */
+  pipeline<TOpaque = null>(options: Dispatcher$1.PipelineOptions<TOpaque>, handler: Dispatcher$1.PipelineHandler<TOpaque>): Duplex;
+  /** A faster version of `Dispatcher.request`. */
+  stream<TOpaque = null>(options: Dispatcher$1.RequestOptions<TOpaque>, factory: Dispatcher$1.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher$1.StreamData<TOpaque>) => void): void;
+  stream<TOpaque = null>(options: Dispatcher$1.RequestOptions<TOpaque>, factory: Dispatcher$1.StreamFactory<TOpaque>): Promise<Dispatcher$1.StreamData<TOpaque>>;
+  /** Upgrade to a different protocol. */
+  upgrade(options: Dispatcher$1.UpgradeOptions, callback: (err: Error | null, data: Dispatcher$1.UpgradeData) => void): void;
+  upgrade(options: Dispatcher$1.UpgradeOptions): Promise<Dispatcher$1.UpgradeData>;
+  /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+  close(callback: () => void): void;
+  close(): Promise<void>;
+  /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+  destroy(err: Error | null, callback: () => void): void;
+  destroy(callback: () => void): void;
+  destroy(err: Error | null): Promise<void>;
+  destroy(): Promise<void>;
+  on(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  on(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  on(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  on(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  once(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  once(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  once(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  once(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  off(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  off(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  off(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  off(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  addListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  addListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  addListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  addListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  removeListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  removeListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  removeListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  removeListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  prependListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  prependListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  prependListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependOnceListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher$1[]) => void): this;
+  prependOnceListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  prependOnceListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void): this;
+  prependOnceListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  listeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher$1[]) => void)[];
+  listeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void)[];
+  listeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void)[];
+  listeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  rawListeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher$1[]) => void)[];
+  rawListeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void)[];
+  rawListeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError) => void)[];
+  rawListeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  emit(eventName: 'connect', origin: URL$1, targets: readonly Dispatcher$1[]): boolean;
+  emit(eventName: 'disconnect', origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError): boolean;
+  emit(eventName: 'connectionError', origin: URL$1, targets: readonly Dispatcher$1[], error: Errors$1.UndiciError): boolean;
+  emit(eventName: 'drain', origin: URL$1): boolean;
+}
+declare namespace Dispatcher$1 {
+  export interface ComposedDispatcher extends Dispatcher$1 {}
+  export type Dispatch = Dispatcher$1['dispatch'];
+  export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch;
+  export interface DispatchOptions {
+    origin?: string | URL$1;
+    path: string;
+    method: HttpMethod;
+    /** Default: `null` */
+    body?: string | Buffer | Uint8Array | Readable | null | FormData$2;
+    /** Default: `null` */
+    headers?: UndiciHeaders$1;
+    /** Query string params to be embedded in the request URL. Default: `null` */
+    query?: Record<string, any>;
+    /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+    idempotent?: boolean;
+    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
+    blocking?: boolean;
+    /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
+    upgrade?: boolean | string | null;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+    headersTimeout?: number | null;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
+    bodyTimeout?: number | null;
+    /** Whether the request should stablish a keep-alive or not. Default `false` */
+    reset?: boolean;
+    /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
+    throwOnError?: boolean;
+    /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
+    expectContinue?: boolean;
+  }
+  export interface ConnectOptions<TOpaque = null> {
+    origin: string | URL$1;
+    path: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders$1;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** This argument parameter is passed through to `ConnectData` */
+    opaque?: TOpaque;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface RequestOptions<TOpaque = null> extends DispatchOptions {
+    /** Default: `null` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    onInfo?: (info: {
+      statusCode: number;
+      headers: Record<string, string | string[]>;
+    }) => void;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+    /** Default: `64 KiB` */
+    highWaterMark?: number;
+  }
+  export interface PipelineOptions<TOpaque = null> extends RequestOptions<TOpaque> {
+    /** `true` if the `handler` will return an object stream. Default: `false` */
+    objectMode?: boolean;
+  }
+  export interface UpgradeOptions {
+    path: string;
+    /** Default: `'GET'` */
+    method?: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders$1;
+    /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+    protocol?: string;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface ConnectData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders$1;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface ResponseData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders$1;
+    body: BodyReadable$1 & BodyMixin;
+    trailers: Record<string, string>;
+    opaque: TOpaque;
+    context: object;
+  }
+  export interface PipelineHandlerData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders$1;
+    opaque: TOpaque;
+    body: BodyReadable$1;
+    context: object;
+  }
+  export interface StreamData<TOpaque = null> {
+    opaque: TOpaque;
+    trailers: Record<string, string>;
+  }
+  export interface UpgradeData<TOpaque = null> {
+    headers: IncomingHttpHeaders$1;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface StreamFactoryData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders$1;
+    opaque: TOpaque;
+    context: object;
+  }
+  export type StreamFactory<TOpaque = null> = (data: StreamFactoryData<TOpaque>) => Writable;
+  export interface DispatchController {
+    get aborted(): boolean;
+    get paused(): boolean;
+    get reason(): Error | null;
+    abort(reason: Error): void;
+    pause(): void;
+    resume(): void;
+  }
+  export interface DispatchHandler {
+    onRequestStart?(controller: DispatchController, context: any): void;
+    onRequestUpgrade?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders$1, socket: Duplex): void;
+    onResponseStart?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders$1, statusMessage?: string): void;
+    onResponseData?(controller: DispatchController, chunk: Buffer): void;
+    onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders$1): void;
+    onResponseError?(controller: DispatchController, error: Error): void;
+    /** Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails. */
+    /** @deprecated */
+    onConnect?(abort: (err?: Error) => void): void;
+    /** Invoked when an error has occurred. */
+    /** @deprecated */
+    onError?(err: Error): void;
+    /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
+    /** @deprecated */
+    onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
+    /** Invoked when response is received, before headers have been read. **/
+    /** @deprecated */
+    onResponseStarted?(): void;
+    /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
+    /** @deprecated */
+    onHeaders?(statusCode: number, headers: Buffer[], resume: () => void, statusText: string): boolean;
+    /** Invoked when response payload data is received. */
+    /** @deprecated */
+    onData?(chunk: Buffer): boolean;
+    /** Invoked when response payload and trailers have been received and the request has completed. */
+    /** @deprecated */
+    onComplete?(trailers: string[] | null): void;
+    /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+    /** @deprecated */
+    onBodySent?(chunkSize: number, totalBytesSent: number): void;
+  }
+  export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable;
+  export type HttpMethod = Autocomplete$1<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>;
+  /**
+   * @link https://fetch.spec.whatwg.org/#body-mixin
+   */
+  interface BodyMixin {
+    readonly body?: never;
+    readonly bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob$1>;
+    bytes(): Promise<Uint8Array>;
+    formData(): Promise<never>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+  }
+  export interface DispatchInterceptor {
+    (dispatch: Dispatch): Dispatch;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.18.2/node_modules/undici-types/mock-interceptor.d.ts
+/** The scope associated with a mock dispatch. */
+declare class MockScope$1<TData extends object = object> {
+  constructor(mockDispatch: MockInterceptor$1.MockDispatch<TData>);
+  /** Delay a reply by a set amount of time in ms. */
+  delay(waitInMs: number): MockScope$1<TData>;
+  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
+  persist(): MockScope$1<TData>;
+  /** Define a reply for a set amount of matching requests. */
+  times(repeatTimes: number): MockScope$1<TData>;
+}
+/** The interceptor for a Mock. */
+declare class MockInterceptor$1 {
+  constructor(options: MockInterceptor$1.Options, mockDispatches: MockInterceptor$1.MockDispatch[]);
+  /** Mock an undici request with the defined reply. */
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor$1.MockReplyOptionsCallback<TData>): MockScope$1<TData>;
+  reply<TData extends object = object>(statusCode: number, data?: TData | Buffer | string | MockInterceptor$1.MockResponseDataHandler<TData>, responseOptions?: MockInterceptor$1.MockResponseOptions): MockScope$1<TData>;
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope$1;
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders(headers: IncomingHttpHeaders$1): MockInterceptor$1;
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor$1;
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength(): MockInterceptor$1;
+}
+declare namespace MockInterceptor$1 {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders$1;
+    trailers?: Record<string, string>;
+  }
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers$2 | Record<string, string>;
+    origin?: string;
+    body?: BodyInit$1 | Dispatcher$1.DispatchOptions['body'] | null;
+  }
+  export type MockResponseDataHandler<TData extends object = object> = (opts: MockResponseCallbackOptions) => TData | Buffer | string;
+  export type MockReplyOptionsCallback<TData extends object = object> = (opts: MockResponseCallbackOptions) => {
+    statusCode: number;
+    data?: TData | Buffer | string;
+    responseOptions?: MockResponseOptions;
+  };
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/utility.d.ts
+type AutocompletePrimitiveBaseType<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>);
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/header.d.ts
+/**
+ * The header type declaration of `undici`.
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+/**
+ * The header type declaration of `undici` for outgoing requests.
+ */
+type OutgoingHttpHeaders = Record<string, number | string | string[] | undefined>;
+type HeaderNames = Autocomplete<'Accept' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'Alt-Svc' | 'Alt-Used' | 'Authorization' | 'Cache-Control' | 'Clear-Site-Data' | 'Connection' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'Device-Memory' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Last-Modified' | 'Link' | 'Location' | 'Max-Forwards' | 'Origin' | 'Permissions-Policy' | 'Priority' | 'Proxy-Authenticate' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'Referrer-Policy' | 'Retry-After' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-Purpose' | 'Sec-WebSocket-Accept' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'SourceMap' | 'Strict-Transport-Security' | 'TE' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Upgrade-Insecure-Requests' | 'User-Agent' | 'Vary' | 'Via' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options'>;
+type IANARegisteredMimeType = Autocomplete<'audio/aac' | 'video/x-msvideo' | 'image/avif' | 'video/av1' | 'application/octet-stream' | 'image/bmp' | 'text/css' | 'text/csv' | 'application/vnd.ms-fontobject' | 'application/epub+zip' | 'image/gif' | 'application/gzip' | 'text/html' | 'image/x-icon' | 'text/calendar' | 'image/jpeg' | 'text/javascript' | 'application/json' | 'application/ld+json' | 'audio/x-midi' | 'audio/mpeg' | 'video/mp4' | 'video/mpeg' | 'audio/ogg' | 'video/ogg' | 'application/ogg' | 'audio/opus' | 'font/otf' | 'application/pdf' | 'image/png' | 'application/rtf' | 'image/svg+xml' | 'image/tiff' | 'video/mp2t' | 'font/ttf' | 'text/plain' | 'application/wasm' | 'video/webm' | 'audio/webm' | 'image/webp' | 'font/woff' | 'font/woff2' | 'application/xhtml+xml' | 'application/xml' | 'application/zip' | 'video/3gpp' | 'video/3gpp2' | 'model/gltf+json' | 'model/gltf-binary'>;
+type KnownHeaderValues = {
+  'content-type': IANARegisteredMimeType;
+};
+type HeaderRecord = { [K in HeaderNames | Lowercase<HeaderNames>]?: Lowercase<K> extends keyof KnownHeaderValues ? KnownHeaderValues[Lowercase<K>] : string; };
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/readable.d.ts
+declare class BodyReadable extends Readable {
+  constructor(opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  });
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text(): Promise<string>;
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json(): Promise<unknown>;
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob(): Promise<Blob$1>;
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>;
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData(): Promise<never>;
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean;
+  /**
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined;
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump(opts?: {
+    limit: number;
+    signal?: AbortSignal;
+  }): Promise<void>;
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/fetch.d.ts
+type BodyInit = ArrayBuffer | AsyncIterable<Uint8Array> | Blob$1 | FormData$1 | Iterable<Uint8Array> | NodeJS.ArrayBufferView | URLSearchParams$1 | null | string;
+interface SpecIterator<T, TReturn = any, TNext = undefined> {
+  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+}
+interface SpecIteratorObject<T, TReturn = undefined, TNext = unknown> extends SpecIterator<T, TReturn, TNext> {
+  [Symbol.iterator](): SpecIteratorObject<T, TReturn, TNext>;
+  map<U>(callbackfn: (value: T, index: number) => U): SpecIteratorObject<U>;
+  filter<S extends T>(predicate: (value: T, index: number) => value is S): SpecIteratorObject<S>;
+  filter(predicate: (value: T, index: number) => unknown): SpecIteratorObject<T>;
+  take(limit: number): SpecIteratorObject<T>;
+  drop(count: number): SpecIteratorObject<T>;
+  flatMap<U>(callbackfn: (value: T, index: number) => Iterator<U> | Iterable<U>): SpecIteratorObject<U>;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U;
+  toArray(): T[];
+  forEach(callbackfn: (value: T, index: number) => void): void;
+  some(predicate: (value: T, index: number) => unknown): boolean;
+  every(predicate: (value: T, index: number) => unknown): boolean;
+  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;
+  find(predicate: (value: T, index: number) => unknown): T | undefined;
+  readonly [Symbol.toStringTag]: string;
+}
+interface SpecIterableIterator<T> extends SpecIteratorObject<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+interface SpecIterable<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+type HeadersInit = [string, string][] | HeaderRecord | Headers$1;
+declare class Headers$1 implements SpecIterable<[string, string]> {
+  constructor(init?: HeadersInit);
+  readonly append: (name: string, value: string) => void;
+  readonly delete: (name: string) => void;
+  readonly get: (name: string) => string | null;
+  readonly has: (name: string) => boolean;
+  readonly set: (name: string, value: string) => void;
+  readonly getSetCookie: () => string[];
+  readonly forEach: (callbackfn: (value: string, key: string, iterable: Headers$1) => void, thisArg?: unknown) => void;
+  readonly keys: () => SpecIterableIterator<string>;
+  readonly values: () => SpecIterableIterator<string>;
+  readonly entries: () => SpecIterableIterator<[string, string]>;
+  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>;
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/formdata.d.ts
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue = string | File$1;
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+declare class FormData$1 {
+  /**
+   * Appends a new value onto an existing key inside a FormData object,
+   * or adds the key if it does not already exist.
+   *
+   * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   */
+  append(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Set a new value for an existing key inside FormData,
+   * or add the new field if it does not already exist.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   *
+   */
+  set(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Returns the first value associated with a given key from within a `FormData` object.
+   * If you expect multiple values and want all of them, use the `getAll()` method instead.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+   */
+  get(name: string): FormDataEntryValue | null;
+  /**
+   * Returns all the values associated with a given key from within a `FormData` object.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+   */
+  getAll(name: string): FormDataEntryValue[];
+  /**
+   * Returns a boolean stating whether a `FormData` object contains a certain key.
+   *
+   * @param name A string representing the name of the key you want to test for.
+   *
+   * @return A boolean value.
+   */
+  has(name: string): boolean;
+  /**
+   * Deletes a key and its value(s) from a `FormData` object.
+   *
+   * @param name The name of the key you want to delete.
+   */
+  delete(name: string): void;
+  /**
+   * Executes given callback function for each field of the FormData instance
+   */
+  forEach: (callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData$1) => void, thisArg?: unknown) => void;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
+   */
+  keys: () => SpecIterableIterator<string>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+   * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  values: () => SpecIterableIterator<FormDataEntryValue>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  entries: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  /**
+   * An alias for FormData#entries()
+   */
+  [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  readonly [Symbol.toStringTag]: string;
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/connector.d.ts
+declare function buildConnector(options?: buildConnector.BuildOptions): buildConnector.connector;
+declare namespace buildConnector {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+    allowH2?: boolean;
+    preferH2?: boolean;
+    maxCachedSessions?: number | null;
+    socketPath?: string | null;
+    timeout?: number | null;
+    port?: number;
+    keepAlive?: boolean | null;
+    keepAliveInitialDelay?: number | null;
+    typeOfService?: number | null;
+  };
+  export interface Options {
+    hostname: string;
+    host?: string;
+    protocol: string;
+    port: string;
+    servername?: string;
+    localAddress?: string | null;
+    socketPath?: string | null;
+    httpSocket?: Socket;
+  }
+  export type Callback = (...args: CallbackArgs) => void;
+  type CallbackArgs = [null, Socket | TLSSocket] | [Error, null];
+  export interface connector {
+    (options: buildConnector.Options, callback: buildConnector.Callback): void;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/client-stats.d.ts
+declare class ClientStats {
+  constructor(pool: Client);
+  /** If socket has open connection. */
+  connected: boolean;
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number;
+  /** Number of currently active requests of this client. */
+  running: number;
+  /** Number of active, pending, or queued requests of this client. */
+  size: number;
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/client.d.ts
+type ClientConnectOptions<TOpaque = null> = Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin'>;
+// TODO: Pendings
+// 1. Reflect this on Client instantiation
+// 2. Client H2 should use this namespaced options instead.
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
+declare class Client extends Dispatcher {
+  constructor(url: string | URL$1, options?: Client.Options);
+  /** Property to get and set the pipelining factor. */
+  pipelining: number;
+  /** `true` after `client.close()` has been called. */
+  closed: boolean;
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean;
+  /** Aggregate stats for a Client. */
+  readonly stats: ClientStats;
+  // Override dispatcher APIs.
+  override connect<TOpaque = null>(options: ClientConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+  override connect<TOpaque = null>(options: ClientConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+}
+declare namespace Client {
+  export interface Options {
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
+    headersTimeout?: number;
+    /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+    socketTimeout?: never;
+    /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+    requestTimeout?: never;
+    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
+    bodyTimeout?: number;
+    /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+    idleTimeout?: never;
+    /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+    keepAlive?: never;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+    maxKeepAliveTimeout?: never;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Only enable values greater than `1` when the remote server is trusted. Default: `1`. */
+    pipelining?: number;
+    /** @deprecated use the connect option instead */
+    tls?: never;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
+    maxCachedSessions?: number;
+    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
+    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
+    maxRequestsPerClient?: number;
+    /** Local IP address the socket should connect from. */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** WebSocket-specific options */
+    webSocket?: Client.WebSocketOptions;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+     * @default true
+     */
+    allowH2?: boolean;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+     * @deprecated Use h2Options.maxConcurrentStreams instead
+     */
+    maxConcurrentStreams?: number;
+    /**
+     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
+     * @default 262144
+     * @deprecated Use h2Options.settings.initialWindowSize instead
+     */
+    initialWindowSize?: number;
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     * @deprecated Use h2Options.connectionWindowSize instead
+     */
+    connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     * @deprecated Use h2Options.connectionWindowSize instead
+     */
+    pingInterval?: number;
+    /**
+     * @description HTTP/2 configuration options
+     */
+    h2Options?: Client.H2Options;
+  }
+  export interface SocketInfo {
+    localAddress?: string;
+    localPort?: number;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    timeout?: number;
+    bytesWritten?: number;
+    bytesRead?: number;
+  }
+  export interface WebSocketOptions {
+    /**
+     * Maximum number of fragments in a message. Set to 0 to disable the limit.
+     * @default 131072
+     */
+    maxFragments?: number;
+    /**
+     * Maximum allowed payload size in bytes for WebSocket messages.
+     * Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages.
+     * Set to 0 to disable the limit.
+     * @default 134217728 (128 MB)
+     */
+    maxPayloadSize?: number;
+  }
+  export interface H2Options extends Omit<SessionOptions, keyof buildConnector.BuildOptions> {
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     */
+    connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     */
+    pingInterval?: number;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+     */
+    maxConcurrentStreams?: number;
+    /**
+     * @description Enable support for H2C (plain text)
+     * @default false
+     */
+    useH2c?: boolean;
+    /**
+     * @description SETTINGS frame object. Default to 'node:http2' defaults
+     */
+    settings?: Omit<SessionOptions['settings'], 'enablePush' | 'maxConcurrentStreams' | 'enableConnectProtocol'>;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/errors.d.ts
+declare namespace Errors {
+  export class UndiciError extends Error {
+    name: string;
+    code: string;
+  }
+  /** Connect timeout error. */
+  export class ConnectTimeoutError extends UndiciError {
+    name: 'ConnectTimeoutError';
+    code: 'UND_ERR_CONNECT_TIMEOUT';
+  }
+  /** A header exceeds the `headersTimeout` option. */
+  export class HeadersTimeoutError extends UndiciError {
+    name: 'HeadersTimeoutError';
+    code: 'UND_ERR_HEADERS_TIMEOUT';
+  }
+  /** Headers overflow error. */
+  export class HeadersOverflowError extends UndiciError {
+    name: 'HeadersOverflowError';
+    code: 'UND_ERR_HEADERS_OVERFLOW';
+  }
+  /** A body exceeds the `bodyTimeout` option. */
+  export class BodyTimeoutError extends UndiciError {
+    name: 'BodyTimeoutError';
+    code: 'UND_ERR_BODY_TIMEOUT';
+  }
+  export class ResponseError extends UndiciError {
+    constructor(message: string, code: number, options: {
+      headers?: IncomingHttpHeaders | string[] | null;
+      body?: null | Record<string, any> | string;
+    });
+    name: 'ResponseError';
+    code: 'UND_ERR_RESPONSE';
+    statusCode: number;
+    body: null | Record<string, any> | string;
+    headers: IncomingHttpHeaders | string[] | null;
+  }
+  /** Passed an invalid argument. */
+  export class InvalidArgumentError extends UndiciError {
+    name: 'InvalidArgumentError';
+    code: 'UND_ERR_INVALID_ARG';
+  }
+  /** Returned an invalid value. */
+  export class InvalidReturnValueError extends UndiciError {
+    name: 'InvalidReturnValueError';
+    code: 'UND_ERR_INVALID_RETURN_VALUE';
+  }
+  /** The request has been aborted by the user. */
+  export class RequestAbortedError extends UndiciError {
+    name: 'AbortError';
+    code: 'UND_ERR_ABORTED';
+  }
+  /** Expected error with reason. */
+  export class InformationalError extends UndiciError {
+    name: 'InformationalError';
+    code: 'UND_ERR_INFO';
+  }
+  /** Request body length does not match content-length header. */
+  export class RequestContentLengthMismatchError extends UndiciError {
+    name: 'RequestContentLengthMismatchError';
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Response body length does not match content-length header. */
+  export class ResponseContentLengthMismatchError extends UndiciError {
+    name: 'ResponseContentLengthMismatchError';
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Trying to use a destroyed client. */
+  export class ClientDestroyedError extends UndiciError {
+    name: 'ClientDestroyedError';
+    code: 'UND_ERR_DESTROYED';
+  }
+  /** Trying to use a closed client. */
+  export class ClientClosedError extends UndiciError {
+    name: 'ClientClosedError';
+    code: 'UND_ERR_CLOSED';
+  }
+  /** There is an error with the socket. */
+  export class SocketError extends UndiciError {
+    name: 'SocketError';
+    code: 'UND_ERR_SOCKET';
+    socket: Client.SocketInfo | null;
+  }
+  /** Encountered unsupported functionality. */
+  export class NotSupportedError extends UndiciError {
+    name: 'NotSupportedError';
+    code: 'UND_ERR_NOT_SUPPORTED';
+  }
+  /** No upstream has been added to the BalancedPool. */
+  export class BalancedPoolMissingUpstreamError extends UndiciError {
+    name: 'MissingUpstreamError';
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+  }
+  export class HTTPParserError extends UndiciError {
+    name: 'HTTPParserError';
+    code: string;
+  }
+  /** The response exceed the length allowed. */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+  }
+  export class RequestRetryError extends UndiciError {
+    constructor(message: string, statusCode: number, headers?: IncomingHttpHeaders | string[] | null, body?: null | Record<string, any> | string);
+    name: 'RequestRetryError';
+    code: 'UND_ERR_REQ_RETRY';
+    statusCode: number;
+    data: {
+      count: number;
+    };
+    headers: Record<string, string | string[]>;
+  }
+  export class SecureProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'SecureProxyConnectionError';
+    code: 'UND_ERR_PRX_TLS';
+  }
+  export class ProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'ProxyConnectionError';
+    code: 'UND_ERR_PRX_CONN';
+  }
+  export class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError';
+    code: 'UND_ERR_MAX_ORIGINS_REACHED';
+  }
+  /** SOCKS5 proxy related error. */
+  export class Socks5ProxyError extends UndiciError {
+    constructor(message?: string, code?: string);
+    name: 'Socks5ProxyError';
+    code: string;
+  }
+  /** WebSocket decompressed message exceeded maximum size. */
+  export class MessageSizeExceededError extends UndiciError {
+    name: 'MessageSizeExceededError';
+    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED';
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/dispatcher.d.ts
+type UndiciHeaders = OutgoingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null;
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher extends EventEmitter {
+  /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+  dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+  /** Starts two-way communications with the requested resource. */
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+  /** Compose a chain of dispatchers */
+  compose(dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  compose(...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  /** Performs an HTTP request. */
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void;
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>;
+  /** For easy use with `stream.pipeline`. */
+  pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex;
+  /** A faster version of `Dispatcher.request`. */
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void;
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>;
+  /** Upgrade to a different protocol. */
+  upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+  upgrade(options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>;
+  /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+  close(callback: () => void): void;
+  close(): Promise<void>;
+  /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+  destroy(err: Error | null, callback: () => void): void;
+  destroy(callback: () => void): void;
+  destroy(err: Error | null): Promise<void>;
+  destroy(): Promise<void>;
+  on(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  on(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  once(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  once(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  off(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  off(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  addListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  addListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  removeListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  removeListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  prependListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependOnceListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  prependOnceListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  listeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher[]) => void)[];
+  listeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  rawListeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher[]) => void)[];
+  rawListeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  emit(eventName: 'connect', origin: URL$1, targets: readonly Dispatcher[]): boolean;
+  emit(eventName: 'disconnect', origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'connectionError', origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'drain', origin: URL$1): boolean;
+}
+declare namespace Dispatcher {
+  export interface ComposedDispatcher extends Dispatcher {}
+  export type Dispatch = Dispatcher['dispatch'];
+  export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch;
+  export interface DispatchOptions {
+    origin?: string | URL$1;
+    path: string;
+    method: HttpMethod;
+    /** Default: `null` */
+    body?: string | Buffer | Uint8Array | Readable | null | FormData$1;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Query string params to be embedded in the request URL. Default: `null` */
+    query?: Record<string, any>;
+    /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+    idempotent?: boolean;
+    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
+    blocking?: boolean;
+    /** The IP Type of Service (ToS) value for the request socket. Must be an integer between 0 and 255. */
+    typeOfService?: number | null;
+    /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
+    upgrade?: boolean | string | null;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
+    headersTimeout?: number | null;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
+    bodyTimeout?: number | null;
+    /** Whether the request should stablish a keep-alive or not. Default `false` */
+    reset?: boolean;
+    /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
+    expectContinue?: boolean;
+  }
+  export interface ConnectOptions<TOpaque = null> {
+    origin: string | URL$1;
+    path: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Default: `null` */
+    signal?: AbortSignal | EventEmitter | null;
+    /** This argument parameter is passed through to `ConnectData` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface RequestOptions<TOpaque = null> extends DispatchOptions {
+    /** Default: `null` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    signal?: AbortSignal | EventEmitter | null;
+    /** Default: `null` */
+    onInfo?: (info: {
+      statusCode: number;
+      headers: Record<string, string | string[]>;
+    }) => void;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+    /** Default: `64 KiB` */
+    highWaterMark?: number;
+  }
+  export interface PipelineOptions<TOpaque = null> extends RequestOptions<TOpaque> {
+    /** `true` if the `handler` will return an object stream. Default: `false` */
+    objectMode?: boolean;
+  }
+  export interface UpgradeOptions {
+    path: string;
+    /** Default: `'GET'` */
+    method?: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+    protocol?: string;
+    /** Default: `null` */
+    signal?: AbortSignal | EventEmitter | null;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface ConnectData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface ResponseData<TOpaque = null> {
+    statusCode: number;
+    statusText: string;
+    headers: IncomingHttpHeaders;
+    body: BodyReadable & BodyMixin;
+    trailers: Record<string, string>;
+    opaque: TOpaque;
+    context: object;
+  }
+  export interface PipelineHandlerData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    body: BodyReadable;
+    context: object;
+  }
+  export interface StreamData<TOpaque = null> {
+    opaque: TOpaque;
+    trailers: Record<string, string>;
+  }
+  export interface UpgradeData<TOpaque = null> {
+    headers: IncomingHttpHeaders;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface StreamFactoryData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    context: object;
+  }
+  export type StreamFactory<TOpaque = null> = (data: StreamFactoryData<TOpaque>) => Writable;
+  export interface DispatchController {
+    get aborted(): boolean;
+    get paused(): boolean;
+    get reason(): Error | null;
+    rawHeaders?: Buffer[] | string[] | IncomingHttpHeaders | null;
+    rawTrailers?: Buffer[] | string[] | IncomingHttpHeaders | null;
+    abort(reason: Error): void;
+    pause(): void;
+    resume(): void;
+  }
+  export interface DispatchHandler {
+    onRequestStart?(controller: DispatchController, context: any): void;
+    onRequestUpgrade?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, socket: Duplex): void;
+    onResponseStart?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, statusMessage?: string): void;
+    onResponseData?(controller: DispatchController, chunk: Buffer): void;
+    onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
+    onResponseError?(controller: DispatchController, error: Error): void;
+    /** Invoked when response is received, before headers have been read. **/
+    onResponseStarted?(): void;
+    /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+    onBodySent?(chunk: Buffer): void;
+    /** Invoked after the request body is fully sent. */
+    onRequestSent?(): void;
+  }
+  export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable;
+  export type HttpMethod = Autocomplete<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>;
+  /**
+   * @link https://fetch.spec.whatwg.org/#body-mixin
+   */
+  interface BodyMixin {
+    readonly body?: never;
+    readonly bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob$1>;
+    bytes(): Promise<Uint8Array>;
+    formData(): Promise<never>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+  }
+  export interface DispatchInterceptor {
+    (dispatch: Dispatch): Dispatch;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici@8.10.0/node_modules/undici/types/mock-interceptor.d.ts
+/** The scope associated with a mock dispatch. */
+declare class MockScope<TData extends object = object> {
+  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+  /** Delay a reply by a set amount of time in ms. */
+  delay(waitInMs: number): MockScope<TData>;
+  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
+  persist(): MockScope<TData>;
+  /** Define a reply for a set amount of matching requests. */
+  times(repeatTimes: number): MockScope<TData>;
+}
+/** The interceptor for a Mock. */
+declare class MockInterceptor {
+  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+  /** Mock an undici request with the defined reply. */
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+  reply<TData extends object = object>(statusCode: number, data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>, responseOptions?: MockInterceptor.MockResponseOptions): MockScope<TData>;
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope;
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength(): MockInterceptor;
+}
+declare namespace MockInterceptor {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders;
+    trailers?: Record<string, string>;
+  }
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers$1 | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  }
+  export type MockResponseDataHandler<TData extends object = object> = (opts: MockResponseCallbackOptions) => TData | Buffer | string;
+  export type MockReplyOptions<TData extends object = object> = {
+    statusCode: number;
+    data?: TData | Buffer | string;
+    responseOptions?: MockResponseOptions;
+  };
+  export type MockReplyOptionsCallback<TData extends object = object> = (opts: MockResponseCallbackOptions) => MockReplyOptions<TData> | Promise<MockReplyOptions<TData>>;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-telemetry@0.84.1/node_modules/@earendil-works/pi-telemetry/dist/index.d.ts
+type AttributeValue = string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+interface SpanAttributes {
+  [name: string]: AttributeValue | undefined;
+}
+interface SpanOptions {
+  name: string;
+  attributes?: SpanAttributes;
+}
+type SpanStatus = {
+  status: "ok";
+} | {
+  status: "error";
+  error?: {
+    name: string;
+    message: string;
+  };
+};
+interface TelemetryContext {
+  startSpan<T>(options: SpanOptions, callback: (span: TelemetrySpan) => T | Promise<T>): Promise<T>;
+}
+interface TelemetrySpan extends TelemetryContext {
+  addEvent(name: string, attributes?: SpanAttributes): void;
+  setAttributes(attributes: SpanAttributes): void;
+  setStatus(status: SpanStatus): void;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/diagnostics.d.ts
+interface DiagnosticErrorInfo {
+  name?: string;
+  message: string;
+  stack?: string;
+  code?: string | number;
+}
+interface AssistantMessageDiagnostic {
+  type: string;
+  timestamp: number;
+  error?: DiagnosticErrorInfo;
+  details?: Record<string, unknown>;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/event-stream.d.ts
+declare class EventStream<T, R = T> implements AsyncIterable<T> {
+  private queue;
+  private waiting;
+  private done;
+  private finalResultPromise;
+  private resolveFinalResult;
+  private isComplete;
+  private extractResult;
+  constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
+  push(event: T): void;
+  end(result?: R): void;
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+  result(): Promise<R>;
+}
+declare class AssistantMessageEventStream$1 extends EventStream<AssistantMessageEvent, AssistantMessage$1> {
+  constructor();
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/types.d.ts
+type KnownApi = "openai-completions" | "mistral-conversations" | "openai-responses" | "azure-openai-responses" | "openai-codex-responses" | "anthropic-messages" | "bedrock-converse-stream" | "google-generative-ai" | "google-vertex" | "pi-messages";
+type Api$1 = KnownApi | (string & {});
+type KnownProvider = "amazon-bedrock" | "ant-ling" | "anthropic" | "google" | "google-vertex" | "openai" | "azure-openai-responses" | "openai-codex" | "radius" | "nvidia" | "deepseek" | "github-copilot" | "xai" | "groq" | "cerebras" | "openrouter" | "vercel-ai-gateway" | "zai" | "zai-coding-cn" | "mistral" | "minimax" | "minimax-cn" | "moonshotai" | "moonshotai-cn" | "huggingface" | "fireworks" | "together" | "baseten" | "opencode" | "opencode-go" | "kimi-coding" | "cloudflare-workers-ai" | "cloudflare-ai-gateway" | "qwen-token-plan" | "qwen-token-plan-cn" | "qwen-token-plan-individual" | "xiaomi" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-sgp";
+type ProviderId = KnownProvider | string;
+type ThinkingLevel$1 = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+type ModelThinkingLevel$1 = "off" | ThinkingLevel$1;
+type ThinkingLevelMap$1 = Partial<Record<ModelThinkingLevel$1, string | null>>;
+type ChatTemplateKwargValue = string | number | boolean | null | {
+  $var: "thinking.enabled" | "thinking.effort";
+  omitWhenOff?: boolean;
+};
+/** Token budgets for each thinking level (token-based providers only) */
+interface ThinkingBudgets {
+  minimal?: number;
+  low?: number;
+  medium?: number;
+  high?: number;
+}
+type CacheRetention = "none" | "short" | "long";
+type Transport = "sse" | "websocket" | "websocket-cached" | "auto";
+/** Provider-scoped environment overrides. Values take precedence over process.env. */
+type ProviderEnv = Record<string, string>;
+type ProviderHeaders = Record<string, string | null>;
+type FetchFunction = typeof globalThis.fetch;
+type SessionAffinityFormat = "openai" | "openai-nosession" | "openrouter";
+interface ProviderResponse {
+  status: number;
+  headers: Record<string, string>;
+}
+/** Authentication, HTTP transport, and lifecycle callbacks shared by provider requests. */
+interface ProviderRequestOptions<TModel = Model$1<Api$1>> {
+  signal?: AbortSignal;
+  /** Explicit parent context for telemetry produced by this logical request. */
+  telemetryContext?: TelemetryContext;
+  apiKey?: string;
+  /**
+   * Optional fetch implementation for provider HTTP requests.
+   * Defaults to `globalThis.fetch`. Provider adapters that cannot inject a custom implementation may reject it.
+   * This does not affect WebSocket transports.
+   */
+  fetch?: FetchFunction;
+  /**
+   * Provider-scoped environment values. These take precedence over process.env for
+   * provider configuration such as regional settings, endpoint placeholders, and
+   * proxy variables.
+   */
+  env?: ProviderEnv;
+  /**
+   * Optional callback for inspecting or replacing provider payloads before sending.
+   * Return undefined to keep the payload unchanged.
+   */
+  onPayload?: (payload: unknown, model: TModel) => unknown | undefined | Promise<unknown | undefined>;
+  /**
+   * Optional callback invoked after an HTTP response is received.
+   */
+  onResponse?: (response: ProviderResponse, model: TModel) => void | Promise<void>;
+  /**
+   * Optional custom HTTP headers to include in API requests.
+   * Merged with provider defaults; caller values override default headers.
+   * On AWS Bedrock these are injected via a Smithy `build`-step middleware so
+   * they are covered by SigV4 signing; reserved headers (`x-amz-*`,
+   * `authorization`, `host`) are silently ignored to preserve SigV4 / bearer auth.
+   * A null value suppresses a provider/API default header with the same name.
+   */
+  headers?: ProviderHeaders;
+  /**
+   * HTTP request timeout in milliseconds for providers/SDKs that support it.
+   * For example, OpenAI and Anthropic SDK clients default to 10 minutes.
+   */
+  timeoutMs?: number;
+  /**
+   * Maximum retry attempts for providers/SDKs that support client-side retries.
+   * For example, OpenAI and Anthropic SDK clients default to 2.
+   */
+  maxRetries?: number;
+  /**
+   * Maximum delay in milliseconds to wait for a retry when the server requests a long wait.
+   * If the server's requested delay exceeds this value, the request fails immediately
+   * with an error containing the requested delay, allowing higher-level retry logic
+   * to handle it with user visibility.
+   * Default: 60000 (60 seconds). Set to 0 to disable the cap.
+   */
+  maxRetryDelayMs?: number;
+}
+interface StreamOptions extends ProviderRequestOptions<Model$1<Api$1>> {
+  /**
+   * Optional callback invoked after an HTTP response is received and before
+   * its body stream is consumed.
+   */
+  onResponse?: (response: ProviderResponse, model: Model$1<Api$1>) => void | Promise<void>;
+  temperature?: number;
+  /**
+   * Arbitrary sampling parameters merged into the request body as-is, after the named request
+   * fields, so keys here override them. Lets custom OpenAI-compatible servers (llama.cpp, vLLM,
+   * SGLang, ...) receive parameters pi does not model, e.g. `top_p`, `top_k`, `min_p`,
+   * `repetition_penalty`. Merged over `Model.samplingParams` per key. Only applied by
+   * OpenAI-compatible adapters (completions, responses, Azure responses); other APIs ignore it.
+   */
+  samplingParams?: Record<string, unknown>;
+  maxTokens?: number;
+  /**
+   * Preferred transport for providers that support multiple transports.
+   * Providers that do not support this option ignore it.
+   */
+  transport?: Transport;
+  /**
+   * Prompt cache retention preference. Providers map this to their supported values.
+   * Default: "short".
+   */
+  cacheRetention?: CacheRetention;
+  /**
+   * Optional session identifier for providers that support session-based caching.
+   * Providers can use this to enable prompt caching, request routing, or other
+   * session-aware features. Ignored by providers that don't support it.
+   */
+  sessionId?: string;
+  /**
+   * WebSocket connect timeout in milliseconds for providers that support
+   * WebSocket transports. This covers the connection/open handshake only;
+   * stream idleness after connection uses timeoutMs.
+   */
+  websocketConnectTimeoutMs?: number;
+  /**
+   * Optional metadata to include in API requests.
+   * Providers extract the fields they understand and ignore the rest.
+   * For example, Anthropic uses `user_id` for abuse tracking and rate limiting.
+   */
+  metadata?: Record<string, unknown>;
+}
+interface SimpleStreamOptions extends StreamOptions {
+  reasoning?: ThinkingLevel$1;
+  /** Ask a capable provider to return a durable handle and continue the request asynchronously. */
+  deferred?: boolean | {
+    window?: "15m" | "1h" | "24h";
+  };
+  /** Custom token budgets for thinking levels (token-based providers only) */
+  thinkingBudgets?: ThinkingBudgets;
+}
+type StreamFunction<TApi extends Api$1 = Api$1, TOptions extends StreamOptions = StreamOptions> = (model: Model$1<TApi>, context: Context, options?: TOptions) => AssistantMessageEventStream$1;
+interface TextContent$1 {
+  type: "text";
+  text: string;
+  textSignature?: string;
+}
+interface ThinkingContent$1 {
+  type: "thinking";
+  thinking: string;
+  thinkingSignature?: string;
+  /** When true, the thinking content was redacted by safety filters. The opaque
+   *  encrypted payload is stored in `thinkingSignature` so it can be passed back
+   *  to the API for multi-turn continuity. */
+  redacted?: boolean;
+}
+interface ImageContent$1 {
+  type: "image";
+  data: string;
+  mimeType: string;
+}
+interface ToolCall$1 {
+  type: "toolCall";
+  id: string;
+  name: string;
+  arguments: Record<string, any>;
+  thoughtSignature?: string;
+}
+interface Usage$2 {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  /** Subset of `cacheWrite` written with 1h retention. Only Anthropic reports this split. */
+  cacheWrite1h?: number;
+  /**
+   * Reasoning/thinking tokens, when the provider reports them. This is a subset of
+   * `output`: `output` already includes these tokens. Set to a number (possibly 0) by
+   * providers that expose a reasoning breakdown; left undefined by providers that don't.
+   */
+  reasoning?: number;
+  totalTokens: number;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+}
+type StopReason = "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+interface DeferredHandle {
+  provider: string;
+  modelId: string;
+  api: string;
+  /** Provider token, such as a response id or batch id plus row id. */
+  id: string;
+  expiresAt?: number;
+  pollAfterMs?: number;
+  /** Provider conversion data required to reconstruct the final assistant message. */
+  data?: JsonValue;
+}
+interface UserMessage$1 {
+  role: "user";
+  content: string | (TextContent$1 | ImageContent$1)[];
+  timestamp: number;
+}
+interface AssistantMessage$1 {
+  role: "assistant";
+  content: (TextContent$1 | ThinkingContent$1 | ToolCall$1)[];
+  api: Api$1;
+  provider: ProviderId;
+  model: string;
+  responseModel?: string;
+  responseId?: string;
+  diagnostics?: AssistantMessageDiagnostic[];
+  usage: Usage$2;
+  stopReason: StopReason;
+  deferred?: DeferredHandle;
+  errorMessage?: string;
+  rawStopReason?: string;
+  timestamp: number;
+}
+interface ToolResultMessage$1<TDetails = any> {
+  role: "toolResult";
+  toolCallId: string;
+  toolName: string;
+  content: (TextContent$1 | ImageContent$1)[];
+  details?: TDetails;
+  /** Usage from the tool execution itself, if available. Not part of main LLM context accounting. */
+  usage?: Usage$2;
+  /**
+   * Names from `Context.tools` that became available after this result.
+   * Providers with native deferred tool loading use this as the load point;
+   * other providers ignore it and use `Context.tools` normally.
+   */
+  addedToolNames?: string[];
+  isError: boolean;
+  timestamp: number;
+}
+type Message$2 = UserMessage$1 | AssistantMessage$1 | ToolResultMessage$1;
+/** OpenAI grammar variants for constrained sampling. */
+type GrammarFormat = "openai_lark" | "openai_regex";
+type GrammarVariants = Partial<Record<GrammarFormat, string>>;
+/**
+ * Optional provider-side constrained sampling configs for a tool.
+ *
+ * The `json_schema` value roughly maps to the concept of `strict` in APIs which is
+ * implemented as json-schema constrained sampling by APIs. Grammar variants let
+ * callers provide provider-specific encodings of the same intended language.
+ */
+type ConstrainedSamplingConfig = {
+  type: "json_schema";
+  strict: "prefer" | "require";
+} | {
+  type: "grammar";
+  variants: GrammarVariants;
+};
+interface Tool<TParameters extends TSchema$1 = TSchema$1> {
+  name: string;
+  description: string;
+  parameters: TParameters;
+  constrainedSampling?: false | ConstrainedSamplingConfig;
+}
+interface Context {
+  systemPrompt?: string;
+  messages: Message$2[];
+  tools?: Tool[];
+}
+/**
+ * Event protocol for AssistantMessageEventStream.
+ *
+ * Streams should emit `start` before partial updates, then terminate with either:
+ * - `done` carrying the final successful AssistantMessage, or
+ * - `error` carrying the final AssistantMessage with stopReason "error" or "aborted"
+ *   and errorMessage.
+ */
+type AssistantMessageEvent = {
+  type: "start";
+  partial: AssistantMessage$1;
+} | {
+  type: "text_start";
+  contentIndex: number;
+  partial: AssistantMessage$1;
+} | {
+  type: "text_delta";
+  contentIndex: number;
+  delta: string;
+  partial: AssistantMessage$1;
+} | {
+  type: "text_end";
+  contentIndex: number;
+  content: string;
+  partial: AssistantMessage$1;
+} | {
+  type: "thinking_start";
+  contentIndex: number;
+  partial: AssistantMessage$1;
+} | {
+  type: "thinking_delta";
+  contentIndex: number;
+  delta: string;
+  partial: AssistantMessage$1;
+} | {
+  type: "thinking_end";
+  contentIndex: number;
+  content: string;
+  partial: AssistantMessage$1;
+} | {
+  type: "toolcall_start";
+  contentIndex: number;
+  partial: AssistantMessage$1;
+} | {
+  type: "toolcall_delta";
+  contentIndex: number;
+  delta: string;
+  partial: AssistantMessage$1;
+} | {
+  type: "toolcall_end";
+  contentIndex: number;
+  toolCall: ToolCall$1;
+  partial: AssistantMessage$1;
+} | {
+  type: "done";
+  reason: Extract<StopReason, "stop" | "length" | "toolUse" | "deferred">;
+  message: AssistantMessage$1;
+} | {
+  type: "error";
+  reason: Extract<StopReason, "aborted" | "error">;
+  error: AssistantMessage$1;
+};
+/**
+ * Compatibility settings for OpenAI-compatible completions APIs.
+ * Use this to override URL-based auto-detection for custom providers.
+ */
+interface OpenAICompletionsCompat {
+  /** Whether the provider supports the `store` field. Default: auto-detected from URL. */
+  supportsStore?: boolean;
+  /** Whether the provider supports the `developer` role (vs `system`). Default: auto-detected from URL. */
+  supportsDeveloperRole?: boolean;
+  /** Whether the provider supports `reasoning_effort`. Default: auto-detected from URL. */
+  supportsReasoningEffort?: boolean;
+  /** Whether the provider supports `stream_options: { include_usage: true }` for token usage in streaming responses. Default: true. */
+  supportsUsageInStreaming?: boolean;
+  /** Whether streamed responses include `finish_reason`. When false, pi infers `stop` or `toolUse` when the stream ends. Default: true. */
+  supportsFinishReason?: boolean;
+  /** Which field to use for max tokens. Default: auto-detected from URL. */
+  maxTokensField?: "max_completion_tokens" | "max_tokens";
+  /** Whether tool results require the `name` field. Default: auto-detected from URL. */
+  requiresToolResultName?: boolean;
+  /** Whether a user message after tool results requires an assistant message in between. Default: auto-detected from URL. */
+  requiresAssistantAfterToolResult?: boolean;
+  /** Whether thinking blocks must be converted to text blocks with <thinking> delimiters. Default: auto-detected from URL. */
+  requiresThinkingAsText?: boolean;
+  /** Whether all replayed assistant messages must include an empty reasoning_content field when reasoning is enabled. Default: auto-detected from URL. */
+  requiresReasoningContentOnAssistantMessages?: boolean;
+  /** Format for reasoning/thinking parameter. "openai" uses reasoning_effort, "openrouter" uses reasoning: { effort }, "deepseek" uses thinking: { type } plus reasoning_effort when supported, "together" uses reasoning: { enabled } plus reasoning_effort when supported, "baseten" uses configurable chat_template_args plus reasoning_effort when supported, "zai" uses thinking: { type }, "qwen" uses top-level enable_thinking: boolean, "qwen-chat-template" uses chat_template_kwargs.enable_thinking and preserve_thinking, "chat-template" uses configurable chat_template_kwargs, "string-thinking" uses top-level thinking: string, and "ant-ling" uses reasoning: { effort } only when the mapped effort is non-null. Default: "openai". */
+  thinkingFormat?: "openai" | "openrouter" | "deepseek" | "together" | "baseten" | "zai" | "qwen" | "chat-template" | "qwen-chat-template" | "string-thinking" | "ant-ling";
+  /** Kwargs to send as `chat_template_kwargs` when `thinkingFormat` is `chat-template`. Use `{ "$var": "thinking.enabled" }` or `{ "$var": "thinking.effort" }` for pi-controlled thinking values. */
+  chatTemplateKwargs?: Record<string, ChatTemplateKwargValue>;
+  /** Arguments to send as `chat_template_args` when `thinkingFormat` is `baseten`. Use `{ "$var": "thinking.enabled" }` or `{ "$var": "thinking.effort" }` for pi-controlled thinking values. */
+  chatTemplateArgs?: Record<string, ChatTemplateKwargValue>;
+  /** OpenRouter-compatible routing preferences sent as the `provider` request field. */
+  openRouterRouting?: OpenRouterRouting;
+  /** Vercel AI Gateway routing preferences. Only used when baseUrl points to Vercel AI Gateway. */
+  vercelGatewayRouting?: VercelGatewayRouting;
+  /** Whether z.ai supports top-level `tool_stream: true` for streaming tool call deltas. Default: false. */
+  zaiToolStream?: boolean;
+  /** Whether the provider supports top-level `thinking_token_budget` to cap reasoning tokens (vLLM). Reasoning and the answer share `max_tokens` on these endpoints, so without a budget a reasoning-heavy turn can consume the whole response and emit no answer. Default: false. */
+  supportsThinkingTokenBudget?: boolean;
+  /** Whether the provider supports OpenAI custom tools with Lark/regex grammar formats. When false, grammar-constrained tools fall back to normal function tools. Default: false; the generated model catalog enables it for capable models. */
+  supportsOpenAIGrammarTools?: boolean;
+  /** Whether the provider supports the `strict` field in tool definitions. Default: true. */
+  supportsStrictMode?: boolean;
+  /** Cache control convention for prompt caching. "anthropic" applies Anthropic-style `cache_control` markers to the system prompt, last tool definition, and last user, assistant, or tool-result text content. */
+  cacheControlFormat?: "anthropic";
+  /** Whether to send session-affinity data from `options.sessionId`. Default: false. */
+  sendSessionAffinityHeaders?: boolean;
+  /** Provider-specific deferred tool serialization mode. */
+  deferredToolsMode?: "kimi";
+  /** Session-affinity header format: `openai` sends `session_id`, `x-client-request-id`, and `x-session-affinity`; `openai-nosession` sends `x-client-request-id` and `x-session-affinity`; `openrouter` sends `x-session-id`. Does not affect the `prompt_cache_key` body param, which is governed by cache retention. Default: auto-detected. */
+  sessionAffinityFormat?: SessionAffinityFormat;
+  /** Whether the provider supports long prompt cache retention (`prompt_cache_retention: "24h"` or Anthropic-style `cache_control.ttl: "1h"`, depending on format). Default: true. */
+  supportsLongCacheRetention?: boolean;
+}
+/** Compatibility settings for OpenAI Responses APIs. */
+interface OpenAIResponsesCompat {
+  /** Whether the provider supports the `developer` role (vs `system`). Default: true. */
+  supportsDeveloperRole?: boolean;
+  /** Session-affinity header format: `openai` sends `session_id` and `x-client-request-id`; `openai-nosession` sends `x-client-request-id`; `openrouter` sends `x-session-id`. Does not affect the `prompt_cache_key` body param, which is governed by cache retention. Default: auto-detected. */
+  sessionAffinityFormat?: SessionAffinityFormat;
+  /** Whether the provider supports `prompt_cache_retention: "24h"`. Default: true. */
+  supportsLongCacheRetention?: boolean;
+  /** Whether the provider supports strict JSON-schema function tools. Defaults are API-specific; generated OpenAI models enable it explicitly. */
+  supportsStrictMode?: boolean;
+  /** Whether to emit OpenAI custom tools with Lark/regex grammar formats. When false, grammar-constrained tools fall back to normal function tools. Default: false; the generated model catalog enables it for capable models. */
+  supportsOpenAIGrammarTools?: boolean;
+  /** Whether the model supports client-executed tool search for deferred tools. Default: false. */
+  supportsToolSearch?: boolean;
+  /** Whether the model accepts `prompt_cache_options` (OpenAI GPT-5.6+ explicit prompt caching). Older OpenAI models reject the parameter. Default: false. */
+  supportsExplicitPromptCacheMode?: boolean;
+}
+/** Compatibility settings for Anthropic Messages-compatible APIs. */
+interface AnthropicMessagesCompat {
+  /**
+   * Whether the provider accepts per-tool `eager_input_streaming`.
+   * When false, the Anthropic provider omits `tools[].eager_input_streaming`
+   * and sends the legacy `fine-grained-tool-streaming-2025-05-14` beta header
+   * for tool-enabled requests.
+   * Default: true.
+   */
+  supportsEagerToolInputStreaming?: boolean;
+  /** Whether the provider supports Anthropic long cache retention (`cache_control.ttl: "1h"`). Default: true. */
+  supportsLongCacheRetention?: boolean;
+  /**
+   * Whether to send the `x-session-affinity` header from `options.sessionId`
+   * when caching is enabled. Required for providers like Fireworks that use
+   * session affinity for prompt cache routing (requests to the same replica
+   * maximize cache hits).
+   * Default: false.
+   */
+  sendSessionAffinityHeaders?: boolean;
+  /**
+   * Whether the provider supports Anthropic-style `cache_control` markers on
+   * tool definitions. When false, `cache_control` is omitted from tool params.
+   * Some Anthropic-compatible providers (e.g., Fireworks) do not support this
+   * field on tools and may reject or ignore it.
+   * Default: true.
+   */
+  supportsCacheControlOnTools?: boolean;
+  /**
+   * Whether the model accepts the Anthropic `temperature` request field.
+   * Claude Opus 4.7+ rejects non-default temperature values.
+   * Default: true.
+   */
+  supportsTemperature?: boolean;
+  /**
+   * Whether to force adaptive thinking (`thinking.type: "adaptive"` plus
+   * `output_config.effort`) regardless of the model id. Built-in models that
+   * require adaptive thinking set this in generated metadata. Custom
+   * Anthropic-compatible providers can set this to `true` for any model whose
+   * upstream requires the adaptive format. Set to `false` to
+   * opt out on overridden built-in models.
+   * Default: false.
+   */
+  forceAdaptiveThinking?: boolean;
+  /** Whether to replay empty thinking signatures as `signature: ""` instead of converting thinking to text. Default: false. */
+  allowEmptySignature?: boolean;
+  /** Whether the provider supports Anthropic strict tool schemas. Default: false; generated Anthropic models enable it explicitly. */
+  supportsStrictTools?: boolean;
+  /**
+   * Whether the provider supports deferred tools loaded by `tool_reference`
+   * blocks in tool results. Default: true for first-party Anthropic models
+   * except Haiku and models older than Claude 4.5; false for other providers.
+   */
+  supportsToolReferences?: boolean;
+}
+/** Compatibility settings for Amazon Bedrock models. */
+interface BedrockCompat {
+  /** Whether the model supports Bedrock strict tool schemas. Default: false. */
+  supportsStrictMode?: boolean;
+}
+/**
+ * OpenRouter provider routing preferences.
+ * Controls which upstream providers OpenRouter routes requests to.
+ * Sent as the `provider` field in the OpenRouter API request body.
+ * @see https://openrouter.ai/docs/guides/routing/provider-selection
+ */
+interface OpenRouterRouting {
+  /** Whether to allow backup providers to serve requests. Default: true. */
+  allow_fallbacks?: boolean;
+  /** Whether to filter providers to only those that support all parameters in the request. Default: false. */
+  require_parameters?: boolean;
+  /** Data collection setting. "allow" (default): allow providers that may store/train on data. "deny": only use providers that don't collect user data. */
+  data_collection?: "deny" | "allow";
+  /** Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. */
+  zdr?: boolean;
+  /** Whether to restrict routing to only models that allow text distillation. */
+  enforce_distillable_text?: boolean;
+  /** An ordered list of provider names/slugs to try in sequence, falling back to the next if unavailable. */
+  order?: string[];
+  /** List of provider names/slugs to exclusively allow for this request. */
+  only?: string[];
+  /** List of provider names/slugs to skip for this request. */
+  ignore?: string[];
+  /** A list of quantization levels to filter providers by (e.g., ["fp16", "bf16", "fp8", "fp6", "int8", "int4", "fp4", "fp32"]). */
+  quantizations?: string[];
+  /** Sorting strategy. Can be a string (e.g., "price", "throughput", "latency") or an object with `by` and `partition`. */
+  sort?: string | {
+    /** The sorting metric: "price", "throughput", "latency". */
+    by?: string;
+    /** Partitioning strategy: "model" (default) or "none". */
+    partition?: string | null;
+  };
+  /** Maximum price per million tokens (USD). */
+  max_price?: {
+    /** Price per million prompt tokens. */
+    prompt?: number | string;
+    /** Price per million completion tokens. */
+    completion?: number | string;
+    /** Price per image. */
+    image?: number | string;
+    /** Price per audio unit. */
+    audio?: number | string;
+    /** Price per request. */
+    request?: number | string;
+  };
+  /** Preferred minimum throughput (tokens/second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. */
+  preferred_min_throughput?: number | {
+    /** Minimum tokens/second at the 50th percentile. */
+    p50?: number;
+    /** Minimum tokens/second at the 75th percentile. */
+    p75?: number;
+    /** Minimum tokens/second at the 90th percentile. */
+    p90?: number;
+    /** Minimum tokens/second at the 99th percentile. */
+    p99?: number;
+  };
+  /** Preferred maximum latency (seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. */
+  preferred_max_latency?: number | {
+    /** Maximum latency in seconds at the 50th percentile. */
+    p50?: number;
+    /** Maximum latency in seconds at the 75th percentile. */
+    p75?: number;
+    /** Maximum latency in seconds at the 90th percentile. */
+    p90?: number;
+    /** Maximum latency in seconds at the 99th percentile. */
+    p99?: number;
+  };
+}
+/**
+ * Vercel AI Gateway routing preferences.
+ * Controls which upstream providers the gateway routes requests to.
+ * @see https://vercel.com/docs/ai-gateway/models-and-providers/provider-options
+ */
+interface VercelGatewayRouting {
+  /** List of provider slugs to exclusively use for this request (e.g., ["bedrock", "anthropic"]). */
+  only?: string[];
+  /** List of provider slugs to try in order (e.g., ["anthropic", "openai"]). */
+  order?: string[];
+}
+interface ModelCostRates {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+interface ModelCostTier extends ModelCostRates {
+  /** Use this tier for requests whose total input usage exceeds this token count. */
+  inputTokensAbove: number;
+}
+interface ModelCost extends ModelCostRates {
+  /** Request-wide pricing tiers. The highest matching input threshold applies to the full request. */
+  tiers?: ModelCostTier[];
+}
+interface Model$1<TApi extends Api$1> {
+  id: string;
+  name: string;
+  api: TApi;
+  provider: ProviderId;
+  baseUrl: string;
+  reasoning: boolean;
+  /**
+   * Maps pi thinking levels to provider/model-specific values.
+   * Missing keys use provider defaults. null marks a level as unsupported.
+   */
+  thinkingLevelMap?: ThinkingLevelMap$1;
+  input: ("text" | "image")[];
+  cost: ModelCost;
+  contextWindow: number;
+  maxTokens: number;
+  /** Default sampling parameters for this model. See {@link StreamOptions.samplingParams}; per-request keys override these. */
+  samplingParams?: Record<string, unknown>;
+  headers?: Record<string, string>;
+  /** Compatibility overrides for OpenAI-compatible APIs. If not set, auto-detected from baseUrl. */
+  compat?: TApi extends "openai-completions" ? OpenAICompletionsCompat : TApi extends "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? OpenAIResponsesCompat : TApi extends "anthropic-messages" ? AnthropicMessagesCompat : TApi extends "bedrock-converse-stream" ? BedrockCompat : never;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/openai-responses.d.ts
+declare const streamSimple: StreamFunction<"openai-responses", SimpleStreamOptions>;
+//#endregion
 //#region src/compat/vendor/pi-oauth-flows/openai-codex.d.ts
 declare const openaiCodexOAuth: {
   name: string;
@@ -357,5 +2633,5 @@ declare function StringEnum<T extends readonly string[]>(values: T, options?: St
   default?: T[number];
 };
 //#endregion
-export { type AgentMessage, Api, type AssistantMessage, AssistantMessageEventStream, type ImageContent, type Message, Model, ModelThinkingLevel, ModelsError, type Static, StringEnum, StringEnumOptions, type TSchema, type TextContent, type ThinkingContent, ThinkingLevel, ThinkingLevelMap, type ToolCallContent, type ToolResultMessage, Type, type Usage, type UserMessage, __getPiAiLlmBridge, __setPiAiLlmBridge, anthropicMessagesApi, anthropicOAuth, azureOpenAIResponsesApi, bedrockConverseStreamApi, builtinProviders, clampThinkingLevel, complete, contentText, createProvider, generatePKCE, getApiProvider, getApiProviders, getBuiltinModel, getBuiltinModels, getBuiltinProviders, getModel, getModels, getProvider, getProviders, getSupportedThinkingLevels, githubCopilotOAuth, googleGenerativeAIApi, googleVertexApi, isContextOverflow, isRecoverableLength, isRetryableAssistantError, kimiCodingOAuth, lazyApi, lazyStream, loadAnthropicOAuth, loadGitHubCopilotOAuth, loadKimiCodingOAuth, loadOpenAICodexOAuth, mistralConversationsApi, modelsAreEqual, openAICodexResponsesApi, openAICompletionsApi, openAIResponsesApi, openaiCodexOAuth, piMessagesApi, pollOAuthDeviceCodeFlow, registerApiProvider, registerProvider, stream, unregisterApiProviders, uuidv7 };
+export { type AgentMessage, Api, type AssistantMessage, AssistantMessageEventStream, type ImageContent, type Message$1 as Message, Model, ModelThinkingLevel, ModelsError, type Static$1 as Static, StringEnum, StringEnumOptions, type TSchema, type TextContent, type ThinkingContent, ThinkingLevel, ThinkingLevelMap, type ToolCallContent, type ToolResultMessage, Type, type Usage$1 as Usage, type UserMessage, __getPiAiLlmBridge, __setPiAiLlmBridge, anthropicMessagesApi, anthropicOAuth, azureOpenAIResponsesApi, bedrockConverseStreamApi, builtinProviders, clampThinkingLevel, complete, contentText, createProvider, generatePKCE, getApiProvider, getApiProviders, getBuiltinModel, getBuiltinModels, getBuiltinProviders, getModel, getModels, getProvider, getProviders, getSupportedThinkingLevels, githubCopilotOAuth, googleGenerativeAIApi, googleVertexApi, isContextOverflow, isRecoverableLength, isRetryableAssistantError, kimiCodingOAuth, lazyApi, lazyStream, loadAnthropicOAuth, loadGitHubCopilotOAuth, loadKimiCodingOAuth, loadOpenAICodexOAuth, mistralConversationsApi, modelsAreEqual, openAICodexResponsesApi, openAICompletionsApi, openAIResponsesApi, openaiCodexOAuth, piMessagesApi, pollOAuthDeviceCodeFlow, registerApiProvider, registerProvider, stream, streamSimple as streamSimpleOpenAIResponses, unregisterApiProviders, uuidv7 };
 //# sourceMappingURL=pi-ai.d.mts.map