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

package/esm/funcs/oAuthCreateSHA256CodeChallenge.js

@@ -0,0 +1,69 @@
+import z from "zod/v3";
+const CreateSHA256CodeChallengeRequestSchema = z.object({
+    /**
+     * If not provided, a random code verifier will be generated.
+     * If provided, must be 43-128 characters and contain only unreserved
+     * characters [A-Za-z0-9-._~] per RFC 7636.
+     */
+    codeVerifier: z
+        .string()
+        .min(43, "Code verifier must be at least 43 characters")
+        .max(128, "Code verifier must be at most 128 characters")
+        .regex(/^[A-Za-z0-9\-._~]+$/, "Code verifier must only contain unreserved characters: [A-Za-z0-9-._~]")
+        .optional(),
+});
+/**
+ * Convert a Uint8Array to base64url encoding (RFC 4648)
+ */
+function arrayBufferToBase64Url(buffer) {
+    let binary = "";
+    for (let i = 0; i < buffer.length; i++) {
+        binary += String.fromCharCode(buffer[i]);
+    }
+    return btoa(binary)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+/**
+ * Generate a cryptographically random code verifier per RFC 7636
+ */
+function generateCodeVerifier() {
+    // RFC 7636 recommends 32 octets of random data, base64url encoded = 43 chars
+    const randomBytes = crypto.getRandomValues(new Uint8Array(32));
+    return arrayBufferToBase64Url(randomBytes);
+}
+/**
+ * Generate a SHA-256 code challenge for PKCE
+ *
+ * @remarks
+ * Generates a SHA-256 code challenge and corresponding code verifier for use
+ * in the PKCE extension to OAuth2. If no code verifier is provided, a random
+ * one will be generated according to RFC 7636 (32 random bytes, base64url
+ * encoded). If a code verifier is provided, it must be 43-128 characters and
+ * contain only unreserved characters [A-Za-z0-9-._~].
+ *
+ * @see {@link https://openrouter.ai/docs/use-cases/oauth-pkce}
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7636}
+ */
+export async function oAuthCreateSHA256CodeChallenge(params = {}) {
+    const parsedParams = CreateSHA256CodeChallengeRequestSchema.safeParse(params);
+    if (!parsedParams.success)
+        return { ok: false, error: parsedParams.error };
+    const { codeVerifier = generateCodeVerifier() } = parsedParams.data;
+    // Generate SHA-256 hash
+    const encoder = new TextEncoder();
+    const data = encoder.encode(codeVerifier);
+    const hash = await crypto.subtle.digest("SHA-256", data);
+    // Convert hash to base64url
+    const hashArray = new Uint8Array(hash);
+    const codeChallenge = arrayBufferToBase64Url(hashArray);
+    return {
+        ok: true,
+        value: {
+            codeChallenge,
+            codeVerifier,
+        },
+    };
+}
+//# sourceMappingURL=oAuthCreateSHA256CodeChallenge.js.map

package/esm/funcs/parametersGetParameters.d.ts

@@ -0,0 +1,15 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Get a model's supported parameters and data about which are most popular
+ */
+export declare function parametersGetParameters(client: OpenRouterCore, security: operations.GetParametersSecurity, request: operations.GetParametersRequest, options?: RequestOptions): APIPromise<Result<operations.GetParametersResponse, errors.ErrorResponse | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=parametersGetParameters.d.ts.map

package/esm/funcs/parametersGetParameters.js

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { resolveSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Get a model's supported parameters and data about which are most popular
+ */
+export function parametersGetParameters(client, security, request, options) {
+    return new APIPromise($do(client, security, request, options));
+}
+async function $do(client, security, request, options) {
+    const parsed = safeParse(request, (value) => operations.GetParametersRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = null;
+    const pathParams = {
+        author: encodeSimple("author", payload.author, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+        slug: encodeSimple("slug", payload.slug, {
+            explode: false,
+            charEncoding: "percent",
+        }),
+    };
+    const path = pathToFunc("/parameters/{author}/{slug}")(pathParams);
+    const query = encodeFormQuery({
+        "provider": payload.provider,
+    });
+    const headers = new Headers(compactMap({
+        Accept: "application/json",
+    }));
+    const requestSecurity = resolveSecurity([
+        {
+            fieldName: "Authorization",
+            type: "http:bearer",
+            value: security?.bearer,
+        },
+    ]);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "getParameters",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: security,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "GET",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        query: query,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["4XX", "5XX"],
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.GetParametersResponse$inboundSchema), M.jsonErr("4XX", errors.ErrorResponse$inboundSchema), M.jsonErr("5XX", errors.ErrorResponse$inboundSchema))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=parametersGetParameters.js.map

package/esm/funcs/providersList.d.ts

@@ -0,0 +1,15 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * List all providers
+ */
+export declare function providersList(client: OpenRouterCore, options?: RequestOptions): APIPromise<Result<operations.ListProvidersResponse, errors.InternalServerError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=providersList.d.ts.map

package/esm/funcs/providersList.js

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * List all providers
+ */
+export function providersList(client, options) {
+    return new APIPromise($do(client, options));
+}
+async function $do(client, options) {
+    const path = pathToFunc("/providers")();
+    const headers = new Headers(compactMap({
+        Accept: "application/json",
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "listProviders",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "GET",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["4XX", "500", "5XX"],
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.ListProvidersResponse$inboundSchema), M.jsonErr(500, errors.InternalServerError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=providersList.js.map

package/esm/hooks/hooks.d.ts

@@ -0,0 +1,25 @@
+import { SDKOptions } from "../lib/config.js";
+import { RequestInput } from "../lib/http.js";
+import { AfterErrorContext, AfterErrorHook, AfterSuccessContext, AfterSuccessHook, BeforeCreateRequestContext, BeforeCreateRequestHook, BeforeRequestContext, BeforeRequestHook, Hooks, SDKInitHook } from "./types.js";
+export declare class SDKHooks implements Hooks {
+    sdkInitHooks: SDKInitHook[];
+    beforeCreateRequestHooks: BeforeCreateRequestHook[];
+    beforeRequestHooks: BeforeRequestHook[];
+    afterSuccessHooks: AfterSuccessHook[];
+    afterErrorHooks: AfterErrorHook[];
+    constructor();
+    registerSDKInitHook(hook: SDKInitHook): void;
+    registerBeforeCreateRequestHook(hook: BeforeCreateRequestHook): void;
+    registerBeforeRequestHook(hook: BeforeRequestHook): void;
+    registerAfterSuccessHook(hook: AfterSuccessHook): void;
+    registerAfterErrorHook(hook: AfterErrorHook): void;
+    sdkInit(opts: SDKOptions): SDKOptions;
+    beforeCreateRequest(hookCtx: BeforeCreateRequestContext, input: RequestInput): RequestInput;
+    beforeRequest(hookCtx: BeforeRequestContext, request: Request): Promise<Request>;
+    afterSuccess(hookCtx: AfterSuccessContext, response: Response): Promise<Response>;
+    afterError(hookCtx: AfterErrorContext, response: Response | null, error: unknown): Promise<{
+        response: Response | null;
+        error: unknown;
+    }>;
+}
+//# sourceMappingURL=hooks.d.ts.map

package/esm/hooks/hooks.js

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { initHooks } from "./registration.js";
+export class SDKHooks {
+    constructor() {
+        this.sdkInitHooks = [];
+        this.beforeCreateRequestHooks = [];
+        this.beforeRequestHooks = [];
+        this.afterSuccessHooks = [];
+        this.afterErrorHooks = [];
+        const presetHooks = [];
+        for (const hook of presetHooks) {
+            if ("sdkInit" in hook) {
+                this.registerSDKInitHook(hook);
+            }
+            if ("beforeCreateRequest" in hook) {
+                this.registerBeforeCreateRequestHook(hook);
+            }
+            if ("beforeRequest" in hook) {
+                this.registerBeforeRequestHook(hook);
+            }
+            if ("afterSuccess" in hook) {
+                this.registerAfterSuccessHook(hook);
+            }
+            if ("afterError" in hook) {
+                this.registerAfterErrorHook(hook);
+            }
+        }
+        initHooks(this);
+    }
+    registerSDKInitHook(hook) {
+        this.sdkInitHooks.push(hook);
+    }
+    registerBeforeCreateRequestHook(hook) {
+        this.beforeCreateRequestHooks.push(hook);
+    }
+    registerBeforeRequestHook(hook) {
+        this.beforeRequestHooks.push(hook);
+    }
+    registerAfterSuccessHook(hook) {
+        this.afterSuccessHooks.push(hook);
+    }
+    registerAfterErrorHook(hook) {
+        this.afterErrorHooks.push(hook);
+    }
+    sdkInit(opts) {
+        return this.sdkInitHooks.reduce((opts, hook) => hook.sdkInit(opts), opts);
+    }
+    beforeCreateRequest(hookCtx, input) {
+        let inp = input;
+        for (const hook of this.beforeCreateRequestHooks) {
+            inp = hook.beforeCreateRequest(hookCtx, inp);
+        }
+        return inp;
+    }
+    async beforeRequest(hookCtx, request) {
+        let req = request;
+        for (const hook of this.beforeRequestHooks) {
+            req = await hook.beforeRequest(hookCtx, req);
+        }
+        return req;
+    }
+    async afterSuccess(hookCtx, response) {
+        let res = response;
+        for (const hook of this.afterSuccessHooks) {
+            res = await hook.afterSuccess(hookCtx, res);
+        }
+        return res;
+    }
+    async afterError(hookCtx, response, error) {
+        let res = response;
+        let err = error;
+        for (const hook of this.afterErrorHooks) {
+            const result = await hook.afterError(hookCtx, res, err);
+            res = result.response;
+            err = result.error;
+        }
+        return { response: res, error: err };
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/esm/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./hooks.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/hooks/index.js

@@ -0,0 +1,6 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export * from "./hooks.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/esm/hooks/registration.d.ts

@@ -0,0 +1,3 @@
+import { Hooks } from "./types.js";
+export declare function initHooks(hooks: Hooks): void;
+//# sourceMappingURL=registration.d.ts.map

package/esm/hooks/registration.js

@@ -0,0 +1,12 @@
+/*
+ * This file is only ever generated once on the first generation and then is free to be modified.
+ * Any hooks you wish to add should be registered in the initHooks function. Feel free to define them
+ * in this file or in separate files in the hooks folder.
+ */
+// @ts-expect-error remove this line when you add your first hook and hooks is used
+export function initHooks(hooks) {
+    // Add hooks by calling hooks.register{ClientInit/BeforeCreateRequest/BeforeRequest/AfterSuccess/AfterError}Hook
+    // with an instance of a hook that implements that specific Hook interface
+    // Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance
+}
+//# sourceMappingURL=registration.js.map

package/esm/hooks/types.d.ts

@@ -0,0 +1,76 @@
+import { SDKOptions } from "../lib/config.js";
+import { RequestInput } from "../lib/http.js";
+import { RetryConfig } from "../lib/retries.js";
+import { SecurityState } from "../lib/security.js";
+export type HookContext = {
+    baseURL: string | URL;
+    operationID: string;
+    oAuth2Scopes: string[] | null;
+    securitySource?: any | (() => Promise<any>);
+    retryConfig: RetryConfig;
+    resolvedSecurity: SecurityState | null;
+    options: SDKOptions;
+};
+export type Awaitable<T> = T | Promise<T>;
+export type BeforeCreateRequestContext = HookContext & {};
+export type BeforeRequestContext = HookContext & {};
+export type AfterSuccessContext = HookContext & {};
+export type AfterErrorContext = HookContext & {};
+/**
+ * SDKInitHook is called when the SDK is initializing. The
+ * hook can return a new baseURL and HTTP client to be used by the SDK.
+ */
+export interface SDKInitHook {
+    sdkInit: (opts: SDKOptions) => SDKOptions;
+}
+export interface BeforeCreateRequestHook {
+    /**
+     * A hook that is called before the SDK creates a `Request` object. The hook
+     * can modify how a request is constructed since certain modifications, like
+     * changing the request URL, cannot be done on a request object directly.
+     */
+    beforeCreateRequest: (hookCtx: BeforeCreateRequestContext, input: RequestInput) => RequestInput;
+}
+export interface BeforeRequestHook {
+    /**
+     * A hook that is called before the SDK sends a request. The hook can
+     * introduce instrumentation code such as logging, tracing and metrics or
+     * replace the request before it is sent or throw an error to stop the
+     * request from being sent.
+     */
+    beforeRequest: (hookCtx: BeforeRequestContext, request: Request) => Awaitable<Request>;
+}
+export interface AfterSuccessHook {
+    /**
+     * A hook that is called after the SDK receives a response. The hook can
+     * introduce instrumentation code such as logging, tracing and metrics or
+     * modify the response before it is handled or throw an error to stop the
+     * response from being handled.
+     */
+    afterSuccess: (hookCtx: AfterSuccessContext, response: Response) => Awaitable<Response>;
+}
+export interface AfterErrorHook {
+    /**
+     * A hook that is called after the SDK encounters an error, or a
+     * non-successful response. The hook can introduce instrumentation code such
+     * as logging, tracing and metrics or modify the response or error values.
+     */
+    afterError: (hookCtx: AfterErrorContext, response: Response | null, error: unknown) => Awaitable<{
+        response: Response | null;
+        error: unknown;
+    }>;
+}
+export interface Hooks {
+    /** Registers a hook to be used by the SDK for initialization event. */
+    registerSDKInitHook(hook: SDKInitHook): void;
+    /** Registers a hook to be used by the SDK for to modify `Request` construction. */
+    registerBeforeCreateRequestHook(hook: BeforeCreateRequestHook): void;
+    /** Registers a hook to be used by the SDK for the before request event. */
+    registerBeforeRequestHook(hook: BeforeRequestHook): void;
+    /** Registers a hook to be used by the SDK for the after success event. */
+    registerAfterSuccessHook(hook: AfterSuccessHook): void;
+    /** Registers a hook to be used by the SDK for the after error event. */
+    registerAfterErrorHook(hook: AfterErrorHook): void;
+}
+export type Hook = SDKInitHook | BeforeCreateRequestHook | BeforeRequestHook | AfterSuccessHook | AfterErrorHook;
+//# sourceMappingURL=types.d.ts.map

package/esm/hooks/types.js

@@ -0,0 +1,5 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/esm/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./lib/config.js";
+export * as files from "./lib/files.js";
+export { HTTPClient } from "./lib/http.js";
+export type { Fetcher, HTTPClientOptions } from "./lib/http.js";
+export * from "./sdk/sdk.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/index.js

@@ -0,0 +1,8 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export * from "./lib/config.js";
+export * as files from "./lib/files.js";
+export { HTTPClient } from "./lib/http.js";
+export * from "./sdk/sdk.js";
+//# sourceMappingURL=index.js.map

package/esm/lib/base64.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+export declare function bytesToBase64(u8arr: Uint8Array): string;
+export declare function bytesFromBase64(encoded: string): Uint8Array;
+export declare function stringToBytes(str: string): Uint8Array;
+export declare function stringFromBytes(u8arr: Uint8Array): string;
+export declare function stringToBase64(str: string): string;
+export declare function stringFromBase64(b64str: string): string;
+export declare const zodOutbound: z.ZodUnion<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>]>;
+export declare const zodInbound: z.ZodUnion<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>]>;
+//# sourceMappingURL=base64.d.ts.map

package/esm/lib/base64.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+export function bytesToBase64(u8arr) {
+    return btoa(String.fromCodePoint(...u8arr));
+}
+export function bytesFromBase64(encoded) {
+    return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+}
+export function stringToBytes(str) {
+    return new TextEncoder().encode(str);
+}
+export function stringFromBytes(u8arr) {
+    return new TextDecoder().decode(u8arr);
+}
+export function stringToBase64(str) {
+    return bytesToBase64(stringToBytes(str));
+}
+export function stringFromBase64(b64str) {
+    return stringFromBytes(bytesFromBase64(b64str));
+}
+export const zodOutbound = z
+    .instanceof(Uint8Array)
+    .or(z.string().transform(stringToBytes));
+export const zodInbound = z
+    .instanceof(Uint8Array)
+    .or(z.string().transform(bytesFromBase64));
+//# sourceMappingURL=base64.js.map

package/esm/lib/config.d.ts

@@ -0,0 +1,44 @@
+import { HTTPClient } from "./http.js";
+import { Logger } from "./logger.js";
+import { RetryConfig } from "./retries.js";
+/**
+ * Production server
+ */
+export declare const ServerProduction = "production";
+/**
+ * Contains the list of servers available to the SDK
+ */
+export declare const ServerList: {
+    readonly production: "https://openrouter.ai/api/v1";
+};
+export type SDKOptions = {
+    apiKey?: string | (() => Promise<string>) | undefined;
+    httpClient?: HTTPClient;
+    /**
+     * Allows overriding the default server used by the SDK
+     */
+    server?: keyof typeof ServerList | undefined;
+    /**
+     * Allows overriding the default server URL used by the SDK
+     */
+    serverURL?: string | undefined;
+    /**
+     * Allows overriding the default user agent used by the SDK
+     */
+    userAgent?: string | undefined;
+    /**
+     * Allows overriding the default retry config used by the SDK
+     */
+    retryConfig?: RetryConfig;
+    timeoutMs?: number;
+    debugLogger?: Logger;
+};
+export declare function serverURLFromOptions(options: SDKOptions): URL | null;
+export declare const SDK_METADATA: {
+    readonly language: "typescript";
+    readonly openapiDocVersion: "1.0.0";
+    readonly sdkVersion: "0.0.1-beta.8";
+    readonly genVersion: "2.730.0";
+    readonly userAgent: "speakeasy-sdk/typescript 0.0.1-beta.8 2.730.0 1.0.0 @openrouter/sdk";
+};
+//# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { pathToFunc } from "./url.js";
+/**
+ * Production server
+ */
+export const ServerProduction = "production";
+/**
+ * Contains the list of servers available to the SDK
+ */
+export const ServerList = {
+    [ServerProduction]: "https://openrouter.ai/api/v1",
+};
+export function serverURLFromOptions(options) {
+    let serverURL = options.serverURL;
+    const params = {};
+    if (!serverURL) {
+        const server = options.server ?? ServerProduction;
+        serverURL = ServerList[server] || "";
+    }
+    const u = pathToFunc(serverURL)(params);
+    return new URL(u);
+}
+export const SDK_METADATA = {
+    language: "typescript",
+    openapiDocVersion: "1.0.0",
+    sdkVersion: "0.0.1-beta.8",
+    genVersion: "2.730.0",
+    userAgent: "speakeasy-sdk/typescript 0.0.1-beta.8 2.730.0 1.0.0 @openrouter/sdk",
+};
+//# sourceMappingURL=config.js.map

package/esm/lib/dlv.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param obj The object to walk
+ * @param key The key path to walk the object with
+ * @param def A default value to return if the result is undefined
+ *
+ * @example
+ * dlv(obj, "a.b.c.d")
+ * @example
+ * dlv(object, ["a", "b", "c", "d"])
+ * @example
+ * dlv(object, "foo.bar.baz", "Hello, default value!")
+ */
+export declare function dlv<T = any>(obj: any, key: string | string[], def?: T, p?: number, undef?: never): T | undefined;
+//# sourceMappingURL=dlv.d.ts.map