@openrouter/sdk 0.0.1-beta.7 → 0.0.1-beta.8

package/lib/matchers.js

@@ -1,202 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-import { OpenRouterDefaultError } from "../models/errors/openrouterdefaulterror.js";
-import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
-import { ERR, OK } from "../types/fp.js";
-import { matchResponse, matchStatusCode } from "./http.js";
-import { isPlainObject } from "./is-plain-object.js";
-const DEFAULT_CONTENT_TYPES = {
-    jsonl: "application/jsonl",
-    json: "application/json",
-    text: "text/plain",
-    bytes: "application/octet-stream",
-    stream: "application/octet-stream",
-    sse: "text/event-stream",
-    nil: "*",
-    fail: "*",
-};
-export function jsonErr(codes, schema, options) {
-    return { ...options, err: true, enc: "json", codes, schema };
-}
-export function json(codes, schema, options) {
-    return { ...options, enc: "json", codes, schema };
-}
-export function jsonl(codes, schema, options) {
-    return { ...options, enc: "jsonl", codes, schema };
-}
-export function jsonlErr(codes, schema, options) {
-    return { ...options, err: true, enc: "jsonl", codes, schema };
-}
-export function textErr(codes, schema, options) {
-    return { ...options, err: true, enc: "text", codes, schema };
-}
-export function text(codes, schema, options) {
-    return { ...options, enc: "text", codes, schema };
-}
-export function bytesErr(codes, schema, options) {
-    return { ...options, err: true, enc: "bytes", codes, schema };
-}
-export function bytes(codes, schema, options) {
-    return { ...options, enc: "bytes", codes, schema };
-}
-export function streamErr(codes, schema, options) {
-    return { ...options, err: true, enc: "stream", codes, schema };
-}
-export function stream(codes, schema, options) {
-    return { ...options, enc: "stream", codes, schema };
-}
-export function sseErr(codes, schema, options) {
-    return { ...options, err: true, enc: "sse", codes, schema };
-}
-export function sse(codes, schema, options) {
-    return { ...options, enc: "sse", codes, schema };
-}
-export function nilErr(codes, schema, options) {
-    return { ...options, err: true, enc: "nil", codes, schema };
-}
-export function nil(codes, schema, options) {
-    return { ...options, enc: "nil", codes, schema };
-}
-export function fail(codes) {
-    return { enc: "fail", codes };
-}
-export function match(...matchers) {
-    return async function matchFunc(response, request, options) {
-        let raw;
-        let matcher;
-        for (const match of matchers) {
-            const { codes } = match;
-            const ctpattern = "ctype" in match
-                ? match.ctype
-                : DEFAULT_CONTENT_TYPES[match.enc];
-            if (ctpattern && matchResponse(response, codes, ctpattern)) {
-                matcher = match;
-                break;
-            }
-            else if (!ctpattern && matchStatusCode(response, codes)) {
-                matcher = match;
-                break;
-            }
-        }
-        if (!matcher) {
-            return [{
-                    ok: false,
-                    error: new OpenRouterDefaultError("Unexpected Status or Content-Type", {
-                        response,
-                        request,
-                        body: await response.text().catch(() => ""),
-                    }),
-                }, raw];
-        }
-        const encoding = matcher.enc;
-        let body = "";
-        switch (encoding) {
-            case "json":
-                body = await response.text();
-                raw = JSON.parse(body);
-                break;
-            case "jsonl":
-                raw = response.body;
-                break;
-            case "bytes":
-                raw = new Uint8Array(await response.arrayBuffer());
-                break;
-            case "stream":
-                raw = response.body;
-                break;
-            case "text":
-                body = await response.text();
-                raw = body;
-                break;
-            case "sse":
-                raw = response.body;
-                break;
-            case "nil":
-                body = await response.text();
-                raw = undefined;
-                break;
-            case "fail":
-                body = await response.text();
-                raw = body;
-                break;
-            default:
-                encoding;
-                throw new Error(`Unsupported response type: ${encoding}`);
-        }
-        if (matcher.enc === "fail") {
-            return [{
-                    ok: false,
-                    error: new OpenRouterDefaultError("API error occurred", {
-                        request,
-                        response,
-                        body,
-                    }),
-                }, raw];
-        }
-        const resultKey = matcher.key || options?.resultKey;
-        let data;
-        if ("err" in matcher) {
-            data = {
-                ...options?.extraFields,
-                ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-                ...(isPlainObject(raw) ? raw : null),
-                request$: request,
-                response$: response,
-                body$: body,
-            };
-        }
-        else if (resultKey) {
-            data = {
-                ...options?.extraFields,
-                ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-                [resultKey]: raw,
-            };
-        }
-        else if (matcher.hdrs) {
-            data = {
-                ...options?.extraFields,
-                ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-                ...(isPlainObject(raw) ? raw : null),
-            };
-        }
-        else {
-            data = raw;
-        }
-        if ("err" in matcher) {
-            const result = safeParseResponse(data, (v) => matcher.schema.parse(v), "Response validation failed", { request, response, body });
-            return [result.ok ? { ok: false, error: result.value } : result, raw];
-        }
-        else {
-            return [
-                safeParseResponse(data, (v) => matcher.schema.parse(v), "Response validation failed", { request, response, body }),
-                raw,
-            ];
-        }
-    };
-}
-const headerValRE = /, */;
-/**
- * Iterates over a Headers object and returns an object with all the header
- * entries. Values are represented as an array to account for repeated headers.
- */
-export function unpackHeaders(headers) {
-    const out = {};
-    for (const [k, v] of headers.entries()) {
-        out[k] = v.split(headerValRE);
-    }
-    return out;
-}
-function safeParseResponse(rawValue, fn, errorMessage, httpMeta) {
-    try {
-        return OK(fn(rawValue));
-    }
-    catch (err) {
-        return ERR(new ResponseValidationError(errorMessage, {
-            cause: err,
-            rawValue,
-            rawMessage: errorMessage,
-            ...httpMeta,
-        }));
-    }
-}

