@openrouter/sdk 0.0.0-beta.1 → 0.0.0-beta.17

package/src/models/chatresponse.ts

@@ -26,7 +26,7 @@ export type ChatResponse = {
   created: number;
   model: string;
   object: "chat.completion";
-  systemFingerprint?: string | undefined;
+  systemFingerprint?: string | null | undefined;
   usage?: ChatGenerationTokenUsage | undefined;
 };
 
@@ -41,7 +41,7 @@ export const ChatResponse$inboundSchema: z.ZodType<
   created: z.number(),
   model: z.string(),
   object: z.literal("chat.completion"),
-  system_fingerprint: z.string().optional(),
+  system_fingerprint: z.nullable(z.string()).optional(),
   usage: ChatGenerationTokenUsage$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -56,7 +56,7 @@ export type ChatResponse$Outbound = {
   created: number;
   model: string;
   object: "chat.completion";
-  system_fingerprint?: string | undefined;
+  system_fingerprint?: string | null | undefined;
   usage?: ChatGenerationTokenUsage$Outbound | undefined;
 };
 
@@ -71,7 +71,7 @@ export const ChatResponse$outboundSchema: z.ZodType<
   created: z.number(),
   model: z.string(),
   object: z.literal("chat.completion"),
-  systemFingerprint: z.string().optional(),
+  systemFingerprint: z.nullable(z.string()).optional(),
   usage: ChatGenerationTokenUsage$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/chatstreamingresponsechunk.ts

@@ -25,19 +25,19 @@ export type ChatStreamingResponseChunkError = {
   code: number;
 };
 
-export type Data = {
+export type ChatStreamingResponseChunkData = {
   id: string;
   choices: Array<ChatStreamingChoice>;
   created: number;
   model: string;
   object: "chat.completion.chunk";
-  systemFingerprint?: string | undefined;
+  systemFingerprint?: string | null | undefined;
   error?: ChatStreamingResponseChunkError | undefined;
   usage?: ChatGenerationTokenUsage | undefined;
 };
 
 export type ChatStreamingResponseChunk = {
-  data: Data;
+  data: ChatStreamingResponseChunkData;
 };
 
 /** @internal */
@@ -100,77 +100,88 @@ export function chatStreamingResponseChunkErrorFromJSON(
 }
 
 /** @internal */
-export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
-  .object({
-    id: z.string(),
-    choices: z.array(ChatStreamingChoice$inboundSchema),
-    created: z.number(),
-    model: z.string(),
-    object: z.literal("chat.completion.chunk"),
-    system_fingerprint: z.string().optional(),
-    error: z.lazy(() => ChatStreamingResponseChunkError$inboundSchema)
-      .optional(),
-    usage: ChatGenerationTokenUsage$inboundSchema.optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      "system_fingerprint": "systemFingerprint",
-    });
+export const ChatStreamingResponseChunkData$inboundSchema: z.ZodType<
+  ChatStreamingResponseChunkData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  choices: z.array(ChatStreamingChoice$inboundSchema),
+  created: z.number(),
+  model: z.string(),
+  object: z.literal("chat.completion.chunk"),
+  system_fingerprint: z.nullable(z.string()).optional(),
+  error: z.lazy(() => ChatStreamingResponseChunkError$inboundSchema).optional(),
+  usage: ChatGenerationTokenUsage$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "system_fingerprint": "systemFingerprint",
   });
+});
 
 /** @internal */
