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

package/src/models/operations/getparametersauthorslug.ts

@@ -10,10 +10,6 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
 
-export type GetParametersAuthorSlugSecurity = {
-  bearer: string;
-};
-
 export const GetParametersAuthorSlugProvider = {
   Ai21: "AI21",
   AionLabs: "AionLabs",
@@ -146,62 +142,6 @@ export type GetParametersAuthorSlugResponse =
   | GetParametersAuthorSlugResponseBody
   | models.ErrorResponse;
 
-/** @internal */
-export const GetParametersAuthorSlugSecurity$inboundSchema: z.ZodType<
-  GetParametersAuthorSlugSecurity,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  bearer: z.string(),
-});
-
-/** @internal */
-export type GetParametersAuthorSlugSecurity$Outbound = {
-  bearer: string;
-};
-
-/** @internal */
-export const GetParametersAuthorSlugSecurity$outboundSchema: z.ZodType<
-  GetParametersAuthorSlugSecurity$Outbound,
-  z.ZodTypeDef,
-  GetParametersAuthorSlugSecurity
-> = z.object({
-  bearer: z.string(),
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace GetParametersAuthorSlugSecurity$ {
-  /** @deprecated use `GetParametersAuthorSlugSecurity$inboundSchema` instead. */
-  export const inboundSchema = GetParametersAuthorSlugSecurity$inboundSchema;
-  /** @deprecated use `GetParametersAuthorSlugSecurity$outboundSchema` instead. */
-  export const outboundSchema = GetParametersAuthorSlugSecurity$outboundSchema;
-  /** @deprecated use `GetParametersAuthorSlugSecurity$Outbound` instead. */
-  export type Outbound = GetParametersAuthorSlugSecurity$Outbound;
-}
-
-export function getParametersAuthorSlugSecurityToJSON(
-  getParametersAuthorSlugSecurity: GetParametersAuthorSlugSecurity,
-): string {
-  return JSON.stringify(
-    GetParametersAuthorSlugSecurity$outboundSchema.parse(
-      getParametersAuthorSlugSecurity,
-    ),
-  );
-}
-
-export function getParametersAuthorSlugSecurityFromJSON(
-  jsonString: string,
-): SafeParseResult<GetParametersAuthorSlugSecurity, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GetParametersAuthorSlugSecurity$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetParametersAuthorSlugSecurity' from JSON`,
-  );
-}
-
 /** @internal */
 export const GetParametersAuthorSlugProvider$inboundSchema: z.ZodNativeEnum<
   typeof GetParametersAuthorSlugProvider

package/src/models/operations/index.ts

@@ -18,8 +18,6 @@ export * from "./getmodelsuser.js";
 export * from "./getparametersauthorslug.js";
 export * from "./getproviders.js";
 export * from "./patchkeyshash.js";
-export * from "./postauthkeys.js";
-export * from "./postauthkeyscode.js";
 export * from "./postchatcompletions.js";
 export * from "./postcreditscoinbase.js";
 export * from "./postembeddings.js";

package/src/models/operations/postchatcompletions.ts

@@ -10,8 +10,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
 
 export type PostChatCompletionsResponse =
-  | models.ChatResponse
-  | EventStream<models.ChatStreamingResponseChunk>;
+  | models.ChatCompletion
+  | EventStream<models.ChatCompletionChunk>;
 
 /** @internal */
 export const PostChatCompletionsResponse$inboundSchema: z.ZodType<
@@ -19,16 +19,14 @@ export const PostChatCompletionsResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  models.ChatResponse$inboundSchema,
+  models.ChatCompletion$inboundSchema,
   z
     .instanceof(ReadableStream<Uint8Array>)
     .transform(stream => {
       return new EventStream(stream, rawEvent => {
         if (rawEvent.data === "[DONE]") return { done: true };
         return {
-          value: models.ChatStreamingResponseChunk$inboundSchema.parse(
-            rawEvent,
-          ),
+          value: models.ChatCompletionChunk$inboundSchema.parse(rawEvent),
         };
       });
     }),
@@ -36,7 +34,7 @@ export const PostChatCompletionsResponse$inboundSchema: z.ZodType<
 
 /** @internal */
 export type PostChatCompletionsResponse$Outbound =
-  | models.ChatResponse$Outbound
+  | models.ChatCompletion$Outbound
   | never;
 
 /** @internal */
@@ -44,7 +42,7 @@ export const PostChatCompletionsResponse$outboundSchema: z.ZodType<
   PostChatCompletionsResponse$Outbound,
   z.ZodTypeDef,
   PostChatCompletionsResponse
