@openrouter/sdk 0.0.1-beta.3 → 0.0.1-beta.5

package/lib/encodings.js

@@ -0,0 +1,353 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { bytesToBase64 } from "./base64.js";
+import { isPlainObject } from "./is-plain-object.js";
+export class EncodingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EncodingError";
+    }
+}
+export function encodeMatrix(key, value, options) {
+    let out = "";
+    const pairs = options?.explode
+        ? explode(key, value)
+        : [[key, value]];
+    if (pairs.every(([_, v]) => v == null)) {
+        return;
+    }
+    const encodeString = (v) => {
+        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    };
+    const encodeValue = (v) => encodeString(serializeValue(v));
+    pairs.forEach(([pk, pv]) => {
+        let tmp = "";
+        let encValue = null;
+        if (pv == null) {
+            return;
+        }
+        else if (Array.isArray(pv)) {
+            encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
+        }
+        else if (isPlainObject(pv)) {
+            const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+                return `,${encodeString(k)},${encodeValue(v)}`;
+            });
+            encValue = mapped?.join("").slice(1);
+        }
+        else {
+            encValue = `${encodeValue(pv)}`;
+        }
+        if (encValue == null) {
+            return;
+        }
+        const keyPrefix = encodeString(pk);
+        tmp = `${keyPrefix}=${encValue}`;
+        // trim trailing '=' if value was empty
+        if (tmp === `${keyPrefix}=`) {
+            tmp = tmp.slice(0, -1);
+        }
+        // If we end up with the nothing then skip forward
+        if (!tmp) {
+            return;
+        }
+        out += `;${tmp}`;
+    });
+    return out;
+}
+export function encodeLabel(key, value, options) {
+    let out = "";
+    const pairs = options?.explode
+        ? explode(key, value)
+        : [[key, value]];
+    if (pairs.every(([_, v]) => v == null)) {
+        return;
+    }
+    const encodeString = (v) => {
+        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    };
+    const encodeValue = (v) => encodeString(serializeValue(v));
+    pairs.forEach(([pk, pv]) => {
+        let encValue = "";
+        if (pv == null) {
+            return;
+        }
+        else if (Array.isArray(pv)) {
+            encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(".");
+        }
+        else if (isPlainObject(pv)) {
+            const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+                return `.${encodeString(k)}.${encodeValue(v)}`;
+            });
+            encValue = mapped?.join("").slice(1);
+        }
+        else {
+            const k = options?.explode && isPlainObject(value) ? `${encodeString(pk)}=` : "";
+            encValue = `${k}${encodeValue(pv)}`;
+        }
+        out += encValue == null ? "" : `.${encValue}`;
+    });
+    return out;
+}
+function formEncoder(sep) {
+    return (key, value, options) => {
+        let out = "";
+        const pairs = options?.explode
+            ? explode(key, value)
+            : [[key, value]];
+        if (pairs.every(([_, v]) => v == null)) {
+            return;
+        }
+        const encodeString = (v) => {
+            return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        };
+        const encodeValue = (v) => encodeString(serializeValue(v));
+        const encodedSep = encodeString(sep);
+        pairs.forEach(([pk, pv]) => {
+            let tmp = "";
+            let encValue = null;
+            if (pv == null) {
+                return;
+            }
+            else if (Array.isArray(pv)) {
+                encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(encodedSep);
+            }
+            else if (isPlainObject(pv)) {
+                encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+                    return `${encodeString(k)}${encodedSep}${encodeValue(v)}`;
+                })?.join(encodedSep);
+            }
+            else {
+                encValue = `${encodeValue(pv)}`;
+            }
+            if (encValue == null) {
+                return;
+            }
+            tmp = `${encodeString(pk)}=${encValue}`;
+            // If we end up with the nothing then skip forward
+            if (!tmp || tmp === "=") {
+                return;
+            }
+            out += `&${tmp}`;
+        });
+        return out.slice(1);
+    };
+}
+export const encodeForm = formEncoder(",");
+export const encodeSpaceDelimited = formEncoder(" ");
+export const encodePipeDelimited = formEncoder("|");
+export function encodeBodyForm(key, value, options) {
+    let out = "";
+    const pairs = options?.explode
+        ? explode(key, value)
+        : [[key, value]];
+    const encodeString = (v) => {
+        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    };
+    const encodeValue = (v) => encodeString(serializeValue(v));
+    pairs.forEach(([pk, pv]) => {
+        let tmp = "";
+        let encValue = "";
+        if (pv == null) {
+            return;
+        }
+        else if (Array.isArray(pv)) {
+            encValue = JSON.stringify(pv, jsonReplacer);
+        }
+        else if (isPlainObject(pv)) {
+            encValue = JSON.stringify(pv, jsonReplacer);
+        }
+        else {
+            encValue = `${encodeValue(pv)}`;
+        }
+        tmp = `${encodeString(pk)}=${encValue}`;
+        // If we end up with the nothing then skip forward
+        if (!tmp || tmp === "=") {
+            return;
+        }
+        out += `&${tmp}`;
+    });
+    return out.slice(1);
+}
+export function encodeDeepObject(key, value, options) {
+    if (value == null) {
+        return;
+    }
+    if (!isPlainObject(value)) {
+        throw new EncodingError(`Value of parameter '${key}' which uses deepObject encoding must be an object or null`);
+    }
+    return encodeDeepObjectObject(key, value, options);
+}
+export function encodeDeepObjectObject(key, value, options) {
+    if (value == null) {
+        return;
+    }
+    let out = "";
+    const encodeString = (v) => {
+        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    };
+    if (!isPlainObject(value)) {
+        throw new EncodingError(`Expected parameter '${key}' to be an object.`);
+    }
+    Object.entries(value).forEach(([ck, cv]) => {
+        if (cv == null) {
+            return;
+        }
+        const pk = `${key}[${ck}]`;
+        if (isPlainObject(cv)) {
+            const objOut = encodeDeepObjectObject(pk, cv, options);
+            out += objOut == null ? "" : `&${objOut}`;
+            return;
+        }
+        const pairs = Array.isArray(cv) ? cv : [cv];
+        const encoded = mapDefined(pairs, (v) => {
+            return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+        })?.join("&");
+        out += encoded == null ? "" : `&${encoded}`;
+    });
+    return out.slice(1);
+}
+export function encodeJSON(key, value, options) {
+    if (typeof value === "undefined") {
+        return;
+    }
+    const encodeString = (v) => {
+        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    };
+    const encVal = encodeString(JSON.stringify(value, jsonReplacer));
+    return options?.explode ? encVal : `${encodeString(key)}=${encVal}`;
+}
+export const encodeSimple = (key, value, options) => {
+    let out = "";
+    const pairs = options?.explode
+        ? explode(key, value)
+        : [[key, value]];
+    if (pairs.every(([_, v]) => v == null)) {
+        return;
+    }
+    const encodeString = (v) => {
+        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+    };
+    const encodeValue = (v) => encodeString(serializeValue(v));
+    pairs.forEach(([pk, pv]) => {
+        let tmp = "";
+        if (pv == null) {
+            return;
+        }
+        else if (Array.isArray(pv)) {
+            tmp = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
+        }
+        else if (isPlainObject(pv)) {
+            const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+                return `,${encodeString(k)},${encodeValue(v)}`;
+            });
+            tmp = mapped?.join("").slice(1);
+        }
+        else {
+            const k = options?.explode && isPlainObject(value) ? `${pk}=` : "";
+            tmp = `${k}${encodeValue(pv)}`;
+        }
+        out += tmp ? `,${tmp}` : "";
+    });
+    return out.slice(1);
+};
+function explode(key, value) {
+    if (Array.isArray(value)) {
+        return value.map((v) => [key, v]);
+    }
+    else if (isPlainObject(value)) {
+        const o = value ?? {};
+        return Object.entries(o).map(([k, v]) => [k, v]);
+    }
+    else {
+        return [[key, value]];
+    }
+}
+function serializeValue(value) {
+    if (value == null) {
+        return "";
+    }
+    else if (value instanceof Date) {
+        return value.toISOString();
+    }
+    else if (value instanceof Uint8Array) {
+        return bytesToBase64(value);
+    }
+    else if (typeof value === "object") {
+        return JSON.stringify(value, jsonReplacer);
+    }
+    return `${value}`;
+}
+function jsonReplacer(_, value) {
+    if (value instanceof Uint8Array) {
+        return bytesToBase64(value);
+    }
+    else {
+        return value;
+    }
+}
+function mapDefined(inp, mapper) {
+    const res = inp.reduce((acc, v) => {
+        if (v == null) {
+            return acc;
+        }
+        const m = mapper(v);
+        if (m == null) {
+            return acc;
+        }
+        acc.push(m);
+        return acc;
+    }, []);
+    return res.length ? res : null;
+}
+function mapDefinedEntries(inp, mapper) {
+    const acc = [];
+    for (const [k, v] of inp) {
+        if (v == null) {
+            continue;
+        }
+        const m = mapper([k, v]);
+        if (m == null) {
+            continue;
+        }
+        acc.push(m);
+    }
+    return acc.length ? acc : null;
+}
+export function queryJoin(...args) {
+    return args.filter(Boolean).join("&");
+}
+export function queryEncoder(f) {
+    const bulkEncode = function (values, options) {
+        const opts = {
+            ...options,
+            explode: options?.explode ?? true,
+            charEncoding: options?.charEncoding ?? "percent",
+        };
+        const encoded = Object.entries(values).map(([key, value]) => {
+            return f(key, value, opts);
+        });
+        return queryJoin(...encoded);
+    };
+    return bulkEncode;
+}
+export const encodeJSONQuery = queryEncoder(encodeJSON);
+export const encodeFormQuery = queryEncoder(encodeForm);
+export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
+export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
+export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+export function appendForm(fd, key, value, fileName) {
+    if (value == null) {
+        return;
+    }
+    else if (value instanceof Blob && fileName) {
+        fd.append(key, value, fileName);
+    }
+    else if (value instanceof Blob) {
+        fd.append(key, value);
+    }
+    else {
+        fd.append(key, String(value));
+    }
+}

