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

package/src/models/openresponseseasyinputmessage.ts

@@ -8,11 +8,23 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
-  OpenResponsesInputContent,
-  OpenResponsesInputContent$inboundSchema,
-  OpenResponsesInputContent$Outbound,
-  OpenResponsesInputContent$outboundSchema,
-} from "./openresponsesinputcontent.js";
+  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";
 
 export const OpenResponsesEasyInputMessageType = {
   Message: "message",
@@ -55,13 +67,19 @@ export type OpenResponsesEasyInputMessageRoleUnion =
   | OpenResponsesEasyInputMessageRoleAssistant
   | OpenResponsesEasyInputMessageRoleDeveloper;
 
-export type OpenResponsesEasyInputMessageContent =
-  | Array<OpenResponsesInputContent>
+export type OpenResponsesEasyInputMessageContent1 =
+  | (ResponseInputText & { type: "input_text" })
+  | (ResponseInputImage & { type: "input_image" })
+  | (ResponseInputFile & { type: "input_file" });
+
+export type OpenResponsesEasyInputMessageContent2 =
+  | Array<
+    | (ResponseInputText & { type: "input_text" })
+    | (ResponseInputImage & { type: "input_image" })
+    | (ResponseInputFile & { type: "input_file" })
+  >
   | string;
 
-/**
- * Simplified input message format that accepts string or array content
- */
 export type OpenResponsesEasyInputMessage = {
   type?: OpenResponsesEasyInputMessageType | undefined;
   role:
@@ -69,7 +87,13 @@ export type OpenResponsesEasyInputMessage = {
     | OpenResponsesEasyInputMessageRoleSystem
     | OpenResponsesEasyInputMessageRoleAssistant
     | OpenResponsesEasyInputMessageRoleDeveloper;
-  content: Array<OpenResponsesInputContent> | string;
+  content:
+    | Array<
+      | (ResponseInputText & { type: "input_text" })
+      | (ResponseInputImage & { type: "input_image" })
+      | (ResponseInputFile & { type: "input_file" })
+    >
+    | string;
 };
 
 /** @internal */
@@ -256,57 +280,191 @@ export function openResponsesEasyInputMessageRoleUnionFromJSON(
 }
 
 /** @internal */
-export const OpenResponsesEasyInputMessageContent$inboundSchema: z.ZodType<
-  OpenResponsesEasyInputMessageContent,
+export const OpenResponsesEasyInputMessageContent1$inboundSchema: z.ZodType<
+  OpenResponsesEasyInputMessageContent1,
+  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 OpenResponsesEasyInputMessageContent1$Outbound =
+  | (ResponseInputText$Outbound & { type: "input_text" })
+  | (ResponseInputImage$Outbound & { type: "input_image" })
+  | (ResponseInputFile$Outbound & { type: "input_file" });
+
+/** @internal */
+export const OpenResponsesEasyInputMessageContent1$outboundSchema: z.ZodType<
+  OpenResponsesEasyInputMessageContent1$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesEasyInputMessageContent1
+> = 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 OpenResponsesEasyInputMessageContent1$ {
+  /** @deprecated use `OpenResponsesEasyInputMessageContent1$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesEasyInputMessageContent1$inboundSchema;
+  /** @deprecated use `OpenResponsesEasyInputMessageContent1$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesEasyInputMessageContent1$outboundSchema;
+  /** @deprecated use `OpenResponsesEasyInputMessageContent1$Outbound` instead. */
+  export type Outbound = OpenResponsesEasyInputMessageContent1$Outbound;
+}
+
+export function openResponsesEasyInputMessageContent1ToJSON(
+  openResponsesEasyInputMessageContent1: OpenResponsesEasyInputMessageContent1,
+): string {
+  return JSON.stringify(
+    OpenResponsesEasyInputMessageContent1$outboundSchema.parse(
+      openResponsesEasyInputMessageContent1,
+    ),
+  );
+}
+
+export function openResponsesEasyInputMessageContent1FromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesEasyInputMessageContent1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesEasyInputMessageContent1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesEasyInputMessageContent1' from JSON`,
+  );
+}
+
+/** @internal */
+export const OpenResponsesEasyInputMessageContent2$inboundSchema: z.ZodType<
+  OpenResponsesEasyInputMessageContent2,
   z.ZodTypeDef,
   unknown