package/lib/primitives.d.ts

@@ -1,25 +0,0 @@
-export declare function invariant(condition: unknown, message: string): asserts condition;
-export type ExactPartial<T> = {
-    [P in keyof T]?: T[P] | undefined;
-};
-export type Remap<Inp, Mapping extends {
-    [k in keyof Inp]?: string | null;
-}> = {
-    [k in keyof Inp as Mapping[k] extends string ? Mapping[k] : Mapping[k] extends null ? never : k]: Inp[k];
-};
-/**
- * Converts or omits an object's keys according to a mapping.
- *
- * @param inp An object whose keys will be remapped
- * @param mappings A mapping of original keys to new keys. If a key is not present in the mapping, it will be left as is. If a key is mapped to `null`, it will be removed in the resulting object.
- * @returns A new object with keys remapped or omitted according to the mappings
- */
-export declare function remap<Inp extends Record<string, unknown>, const Mapping extends {
-    [k in keyof Inp]?: string | null;
-}>(inp: Inp, mappings: Mapping): Remap<Inp, Mapping>;
-export declare function combineSignals(...signals: Array<AbortSignal | null | undefined>): AbortSignal | null;
-export declare function abortSignalAny(signals: AbortSignal[]): AbortSignal;
-export declare function compactMap<T>(values: Record<string, T | undefined>): Record<string, T>;
-export declare function allRequired<V extends Record<string, unknown>>(v: V): {
-    [K in keyof V]: NonNullable<V[K]>;
-} | undefined;

package/lib/primitives.js