-> = z.union([models.ChatResponse$outboundSchema, z.never()]);
+> = z.union([models.ChatCompletion$outboundSchema, z.never()]);
 
 /**
  * @internal

package/src/models/operations/postcreditscoinbase.ts

@@ -10,10 +10,6 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
 
-export type PostCreditsCoinbaseSecurity = {
-  bearer: string;
-};
-
 export const ChainId = {
   One: 1,
   OneHundredAndThirtySeven: 137,
@@ -73,62 +69,6 @@ export type PostCreditsCoinbaseResponse =
   | PostCreditsCoinbaseResponseBody
   | models.ErrorResponse;
 
-/** @internal */
-export const PostCreditsCoinbaseSecurity$inboundSchema: z.ZodType<
-  PostCreditsCoinbaseSecurity,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  bearer: z.string(),
-});
-
-/** @internal */
-export type PostCreditsCoinbaseSecurity$Outbound = {
-  bearer: string;
-};
-
-/** @internal */
-export const PostCreditsCoinbaseSecurity$outboundSchema: z.ZodType<
-  PostCreditsCoinbaseSecurity$Outbound,
-  z.ZodTypeDef,
-  PostCreditsCoinbaseSecurity
-> = z.object({
-  bearer: z.string(),
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace PostCreditsCoinbaseSecurity$ {
-  /** @deprecated use `PostCreditsCoinbaseSecurity$inboundSchema` instead. */
-  export const inboundSchema = PostCreditsCoinbaseSecurity$inboundSchema;
-  /** @deprecated use `PostCreditsCoinbaseSecurity$outboundSchema` instead. */
-  export const outboundSchema = PostCreditsCoinbaseSecurity$outboundSchema;
-  /** @deprecated use `PostCreditsCoinbaseSecurity$Outbound` instead. */
-  export type Outbound = PostCreditsCoinbaseSecurity$Outbound;
-}
-
-export function postCreditsCoinbaseSecurityToJSON(
-  postCreditsCoinbaseSecurity: PostCreditsCoinbaseSecurity,
-): string {
-  return JSON.stringify(
-    PostCreditsCoinbaseSecurity$outboundSchema.parse(
-      postCreditsCoinbaseSecurity,
-    ),
-  );
-}
-
-export function postCreditsCoinbaseSecurityFromJSON(
-  jsonString: string,
-): SafeParseResult<PostCreditsCoinbaseSecurity, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PostCreditsCoinbaseSecurity$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PostCreditsCoinbaseSecurity' from JSON`,
-  );
-}
-
 /** @internal */
 export const ChainId$inboundSchema: z.ZodNativeEnum<typeof ChainId> = z
   .nativeEnum(ChainId);

package/src/models/security.ts

@@ -8,7 +8,8 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export type Security = {
-  apiKey?: string | undefined;
+  apiKeyAuth?: string | undefined;
+  bearerAuth?: string | undefined;
 };
 
 /** @internal */
@@ -17,12 +18,14 @@ export const Security$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  apiKey: z.string().optional(),
+  apiKeyAuth: z.string().optional(),
+  bearerAuth: z.string().optional(),
 });
 
 /** @internal */
 export type Security$Outbound = {
-  apiKey?: string | undefined;
+  apiKeyAuth?: string | undefined;
+  bearerAuth?: string | undefined;
 };
 
 /** @internal */