package/lib/env.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v3";
+export interface Env {
+    OPENROUTER_API_KEY?: string | undefined;
+    OPENROUTER_DEBUG?: boolean | undefined;
+}
+export declare const envSchema: z.ZodType<Env, z.ZodTypeDef, unknown>;
+/**
+ * Reads and validates environment variables.
+ */
+export declare function env(): Env;
+/**
+ * Clears the cached env object. Useful for testing with a fresh environment.
+ */
+export declare function resetEnv(): void;

package/lib/env.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { dlv } from "./dlv.js";
+export const envSchema = z.object({
+    OPENROUTER_API_KEY: z.string().optional(),
+    OPENROUTER_DEBUG: z.coerce.boolean().optional(),
+});
+/**
+ * Checks for the existence of the Deno global object to determine the environment.
+ * @returns {boolean} True if the runtime is Deno, false otherwise.
+ */
+function isDeno() {
+    if ("Deno" in globalThis) {
+        return true;
+    }
+    return false;
+}
+let envMemo = undefined;
+/**
+ * Reads and validates environment variables.
+ */
+export function env() {
+    if (envMemo) {
+        return envMemo;
+    }
+    let envObject = {};
+    if (isDeno()) {
+        envObject = globalThis.Deno?.env?.toObject?.() ?? {};
+    }
+    else {
+        envObject = dlv(globalThis, "process.env") ?? {};
+    }
+    envMemo = envSchema.parse(envObject);
+    return envMemo;
+}
+/**
+ * Clears the cached env object. Useful for testing with a fresh environment.
+ */
+export function resetEnv() {
+    envMemo = undefined;
+}