@@ -1,102 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-class InvariantError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InvariantError";
-    }
-}
-export function invariant(condition, message) {
-    if (!condition) {
-        throw new InvariantError(message);
-    }
-}
-/**
- * Converts or omits an object's keys according to a mapping.
- *
- * @param inp An object whose keys will be remapped
- * @param mappings A mapping of original keys to new keys. If a key is not present in the mapping, it will be left as is. If a key is mapped to `null`, it will be removed in the resulting object.
- * @returns A new object with keys remapped or omitted according to the mappings
- */
-export function remap(inp, mappings) {
-    let out = {};
-    if (!Object.keys(mappings).length) {
-        out = inp;
-        return out;
-    }
-    for (const [k, v] of Object.entries(inp)) {
-        const j = mappings[k];
-        if (j === null) {
-            continue;
-        }
-        out[j ?? k] = v;
-    }
-    return out;
-}
-export function combineSignals(...signals) {
-    const filtered = [];
-    for (const signal of signals) {
-        if (signal) {
-            filtered.push(signal);
-        }
-    }
-    switch (filtered.length) {
-        case 0:
-        case 1:
-            return filtered[0] || null;
-        default:
-            if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
-                return AbortSignal.any(filtered);
-            }
-            return abortSignalAny(filtered);
-    }
-}
-export function abortSignalAny(signals) {
-    const controller = new AbortController();
-    const result = controller.signal;
-    if (!signals.length) {
-        return controller.signal;
-    }
-    if (signals.length === 1) {
-        return signals[0] || controller.signal;
-    }
-    for (const signal of signals) {
-        if (signal.aborted) {
-            return signal;
-        }
-    }
-    function abort() {
-        controller.abort(this.reason);
-        clean();
-    }
-    const signalRefs = [];
-    function clean() {
-        for (const signalRef of signalRefs) {
-            const signal = signalRef.deref();
-            if (signal) {
-                signal.removeEventListener("abort", abort);
-            }
-        }
-    }
-    for (const signal of signals) {
-        signalRefs.push(new WeakRef(signal));
-        signal.addEventListener("abort", abort);
-    }
-    return result;
-}
-export function compactMap(values) {
-    const out = {};
-    for (const [k, v] of Object.entries(values)) {
-        if (typeof v !== "undefined") {
-            out[k] = v;
-        }
-    }
-    return out;
-}
-export function allRequired(v) {
-    if (Object.values(v).every((x) => x == null)) {
-        return void 0;
-    }
-    return v;
-}

package/lib/retries.d.ts