@@ -31,7 +34,8 @@ export const Security$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Security
 > = z.object({
-  apiKey: z.string().optional(),
+  apiKeyAuth: z.string().optional(),
+  bearerAuth: z.string().optional(),
 });
 
 /**

package/src/models/toolmessage.ts

@@ -0,0 +1,140 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  ChatMessageContentItem,
+  ChatMessageContentItem$inboundSchema,
+  ChatMessageContentItem$Outbound,
+  ChatMessageContentItem$outboundSchema,
+} from "./chatmessagecontentitem.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ToolMessageContent = string | Array<ChatMessageContentItem>;
+
+export type ToolMessage = {
+  role: "tool";
+  content: string | Array<ChatMessageContentItem>;
+  toolCallId: string;
+};
+
+/** @internal */
+export const ToolMessageContent$inboundSchema: z.ZodType<
+  ToolMessageContent,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]);
+
+/** @internal */
+export type ToolMessageContent$Outbound =
+  | string
+  | Array<ChatMessageContentItem$Outbound>;
+
+/** @internal */
+export const ToolMessageContent$outboundSchema: z.ZodType<
+  ToolMessageContent$Outbound,
+  z.ZodTypeDef,
+  ToolMessageContent
+> = z.union([z.string(), z.array(ChatMessageContentItem$outboundSchema)]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ToolMessageContent$ {
+  /** @deprecated use `ToolMessageContent$inboundSchema` instead. */
+  export const inboundSchema = ToolMessageContent$inboundSchema;
+  /** @deprecated use `ToolMessageContent$outboundSchema` instead. */
+  export const outboundSchema = ToolMessageContent$outboundSchema;
+  /** @deprecated use `ToolMessageContent$Outbound` instead. */
+  export type Outbound = ToolMessageContent$Outbound;
+}
+
+export function toolMessageContentToJSON(
+  toolMessageContent: ToolMessageContent,
+): string {
+  return JSON.stringify(
+    ToolMessageContent$outboundSchema.parse(toolMessageContent),
+  );
+}
+
+export function toolMessageContentFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolMessageContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolMessageContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolMessageContent' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolMessage$inboundSchema: z.ZodType<
+  ToolMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  role: z.literal("tool"),
+  content: z.union([z.string(), z.array(ChatMessageContentItem$inboundSchema)]),
+  tool_call_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_call_id": "toolCallId",
+  });
+});
+
+/** @internal */
+export type ToolMessage$Outbound = {
+  role: "tool";
+  content: string | Array<ChatMessageContentItem$Outbound>;
+  tool_call_id: string;
+};
+
+/** @internal */
+export const ToolMessage$outboundSchema: z.ZodType<
+  ToolMessage$Outbound,
+  z.ZodTypeDef,
+  ToolMessage
+> = z.object({
+  role: z.literal("tool"),
+  content: z.union([
+    z.string(),
+    z.array(ChatMessageContentItem$outboundSchema),
+  ]),
+  toolCallId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCallId: "tool_call_id",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ToolMessage$ {
+  /** @deprecated use `ToolMessage$inboundSchema` instead. */
+  export const inboundSchema = ToolMessage$inboundSchema;
+  /** @deprecated use `ToolMessage$outboundSchema` instead. */
+  export const outboundSchema = ToolMessage$outboundSchema;
+  /** @deprecated use `ToolMessage$Outbound` instead. */
+  export type Outbound = ToolMessage$Outbound;
+}
+
+export function toolMessageToJSON(toolMessage: ToolMessage): string {
+  return JSON.stringify(ToolMessage$outboundSchema.parse(toolMessage));
+}
+
+export function toolMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolMessage' from JSON`,
+  );
+}

package/src/react-query/{chatSend.ts → chatGenerateResponse.ts}

@@ -8,7 +8,10 @@ import {
   UseMutationResult,
 } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
-import { chatSend, SendAcceptEnum } from "../funcs/chatSend.js";
+import {
+  chatGenerateResponse,
+  GenerateResponseAcceptEnum,
+} from "../funcs/chatGenerateResponse.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
@@ -17,54 +20,61 @@ import { unwrapAsync } from "../types/fp.js";
 import { useOpenRouterContext } from "./_context.js";
 import { MutationHookOptions } from "./_types.js";
 
-export { SendAcceptEnum } from "../funcs/chatSend.js";
+export { GenerateResponseAcceptEnum } from "../funcs/chatGenerateResponse.js";
 