package/lib/event-streams.d.ts

@@ -0,0 +1,10 @@
+export type SseMessage<T> = {
+    data?: T | undefined;
+    event?: string | undefined;
+    id?: string | undefined;
+    retry?: number | undefined;
+};
+export declare class EventStream<T extends SseMessage<unknown>> extends ReadableStream<T> {
+    constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>);
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/lib/event-streams.js

@@ -0,0 +1,124 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export class EventStream extends ReadableStream {
+    constructor(responseBody, parse) {
+        const upstream = responseBody.getReader();
+        let buffer = new Uint8Array();
+        super({
+            async pull(downstream) {
+                try {
+                    while (true) {
+                        const match = findBoundary(buffer);
+                        if (!match) {
+                            const chunk = await upstream.read();
+                            if (chunk.done)
+                                return downstream.close();
+                            buffer = concatBuffer(buffer, chunk.value);
+                            continue;
+                        }
+                        const message = buffer.slice(0, match.index);
+                        buffer = buffer.slice(match.index + match.length);
+                        const item = parseMessage(message, parse);
+                        if (item?.value)
+                            return downstream.enqueue(item.value);
+                        if (item?.done) {
+                            await upstream.cancel("done");
+                            return downstream.close();
+                        }
+                    }
+                }
+                catch (e) {
+                    downstream.error(e);
+                    await upstream.cancel(e);
+                }
+            },
+            cancel: reason => upstream.cancel(reason),
+        });
+    }
+    // Polyfill for older browsers
+    [Symbol.asyncIterator]() {
+        const fn = ReadableStream.prototype[Symbol.asyncIterator];
+        if (typeof fn === "function")
+            return fn.call(this);
+        const reader = this.getReader();
+        return {
+            next: async () => {
+                const r = await reader.read();
+                if (r.done) {
+                    reader.releaseLock();
+                    return { done: true, value: undefined };
+                }
+                return { done: false, value: r.value };
+            },
+            throw: async (e) => {
+                await reader.cancel(e);
+                reader.releaseLock();
+                return { done: true, value: undefined };
+            },
+            return: async () => {
+                await reader.cancel("done");
+                reader.releaseLock();
+                return { done: true, value: undefined };
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
+}
+function concatBuffer(a, b) {
+    const c = new Uint8Array(a.length + b.length);
+    c.set(a, 0);
+    c.set(b, a.length);
+    return c;
+}
+/** Finds the first (CR,LF,CR,LF) or (CR,CR) or (LF,LF) */
+function findBoundary(buf) {
+    const len = buf.length;
+    for (let i = 0; i < len; i++) {
+        if (i <= len - 4
+            && buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13
+            && buf[i + 3] === 10) {
+            return { index: i, length: 4 };
+        }
+        if (i <= len - 2 && buf[i] === 13 && buf[i + 1] === 13) {
+            return { index: i, length: 2 };
+        }
+        if (i <= len - 2 && buf[i] === 10 && buf[i + 1] === 10) {
+            return { index: i, length: 2 };
+        }
+    }
+    return null;
+}
+function parseMessage(chunk, parse) {
+    const text = new TextDecoder().decode(chunk);
+    const lines = text.split(/\r\n|\r|\n/);
+    const dataLines = [];
+    const ret = {};
+    let ignore = true;
+    for (const line of lines) {
+        if (!line || line.startsWith(":"))
+            continue;
+        ignore = false;
+        const i = line.indexOf(":");
+        const field = line.slice(0, i);
+        const value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+        if (field === "data")
+            dataLines.push(value);
+        else if (field === "event")
+            ret.event = value;
+        else if (field === "id")
+            ret.id = value;
+        else if (field === "retry") {
+            const n = Number(value);
+            if (!isNaN(n))
+                ret.retry = n;
+        }
+    }
+    if (ignore)
+        return;
+    if (dataLines.length)
+        ret.data = dataLines.join("\n");
+    return parse(ret);
+}

package/lib/files.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Consumes a stream and returns a concatenated array buffer. Useful in
+ * situations where we need to read the whole file because it forms part of a
+ * larger payload containing other fields, and we can't modify the underlying
+ * request structure.
+ */
+export declare function readableStreamToArrayBuffer(readable: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
+/**
+ * Determines the MIME content type based on a file's extension.
+ * Returns null if the extension is not recognized.
+ */
+export declare function getContentTypeFromFileName(fileName: string): string | null;

package/lib/files.js

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+/**
+ * Consumes a stream and returns a concatenated array buffer. Useful in
+ * situations where we need to read the whole file because it forms part of a
+ * larger payload containing other fields, and we can't modify the underlying
+ * request structure.
+ */
+export async function readableStreamToArrayBuffer(readable) {
+    const reader = readable.getReader();
+    const chunks = [];
+    let totalLength = 0;
+    let done = false;
+    while (!done) {
+        const { value, done: doneReading } = await reader.read();
+        if (doneReading) {
+            done = true;
+        }
+        else {
+            chunks.push(value);
+            totalLength += value.length;
+        }
+    }
+    const concatenatedChunks = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        concatenatedChunks.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return concatenatedChunks.buffer;
+}
+/**
+ * Determines the MIME content type based on a file's extension.
+ * Returns null if the extension is not recognized.
+ */
+export function getContentTypeFromFileName(fileName) {
+    if (!fileName)
+        return null;
+    const ext = fileName.toLowerCase().split(".").pop();
+    if (!ext)
+        return null;
+    const mimeTypes = {
+        json: "application/json",
+        xml: "application/xml",
+        html: "text/html",
+        htm: "text/html",
+        txt: "text/plain",
+        csv: "text/csv",
+        pdf: "application/pdf",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        js: "application/javascript",
+        css: "text/css",
+        zip: "application/zip",
+        tar: "application/x-tar",
+        gz: "application/gzip",
+        mp4: "video/mp4",
+        mp3: "audio/mpeg",
+        wav: "audio/wav",
+        webp: "image/webp",
+        ico: "image/x-icon",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        ttf: "font/ttf",
+        otf: "font/otf",
+    };
+    return mimeTypes[ext] || null;
+}

package/lib/http.d.ts

@@ -0,0 +1,66 @@
+export type Fetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type Awaitable<T> = T | Promise<T>;
+export type RequestInput = {
+    /**
+     * The URL the request will use.
+     */
+    url: URL;
+    /**
+     * Options used to create a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).
+     */
+    options?: RequestInit | undefined;
+};
+export interface HTTPClientOptions {
+    fetcher?: Fetcher;
+}
+export type BeforeRequestHook = (req: Request) => Awaitable<Request | void>;
+export type RequestErrorHook = (err: unknown, req: Request) => Awaitable<void>;
+export type ResponseHook = (res: Response, req: Request) => Awaitable<void>;
+export declare class HTTPClient {
+    private options;
+    private fetcher;
+    private requestHooks;
+    private requestErrorHooks;
+    private responseHooks;
+    constructor(options?: HTTPClientOptions);
+    request(request: Request): Promise<Response>;
+    /**
+     * Registers a hook that is called before a request is made. The hook function
+     * can mutate the request or return a new request. This may be useful to add
+     * additional information to request such as request IDs and tracing headers.
+     */
+    addHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
+    /**
+     * Registers a hook that is called when a request cannot be made due to a
+     * network error.
+     */
+    addHook(hook: "requestError", fn: RequestErrorHook): this;
+    /**
+     * Registers a hook that is called when a response has been received from the
+     * server.
+     */
+    addHook(hook: "response", fn: ResponseHook): this;
+    /** Removes a hook that was previously registered with `addHook`. */
+    removeHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
+    /** Removes a hook that was previously registered with `addHook`. */
+    removeHook(hook: "requestError", fn: RequestErrorHook): this;
+    /** Removes a hook that was previously registered with `addHook`. */
+    removeHook(hook: "response", fn: ResponseHook): this;
+    clone(): HTTPClient;
+}
+export type StatusCodePredicate = number | string | (number | string)[];
+export declare function matchContentType(response: Response, pattern: string): boolean;
+export declare function matchStatusCode(response: Response, codes: StatusCodePredicate): boolean;
+export declare function matchResponse(response: Response, code: StatusCodePredicate, contentTypePattern: string): boolean;
+/**
+ * Uses various heurisitics to determine if an error is a connection error.
+ */
+export declare function isConnectionError(err: unknown): boolean;
+/**
+ * Uses various heurisitics to determine if an error is a timeout error.
+ */
+export declare function isTimeoutError(err: unknown): boolean;
+/**
+ * Uses various heurisitics to determine if an error is a abort error.
+ */
+export declare function isAbortError(err: unknown): boolean;