@@ -1,37 +0,0 @@
-export type BackoffStrategy = {
-    initialInterval: number;
-    maxInterval: number;
-    exponent: number;
-    maxElapsedTime: number;
-};
-export type RetryConfig = {
-    strategy: "none";
-} | {
-    strategy: "backoff";
-    backoff?: BackoffStrategy;
-    retryConnectionErrors?: boolean;
-};
-/**
- * PermanentError is an error that is not recoverable. Throwing this error will
- * cause a retry loop to terminate.
- */
-export declare class PermanentError extends Error {
-    /** The underlying cause of the error. */
-    readonly cause: unknown;
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * TemporaryError is an error is used to signal that an HTTP request can be
- * retried as part of a retry loop. If retry attempts are exhausted and this
- * error is thrown, the response will be returned to the caller.
- */
-export declare class TemporaryError extends Error {
-    response: Response;
-    constructor(message: string, response: Response);
-}
-export declare function retry(fetchFn: () => Promise<Response>, options: {
-    config: RetryConfig;
-    statusCodes: string[];
-}): Promise<Response>;

package/lib/retries.js

@@ -1,146 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-import { isConnectionError, isTimeoutError } from "./http.js";
-const defaultBackoff = {
-    initialInterval: 500,
-    maxInterval: 60000,
-    exponent: 1.5,
-    maxElapsedTime: 3600000,
-};
-/**
- * PermanentError is an error that is not recoverable. Throwing this error will
- * cause a retry loop to terminate.
- */
-export class PermanentError extends Error {
-    constructor(message, options) {
-        let msg = message;
-        if (options?.cause) {
-            msg += `: ${options.cause}`;
-        }
-        super(msg, options);
-        this.name = "PermanentError";
-        // In older runtimes, the cause field would not have been assigned through
-        // the super() call.
-        if (typeof this.cause === "undefined") {
-            this.cause = options?.cause;
-        }
-        Object.setPrototypeOf(this, PermanentError.prototype);
-    }
-}
-/**
- * TemporaryError is an error is used to signal that an HTTP request can be
- * retried as part of a retry loop. If retry attempts are exhausted and this
- * error is thrown, the response will be returned to the caller.
- */
-export class TemporaryError extends Error {
-    constructor(message, response) {
-        super(message);
-        this.response = response;
-        this.name = "TemporaryError";
-        Object.setPrototypeOf(this, TemporaryError.prototype);
-    }
-}
-export async function retry(fetchFn, options) {
-    switch (options.config.strategy) {
-        case "backoff":
-            return retryBackoff(wrapFetcher(fetchFn, {
-                statusCodes: options.statusCodes,
-                retryConnectionErrors: !!options.config.retryConnectionErrors,
-            }), options.config.backoff ?? defaultBackoff);
-        default:
-            return await fetchFn();
-    }
-}
-function wrapFetcher(fn, options) {
-    return async () => {
-        try {
-            const res = await fn();
-            if (isRetryableResponse(res, options.statusCodes)) {
-                throw new TemporaryError("Response failed with retryable status code", res);
-            }
-            return res;
-        }
-        catch (err) {
-            if (err instanceof TemporaryError) {
-                throw err;
-            }
-            if (options.retryConnectionErrors &&
-                (isTimeoutError(err) || isConnectionError(err))) {
-                throw err;
-            }
-            throw new PermanentError("Permanent error", { cause: err });
-        }
-    };
-}
-const codeRangeRE = new RegExp("^[0-9]xx$", "i");
-function isRetryableResponse(res, statusCodes) {
-    const actual = `${res.status}`;
-    return statusCodes.some((code) => {
-        if (!codeRangeRE.test(code)) {
-            return code === actual;
-        }
-        const expectFamily = code.charAt(0);
-        if (!expectFamily) {
-            throw new Error("Invalid status code range");
-        }
-        const actualFamily = actual.charAt(0);
-        if (!actualFamily) {
-            throw new Error(`Invalid response status code: ${actual}`);
-        }
-        return actualFamily === expectFamily;
-    });
-}
-async function retryBackoff(fn, strategy) {
-    const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
-    const start = Date.now();
-    let x = 0;
-    while (true) {
-        try {
-            const res = await fn();
-            return res;
-        }
-        catch (err) {
-            if (err instanceof PermanentError) {
-                throw err.cause;
-            }
-            const elapsed = Date.now() - start;
-            if (elapsed > maxElapsedTime) {
-                if (err instanceof TemporaryError) {
-                    return err.response;
-                }
-                throw err;
-            }
-            let retryInterval = 0;
-            if (err instanceof TemporaryError) {
-                retryInterval = retryIntervalFromResponse(err.response);
-            }
-            if (retryInterval <= 0) {
-                retryInterval =
-                    initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
-            }
-            const d = Math.min(retryInterval, maxInterval);
-            await delay(d);
-            x++;
-        }
-    }
-}
-function retryIntervalFromResponse(res) {
-    const retryVal = res.headers.get("retry-after") || "";
-    if (!retryVal) {
-        return 0;
-    }
-    const parsedNumber = Number(retryVal);
-    if (Number.isInteger(parsedNumber)) {
-        return parsedNumber * 1000;
-    }
-    const parsedDate = Date.parse(retryVal);
-    if (Number.isInteger(parsedDate)) {
-        const deltaMS = parsedDate - Date.now();
-        return deltaMS > 0 ? Math.ceil(deltaMS) : 0;
-    }
-    return 0;
-}
-async function delay(delay) {
-    return new Promise((resolve) => setTimeout(resolve, delay));
-}

package/lib/schemas.d.ts

@@ -1,20 +0,0 @@
-import * as z from "zod/v4";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { Result } from "../types/fp.js";
-/**
- * Utility function that executes some code which may throw a ZodError. It
- * intercepts this error and converts it to an SDKValidationError so as to not
- * leak Zod implementation details to user code.
- */
-export declare function parse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMessage: string): Out;
-/**
- * Utility function that executes some code which may result in a ZodError. It
- * intercepts this error and converts it to an SDKValidationError so as to not
- * leak Zod implementation details to user code.
- */
-export declare function safeParse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMessage: string): Result<Out, SDKValidationError>;
-export declare function collectExtraKeys<Shape extends z.ZodRawShape, Catchall extends z.ZodType, K extends string, Optional extends boolean>(obj: z.ZodObject<Shape, z.core.$catchall<Catchall>>, extrasKey: K, optional: Optional): z.ZodPipe<z.ZodObject<Shape, z.core.$catchall<Catchall>>, z.ZodTransform<z.output<z.ZodObject<Shape, z.core.$strip>> & (Optional extends true ? {
-    [k in K]: Record<string, z.output<Catchall>>;
-} : {
-    [k in K]?: Record<string, z.output<Catchall>> | undefined;
-}), z.output<z.ZodObject<Shape, z.core.$catchall<Catchall>>>>>;

