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

package/src/react-query/{parametersGetParametersAuthorSlug.ts → modelGetParametersAuthorSlug.ts}

@@ -13,7 +13,7 @@ import {
   UseSuspenseQueryResult,
 } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
-import { parametersGetParametersAuthorSlug } from "../funcs/parametersGetParametersAuthorSlug.js";
+import { modelGetParametersAuthorSlug } from "../funcs/modelGetParametersAuthorSlug.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
@@ -25,20 +25,22 @@ import {
   TupleToPrefixes,
 } from "./_types.js";
 
-export type ParametersGetParametersAuthorSlugQueryData =
+export type ModelGetParametersAuthorSlugQueryData =
   operations.GetParametersAuthorSlugResponse;
 
 /**
  * Get a model's supported parameters and data about which are most popular
  */
-export function useParametersGetParametersAuthorSlug(
+export function useModelGetParametersAuthorSlug(
+  security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
-  options?: QueryHookOptions<ParametersGetParametersAuthorSlugQueryData>,
-): UseQueryResult<ParametersGetParametersAuthorSlugQueryData, Error> {
+  options?: QueryHookOptions<ModelGetParametersAuthorSlugQueryData>,
+): UseQueryResult<ModelGetParametersAuthorSlugQueryData, Error> {
   const client = useOpenRouterContext();
   return useQuery({
-    ...buildParametersGetParametersAuthorSlugQuery(
+    ...buildModelGetParametersAuthorSlugQuery(
       client,
+      security,
       request,
       options,
     ),
@@ -49,16 +51,16 @@ export function useParametersGetParametersAuthorSlug(
 /**
  * Get a model's supported parameters and data about which are most popular
  */
-export function useParametersGetParametersAuthorSlugSuspense(
+export function useModelGetParametersAuthorSlugSuspense(
+  security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
-  options?: SuspenseQueryHookOptions<
-    ParametersGetParametersAuthorSlugQueryData
-  >,
-): UseSuspenseQueryResult<ParametersGetParametersAuthorSlugQueryData, Error> {
+  options?: SuspenseQueryHookOptions<ModelGetParametersAuthorSlugQueryData>,
+): UseSuspenseQueryResult<ModelGetParametersAuthorSlugQueryData, Error> {
   const client = useOpenRouterContext();
   return useSuspenseQuery({
-    ...buildParametersGetParametersAuthorSlugQuery(
+    ...buildModelGetParametersAuthorSlugQuery(
       client,
+      security,
       request,
       options,
     ),
@@ -66,20 +68,22 @@ export function useParametersGetParametersAuthorSlugSuspense(
   });
 }
 
-export function prefetchParametersGetParametersAuthorSlug(
+export function prefetchModelGetParametersAuthorSlug(
   queryClient: QueryClient,
   client$: OpenRouterCore,
+  security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
 ): Promise<void> {
   return queryClient.prefetchQuery({
-    ...buildParametersGetParametersAuthorSlugQuery(
+    ...buildModelGetParametersAuthorSlugQuery(
       client$,
+      security,
       request,
     ),
   });
 }
 
-export function setParametersGetParametersAuthorSlugData(
+export function setModelGetParametersAuthorSlugData(
   client: QueryClient,
   queryKeyBase: [
     author: string,
@@ -88,17 +92,14 @@ export function setParametersGetParametersAuthorSlugData(
       provider?: operations.GetParametersAuthorSlugProvider | undefined;
     },
   ],
-  data: ParametersGetParametersAuthorSlugQueryData,
-): ParametersGetParametersAuthorSlugQueryData | undefined {
-  const key = queryKeyParametersGetParametersAuthorSlug(...queryKeyBase);
+  data: ModelGetParametersAuthorSlugQueryData,
+): ModelGetParametersAuthorSlugQueryData | undefined {
+  const key = queryKeyModelGetParametersAuthorSlug(...queryKeyBase);
 
-  return client.setQueryData<ParametersGetParametersAuthorSlugQueryData>(
-    key,
-    data,
-  );
+  return client.setQueryData<ModelGetParametersAuthorSlugQueryData>(key, data);
 }
 
-export function invalidateParametersGetParametersAuthorSlug(
+export function invalidateModelGetParametersAuthorSlug(
   client: QueryClient,
   queryKeyBase: TupleToPrefixes<
     [
@@ -115,50 +116,52 @@ export function invalidateParametersGetParametersAuthorSlug(
     ...filters,
     queryKey: [
       "@openrouter/sdk",
-      "Parameters",
+      "Model",
       "getParametersAuthorSlug",
       ...queryKeyBase,
     ],
   });
 }
 
-export function invalidateAllParametersGetParametersAuthorSlug(
+export function invalidateAllModelGetParametersAuthorSlug(
   client: QueryClient,
   filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
 ): Promise<void> {
   return client.invalidateQueries({
     ...filters,
-    queryKey: ["@openrouter/sdk", "Parameters", "getParametersAuthorSlug"],
+    queryKey: ["@openrouter/sdk", "Model", "getParametersAuthorSlug"],
   });
 }
 
-export function buildParametersGetParametersAuthorSlugQuery(
+export function buildModelGetParametersAuthorSlugQuery(
   client$: OpenRouterCore,
+  security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
   options?: RequestOptions,
 ): {
   queryKey: QueryKey;
   queryFn: (
     context: QueryFunctionContext,
-  ) => Promise<ParametersGetParametersAuthorSlugQueryData>;
+  ) => Promise<ModelGetParametersAuthorSlugQueryData>;
 } {
   return {
-    queryKey: queryKeyParametersGetParametersAuthorSlug(
+    queryKey: queryKeyModelGetParametersAuthorSlug(
       request.author,
       request.slug,
       { provider: request.provider },
     ),
-    queryFn: async function parametersGetParametersAuthorSlugQueryFn(
+    queryFn: async function modelGetParametersAuthorSlugQueryFn(
       ctx,
-    ): Promise<ParametersGetParametersAuthorSlugQueryData> {
+    ): Promise<ModelGetParametersAuthorSlugQueryData> {
       const sig = combineSignals(ctx.signal, options?.fetchOptions?.signal);
       const mergedOptions = {
         ...options,
         fetchOptions: { ...options?.fetchOptions, signal: sig },
       };
 
-      return unwrapAsync(parametersGetParametersAuthorSlug(
+      return unwrapAsync(modelGetParametersAuthorSlug(
         client$,
+        security,
         request,
         mergedOptions,
       ));
@@ -166,7 +169,7 @@ export function buildParametersGetParametersAuthorSlugQuery(
   };
 }
 
-export function queryKeyParametersGetParametersAuthorSlug(
+export function queryKeyModelGetParametersAuthorSlug(
   author: string,
   slug: string,
   parameters: {
@@ -175,7 +178,7 @@ export function queryKeyParametersGetParametersAuthorSlug(
 ): QueryKey {
   return [
     "@openrouter/sdk",
-    "Parameters",
+    "Model",
     "getParametersAuthorSlug",
     author,
     slug,

package/src/react-query/modelsGetModelsUser.ts

@@ -27,12 +27,14 @@ export type ModelsGetModelsUserQueryData = operations.GetModelsUserResponse;
  * List models filtered by user provider preferences
  */
 export function useModelsGetModelsUser(
+  security: operations.GetModelsUserSecurity,
   options?: QueryHookOptions<ModelsGetModelsUserQueryData>,
 ): UseQueryResult<ModelsGetModelsUserQueryData, Error> {
   const client = useOpenRouterContext();
   return useQuery({
     ...buildModelsGetModelsUserQuery(
       client,
+      security,
       options,
     ),
     ...options,
@@ -43,12 +45,14 @@ export function useModelsGetModelsUser(
  * List models filtered by user provider preferences
  */
 export function useModelsGetModelsUserSuspense(
+  security: operations.GetModelsUserSecurity,
   options?: SuspenseQueryHookOptions<ModelsGetModelsUserQueryData>,
 ): UseSuspenseQueryResult<ModelsGetModelsUserQueryData, Error> {
   const client = useOpenRouterContext();
   return useSuspenseQuery({
     ...buildModelsGetModelsUserQuery(
       client,
+      security,
       options,
     ),
     ...options,
@@ -58,10 +62,12 @@ export function useModelsGetModelsUserSuspense(
 export function prefetchModelsGetModelsUser(
   queryClient: QueryClient,
   client$: OpenRouterCore,
+  security: operations.GetModelsUserSecurity,
 ): Promise<void> {
   return queryClient.prefetchQuery({
     ...buildModelsGetModelsUserQuery(
       client$,
+      security,
     ),
   });
 }
@@ -87,6 +93,7 @@ export function invalidateAllModelsGetModelsUser(
 
 export function buildModelsGetModelsUserQuery(
   client$: OpenRouterCore,
+  security: operations.GetModelsUserSecurity,
   options?: RequestOptions,
 ): {
   queryKey: QueryKey;
@@ -107,6 +114,7 @@ export function buildModelsGetModelsUserQuery(
 
       return unwrapAsync(modelsGetModelsUser(
         client$,
+        security,
         mergedOptions,
       ));
     },

package/src/react-query/oAuthPostAuthKeys.ts

@@ -0,0 +1,88 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { OpenRouterCore } from "../core.js";
+import { oAuthPostAuthKeys } from "../funcs/oAuthPostAuthKeys.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useOpenRouterContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type OAuthPostAuthKeysMutationVariables = {
+  request?: operations.PostAuthKeysRequest | undefined;
+  options?: RequestOptions;
+};
+
+export type OAuthPostAuthKeysMutationData = operations.PostAuthKeysResponse;
+
+/**
+ * Exchange authorization code for API key
+ *
+ * @remarks
+ * Exchange an authorization code from the PKCE flow for a user-controlled API key
+ */
+export function useOAuthPostAuthKeysMutation(
+  options?: MutationHookOptions<
+    OAuthPostAuthKeysMutationData,
+    Error,
+    OAuthPostAuthKeysMutationVariables
+  >,
+): UseMutationResult<
+  OAuthPostAuthKeysMutationData,
+  Error,
+  OAuthPostAuthKeysMutationVariables
+> {
+  const client = useOpenRouterContext();
+  return useMutation({
+    ...buildOAuthPostAuthKeysMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyOAuthPostAuthKeys(): MutationKey {
+  return ["@openrouter/sdk", "OAuth", "postAuthKeys"];
+}
+
+export function buildOAuthPostAuthKeysMutation(
+  client$: OpenRouterCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: OAuthPostAuthKeysMutationVariables,
+  ) => Promise<OAuthPostAuthKeysMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyOAuthPostAuthKeys(),
+    mutationFn: function oAuthPostAuthKeysMutationFn({
+      request,
+      options,
+    }): Promise<OAuthPostAuthKeysMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(oAuthPostAuthKeys(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/oAuthPostAuthKeysCode.ts

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { OpenRouterCore } from "../core.js";
+import { oAuthPostAuthKeysCode } from "../funcs/oAuthPostAuthKeysCode.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useOpenRouterContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type OAuthPostAuthKeysCodeMutationVariables = {
+  request?: operations.PostAuthKeysCodeRequest | undefined;
+  options?: RequestOptions;
+};
+
+export type OAuthPostAuthKeysCodeMutationData =
+  operations.PostAuthKeysCodeResponse;
+
+/**
+ * Create authorization code
+ *
+ * @remarks
+ * Create an authorization code for the PKCE flow to generate a user-controlled API key
+ */
+export function useOAuthPostAuthKeysCodeMutation(
+  options?: MutationHookOptions<
+    OAuthPostAuthKeysCodeMutationData,
+    Error,
+    OAuthPostAuthKeysCodeMutationVariables
+  >,
+): UseMutationResult<
+  OAuthPostAuthKeysCodeMutationData,
+  Error,
+  OAuthPostAuthKeysCodeMutationVariables
+> {
+  const client = useOpenRouterContext();
+  return useMutation({
+    ...buildOAuthPostAuthKeysCodeMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyOAuthPostAuthKeysCode(): MutationKey {
+  return ["@openrouter/sdk", "OAuth", "postAuthKeysCode"];
+}
+
+export function buildOAuthPostAuthKeysCodeMutation(
+  client$: OpenRouterCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: OAuthPostAuthKeysCodeMutationVariables,
+  ) => Promise<OAuthPostAuthKeysCodeMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyOAuthPostAuthKeysCode(),
+    mutationFn: function oAuthPostAuthKeysCodeMutationFn({
+      request,
+      options,
+    }): Promise<OAuthPostAuthKeysCodeMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(oAuthPostAuthKeysCode(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/{getProviders.ts → providersGetProviders.ts}

@@ -13,7 +13,7 @@ import {
   UseSuspenseQueryResult,
 } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
-import { getProviders } from "../funcs/getProviders.js";
+import { providersGetProviders } from "../funcs/providersGetProviders.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
@@ -21,14 +21,17 @@ import { unwrapAsync } from "../types/fp.js";
 import { useOpenRouterContext } from "./_context.js";
 import { QueryHookOptions, SuspenseQueryHookOptions } from "./_types.js";
 
-export type GetProvidersQueryData = operations.GetProvidersResponse;
+export type ProvidersGetProvidersQueryData = operations.GetProvidersResponse;
 
-export function useGetProviders(
-  options?: QueryHookOptions<GetProvidersQueryData>,
-): UseQueryResult<GetProvidersQueryData, Error> {
+/**
+ * List all available model providers
+ */
+export function useProvidersGetProviders(
+  options?: QueryHookOptions<ProvidersGetProvidersQueryData>,
+): UseQueryResult<ProvidersGetProvidersQueryData, Error> {
   const client = useOpenRouterContext();
   return useQuery({
-    ...buildGetProvidersQuery(
+    ...buildProvidersGetProvidersQuery(
       client,
       options,
     ),
@@ -36,12 +39,15 @@ export function useGetProviders(
   });
 }
 
-export function useGetProvidersSuspense(
-  options?: SuspenseQueryHookOptions<GetProvidersQueryData>,
-): UseSuspenseQueryResult<GetProvidersQueryData, Error> {
+/**
+ * List all available model providers
+ */
+export function useProvidersGetProvidersSuspense(
+  options?: SuspenseQueryHookOptions<ProvidersGetProvidersQueryData>,
+): UseSuspenseQueryResult<ProvidersGetProvidersQueryData, Error> {
   const client = useOpenRouterContext();
   return useSuspenseQuery({
-    ...buildGetProvidersQuery(
+    ...buildProvidersGetProvidersQuery(
       client,
       options,
     ),
@@ -49,55 +55,57 @@ export function useGetProvidersSuspense(
   });
 }
 
-export function prefetchGetProviders(
+export function prefetchProvidersGetProviders(
   queryClient: QueryClient,
   client$: OpenRouterCore,
 ): Promise<void> {
   return queryClient.prefetchQuery({
-    ...buildGetProvidersQuery(
+    ...buildProvidersGetProvidersQuery(
       client$,
     ),
   });
 }
 
-export function setGetProvidersData(
+export function setProvidersGetProvidersData(
   client: QueryClient,
-  data: GetProvidersQueryData,
-): GetProvidersQueryData | undefined {
-  const key = queryKeyGetProviders();
+  data: ProvidersGetProvidersQueryData,
+): ProvidersGetProvidersQueryData | undefined {
+  const key = queryKeyProvidersGetProviders();
 
-  return client.setQueryData<GetProvidersQueryData>(key, data);
+  return client.setQueryData<ProvidersGetProvidersQueryData>(key, data);
 }
 
-export function invalidateAllGetProviders(
+export function invalidateAllProvidersGetProviders(
   client: QueryClient,
   filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
 ): Promise<void> {
   return client.invalidateQueries({
     ...filters,
-    queryKey: ["@openrouter/sdk", "getProviders"],
+    queryKey: ["@openrouter/sdk", "Providers", "getProviders"],
   });
 }
 
-export function buildGetProvidersQuery(
+export function buildProvidersGetProvidersQuery(
   client$: OpenRouterCore,
   options?: RequestOptions,
 ): {
   queryKey: QueryKey;
-  queryFn: (context: QueryFunctionContext) => Promise<GetProvidersQueryData>;
+  queryFn: (
+    context: QueryFunctionContext,
+  ) => Promise<ProvidersGetProvidersQueryData>;
 } {
   return {
-    queryKey: queryKeyGetProviders(),
-    queryFn: async function getProvidersQueryFn(
+    queryKey: queryKeyProvidersGetProviders(),
+    queryFn: async function providersGetProvidersQueryFn(
       ctx,
-    ): Promise<GetProvidersQueryData> {
+    ): Promise<ProvidersGetProvidersQueryData> {
       const sig = combineSignals(ctx.signal, options?.fetchOptions?.signal);
       const mergedOptions = {
         ...options,
         fetchOptions: { ...options?.fetchOptions, signal: sig },
       };
 
-      return unwrapAsync(getProviders(
+      return unwrapAsync(providersGetProviders(
         client$,
         mergedOptions,
       ));
@@ -105,6 +113,6 @@ export function buildGetProvidersQuery(
   };
 }
 
-export function queryKeyGetProviders(): QueryKey {
-  return ["@openrouter/sdk", "getProviders"];
+export function queryKeyProvidersGetProviders(): QueryKey {
+  return ["@openrouter/sdk", "Providers", "getProviders"];
 }

package/src/sdk/chat.ts

@@ -2,31 +2,26 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import {
-  chatGenerateResponse,
-  GenerateResponseAcceptEnum,
-} from "../funcs/chatGenerateResponse.js";
+import { chatSend, SendAcceptEnum } from "../funcs/chatSend.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
-export { GenerateResponseAcceptEnum } from "../funcs/chatGenerateResponse.js";
+export { SendAcceptEnum } from "../funcs/chatSend.js";
 
 export class Chat extends ClientSDK {
   /**
    * Create a chat completion
    *
    * @remarks
-   * Creates a model response for the given chat conversation. Supports both streaming and non-streaming modes.
+   * Sends a request for a model response for the given chat conversation. Supports both streaming and non-streaming modes.
    */
-  async generateResponse(
+  async send(
     request?: models.ChatGenerationParams | undefined,
-    options?: RequestOptions & {
-      acceptHeaderOverride?: GenerateResponseAcceptEnum;
-    },
+    options?: RequestOptions & { acceptHeaderOverride?: SendAcceptEnum },
   ): Promise<operations.PostChatCompletionsResponse> {
-    return unwrapAsync(chatGenerateResponse(
+    return unwrapAsync(chatSend(
       this,
       request,
       options,

package/src/sdk/completions.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  completionsCreate,
+  CreateAcceptEnum,
+} from "../funcs/completionsCreate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export { CreateAcceptEnum } from "../funcs/completionsCreate.js";
+
+export class Completions extends ClientSDK {
+  /**
+   * Create a completion
+   *
+   * @remarks
+   * Creates a completion for the provided prompt and parameters. Supports both streaming and non-streaming modes.
+   */
+  async create(
+    request?: models.CompletionCreateParams | undefined,
+    options?: RequestOptions & { acceptHeaderOverride?: CreateAcceptEnum },
+  ): Promise<operations.PostCompletionsResponse> {
+    return unwrapAsync(completionsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/credits.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { creditsGetCredits } from "../funcs/creditsGetCredits.js";
+import { creditsPostCreditsCoinbase } from "../funcs/creditsPostCreditsCoinbase.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Credits extends ClientSDK {
+  /**
+   * Get total credits purchased and used for the authenticated user
+   */
+  async getCredits(
+    options?: RequestOptions,
+  ): Promise<operations.GetCreditsResponse> {
+    return unwrapAsync(creditsGetCredits(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Create a Coinbase charge for crypto payment
+   */
+  async postCreditsCoinbase(
+    security: operations.PostCreditsCoinbaseSecurity,
+    request?: operations.PostCreditsCoinbaseRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.PostCreditsCoinbaseResponse> {
+    return unwrapAsync(creditsPostCreditsCoinbase(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+}