-> = z.union([z.array(OpenResponsesInputContent$inboundSchema), z.string()]);
+> = z.union([
+  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,
+        })),
+      ),
+    ]),
+  ),
+  z.string(),
+]);
 
 /** @internal */
-export type OpenResponsesEasyInputMessageContent$Outbound =
-  | Array<OpenResponsesInputContent$Outbound>
+export type OpenResponsesEasyInputMessageContent2$Outbound =
+  | Array<
+    | (ResponseInputText$Outbound & { type: "input_text" })
+    | (ResponseInputImage$Outbound & { type: "input_image" })
+    | (ResponseInputFile$Outbound & { type: "input_file" })
+  >
   | string;
 
 /** @internal */
-export const OpenResponsesEasyInputMessageContent$outboundSchema: z.ZodType<
-  OpenResponsesEasyInputMessageContent$Outbound,
+export const OpenResponsesEasyInputMessageContent2$outboundSchema: z.ZodType<
+  OpenResponsesEasyInputMessageContent2$Outbound,
   z.ZodTypeDef,
-  OpenResponsesEasyInputMessageContent
-> = z.union([z.array(OpenResponsesInputContent$outboundSchema), z.string()]);
+  OpenResponsesEasyInputMessageContent2
+> = z.union([
+  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,
+        })),
+      ),
+    ]),
+  ),
+  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 OpenResponsesEasyInputMessageContent$ {
-  /** @deprecated use `OpenResponsesEasyInputMessageContent$inboundSchema` instead. */
+export namespace OpenResponsesEasyInputMessageContent2$ {
+  /** @deprecated use `OpenResponsesEasyInputMessageContent2$inboundSchema` instead. */
   export const inboundSchema =
-    OpenResponsesEasyInputMessageContent$inboundSchema;
-  /** @deprecated use `OpenResponsesEasyInputMessageContent$outboundSchema` instead. */
+    OpenResponsesEasyInputMessageContent2$inboundSchema;
+  /** @deprecated use `OpenResponsesEasyInputMessageContent2$outboundSchema` instead. */
   export const outboundSchema =
-    OpenResponsesEasyInputMessageContent$outboundSchema;
-  /** @deprecated use `OpenResponsesEasyInputMessageContent$Outbound` instead. */
-  export type Outbound = OpenResponsesEasyInputMessageContent$Outbound;
+    OpenResponsesEasyInputMessageContent2$outboundSchema;
+  /** @deprecated use `OpenResponsesEasyInputMessageContent2$Outbound` instead. */
+  export type Outbound = OpenResponsesEasyInputMessageContent2$Outbound;
 }
 
-export function openResponsesEasyInputMessageContentToJSON(
-  openResponsesEasyInputMessageContent: OpenResponsesEasyInputMessageContent,
+export function openResponsesEasyInputMessageContent2ToJSON(
+  openResponsesEasyInputMessageContent2: OpenResponsesEasyInputMessageContent2,
 ): string {
   return JSON.stringify(
-    OpenResponsesEasyInputMessageContent$outboundSchema.parse(
-      openResponsesEasyInputMessageContent,
+    OpenResponsesEasyInputMessageContent2$outboundSchema.parse(
+      openResponsesEasyInputMessageContent2,
     ),
   );
 }
 
-export function openResponsesEasyInputMessageContentFromJSON(
+export function openResponsesEasyInputMessageContent2FromJSON(
   jsonString: string,
-): SafeParseResult<OpenResponsesEasyInputMessageContent, SDKValidationError> {
+): SafeParseResult<OpenResponsesEasyInputMessageContent2, SDKValidationError> {
   return safeParse(
     jsonString,
     (x) =>
-      OpenResponsesEasyInputMessageContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OpenResponsesEasyInputMessageContent' from JSON`,
+      OpenResponsesEasyInputMessageContent2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesEasyInputMessageContent2' from JSON`,
   );
 }
 
@@ -324,7 +482,25 @@ export const OpenResponsesEasyInputMessage$inboundSchema: z.ZodType<
     OpenResponsesEasyInputMessageRoleDeveloper$inboundSchema,
   ]),
   content: z.union([
-    z.array(OpenResponsesInputContent$inboundSchema),
+    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,
+          })),
+        ),
+      ]),
+    ),
     z.string(),
   ]),
 });
