@openrouter/sdk 0.0.0-beta.42 → 0.0.0-beta.43

package/src/models/openresponsesinputmessageitem.ts

@@ -8,23 +8,11 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
-  ResponseInputFile,
-  ResponseInputFile$inboundSchema,
-  ResponseInputFile$Outbound,
-  ResponseInputFile$outboundSchema,
-} from "./responseinputfile.js";
-import {
-  ResponseInputImage,
-  ResponseInputImage$inboundSchema,
-  ResponseInputImage$Outbound,
-  ResponseInputImage$outboundSchema,
-} from "./responseinputimage.js";
-import {
-  ResponseInputText,
-  ResponseInputText$inboundSchema,
-  ResponseInputText$Outbound,
-  ResponseInputText$outboundSchema,
-} from "./responseinputtext.js";
+  OpenResponsesInputContent,
+  OpenResponsesInputContent$inboundSchema,
+  OpenResponsesInputContent$Outbound,
+  OpenResponsesInputContent$outboundSchema,
+} from "./openresponsesinputcontent.js";
 
 export const OpenResponsesInputMessageItemType = {
   Message: "message",
@@ -59,23 +47,17 @@ export type OpenResponsesInputMessageItemRoleUnion =
   | OpenResponsesInputMessageItemRoleSystem
   | OpenResponsesInputMessageItemRoleDeveloper;
 
-export type OpenResponsesInputMessageItemContent =
-  | (ResponseInputText & { type: "input_text" })
-  | (ResponseInputImage & { type: "input_image" })
-  | (ResponseInputFile & { type: "input_file" });
-
+/**
+ * Input message item with structured content array
+ */
 export type OpenResponsesInputMessageItem = {
-  id?: string | undefined;
+  id: string;
   type?: OpenResponsesInputMessageItemType | undefined;
   role:
     | OpenResponsesInputMessageItemRoleUser
     | OpenResponsesInputMessageItemRoleSystem
     | OpenResponsesInputMessageItemRoleDeveloper;
-  content: Array<
-    | (ResponseInputText & { type: "input_text" })
-    | (ResponseInputImage & { type: "input_image" })
-    | (ResponseInputFile & { type: "input_file" })
-  >;
+  content: Array<OpenResponsesInputContent>;
 };
 
 /** @internal */
@@ -235,138 +217,28 @@ export function openResponsesInputMessageItemRoleUnionFromJSON(
   );
 }
 
