@openrouter/sdk 0.12.35 → 0.13.7

package/esm/models/easyinputmessage.js

@@ -13,6 +13,7 @@ export const EasyInputMessageDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
+    Original: "original",
 };
 export const EasyInputMessagePhaseFinalAnswer = {
     FinalAnswer: "final_answer",

package/esm/models/filedeleteresponse.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const FileDeleteResponseType: {
+    readonly FileDeleted: "file_deleted";
+};
+export type FileDeleteResponseType = ClosedEnum<typeof FileDeleteResponseType>;
+/**
+ * Confirmation that a file was deleted.
+ */
+export type FileDeleteResponse = {
+    id: string;
+    type: FileDeleteResponseType;
+};
+/** @internal */
+export declare const FileDeleteResponseType$inboundSchema: z.ZodEnum<typeof FileDeleteResponseType>;
+/** @internal */
+export declare const FileDeleteResponse$inboundSchema: z.ZodType<FileDeleteResponse, unknown>;
+export declare function fileDeleteResponseFromJSON(jsonString: string): SafeParseResult<FileDeleteResponse, SDKValidationError>;
+//# sourceMappingURL=filedeleteresponse.d.ts.map

package/esm/models/filedeleteresponse.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2464f2b51ee5
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const FileDeleteResponseType = {
+    FileDeleted: "file_deleted",
+};
+/** @internal */
+export const FileDeleteResponseType$inboundSchema = z.enum(FileDeleteResponseType);
+/** @internal */
+export const FileDeleteResponse$inboundSchema = z.object({
+    id: z.string(),
+    type: FileDeleteResponseType$inboundSchema,
+});
+export function fileDeleteResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileDeleteResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileDeleteResponse' from JSON`);
+}
+//# sourceMappingURL=filedeleteresponse.js.map

package/esm/models/filelistresponse.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { FileMetadata } from "./filemetadata.js";
+/**
+ * A page of files belonging to the requesting workspace.
+ */
+export type FileListResponse = {
+    /**
+     * Opaque cursor for the next page; null when there are no more results.
+     */
+    cursor: string | null;
+    data: Array<FileMetadata>;
+    firstId: string | null;
+    hasMore: boolean;
+    lastId: string | null;
+};
+/** @internal */
+export declare const FileListResponse$inboundSchema: z.ZodType<FileListResponse, unknown>;
+export declare function fileListResponseFromJSON(jsonString: string): SafeParseResult<FileListResponse, SDKValidationError>;
+//# sourceMappingURL=filelistresponse.d.ts.map

package/esm/models/filelistresponse.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e4978ed568c7
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { FileMetadata$inboundSchema } from "./filemetadata.js";
+/** @internal */
+export const FileListResponse$inboundSchema = z.object({
+    cursor: z.nullable(z.string()),
+    data: z.array(FileMetadata$inboundSchema),
+    first_id: z.nullable(z.string()),
+    has_more: z.boolean(),
+    last_id: z.nullable(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        "first_id": "firstId",
+        "has_more": "hasMore",
+        "last_id": "lastId",
+    });
+});
+export function fileListResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileListResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileListResponse' from JSON`);
+}
+//# sourceMappingURL=filelistresponse.js.map

package/esm/models/filemetadata.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const FileMetadataType: {
+    readonly File: "file";
+};
+export type FileMetadataType = ClosedEnum<typeof FileMetadataType>;
+/**
+ * Metadata describing a stored file.
+ */
+export type FileMetadata = {
+    createdAt: string;
+    downloadable: boolean;
+    filename: string;
+    id: string;
+    mimeType: string;
+    sizeBytes: number;
+    type: FileMetadataType;
+};
+/** @internal */
+export declare const FileMetadataType$inboundSchema: z.ZodEnum<typeof FileMetadataType>;
+/** @internal */
+export declare const FileMetadata$inboundSchema: z.ZodType<FileMetadata, unknown>;
+export declare function fileMetadataFromJSON(jsonString: string): SafeParseResult<FileMetadata, SDKValidationError>;
+//# sourceMappingURL=filemetadata.d.ts.map