-export type Data$Outbound = {
+export type ChatStreamingResponseChunkData$Outbound = {
   id: string;
   choices: Array<ChatStreamingChoice$Outbound>;
   created: number;
   model: string;
   object: "chat.completion.chunk";
-  system_fingerprint?: string | undefined;
+  system_fingerprint?: string | null | undefined;
   error?: ChatStreamingResponseChunkError$Outbound | undefined;
   usage?: ChatGenerationTokenUsage$Outbound | undefined;
 };
 
 /** @internal */
-export const Data$outboundSchema: z.ZodType<Data$Outbound, z.ZodTypeDef, Data> =
-  z.object({
-    id: z.string(),
-    choices: z.array(ChatStreamingChoice$outboundSchema),
-    created: z.number(),
-    model: z.string(),
-    object: z.literal("chat.completion.chunk"),
-    systemFingerprint: z.string().optional(),
-    error: z.lazy(() => ChatStreamingResponseChunkError$outboundSchema)
-      .optional(),
-    usage: ChatGenerationTokenUsage$outboundSchema.optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      systemFingerprint: "system_fingerprint",
-    });
+export const ChatStreamingResponseChunkData$outboundSchema: z.ZodType<
+  ChatStreamingResponseChunkData$Outbound,
+  z.ZodTypeDef,
+  ChatStreamingResponseChunkData
+> = z.object({
+  id: z.string(),
+  choices: z.array(ChatStreamingChoice$outboundSchema),
+  created: z.number(),
+  model: z.string(),
+  object: z.literal("chat.completion.chunk"),
+  systemFingerprint: z.nullable(z.string()).optional(),
+  error: z.lazy(() => ChatStreamingResponseChunkError$outboundSchema)
+    .optional(),
+  usage: ChatGenerationTokenUsage$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    systemFingerprint: "system_fingerprint",
   });
+});
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Data$ {
-  /** @deprecated use `Data$inboundSchema` instead. */
-  export const inboundSchema = Data$inboundSchema;
-  /** @deprecated use `Data$outboundSchema` instead. */
-  export const outboundSchema = Data$outboundSchema;
-  /** @deprecated use `Data$Outbound` instead. */
-  export type Outbound = Data$Outbound;
+export namespace ChatStreamingResponseChunkData$ {
+  /** @deprecated use `ChatStreamingResponseChunkData$inboundSchema` instead. */
+  export const inboundSchema = ChatStreamingResponseChunkData$inboundSchema;
+  /** @deprecated use `ChatStreamingResponseChunkData$outboundSchema` instead. */
+  export const outboundSchema = ChatStreamingResponseChunkData$outboundSchema;
+  /** @deprecated use `ChatStreamingResponseChunkData$Outbound` instead. */
+  export type Outbound = ChatStreamingResponseChunkData$Outbound;
 }
 
-export function dataToJSON(data: Data): string {
-  return JSON.stringify(Data$outboundSchema.parse(data));
+export function chatStreamingResponseChunkDataToJSON(
+  chatStreamingResponseChunkData: ChatStreamingResponseChunkData,
+): string {
+  return JSON.stringify(
+    ChatStreamingResponseChunkData$outboundSchema.parse(
+      chatStreamingResponseChunkData,
+    ),
+  );
 }
 
-export function dataFromJSON(
+export function chatStreamingResponseChunkDataFromJSON(
   jsonString: string,
-): SafeParseResult<Data, SDKValidationError> {
+): SafeParseResult<ChatStreamingResponseChunkData, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Data$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Data' from JSON`,
+    (x) => ChatStreamingResponseChunkData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatStreamingResponseChunkData' from JSON`,
   );
 }
 
@@ -190,12 +201,12 @@ export const ChatStreamingResponseChunk$inboundSchema: z.ZodType<
       });
       return z.NEVER;
     }
-  }).pipe(z.lazy(() => Data$inboundSchema)),
+  }).pipe(z.lazy(() => ChatStreamingResponseChunkData$inboundSchema)),
 });
 
 /** @internal */
 export type ChatStreamingResponseChunk$Outbound = {
-  data: Data$Outbound;
+  data: ChatStreamingResponseChunkData$Outbound;
 };
 
 /** @internal */
@@ -204,7 +215,7 @@ export const ChatStreamingResponseChunk$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ChatStreamingResponseChunk
 > = z.object({
-  data: z.lazy(() => Data$outboundSchema),
+  data: z.lazy(() => ChatStreamingResponseChunkData$outboundSchema),
 });
 
 /**

package/src/models/completionchoice.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 {
+  CompletionFinishReason,
+  CompletionFinishReason$inboundSchema,
+  CompletionFinishReason$outboundSchema,
+} from "./completionfinishreason.js";
+import {
+  CompletionLogprobs,
+  CompletionLogprobs$inboundSchema,
+  CompletionLogprobs$Outbound,
+  CompletionLogprobs$outboundSchema,
+} from "./completionlogprobs.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type CompletionChoice = {
+  text: string;
+  index: number;
+  logprobs: CompletionLogprobs | null;
+  finishReason: CompletionFinishReason | null;
+};
+
+/** @internal */
+export const CompletionChoice$inboundSchema: z.ZodType<
+  CompletionChoice,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+  index: z.number(),
+  logprobs: z.nullable(CompletionLogprobs$inboundSchema),
+  finish_reason: z.nullable(CompletionFinishReason$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "finish_reason": "finishReason",
+  });
+});
+
+/** @internal */
+export type CompletionChoice$Outbound = {
+  text: string;
+  index: number;
+  logprobs: CompletionLogprobs$Outbound | null;
+  finish_reason: string | null;
+};
+
+/** @internal */
+export const CompletionChoice$outboundSchema: z.ZodType<
+  CompletionChoice$Outbound,
+  z.ZodTypeDef,
+  CompletionChoice
+> = z.object({
+  text: z.string(),
+  index: z.number(),
+  logprobs: z.nullable(CompletionLogprobs$outboundSchema),
+  finishReason: z.nullable(CompletionFinishReason$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    finishReason: "finish_reason",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CompletionChoice$ {
+  /** @deprecated use `CompletionChoice$inboundSchema` instead. */
+  export const inboundSchema = CompletionChoice$inboundSchema;
+  /** @deprecated use `CompletionChoice$outboundSchema` instead. */
+  export const outboundSchema = CompletionChoice$outboundSchema;
+  /** @deprecated use `CompletionChoice$Outbound` instead. */
+  export type Outbound = CompletionChoice$Outbound;
+}
+
+export function completionChoiceToJSON(
+  completionChoice: CompletionChoice,
+): string {
+  return JSON.stringify(
+    CompletionChoice$outboundSchema.parse(completionChoice),
+  );
+}
+
+export function completionChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<CompletionChoice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompletionChoice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompletionChoice' from JSON`,
+  );
+}