package/lib/schemas.js

@@ -1,56 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-import { ZodError } from "zod/v4";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { ERR, OK } from "../types/fp.js";
-/**
- * Utility function that executes some code which may throw a ZodError. It
- * intercepts this error and converts it to an SDKValidationError so as to not
- * leak Zod implementation details to user code.
- */
-export function parse(rawValue, fn, errorMessage) {
-    try {
-        return fn(rawValue);
-    }
-    catch (err) {
-        if (err instanceof ZodError) {
-            throw new SDKValidationError(errorMessage, err, rawValue);
-        }
-        throw err;
-    }
-}
-/**
- * Utility function that executes some code which may result in a ZodError. It
- * intercepts this error and converts it to an SDKValidationError so as to not
- * leak Zod implementation details to user code.
- */
-export function safeParse(rawValue, fn, errorMessage) {
-    try {
-        return OK(fn(rawValue));
-    }
-    catch (err) {
-        return ERR(new SDKValidationError(errorMessage, err, rawValue));
-    }
-}
-export function collectExtraKeys(obj, extrasKey, optional) {
-    return obj.transform((val) => {
-        const extras = {};
-        const { shape } = obj;
-        for (const [key] of Object.entries(val)) {
-            if (key in shape) {
-                continue;
-            }
-            const v = val[key];
-            if (typeof v === "undefined") {
-                continue;
-            }
-            extras[key] = v;
-            delete val[key];
-        }
-        if (optional && Object.keys(extras).length === 0) {
-            return val;
-        }
-        return { ...val, [extrasKey]: extras };
-    });
-}

package/lib/sdks.d.ts

@@ -1,62 +0,0 @@
-import { SDKHooks } from "../hooks/hooks.js";
-import { HookContext } from "../hooks/types.js";
-import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
-import { Result } from "../types/fp.js";
-import { SDKOptions } from "./config.js";
-import { RetryConfig } from "./retries.js";
-import { SecurityState } from "./security.js";
-export type RequestOptions = {
-    /**
-     * Sets a timeout, in milliseconds, on HTTP requests made by an SDK method. If
-     * `fetchOptions.signal` is set then it will take precedence over this option.
-     */
-    timeoutMs?: number;
-    /**
-     * Set or override a retry policy on HTTP calls.
-     */
-    retries?: RetryConfig;
-    /**
-     * Specifies the status codes which should be retried using the given retry policy.
-     */
-    retryCodes?: string[];
-    /**
-     * Overrides the base server URL that will be used by an operation.
-     */
-    serverURL?: string | URL;
-    /**
-     * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
-     *
-     * Sets various request options on the `fetch` call made by an SDK method.
-     *
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
-     */
-    fetchOptions?: Omit<RequestInit, "method" | "body">;
-} & Omit<RequestInit, "method" | "body">;
-type RequestConfig = {
-    method: string;
-    path: string;
-    baseURL?: string | URL | undefined;
-    query?: string;
-    body?: RequestInit["body"];
-    headers?: HeadersInit;
-    security?: SecurityState | null;
-    uaHeader?: string;
-    userAgent?: string | undefined;
-    timeoutMs?: number;
-};
-export declare class ClientSDK {
-    #private;
-    readonly _baseURL: URL | null;
-    readonly _options: SDKOptions & {
-        hooks?: SDKHooks;
-    };
-    constructor(options?: SDKOptions);
-    _createRequest(context: HookContext, conf: RequestConfig, options?: RequestOptions): Result<Request, InvalidRequestError | UnexpectedClientError>;
-    _do(request: Request, options: {
-        context: HookContext;
-        errorCodes: number | string | (number | string)[];
-        retryConfig: RetryConfig;
-        retryCodes: string[];
-    }): Promise<Result<Response, RequestAbortedError | RequestTimeoutError | ConnectionError | UnexpectedClientError>>;
-}
-export {};