@@ -333,7 +509,13 @@ export const OpenResponsesEasyInputMessage$inboundSchema: z.ZodType<
 export type OpenResponsesEasyInputMessage$Outbound = {
   type?: string | undefined;
   role: string | string | string | string;
-  content: Array<OpenResponsesInputContent$Outbound> | string;
+  content:
+    | Array<
+      | (ResponseInputText$Outbound & { type: "input_text" })
+      | (ResponseInputImage$Outbound & { type: "input_image" })
+      | (ResponseInputFile$Outbound & { type: "input_file" })
+    >
+    | string;
 };
 
 /** @internal */
@@ -350,7 +532,25 @@ export const OpenResponsesEasyInputMessage$outboundSchema: z.ZodType<
     OpenResponsesEasyInputMessageRoleDeveloper$outboundSchema,
   ]),
   content: z.union([
-    z.array(OpenResponsesInputContent$outboundSchema),
+    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,
+          })),
+        ),
+      ]),
+    ),
     z.string(),
   ]),
 });

package/src/models/openresponseserrorevent.ts

@@ -0,0 +1,123 @@
+/*
+ * 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 { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const OpenResponsesErrorEventType = {
+  Error: "error",
+} as const;
+export type OpenResponsesErrorEventType = ClosedEnum<
+  typeof OpenResponsesErrorEventType
+>;
+
+/**
+ * Event emitted when an error occurs during streaming
+ */
+export type OpenResponsesErrorEvent = {
+  type: OpenResponsesErrorEventType;
+  code: string | null;
+  message: string;
+  param: string | null;
+  sequenceNumber: number;
+};
+
+/** @internal */
+export const OpenResponsesErrorEventType$inboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesErrorEventType
+> = z.nativeEnum(OpenResponsesErrorEventType);
+
+/** @internal */
+export const OpenResponsesErrorEventType$outboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesErrorEventType
+> = OpenResponsesErrorEventType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesErrorEventType$ {
+  /** @deprecated use `OpenResponsesErrorEventType$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesErrorEventType$inboundSchema;
+  /** @deprecated use `OpenResponsesErrorEventType$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesErrorEventType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesErrorEvent$inboundSchema: z.ZodType<
+  OpenResponsesErrorEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: OpenResponsesErrorEventType$inboundSchema,
+  code: z.nullable(z.string()),
+  message: z.string(),
+  param: z.nullable(z.string()),
+  sequence_number: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "sequence_number": "sequenceNumber",
+  });
+});
+
+/** @internal */
+export type OpenResponsesErrorEvent$Outbound = {
+  type: string;
+  code: string | null;
+  message: string;
+  param: string | null;
+  sequence_number: number;
+};
+
+/** @internal */
+export const OpenResponsesErrorEvent$outboundSchema: z.ZodType<
+  OpenResponsesErrorEvent$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesErrorEvent
+> = z.object({
+  type: OpenResponsesErrorEventType$outboundSchema,
+  code: z.nullable(z.string()),
+  message: z.string(),
+  param: z.nullable(z.string()),
+  sequenceNumber: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    sequenceNumber: "sequence_number",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesErrorEvent$ {
+  /** @deprecated use `OpenResponsesErrorEvent$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesErrorEvent$inboundSchema;
+  /** @deprecated use `OpenResponsesErrorEvent$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesErrorEvent$outboundSchema;
+  /** @deprecated use `OpenResponsesErrorEvent$Outbound` instead. */
+  export type Outbound = OpenResponsesErrorEvent$Outbound;
+}
+
+export function openResponsesErrorEventToJSON(
+  openResponsesErrorEvent: OpenResponsesErrorEvent,
+): string {
+  return JSON.stringify(
+    OpenResponsesErrorEvent$outboundSchema.parse(openResponsesErrorEvent),
+  );
+}
+
+export function openResponsesErrorEventFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesErrorEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenResponsesErrorEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesErrorEvent' from JSON`,
+  );
+}

package/src/models/openresponsesimagegencallcompleted.ts

@@ -0,0 +1,131 @@
+/*
+ * 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 { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const OpenResponsesImageGenCallCompletedType = {
+  ResponseImageGenerationCallCompleted:
+    "response.image_generation_call.completed",
+} as const;
+export type OpenResponsesImageGenCallCompletedType = ClosedEnum<
+  typeof OpenResponsesImageGenCallCompletedType
+>;
+
+/**
+ * Image generation call completed
+ */
+export type OpenResponsesImageGenCallCompleted = {
+  type: OpenResponsesImageGenCallCompletedType;
+  itemId: string;
+  outputIndex: number;
+  sequenceNumber: number;
+};
+
+/** @internal */
+export const OpenResponsesImageGenCallCompletedType$inboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesImageGenCallCompletedType> = z.nativeEnum(
+    OpenResponsesImageGenCallCompletedType,
+  );
+
+/** @internal */
+export const OpenResponsesImageGenCallCompletedType$outboundSchema:
+  z.ZodNativeEnum<typeof OpenResponsesImageGenCallCompletedType> =
+    OpenResponsesImageGenCallCompletedType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesImageGenCallCompletedType$ {
+  /** @deprecated use `OpenResponsesImageGenCallCompletedType$inboundSchema` instead. */
+  export const inboundSchema =
+    OpenResponsesImageGenCallCompletedType$inboundSchema;
+  /** @deprecated use `OpenResponsesImageGenCallCompletedType$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesImageGenCallCompletedType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesImageGenCallCompleted$inboundSchema: z.ZodType<
+  OpenResponsesImageGenCallCompleted,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: OpenResponsesImageGenCallCompletedType$inboundSchema,
+  item_id: z.string(),
+  output_index: z.number(),
+  sequence_number: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "item_id": "itemId",
+    "output_index": "outputIndex",
+    "sequence_number": "sequenceNumber",
+  });
+});
+
+/** @internal */
+export type OpenResponsesImageGenCallCompleted$Outbound = {
+  type: string;
+  item_id: string;
+  output_index: number;
+  sequence_number: number;
+};
+
+/** @internal */
+export const OpenResponsesImageGenCallCompleted$outboundSchema: z.ZodType<
+  OpenResponsesImageGenCallCompleted$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesImageGenCallCompleted
+> = z.object({
+  type: OpenResponsesImageGenCallCompletedType$outboundSchema,
+  itemId: z.string(),
+  outputIndex: z.number(),
+  sequenceNumber: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    itemId: "item_id",
+    outputIndex: "output_index",
+    sequenceNumber: "sequence_number",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesImageGenCallCompleted$ {
+  /** @deprecated use `OpenResponsesImageGenCallCompleted$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesImageGenCallCompleted$inboundSchema;
+  /** @deprecated use `OpenResponsesImageGenCallCompleted$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesImageGenCallCompleted$outboundSchema;
+  /** @deprecated use `OpenResponsesImageGenCallCompleted$Outbound` instead. */
+  export type Outbound = OpenResponsesImageGenCallCompleted$Outbound;
+}
+
+export function openResponsesImageGenCallCompletedToJSON(
+  openResponsesImageGenCallCompleted: OpenResponsesImageGenCallCompleted,
+): string {
+  return JSON.stringify(
+    OpenResponsesImageGenCallCompleted$outboundSchema.parse(
+      openResponsesImageGenCallCompleted,
+    ),
+  );
+}
+
+export function openResponsesImageGenCallCompletedFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesImageGenCallCompleted, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      OpenResponsesImageGenCallCompleted$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesImageGenCallCompleted' from JSON`,
+  );
+}