-export type ChatSendMutationVariables = {
+export type ChatGenerateResponseMutationVariables = {
   request?: models.ChatGenerationParams | undefined;
-  options?: RequestOptions & { acceptHeaderOverride?: SendAcceptEnum };
+  options?: RequestOptions & {
+    acceptHeaderOverride?: GenerateResponseAcceptEnum;
+  };
 };
 
-export type ChatSendMutationData = operations.PostChatCompletionsResponse;
+export type ChatGenerateResponseMutationData =
+  operations.PostChatCompletionsResponse;
 
 /**
  * Create a chat completion
  *
  * @remarks
- * Sends a request for a model response for the given chat conversation. Supports both streaming and non-streaming modes.
+ * Creates a model response for the given chat conversation. Supports both streaming and non-streaming modes.
  */
-export function useChatSendMutation(
+export function useChatGenerateResponseMutation(
   options?: MutationHookOptions<
-    ChatSendMutationData,
+    ChatGenerateResponseMutationData,
     Error,
-    ChatSendMutationVariables
+    ChatGenerateResponseMutationVariables
   >,
-): UseMutationResult<ChatSendMutationData, Error, ChatSendMutationVariables> {
+): UseMutationResult<
+  ChatGenerateResponseMutationData,
+  Error,
+  ChatGenerateResponseMutationVariables
+> {
   const client = useOpenRouterContext();
   return useMutation({
-    ...buildChatSendMutation(client, options),
+    ...buildChatGenerateResponseMutation(client, options),
     ...options,
   });
 }
 
-export function mutationKeyChatSend(): MutationKey {
-  return ["@openrouter/sdk", "chat", "send"];
+export function mutationKeyChatGenerateResponse(): MutationKey {
+  return ["@openrouter/sdk", "chat", "generateResponse"];
 }
 
-export function buildChatSendMutation(
+export function buildChatGenerateResponseMutation(
   client$: OpenRouterCore,
   hookOptions?: RequestOptions,
 ): {
   mutationKey: MutationKey;
   mutationFn: (
-    variables: ChatSendMutationVariables,
-  ) => Promise<ChatSendMutationData>;
+    variables: ChatGenerateResponseMutationVariables,
+  ) => Promise<ChatGenerateResponseMutationData>;
 } {
   return {
-    mutationKey: mutationKeyChatSend(),
-    mutationFn: function chatSendMutationFn({
+    mutationKey: mutationKeyChatGenerateResponse(),
+    mutationFn: function chatGenerateResponseMutationFn({
       request,
       options,
-    }): Promise<ChatSendMutationData> {
+    }): Promise<ChatGenerateResponseMutationData> {
       const mergedOptions = {
         ...hookOptions,
         ...options,
@@ -77,7 +87,7 @@ export function buildChatSendMutation(
           ),
         },
       };
-      return unwrapAsync(chatSend(
+      return unwrapAsync(chatGenerateResponse(
         client$,
         request,
         mergedOptions,

package/src/react-query/{embeddingsGenerate.ts → embeddingsPostEmbeddings.ts}

@@ -8,7 +8,7 @@ import {
   UseMutationResult,
 } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
-import { embeddingsGenerate } from "../funcs/embeddingsGenerate.js";
+import { embeddingsPostEmbeddings } from "../funcs/embeddingsPostEmbeddings.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
@@ -16,12 +16,13 @@ import { unwrapAsync } from "../types/fp.js";
 import { useOpenRouterContext } from "./_context.js";
 import { MutationHookOptions } from "./_types.js";
 
-export type EmbeddingsGenerateMutationVariables = {
+export type EmbeddingsPostEmbeddingsMutationVariables = {
   request?: operations.PostEmbeddingsRequest | undefined;
   options?: RequestOptions;
 };
 
-export type EmbeddingsGenerateMutationData = operations.PostEmbeddingsResponse;
+export type EmbeddingsPostEmbeddingsMutationData =
+  operations.PostEmbeddingsResponse;
 
 /**
  * Submit an embedding request
@@ -29,43 +30,43 @@ export type EmbeddingsGenerateMutationData = operations.PostEmbeddingsResponse;
  * @remarks
  * Submits an embedding request to the embeddings router
  */
-export function useEmbeddingsGenerateMutation(
+export function useEmbeddingsPostEmbeddingsMutation(
   options?: MutationHookOptions<
-    EmbeddingsGenerateMutationData,
+    EmbeddingsPostEmbeddingsMutationData,
     Error,
-    EmbeddingsGenerateMutationVariables
+    EmbeddingsPostEmbeddingsMutationVariables
   >,
 ): UseMutationResult<
-  EmbeddingsGenerateMutationData,
+  EmbeddingsPostEmbeddingsMutationData,
   Error,
-  EmbeddingsGenerateMutationVariables
+  EmbeddingsPostEmbeddingsMutationVariables
 > {
   const client = useOpenRouterContext();
   return useMutation({
-    ...buildEmbeddingsGenerateMutation(client, options),
+    ...buildEmbeddingsPostEmbeddingsMutation(client, options),
     ...options,
   });
 }
 
-export function mutationKeyEmbeddingsGenerate(): MutationKey {
-  return ["@openrouter/sdk", "Embeddings", "generate"];
+export function mutationKeyEmbeddingsPostEmbeddings(): MutationKey {
+  return ["@openrouter/sdk", "Embeddings", "postEmbeddings"];
 }
 
-export function buildEmbeddingsGenerateMutation(
+export function buildEmbeddingsPostEmbeddingsMutation(
   client$: OpenRouterCore,
   hookOptions?: RequestOptions,
 ): {
   mutationKey: MutationKey;
   mutationFn: (
-    variables: EmbeddingsGenerateMutationVariables,
-  ) => Promise<EmbeddingsGenerateMutationData>;
+    variables: EmbeddingsPostEmbeddingsMutationVariables,
+  ) => Promise<EmbeddingsPostEmbeddingsMutationData>;
 } {
   return {
-    mutationKey: mutationKeyEmbeddingsGenerate(),
-    mutationFn: function embeddingsGenerateMutationFn({
+    mutationKey: mutationKeyEmbeddingsPostEmbeddings(),
+    mutationFn: function embeddingsPostEmbeddingsMutationFn({
       request,
       options,
-    }): Promise<EmbeddingsGenerateMutationData> {
+    }): Promise<EmbeddingsPostEmbeddingsMutationData> {
       const mergedOptions = {
         ...hookOptions,
         ...options,
@@ -78,7 +79,7 @@ export function buildEmbeddingsGenerateMutation(
           ),
         },
       };
-      return unwrapAsync(embeddingsGenerate(
+      return unwrapAsync(embeddingsPostEmbeddings(
         client$,
         request,
         mergedOptions,