package/esm/models/filemetadata.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7a5c3a86d7a2
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const FileMetadataType = {
+    File: "file",
+};
+/** @internal */
+export const FileMetadataType$inboundSchema = z.enum(FileMetadataType);
+/** @internal */
+export const FileMetadata$inboundSchema = z
+    .object({
+    created_at: z.string(),
+    downloadable: z.boolean(),
+    filename: z.string(),
+    id: z.string(),
+    mime_type: z.string(),
+    size_bytes: z.int(),
+    type: FileMetadataType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "mime_type": "mimeType",
+        "size_bytes": "sizeBytes",
+    });
+});
+export function fileMetadataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileMetadata$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileMetadata' from JSON`);
+}
+//# sourceMappingURL=filemetadata.js.map

package/esm/models/filesearchservertool.d.ts

@@ -12,8 +12,8 @@ export declare const FiltersType: {
     readonly Lte: "lte";
 };
 export type FiltersType = OpenEnum<typeof FiltersType>;
-export type Value1 = string | number;
-export type Value2 = string | number | boolean | Array<string | number>;
+export type FileSearchServerToolValue1 = string | number;
+export type FileSearchServerToolValue2 = string | number | boolean | Array<string | number>;
 export type Filters = {
     key: string;
     type: FiltersType;
@@ -44,21 +44,21 @@ export declare const FiltersType$inboundSchema: z.ZodType<FiltersType, unknown>;
 /** @internal */
 export declare const FiltersType$outboundSchema: z.ZodType<string, FiltersType>;
 /** @internal */
-export declare const Value1$inboundSchema: z.ZodType<Value1, unknown>;
+export declare const FileSearchServerToolValue1$inboundSchema: z.ZodType<FileSearchServerToolValue1, unknown>;
 /** @internal */
-export type Value1$Outbound = string | number;
+export type FileSearchServerToolValue1$Outbound = string | number;
 /** @internal */
-export declare const Value1$outboundSchema: z.ZodType<Value1$Outbound, Value1>;
-export declare function value1ToJSON(value1: Value1): string;
-export declare function value1FromJSON(jsonString: string): SafeParseResult<Value1, SDKValidationError>;
+export declare const FileSearchServerToolValue1$outboundSchema: z.ZodType<FileSearchServerToolValue1$Outbound, FileSearchServerToolValue1>;
+export declare function fileSearchServerToolValue1ToJSON(fileSearchServerToolValue1: FileSearchServerToolValue1): string;
+export declare function fileSearchServerToolValue1FromJSON(jsonString: string): SafeParseResult<FileSearchServerToolValue1, SDKValidationError>;
 /** @internal */
-export declare const Value2$inboundSchema: z.ZodType<Value2, unknown>;
+export declare const FileSearchServerToolValue2$inboundSchema: z.ZodType<FileSearchServerToolValue2, unknown>;
 /** @internal */
-export type Value2$Outbound = string | number | boolean | Array<string | number>;
+export type FileSearchServerToolValue2$Outbound = string | number | boolean | Array<string | number>;
 /** @internal */
-export declare const Value2$outboundSchema: z.ZodType<Value2$Outbound, Value2>;
-export declare function value2ToJSON(value2: Value2): string;
-export declare function value2FromJSON(jsonString: string): SafeParseResult<Value2, SDKValidationError>;
+export declare const FileSearchServerToolValue2$outboundSchema: z.ZodType<FileSearchServerToolValue2$Outbound, FileSearchServerToolValue2>;
+export declare function fileSearchServerToolValue2ToJSON(fileSearchServerToolValue2: FileSearchServerToolValue2): string;
+export declare function fileSearchServerToolValue2FromJSON(jsonString: string): SafeParseResult<FileSearchServerToolValue2, SDKValidationError>;
 /** @internal */
 export declare const Filters$inboundSchema: z.ZodType<Filters, unknown>;
 /** @internal */

package/esm/models/filesearchservertool.js

@@ -24,39 +24,34 @@ export const FiltersType$inboundSchema = openEnums.inboundSchema(FiltersType);
 /** @internal */
 export const FiltersType$outboundSchema = openEnums.outboundSchema(FiltersType);
 /** @internal */
-export const Value1$inboundSchema = z.union([
-    z.string(),
-    z.number(),
-]);
+export const FileSearchServerToolValue1$inboundSchema = z.union([z.string(), z.number()]);
 /** @internal */
-export const Value1$outboundSchema = z
-    .union([z.string(), z.number()]);
-export function value1ToJSON(value1) {
-    return JSON.stringify(Value1$outboundSchema.parse(value1));
+export const FileSearchServerToolValue1$outboundSchema = z.union([z.string(), z.number()]);
+export function fileSearchServerToolValue1ToJSON(fileSearchServerToolValue1) {
+    return JSON.stringify(FileSearchServerToolValue1$outboundSchema.parse(fileSearchServerToolValue1));
 }
-export function value1FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Value1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value1' from JSON`);
+export function fileSearchServerToolValue1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileSearchServerToolValue1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileSearchServerToolValue1' from JSON`);
 }
 /** @internal */
-export const Value2$inboundSchema = z.union([
+export const FileSearchServerToolValue2$inboundSchema = z.union([
     z.string(),
     z.number(),
     z.boolean(),
     z.array(z.union([z.string(), z.number()])),
 ]);
 /** @internal */
-export const Value2$outboundSchema = z
-    .union([
+export const FileSearchServerToolValue2$outboundSchema = z.union([
     z.string(),
     z.number(),
     z.boolean(),
     z.array(z.union([z.string(), z.number()])),
 ]);
-export function value2ToJSON(value2) {
-    return JSON.stringify(Value2$outboundSchema.parse(value2));
+export function fileSearchServerToolValue2ToJSON(fileSearchServerToolValue2) {
+    return JSON.stringify(FileSearchServerToolValue2$outboundSchema.parse(fileSearchServerToolValue2));
 }
-export function value2FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Value2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value2' from JSON`);
+export function fileSearchServerToolValue2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileSearchServerToolValue2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileSearchServerToolValue2' from JSON`);
 }
 /** @internal */
 export const Filters$inboundSchema = z.object({

package/esm/models/functioncalloutputitem.d.ts

@@ -6,18 +6,19 @@ export declare const FunctionCallOutputItemDetail: {
     readonly Auto: "auto";
     readonly High: "high";
     readonly Low: "low";
+    readonly Original: "original";
 };
 export type FunctionCallOutputItemDetail = OpenEnum<typeof FunctionCallOutputItemDetail>;
 /**
  * Image input content item
  */
-export type OutputInputImage = {
+export type FunctionCallOutputItemOutputInputImage = {
     detail: FunctionCallOutputItemDetail;
     imageUrl?: string | null | undefined;
     type: "input_image";
 };
-export type FunctionCallOutputItemOutputUnion1 = InputText | OutputInputImage | InputFile;
-export type FunctionCallOutputItemOutputUnion2 = string | Array<InputText | OutputInputImage | InputFile>;
+export type FunctionCallOutputItemOutputUnion1 = InputText | FunctionCallOutputItemOutputInputImage | InputFile;
+export type FunctionCallOutputItemOutputUnion2 = string | Array<InputText | FunctionCallOutputItemOutputInputImage | InputFile>;
 export declare const FunctionCallOutputItemStatus: {
     readonly InProgress: "in_progress";
     readonly Completed: "completed";
@@ -34,28 +35,28 @@ export type FunctionCallOutputItemTypeFunctionCallOutput = ClosedEnum<typeof Fun
 export type FunctionCallOutputItem = {
     callId: string;
     id?: string | null | undefined;
-    output: string | Array<InputText | OutputInputImage | InputFile>;
+    output: string | Array<InputText | FunctionCallOutputItemOutputInputImage | InputFile>;
     status?: FunctionCallOutputItemStatus | null | undefined;
     type: FunctionCallOutputItemTypeFunctionCallOutput;
 };
 /** @internal */
 export declare const FunctionCallOutputItemDetail$outboundSchema: z.ZodType<string, FunctionCallOutputItemDetail>;
 /** @internal */
-export type OutputInputImage$Outbound = {
+export type FunctionCallOutputItemOutputInputImage$Outbound = {
     detail: string;
     image_url?: string | null | undefined;
     type: "input_image";
 };
 /** @internal */
-export declare const OutputInputImage$outboundSchema: z.ZodType<OutputInputImage$Outbound, OutputInputImage>;
-export declare function outputInputImageToJSON(outputInputImage: OutputInputImage): string;
+export declare const FunctionCallOutputItemOutputInputImage$outboundSchema: z.ZodType<FunctionCallOutputItemOutputInputImage$Outbound, FunctionCallOutputItemOutputInputImage>;
+export declare function functionCallOutputItemOutputInputImageToJSON(functionCallOutputItemOutputInputImage: FunctionCallOutputItemOutputInputImage): string;
 /** @internal */
-export type FunctionCallOutputItemOutputUnion1$Outbound = InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound;
+export type FunctionCallOutputItemOutputUnion1$Outbound = InputText$Outbound | FunctionCallOutputItemOutputInputImage$Outbound | InputFile$Outbound;
 /** @internal */
 export declare const FunctionCallOutputItemOutputUnion1$outboundSchema: z.ZodType<FunctionCallOutputItemOutputUnion1$Outbound, FunctionCallOutputItemOutputUnion1>;
 export declare function functionCallOutputItemOutputUnion1ToJSON(functionCallOutputItemOutputUnion1: FunctionCallOutputItemOutputUnion1): string;
 /** @internal */
-export type FunctionCallOutputItemOutputUnion2$Outbound = string | Array<InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound>;
+export type FunctionCallOutputItemOutputUnion2$Outbound = string | Array<InputText$Outbound | FunctionCallOutputItemOutputInputImage$Outbound | InputFile$Outbound>;
 /** @internal */
 export declare const FunctionCallOutputItemOutputUnion2$outboundSchema: z.ZodType<FunctionCallOutputItemOutputUnion2$Outbound, FunctionCallOutputItemOutputUnion2>;
 export declare function functionCallOutputItemOutputUnion2ToJSON(functionCallOutputItemOutputUnion2: FunctionCallOutputItemOutputUnion2): string;
@@ -67,7 +68,7 @@ export declare const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema
 export type FunctionCallOutputItem$Outbound = {
     call_id: string;
     id?: string | null | undefined;
-    output: string | Array<InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound>;
+    output: string | Array<InputText$Outbound | FunctionCallOutputItemOutputInputImage$Outbound | InputFile$Outbound>;
     status?: string | null | undefined;
     type: string;
 };

package/esm/models/functioncalloutputitem.js

@@ -11,6 +11,7 @@ export const FunctionCallOutputItemDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
+    Original: "original",
 };
 export const FunctionCallOutputItemStatus = {
     InProgress: "in_progress",
@@ -23,7 +24,7 @@ export const FunctionCallOutputItemTypeFunctionCallOutput = {
 /** @internal */
 export const FunctionCallOutputItemDetail$outboundSchema = openEnums.outboundSchema(FunctionCallOutputItemDetail);
 /** @internal */
-export const OutputInputImage$outboundSchema = z.object({
+export const FunctionCallOutputItemOutputInputImage$outboundSchema = z.object({
     detail: FunctionCallOutputItemDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
     type: z.literal("input_image"),
@@ -32,13 +33,13 @@ export const OutputInputImage$outboundSchema = z.object({
         imageUrl: "image_url",
     });
 });
-export function outputInputImageToJSON(outputInputImage) {
-    return JSON.stringify(OutputInputImage$outboundSchema.parse(outputInputImage));
+export function functionCallOutputItemOutputInputImageToJSON(functionCallOutputItemOutputInputImage) {
+    return JSON.stringify(FunctionCallOutputItemOutputInputImage$outboundSchema.parse(functionCallOutputItemOutputInputImage));
 }
 /** @internal */
 export const FunctionCallOutputItemOutputUnion1$outboundSchema = z.union([
     InputText$outboundSchema,
-    z.lazy(() => OutputInputImage$outboundSchema),
+    z.lazy(() => FunctionCallOutputItemOutputInputImage$outboundSchema),
     InputFile$outboundSchema,
 ]);
 export function functionCallOutputItemOutputUnion1ToJSON(functionCallOutputItemOutputUnion1) {
@@ -49,7 +50,7 @@ export const FunctionCallOutputItemOutputUnion2$outboundSchema = z.union([
     z.string(),
     z.array(z.union([
         InputText$outboundSchema,
-        z.lazy(() => OutputInputImage$outboundSchema),
+        z.lazy(() => FunctionCallOutputItemOutputInputImage$outboundSchema),
         InputFile$outboundSchema,
     ])),
 ]);
@@ -68,7 +69,7 @@ export const FunctionCallOutputItem$outboundSchema = z.object({
         z.string(),
         z.array(z.union([
             InputText$outboundSchema,
-            z.lazy(() => OutputInputImage$outboundSchema),
+            z.lazy(() => FunctionCallOutputItemOutputInputImage$outboundSchema),
             InputFile$outboundSchema,
         ])),
     ]),

package/esm/models/fusionanalysisresult.d.ts

@@ -0,0 +1,88 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type Stance = {
+    model: string;
+    stance: string;
+};
+export type Contradiction = {
+    stances: Array<Stance>;
+    topic: string;
+};
+export type PartialCoverage = {
+    models: Array<string>;
+    point: string;
+};
+export type UniqueInsight = {
+    insight: string;
+    model: string;
+};
+/**
+ * Structured analysis produced by the fusion judge model.
+ */
+export type FusionAnalysisResult = {
+    blindSpots: Array<string>;
+    consensus: Array<string>;
+    contradictions: Array<Contradiction>;
+    partialCoverage: Array<PartialCoverage>;
+    uniqueInsights: Array<UniqueInsight>;
+};
+/** @internal */
+export declare const Stance$inboundSchema: z.ZodType<Stance, unknown>;
+/** @internal */
+export type Stance$Outbound = {
+    model: string;
+    stance: string;
+};
+/** @internal */
+export declare const Stance$outboundSchema: z.ZodType<Stance$Outbound, Stance>;
+export declare function stanceToJSON(stance: Stance): string;
+export declare function stanceFromJSON(jsonString: string): SafeParseResult<Stance, SDKValidationError>;
+/** @internal */
+export declare const Contradiction$inboundSchema: z.ZodType<Contradiction, unknown>;
+/** @internal */
+export type Contradiction$Outbound = {
+    stances: Array<Stance$Outbound>;
+    topic: string;
+};
+/** @internal */
+export declare const Contradiction$outboundSchema: z.ZodType<Contradiction$Outbound, Contradiction>;
+export declare function contradictionToJSON(contradiction: Contradiction): string;
+export declare function contradictionFromJSON(jsonString: string): SafeParseResult<Contradiction, SDKValidationError>;
+/** @internal */
+export declare const PartialCoverage$inboundSchema: z.ZodType<PartialCoverage, unknown>;
+/** @internal */
+export type PartialCoverage$Outbound = {
+    models: Array<string>;
+    point: string;
+};
+/** @internal */
+export declare const PartialCoverage$outboundSchema: z.ZodType<PartialCoverage$Outbound, PartialCoverage>;
+export declare function partialCoverageToJSON(partialCoverage: PartialCoverage): string;
+export declare function partialCoverageFromJSON(jsonString: string): SafeParseResult<PartialCoverage, SDKValidationError>;
+/** @internal */
+export declare const UniqueInsight$inboundSchema: z.ZodType<UniqueInsight, unknown>;
+/** @internal */
+export type UniqueInsight$Outbound = {
+    insight: string;
+    model: string;
+};
+/** @internal */
+export declare const UniqueInsight$outboundSchema: z.ZodType<UniqueInsight$Outbound, UniqueInsight>;
+export declare function uniqueInsightToJSON(uniqueInsight: UniqueInsight): string;
+export declare function uniqueInsightFromJSON(jsonString: string): SafeParseResult<UniqueInsight, SDKValidationError>;
+/** @internal */
+export declare const FusionAnalysisResult$inboundSchema: z.ZodType<FusionAnalysisResult, unknown>;
+/** @internal */
+export type FusionAnalysisResult$Outbound = {
+    blind_spots: Array<string>;
+    consensus: Array<string>;
+    contradictions: Array<Contradiction$Outbound>;
+    partial_coverage: Array<PartialCoverage$Outbound>;
+    unique_insights: Array<UniqueInsight$Outbound>;
+};
+/** @internal */
+export declare const FusionAnalysisResult$outboundSchema: z.ZodType<FusionAnalysisResult$Outbound, FusionAnalysisResult>;
+export declare function fusionAnalysisResultToJSON(fusionAnalysisResult: FusionAnalysisResult): string;
+export declare function fusionAnalysisResultFromJSON(jsonString: string): SafeParseResult<FusionAnalysisResult, SDKValidationError>;
+//# sourceMappingURL=fusionanalysisresult.d.ts.map

package/esm/models/fusionanalysisresult.js

@@ -0,0 +1,109 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ffc6f5c74b6c
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const Stance$inboundSchema = z.object({
+    model: z.string(),
+    stance: z.string(),
+});
+/** @internal */
+export const Stance$outboundSchema = z
+    .object({
+    model: z.string(),
+    stance: z.string(),
+});
+export function stanceToJSON(stance) {
+    return JSON.stringify(Stance$outboundSchema.parse(stance));
+}
+export function stanceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Stance$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Stance' from JSON`);
+}
+/** @internal */
+export const Contradiction$inboundSchema = z
+    .object({
+    stances: z.array(z.lazy(() => Stance$inboundSchema)),
+    topic: z.string(),
+});
+/** @internal */
+export const Contradiction$outboundSchema = z.object({
+    stances: z.array(z.lazy(() => Stance$outboundSchema)),
+    topic: z.string(),
+});
+export function contradictionToJSON(contradiction) {
+    return JSON.stringify(Contradiction$outboundSchema.parse(contradiction));
+}
+export function contradictionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Contradiction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Contradiction' from JSON`);
+}
+/** @internal */
+export const PartialCoverage$inboundSchema = z.object({
+    models: z.array(z.string()),
+    point: z.string(),
+});
+/** @internal */
+export const PartialCoverage$outboundSchema = z.object({
+    models: z.array(z.string()),
+    point: z.string(),
+});
+export function partialCoverageToJSON(partialCoverage) {
+    return JSON.stringify(PartialCoverage$outboundSchema.parse(partialCoverage));
+}
+export function partialCoverageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PartialCoverage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PartialCoverage' from JSON`);
+}
+/** @internal */
+export const UniqueInsight$inboundSchema = z
+    .object({
+    insight: z.string(),
+    model: z.string(),
+});
+/** @internal */
+export const UniqueInsight$outboundSchema = z.object({
+    insight: z.string(),
+    model: z.string(),
+});
+export function uniqueInsightToJSON(uniqueInsight) {
+    return JSON.stringify(UniqueInsight$outboundSchema.parse(uniqueInsight));
+}
+export function uniqueInsightFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UniqueInsight$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UniqueInsight' from JSON`);
+}
+/** @internal */
+export const FusionAnalysisResult$inboundSchema = z.object({
+    blind_spots: z.array(z.string()),
+    consensus: z.array(z.string()),
+    contradictions: z.array(z.lazy(() => Contradiction$inboundSchema)),
+    partial_coverage: z.array(z.lazy(() => PartialCoverage$inboundSchema)),
+    unique_insights: z.array(z.lazy(() => UniqueInsight$inboundSchema)),
+}).transform((v) => {
+    return remap$(v, {
+        "blind_spots": "blindSpots",
+        "partial_coverage": "partialCoverage",
+        "unique_insights": "uniqueInsights",
+    });
+});
+/** @internal */
+export const FusionAnalysisResult$outboundSchema = z.object({
+    blindSpots: z.array(z.string()),
+    consensus: z.array(z.string()),
+    contradictions: z.array(z.lazy(() => Contradiction$outboundSchema)),
+    partialCoverage: z.array(z.lazy(() => PartialCoverage$outboundSchema)),
+    uniqueInsights: z.array(z.lazy(() => UniqueInsight$outboundSchema)),
+}).transform((v) => {
+    return remap$(v, {
+        blindSpots: "blind_spots",
+        partialCoverage: "partial_coverage",
+        uniqueInsights: "unique_insights",
+    });
+});
+export function fusionAnalysisResultToJSON(fusionAnalysisResult) {
+    return JSON.stringify(FusionAnalysisResult$outboundSchema.parse(fusionAnalysisResult));
+}
+export function fusionAnalysisResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FusionAnalysisResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FusionAnalysisResult' from JSON`);
+}
+//# sourceMappingURL=fusionanalysisresult.js.map

package/esm/models/fusioncallanalysiscompletedevent.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { FusionAnalysisResult } from "./fusionanalysisresult.js";
+/**
+ * Emitted when the fusion judge completes with the structured analysis.
+ */
+export type FusionCallAnalysisCompletedEvent = {
+    /**
+     * Structured analysis produced by the fusion judge model.
+     */
+    analysis: FusionAnalysisResult;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.fusion_call.analysis.completed";
+};
+/** @internal */
+export declare const FusionCallAnalysisCompletedEvent$inboundSchema: z.ZodType<FusionCallAnalysisCompletedEvent, unknown>;
+export declare function fusionCallAnalysisCompletedEventFromJSON(jsonString: string): SafeParseResult<FusionCallAnalysisCompletedEvent, SDKValidationError>;
+//# sourceMappingURL=fusioncallanalysiscompletedevent.d.ts.map

package/esm/models/fusioncallanalysiscompletedevent.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0df2084e1a56
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { FusionAnalysisResult$inboundSchema, } from "./fusionanalysisresult.js";
+/** @internal */
+export const FusionCallAnalysisCompletedEvent$inboundSchema = z.object({
+    analysis: FusionAnalysisResult$inboundSchema,
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.fusion_call.analysis.completed"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function fusionCallAnalysisCompletedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FusionCallAnalysisCompletedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FusionCallAnalysisCompletedEvent' from JSON`);
+}
+//# sourceMappingURL=fusioncallanalysiscompletedevent.js.map

package/esm/models/fusioncallanalysisinprogressevent.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Emitted when the fusion judge starts producing the structured analysis.
+ */
+export type FusionCallAnalysisInProgressEvent = {
+    itemId: string;
+    judgeModel: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.fusion_call.analysis.in_progress";
+};
+/** @internal */
+export declare const FusionCallAnalysisInProgressEvent$inboundSchema: z.ZodType<FusionCallAnalysisInProgressEvent, unknown>;
+export declare function fusionCallAnalysisInProgressEventFromJSON(jsonString: string): SafeParseResult<FusionCallAnalysisInProgressEvent, SDKValidationError>;
+//# sourceMappingURL=fusioncallanalysisinprogressevent.d.ts.map