-/** @internal */
-export const OpenResponsesInputMessageItemContent$inboundSchema: z.ZodType<
-  OpenResponsesInputMessageItemContent,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  ResponseInputText$inboundSchema.and(
-    z.object({ type: z.literal("input_text") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputImage$inboundSchema.and(
-    z.object({ type: z.literal("input_image") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputFile$inboundSchema.and(
-    z.object({ type: z.literal("input_file") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-]);
-
-/** @internal */
-export type OpenResponsesInputMessageItemContent$Outbound =
-  | (ResponseInputText$Outbound & { type: "input_text" })
-  | (ResponseInputImage$Outbound & { type: "input_image" })
-  | (ResponseInputFile$Outbound & { type: "input_file" });
-
-/** @internal */
-export const OpenResponsesInputMessageItemContent$outboundSchema: z.ZodType<
-  OpenResponsesInputMessageItemContent$Outbound,
-  z.ZodTypeDef,
-  OpenResponsesInputMessageItemContent
-> = z.union([
-  ResponseInputText$outboundSchema.and(
-    z.object({ type: z.literal("input_text") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputImage$outboundSchema.and(
-    z.object({ type: z.literal("input_image") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputFile$outboundSchema.and(
-    z.object({ type: z.literal("input_file") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace OpenResponsesInputMessageItemContent$ {
-  /** @deprecated use `OpenResponsesInputMessageItemContent$inboundSchema` instead. */
-  export const inboundSchema =
-    OpenResponsesInputMessageItemContent$inboundSchema;
-  /** @deprecated use `OpenResponsesInputMessageItemContent$outboundSchema` instead. */
-  export const outboundSchema =
-    OpenResponsesInputMessageItemContent$outboundSchema;
-  /** @deprecated use `OpenResponsesInputMessageItemContent$Outbound` instead. */
-  export type Outbound = OpenResponsesInputMessageItemContent$Outbound;
-}
-
-export function openResponsesInputMessageItemContentToJSON(
-  openResponsesInputMessageItemContent: OpenResponsesInputMessageItemContent,
-): string {
-  return JSON.stringify(
-    OpenResponsesInputMessageItemContent$outboundSchema.parse(
-      openResponsesInputMessageItemContent,
-    ),
-  );
-}
-
-export function openResponsesInputMessageItemContentFromJSON(
-  jsonString: string,
-): SafeParseResult<OpenResponsesInputMessageItemContent, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      OpenResponsesInputMessageItemContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OpenResponsesInputMessageItemContent' from JSON`,
-  );
-}
-
 /** @internal */
 export const OpenResponsesInputMessageItem$inboundSchema: z.ZodType<
   OpenResponsesInputMessageItem,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().optional(),
+  id: z.string(),
   type: OpenResponsesInputMessageItemType$inboundSchema.optional(),
   role: z.union([
     OpenResponsesInputMessageItemRoleUser$inboundSchema,
     OpenResponsesInputMessageItemRoleSystem$inboundSchema,
     OpenResponsesInputMessageItemRoleDeveloper$inboundSchema,
   ]),
-  content: z.array(
-    z.union([
-      ResponseInputText$inboundSchema.and(
-        z.object({ type: z.literal("input_text") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputImage$inboundSchema.and(
-        z.object({ type: z.literal("input_image") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputFile$inboundSchema.and(
-        z.object({ type: z.literal("input_file") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-    ]),
-  ),
+  content: z.array(OpenResponsesInputContent$inboundSchema),
 });
 
 /** @internal */
 export type OpenResponsesInputMessageItem$Outbound = {
-  id?: string | undefined;
+  id: string;
   type?: string | undefined;
   role: string | string | string;
-  content: Array<
-    | (ResponseInputText$Outbound & { type: "input_text" })
-    | (ResponseInputImage$Outbound & { type: "input_image" })
-    | (ResponseInputFile$Outbound & { type: "input_file" })
-  >;
+  content: Array<OpenResponsesInputContent$Outbound>;
 };
 
 /** @internal */
@@ -375,32 +247,14 @@ export const OpenResponsesInputMessageItem$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OpenResponsesInputMessageItem
 > = z.object({
-  id: z.string().optional(),
+  id: z.string(),
   type: OpenResponsesInputMessageItemType$outboundSchema.optional(),
   role: z.union([
     OpenResponsesInputMessageItemRoleUser$outboundSchema,
     OpenResponsesInputMessageItemRoleSystem$outboundSchema,
     OpenResponsesInputMessageItemRoleDeveloper$outboundSchema,
   ]),
-  content: z.array(
-    z.union([
-      ResponseInputText$outboundSchema.and(
-        z.object({ type: z.literal("input_text") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputImage$outboundSchema.and(
-        z.object({ type: z.literal("input_image") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputFile$outboundSchema.and(
-        z.object({ type: z.literal("input_file") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-    ]),
-  ),
+  content: z.array(OpenResponsesInputContent$outboundSchema),
 });
 
 /**

package/src/models/openresponsesinputtext.ts

@@ -0,0 +1,102 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const OpenResponsesInputTextType = {
+  InputText: "input_text",
+} as const;
+export type OpenResponsesInputTextType = ClosedEnum<
+  typeof OpenResponsesInputTextType
+>;
+
+/**
+ * Text input content item
+ */
+export type OpenResponsesInputText = {
+  type: OpenResponsesInputTextType;
+  text: string;
+};
+
+/** @internal */
+export const OpenResponsesInputTextType$inboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesInputTextType
+> = z.nativeEnum(OpenResponsesInputTextType);
+
+/** @internal */
+export const OpenResponsesInputTextType$outboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesInputTextType
+> = OpenResponsesInputTextType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesInputTextType$ {
+  /** @deprecated use `OpenResponsesInputTextType$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesInputTextType$inboundSchema;
+  /** @deprecated use `OpenResponsesInputTextType$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesInputTextType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesInputText$inboundSchema: z.ZodType<
+  OpenResponsesInputText,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: OpenResponsesInputTextType$inboundSchema,
+  text: z.string(),
+});
+
+/** @internal */
+export type OpenResponsesInputText$Outbound = {
+  type: string;
+  text: string;
+};
+
+/** @internal */
+export const OpenResponsesInputText$outboundSchema: z.ZodType<
+  OpenResponsesInputText$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesInputText
+> = z.object({
+  type: OpenResponsesInputTextType$outboundSchema,
+  text: 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 OpenResponsesInputText$ {
+  /** @deprecated use `OpenResponsesInputText$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesInputText$inboundSchema;
+  /** @deprecated use `OpenResponsesInputText$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesInputText$outboundSchema;
+  /** @deprecated use `OpenResponsesInputText$Outbound` instead. */
+  export type Outbound = OpenResponsesInputText$Outbound;
+}
+
+export function openResponsesInputTextToJSON(
+  openResponsesInputText: OpenResponsesInputText,
+): string {
+  return JSON.stringify(
+    OpenResponsesInputText$outboundSchema.parse(openResponsesInputText),
+  );
+}
+
+export function openResponsesInputTextFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesInputText, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenResponsesInputText$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesInputText' from JSON`,
+  );
+}

package/src/models/openresponseslogprobs.ts

@@ -7,12 +7,14 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  OpenResponsesTopLogprobs,
-  OpenResponsesTopLogprobs$inboundSchema,
-  OpenResponsesTopLogprobs$Outbound,
-  OpenResponsesTopLogprobs$outboundSchema,
-} from "./openresponsestoplogprobs.js";
+
+/**
+ * Alternative token with its log probability
+ */
+export type OpenResponsesLogProbsTopLogprob = {
+  token?: string | undefined;
+  logprob?: number | undefined;
+};
 
 /**
  * Log probability information for a token
@@ -20,9 +22,68 @@ import {
 export type OpenResponsesLogProbs = {
   logprob: number;
   token: string;
-  topLogprobs?: Array<OpenResponsesTopLogprobs> | undefined;
+  topLogprobs?: Array<OpenResponsesLogProbsTopLogprob> | undefined;
+};
+
+/** @internal */
+export const OpenResponsesLogProbsTopLogprob$inboundSchema: z.ZodType<
+  OpenResponsesLogProbsTopLogprob,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  token: z.string().optional(),
+  logprob: z.number().optional(),
+});
+
+/** @internal */
+export type OpenResponsesLogProbsTopLogprob$Outbound = {
+  token?: string | undefined;
+  logprob?: number | undefined;
 };
 
+/** @internal */
+export const OpenResponsesLogProbsTopLogprob$outboundSchema: z.ZodType<
+  OpenResponsesLogProbsTopLogprob$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesLogProbsTopLogprob
+> = z.object({
+  token: z.string().optional(),
+  logprob: z.number().optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesLogProbsTopLogprob$ {
+  /** @deprecated use `OpenResponsesLogProbsTopLogprob$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesLogProbsTopLogprob$inboundSchema;
+  /** @deprecated use `OpenResponsesLogProbsTopLogprob$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesLogProbsTopLogprob$outboundSchema;
+  /** @deprecated use `OpenResponsesLogProbsTopLogprob$Outbound` instead. */
+  export type Outbound = OpenResponsesLogProbsTopLogprob$Outbound;
+}
+
+export function openResponsesLogProbsTopLogprobToJSON(
+  openResponsesLogProbsTopLogprob: OpenResponsesLogProbsTopLogprob,
+): string {
+  return JSON.stringify(
+    OpenResponsesLogProbsTopLogprob$outboundSchema.parse(
+      openResponsesLogProbsTopLogprob,
+    ),
+  );
+}
+
+export function openResponsesLogProbsTopLogprobFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesLogProbsTopLogprob, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenResponsesLogProbsTopLogprob$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesLogProbsTopLogprob' from JSON`,
+  );
+}
+
 /** @internal */
 export const OpenResponsesLogProbs$inboundSchema: z.ZodType<
   OpenResponsesLogProbs,
@@ -31,7 +92,9 @@ export const OpenResponsesLogProbs$inboundSchema: z.ZodType<
 > = z.object({
   logprob: z.number(),
   token: z.string(),
-  top_logprobs: z.array(OpenResponsesTopLogprobs$inboundSchema).optional(),
+  top_logprobs: z.array(
+    z.lazy(() => OpenResponsesLogProbsTopLogprob$inboundSchema),
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
     "top_logprobs": "topLogprobs",
@@ -42,7 +105,7 @@ export const OpenResponsesLogProbs$inboundSchema: z.ZodType<
 export type OpenResponsesLogProbs$Outbound = {
   logprob: number;
   token: string;
-  top_logprobs?: Array<OpenResponsesTopLogprobs$Outbound> | undefined;
+  top_logprobs?: Array<OpenResponsesLogProbsTopLogprob$Outbound> | undefined;
 };
 
 /** @internal */
@@ -53,7 +116,9 @@ export const OpenResponsesLogProbs$outboundSchema: z.ZodType<
 > = z.object({
   logprob: z.number(),
   token: z.string(),
-  topLogprobs: z.array(OpenResponsesTopLogprobs$outboundSchema).optional(),
+  topLogprobs: z.array(
+    z.lazy(() => OpenResponsesLogProbsTopLogprob$outboundSchema),
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
     topLogprobs: "top_logprobs",