@openrouter/sdk 0.12.34 → 0.12.79

package/esm/models/outputfunctioncallitem.js

@@ -57,6 +57,7 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
     call_id: z.string(),
     id: z.string().optional(),
     name: z.string(),
+    namespace: z.string().optional(),
     status: z.union([
         OutputFunctionCallItemStatusCompleted$inboundSchema,
         OutputFunctionCallItemStatusIncomplete$inboundSchema,
@@ -74,6 +75,7 @@ export const OutputFunctionCallItem$outboundSchema = z.object({
     callId: z.string(),
     id: z.string().optional(),
     name: z.string(),
+    namespace: z.string().optional(),
     status: z.union([
         OutputFunctionCallItemStatusCompleted$outboundSchema,
         OutputFunctionCallItemStatusIncomplete$outboundSchema,

package/esm/models/outputfusionservertoolitem.d.ts

@@ -0,0 +1,100 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.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 Analysis = {
+    blindSpots: Array<string>;
+    consensus: Array<string>;
+    contradictions: Array<Contradiction>;
+    partialCoverage: Array<PartialCoverage>;
+    uniqueInsights: Array<UniqueInsight>;
+};
+export type FailedModel = {
+    /**
+     * Error message describing why the model failed.
+     */
+    error: string;
+    /**
+     * Slug of the analysis model that failed.
+     */
+    model: string;
+    /**
+     * HTTP status code from the upstream response, when available (e.g. 402, 429).
+     */
+    statusCode?: number | undefined;
+};
+export type ResponseT = {
+    model: string;
+};
+/**
+ * An openrouter:fusion server tool output item
+ */
+export type OutputFusionServerToolItem = {
+    /**
+     * Structured analysis produced by the fusion judge model.
+     */
+    analysis?: Analysis | undefined;
+    /**
+     * Error message when the fusion run did not produce an analysis result.
+     */
+    error?: string | undefined;
+    /**
+     * Models that were requested as part of the analysis panel but did not produce a response. Present when at least one requested analysis model failed. The fusion result is still usable but was produced from a degraded panel.
+     */
+    failedModels?: Array<FailedModel> | undefined;
+    /**
+     * Typed failure reason when the fusion run failed. Possible values include: all_panels_failed, insufficient_credits, rate_limited, judge_not_valid_json, judge_schema_mismatch, judge_upstream_error, judge_empty_completion.
+     */
+    failureReason?: string | undefined;
+    id?: string | undefined;
+    /**
+     * Slugs of the analysis models that produced a response in this fusion run.
+     */
+    responses?: Array<ResponseT> | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:fusion";
+};
+/** @internal */
+export declare const Stance$inboundSchema: z.ZodType<Stance, unknown>;
+export declare function stanceFromJSON(jsonString: string): SafeParseResult<Stance, SDKValidationError>;
+/** @internal */
+export declare const Contradiction$inboundSchema: z.ZodType<Contradiction, unknown>;
+export declare function contradictionFromJSON(jsonString: string): SafeParseResult<Contradiction, SDKValidationError>;
+/** @internal */
+export declare const PartialCoverage$inboundSchema: z.ZodType<PartialCoverage, unknown>;
+export declare function partialCoverageFromJSON(jsonString: string): SafeParseResult<PartialCoverage, SDKValidationError>;
+/** @internal */
+export declare const UniqueInsight$inboundSchema: z.ZodType<UniqueInsight, unknown>;
+export declare function uniqueInsightFromJSON(jsonString: string): SafeParseResult<UniqueInsight, SDKValidationError>;
+/** @internal */
+export declare const Analysis$inboundSchema: z.ZodType<Analysis, unknown>;
+export declare function analysisFromJSON(jsonString: string): SafeParseResult<Analysis, SDKValidationError>;
+/** @internal */
+export declare const FailedModel$inboundSchema: z.ZodType<FailedModel, unknown>;
+export declare function failedModelFromJSON(jsonString: string): SafeParseResult<FailedModel, SDKValidationError>;
+/** @internal */
+export declare const ResponseT$inboundSchema: z.ZodType<ResponseT, unknown>;
+export declare function responseFromJSON(jsonString: string): SafeParseResult<ResponseT, SDKValidationError>;
+/** @internal */
+export declare const OutputFusionServerToolItem$inboundSchema: z.ZodType<OutputFusionServerToolItem, unknown>;
+export declare function outputFusionServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputFusionServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputfusionservertoolitem.d.ts.map

package/esm/models/outputfusionservertoolitem.js

@@ -0,0 +1,100 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 30bcfe965217
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const Stance$inboundSchema = z.object({
+    model: z.string(),
+    stance: z.string(),
+});
+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(),
+});
+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(),
+});
+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(),
+});
+export function uniqueInsightFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UniqueInsight$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UniqueInsight' from JSON`);
+}
+/** @internal */
+export const Analysis$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",
+    });
+});
+export function analysisFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Analysis$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Analysis' from JSON`);
+}
+/** @internal */
+export const FailedModel$inboundSchema = z
+    .object({
+    error: z.string(),
+    model: z.string(),
+    status_code: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "status_code": "statusCode",
+    });
+});
+export function failedModelFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FailedModel$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FailedModel' from JSON`);
+}
+/** @internal */
+export const ResponseT$inboundSchema = z.object({
+    model: z.string(),
+});
+export function responseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponseT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseT' from JSON`);
+}
+/** @internal */
+export const OutputFusionServerToolItem$inboundSchema = z.object({
+    analysis: z.lazy(() => Analysis$inboundSchema).optional(),
+    error: z.string().optional(),
+    failed_models: z.array(z.lazy(() => FailedModel$inboundSchema)).optional(),
+    failure_reason: z.string().optional(),
+    id: z.string().optional(),
+    responses: z.array(z.lazy(() => ResponseT$inboundSchema)).optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:fusion"),
+}).transform((v) => {
+    return remap$(v, {
+        "failed_models": "failedModels",
+        "failure_reason": "failureReason",
+    });
+});
+export function outputFusionServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFusionServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFusionServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputfusionservertoolitem.js.map

package/esm/models/outputitems.d.ts

@@ -2,16 +2,19 @@ import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OutputApplyPatchCallItem } from "./outputapplypatchcallitem.js";
 import { OutputApplyPatchServerToolItem } from "./outputapplypatchservertoolitem.js";
 import { OutputBashServerToolItem } from "./outputbashservertoolitem.js";
 import { OutputBrowserUseServerToolItem } from "./outputbrowseruseservertoolitem.js";
 import { OutputCodeInterpreterCallItem } from "./outputcodeinterpretercallitem.js";
 import { OutputCodeInterpreterServerToolItem } from "./outputcodeinterpreterservertoolitem.js";
 import { OutputComputerCallItem } from "./outputcomputercallitem.js";
+import { OutputCustomToolCallItem } from "./outputcustomtoolcallitem.js";
 import { OutputDatetimeItem } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem } from "./outputfilesearchcallitem.js";
 import { OutputFileSearchServerToolItem } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem } from "./outputfunctioncallitem.js";
+import { OutputFusionServerToolItem } from "./outputfusionservertoolitem.js";
 import { OutputImageGenerationCallItem } from "./outputimagegenerationcallitem.js";
 import { OutputImageGenerationServerToolItem } from "./outputimagegenerationservertoolitem.js";
 import { OutputMcpServerToolItem } from "./outputmcpservertoolitem.js";
@@ -27,10 +30,12 @@ import { OutputWebSearchServerToolItem } from "./outputwebsearchservertoolitem.j
 /**
  * An output item from the response
  */
-export type OutputItems = (OutputCodeInterpreterCallItem & {
+export type OutputItems = OutputApplyPatchCallItem | (OutputCodeInterpreterCallItem & {
     type: "code_interpreter_call";
 }) | (OutputComputerCallItem & {
     type: "computer_call";
+}) | (OutputCustomToolCallItem & {
+    type: "custom_tool_call";
 }) | (OutputFileSearchCallItem & {
     type: "file_search_call";
 }) | (OutputFunctionCallItem & {
@@ -51,7 +56,7 @@ export type OutputItems = (OutputCodeInterpreterCallItem & {
     type: "openrouter:experimental__search_models";
 }) | (OutputFileSearchServerToolItem & {
     type: "openrouter:file_search";
-}) | (OutputImageGenerationServerToolItem & {
+}) | OutputFusionServerToolItem | (OutputImageGenerationServerToolItem & {
     type: "openrouter:image_generation";
 }) | (OutputMcpServerToolItem & {
     type: "openrouter:mcp";

package/esm/models/outputitems.js

@@ -5,16 +5,19 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { OutputApplyPatchCallItem$inboundSchema, } from "./outputapplypatchcallitem.js";
 import { OutputApplyPatchServerToolItem$inboundSchema, } from "./outputapplypatchservertoolitem.js";
 import { OutputBashServerToolItem$inboundSchema, } from "./outputbashservertoolitem.js";
 import { OutputBrowserUseServerToolItem$inboundSchema, } from "./outputbrowseruseservertoolitem.js";
 import { OutputCodeInterpreterCallItem$inboundSchema, } from "./outputcodeinterpretercallitem.js";
 import { OutputCodeInterpreterServerToolItem$inboundSchema, } from "./outputcodeinterpreterservertoolitem.js";
 import { OutputComputerCallItem$inboundSchema, } from "./outputcomputercallitem.js";
+import { OutputCustomToolCallItem$inboundSchema, } from "./outputcustomtoolcallitem.js";
 import { OutputDatetimeItem$inboundSchema, } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem$inboundSchema, } from "./outputfilesearchcallitem.js";
 import { OutputFileSearchServerToolItem$inboundSchema, } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem$inboundSchema, } from "./outputfunctioncallitem.js";
+import { OutputFusionServerToolItem$inboundSchema, } from "./outputfusionservertoolitem.js";
 import { OutputImageGenerationCallItem$inboundSchema, } from "./outputimagegenerationcallitem.js";
 import { OutputImageGenerationServerToolItem$inboundSchema, } from "./outputimagegenerationservertoolitem.js";
 import { OutputMcpServerToolItem$inboundSchema, } from "./outputmcpservertoolitem.js";
@@ -29,8 +32,10 @@ import { OutputWebSearchCallItem$inboundSchema, } from "./outputwebsearchcallite
 import { OutputWebSearchServerToolItem$inboundSchema, } from "./outputwebsearchservertoolitem.js";
 /** @internal */
 export const OutputItems$inboundSchema = discriminatedUnion("type", {
+    apply_patch_call: OutputApplyPatchCallItem$inboundSchema,
     code_interpreter_call: OutputCodeInterpreterCallItem$inboundSchema.and(z.object({ type: z.literal("code_interpreter_call") })),
     computer_call: OutputComputerCallItem$inboundSchema.and(z.object({ type: z.literal("computer_call") })),
+    custom_tool_call: OutputCustomToolCallItem$inboundSchema.and(z.object({ type: z.literal("custom_tool_call") })),
     file_search_call: OutputFileSearchCallItem$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
     function_call: OutputFunctionCallItem$inboundSchema.and(z.object({ type: z.literal("function_call") })),
     image_generation_call: OutputImageGenerationCallItem$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
@@ -45,6 +50,7 @@ export const OutputItems$inboundSchema = discriminatedUnion("type", {
     ["openrouter:experimental__search_models"]: OutputSearchModelsServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:experimental__search_models") })),
     ["openrouter:file_search"]: OutputFileSearchServerToolItem$inboundSchema
         .and(z.object({ type: z.literal("openrouter:file_search") })),
+    ["openrouter:fusion"]: OutputFusionServerToolItem$inboundSchema,
     ["openrouter:image_generation"]: OutputImageGenerationServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:image_generation") })),
     ["openrouter:mcp"]: OutputMcpServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:mcp") })),
     ["openrouter:memory"]: OutputMemoryServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:memory") })),

package/esm/models/outputwebsearchservertoolitem.d.ts

@@ -7,7 +7,7 @@ export declare const OutputWebSearchServerToolItemTypeURL: {
     readonly Url: "url";
 };
 export type OutputWebSearchServerToolItemTypeURL = ClosedEnum<typeof OutputWebSearchServerToolItemTypeURL>;
-export type Source = {
+export type OutputWebSearchServerToolItemSource = {
     type: OutputWebSearchServerToolItemTypeURL;
     url: string;
 };
@@ -20,7 +20,7 @@ export type OutputWebSearchServerToolItemTypeSearch = ClosedEnum<typeof OutputWe
  */
 export type OutputWebSearchServerToolItemAction = {
     query: string;
-    sources?: Array<Source> | undefined;
+    sources?: Array<OutputWebSearchServerToolItemSource> | undefined;
     type: OutputWebSearchServerToolItemTypeSearch;
 };
 export declare const OutputWebSearchServerToolItemTypeOpenrouterWebSearch: {
@@ -44,16 +44,16 @@ export declare const OutputWebSearchServerToolItemTypeURL$inboundSchema: z.ZodEn
 /** @internal */
 export declare const OutputWebSearchServerToolItemTypeURL$outboundSchema: z.ZodEnum<typeof OutputWebSearchServerToolItemTypeURL>;
 /** @internal */
-export declare const Source$inboundSchema: z.ZodType<Source, unknown>;
+export declare const OutputWebSearchServerToolItemSource$inboundSchema: z.ZodType<OutputWebSearchServerToolItemSource, unknown>;
 /** @internal */
-export type Source$Outbound = {
+export type OutputWebSearchServerToolItemSource$Outbound = {
     type: string;
     url: string;
 };
 /** @internal */
-export declare const Source$outboundSchema: z.ZodType<Source$Outbound, Source>;
-export declare function sourceToJSON(source: Source): string;
-export declare function sourceFromJSON(jsonString: string): SafeParseResult<Source, SDKValidationError>;
+export declare const OutputWebSearchServerToolItemSource$outboundSchema: z.ZodType<OutputWebSearchServerToolItemSource$Outbound, OutputWebSearchServerToolItemSource>;
+export declare function outputWebSearchServerToolItemSourceToJSON(outputWebSearchServerToolItemSource: OutputWebSearchServerToolItemSource): string;
+export declare function outputWebSearchServerToolItemSourceFromJSON(jsonString: string): SafeParseResult<OutputWebSearchServerToolItemSource, SDKValidationError>;
 /** @internal */
 export declare const OutputWebSearchServerToolItemTypeSearch$inboundSchema: z.ZodEnum<typeof OutputWebSearchServerToolItemTypeSearch>;
 /** @internal */
@@ -63,7 +63,7 @@ export declare const OutputWebSearchServerToolItemAction$inboundSchema: z.ZodTyp
 /** @internal */
 export type OutputWebSearchServerToolItemAction$Outbound = {
     query: string;
-    sources?: Array<Source$Outbound> | undefined;
+    sources?: Array<OutputWebSearchServerToolItemSource$Outbound> | undefined;
     type: string;
 };
 /** @internal */

package/esm/models/outputwebsearchservertoolitem.js

@@ -19,21 +19,20 @@ export const OutputWebSearchServerToolItemTypeURL$inboundSchema = z.enum(OutputW
 /** @internal */
 export const OutputWebSearchServerToolItemTypeURL$outboundSchema = OutputWebSearchServerToolItemTypeURL$inboundSchema;
 /** @internal */
-export const Source$inboundSchema = z.object({
+export const OutputWebSearchServerToolItemSource$inboundSchema = z.object({
     type: OutputWebSearchServerToolItemTypeURL$inboundSchema,
     url: z.string(),
 });
 /** @internal */
-export const Source$outboundSchema = z
-    .object({
+export const OutputWebSearchServerToolItemSource$outboundSchema = z.object({
     type: OutputWebSearchServerToolItemTypeURL$outboundSchema,
     url: z.string(),
 });
-export function sourceToJSON(source) {
-    return JSON.stringify(Source$outboundSchema.parse(source));
+export function outputWebSearchServerToolItemSourceToJSON(outputWebSearchServerToolItemSource) {
+    return JSON.stringify(OutputWebSearchServerToolItemSource$outboundSchema.parse(outputWebSearchServerToolItemSource));
 }
-export function sourceFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Source$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Source' from JSON`);
+export function outputWebSearchServerToolItemSourceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputWebSearchServerToolItemSource$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputWebSearchServerToolItemSource' from JSON`);
 }
 /** @internal */
 export const OutputWebSearchServerToolItemTypeSearch$inboundSchema = z.enum(OutputWebSearchServerToolItemTypeSearch);
@@ -42,13 +41,13 @@ export const OutputWebSearchServerToolItemTypeSearch$outboundSchema = OutputWebS
 /** @internal */
 export const OutputWebSearchServerToolItemAction$inboundSchema = z.object({
     query: z.string(),
-    sources: z.array(z.lazy(() => Source$inboundSchema)).optional(),
+    sources: z.array(z.lazy(() => OutputWebSearchServerToolItemSource$inboundSchema)).optional(),
     type: OutputWebSearchServerToolItemTypeSearch$inboundSchema,
 });
 /** @internal */
 export const OutputWebSearchServerToolItemAction$outboundSchema = z.object({
     query: z.string(),
-    sources: z.array(z.lazy(() => Source$outboundSchema)).optional(),
+    sources: z.array(z.lazy(() => OutputWebSearchServerToolItemSource$outboundSchema)).optional(),
     type: OutputWebSearchServerToolItemTypeSearch$outboundSchema,
 });
 export function outputWebSearchServerToolItemActionToJSON(outputWebSearchServerToolItemAction) {

package/esm/models/pipelinestage.d.ts

@@ -10,6 +10,7 @@ export type PipelineStage = {
     guardrailId?: string | undefined;
     guardrailScope?: string | undefined;
     name: string;
+    summary?: string | undefined;
     /**
      * Categorical kind of a pipeline stage. Multiple plugins can share a type (e.g. all guardrail-level plugins emit `guardrail`); the `name` field disambiguates which plugin emitted it.
      */

package/esm/models/pipelinestage.js

@@ -14,6 +14,7 @@ export const PipelineStage$inboundSchema = z
     guardrail_id: z.string().optional(),
     guardrail_scope: z.string().optional(),
     name: z.string(),
+    summary: z.string().optional(),
     type: PipelineStageType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {

package/esm/models/presetdesignatedversion.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A specific version of a preset, containing config and optional system prompt.
+ */
+export type PresetDesignatedVersion = {
+    config: {
+        [k: string]: any | null;
+    };
+    createdAt: string;
+    creatorId: string;
+    id: string;
+    presetId: string;
+    systemPrompt: string | null;
+    updatedAt: string;
+    version: number;
+};
+/** @internal */
+export declare const PresetDesignatedVersion$inboundSchema: z.ZodType<PresetDesignatedVersion, unknown>;
+export declare function presetDesignatedVersionFromJSON(jsonString: string): SafeParseResult<PresetDesignatedVersion, SDKValidationError>;
+//# sourceMappingURL=presetdesignatedversion.d.ts.map

package/esm/models/presetdesignatedversion.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 259a18622bbe
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const PresetDesignatedVersion$inboundSchema = z.object({
+    config: z.record(z.string(), z.nullable(z.any())),
+    created_at: z.string(),
+    creator_id: z.string(),
+    id: z.string(),
+    preset_id: z.string(),
+    system_prompt: z.nullable(z.string()),
+    updated_at: z.string(),
+    version: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "creator_id": "creatorId",
+        "preset_id": "presetId",
+        "system_prompt": "systemPrompt",
+        "updated_at": "updatedAt",
+    });
+});
+export function presetDesignatedVersionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PresetDesignatedVersion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PresetDesignatedVersion' from JSON`);
+}
+//# sourceMappingURL=presetdesignatedversion.js.map

package/esm/models/presetwithdesignatedversion.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { PresetDesignatedVersion } from "./presetdesignatedversion.js";
+export declare const PresetWithDesignatedVersionStatus: {
+    readonly Active: "active";
+    readonly Disabled: "disabled";
+    readonly Archived: "archived";
+};
+export type PresetWithDesignatedVersionStatus = OpenEnum<typeof PresetWithDesignatedVersionStatus>;
+/**
+ * A preset with its currently designated version.
+ */
+export type PresetWithDesignatedVersion = {
+    createdAt: string;
+    creatorUserId: string | null;
+    description: string | null;
+    /**
+     * A specific version of a preset, containing config and optional system prompt.
+     */
+    designatedVersion: PresetDesignatedVersion | null;
+    designatedVersionId: string | null;
+    id: string;
+    name: string;
+    slug: string;
+    status: PresetWithDesignatedVersionStatus;
+    statusUpdatedAt: string | null;
+    updatedAt: string;
+    workspaceId: string | null;
+};
+/** @internal */
+export declare const PresetWithDesignatedVersionStatus$inboundSchema: z.ZodType<PresetWithDesignatedVersionStatus, unknown>;
+/** @internal */
+export declare const PresetWithDesignatedVersion$inboundSchema: z.ZodType<PresetWithDesignatedVersion, unknown>;
+export declare function presetWithDesignatedVersionFromJSON(jsonString: string): SafeParseResult<PresetWithDesignatedVersion, SDKValidationError>;
+//# sourceMappingURL=presetwithdesignatedversion.d.ts.map

package/esm/models/presetwithdesignatedversion.js

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6ebecbfabdd3
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { PresetDesignatedVersion$inboundSchema, } from "./presetdesignatedversion.js";
+export const PresetWithDesignatedVersionStatus = {
+    Active: "active",
+    Disabled: "disabled",
+    Archived: "archived",
+};
+/** @internal */
+export const PresetWithDesignatedVersionStatus$inboundSchema = openEnums.inboundSchema(PresetWithDesignatedVersionStatus);
+/** @internal */
+export const PresetWithDesignatedVersion$inboundSchema = z.object({
+    created_at: z.string(),
+    creator_user_id: z.nullable(z.string()),
+    description: z.nullable(z.string()),
+    designated_version: z.nullable(PresetDesignatedVersion$inboundSchema),
+    designated_version_id: z.nullable(z.string()),
+    id: z.string(),
+    name: z.string(),
+    slug: z.string(),
+    status: PresetWithDesignatedVersionStatus$inboundSchema,
+    status_updated_at: z.nullable(z.string()),
+    updated_at: z.string(),
+    workspace_id: z.nullable(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "creator_user_id": "creatorUserId",
+        "designated_version": "designatedVersion",
+        "designated_version_id": "designatedVersionId",
+        "status_updated_at": "statusUpdatedAt",
+        "updated_at": "updatedAt",
+        "workspace_id": "workspaceId",
+    });
+});
+export function presetWithDesignatedVersionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PresetWithDesignatedVersion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PresetWithDesignatedVersion' from JSON`);
+}
+//# sourceMappingURL=presetwithdesignatedversion.js.map

package/esm/models/providername.d.ts

@@ -23,10 +23,13 @@ export declare const ProviderName: {
     readonly Clarifai: "Clarifai";
     readonly Cloudflare: "Cloudflare";
     readonly Cohere: "Cohere";
+    readonly Crucible: "Crucible";
     readonly Crusoe: "Crusoe";
+    readonly Darkbloom: "Darkbloom";
     readonly DeepInfra: "DeepInfra";
     readonly DeepSeek: "DeepSeek";
     readonly DekaLLM: "DekaLLM";
+    readonly DigitalOcean: "DigitalOcean";
     readonly Featherless: "Featherless";
     readonly Fireworks: "Fireworks";
     readonly Friendli: "Friendli";

package/esm/models/providername.js

@@ -26,10 +26,13 @@ export const ProviderName = {
     Clarifai: "Clarifai",
     Cloudflare: "Cloudflare",
     Cohere: "Cohere",
+    Crucible: "Crucible",
     Crusoe: "Crusoe",
+    Darkbloom: "Darkbloom",
     DeepInfra: "DeepInfra",
     DeepSeek: "DeepSeek",
     DekaLLM: "DekaLLM",
+    DigitalOcean: "DigitalOcean",
     Featherless: "Featherless",
     Fireworks: "Fireworks",
     Friendli: "Friendli",

package/esm/models/provideroptions.d.ts

@@ -84,9 +84,15 @@ export type ProviderOptions = {
     crofai?: {
         [k: string]: any | null;
     } | undefined;
+    crucible?: {
+        [k: string]: any | null;
+    } | undefined;
     crusoe?: {
         [k: string]: any | null;
     } | undefined;
+    darkbloom?: {
+        [k: string]: any | null;
+    } | undefined;
     deepinfra?: {
         [k: string]: any | null;
     } | undefined;
@@ -96,6 +102,9 @@ export type ProviderOptions = {
     dekallm?: {
         [k: string]: any | null;
     } | undefined;
+    digitalocean?: {
+        [k: string]: any | null;
+    } | undefined;
     enfer?: {
         [k: string]: any | null;
     } | undefined;
@@ -417,9 +426,15 @@ export type ProviderOptions$Outbound = {
     crofai?: {
         [k: string]: any | null;
     } | undefined;
+    crucible?: {
+        [k: string]: any | null;
+    } | undefined;
     crusoe?: {
         [k: string]: any | null;
     } | undefined;
+    darkbloom?: {
+        [k: string]: any | null;
+    } | undefined;
     deepinfra?: {
         [k: string]: any | null;
     } | undefined;
@@ -429,6 +444,9 @@ export type ProviderOptions$Outbound = {
     dekallm?: {
         [k: string]: any | null;
     } | undefined;
+    digitalocean?: {
+        [k: string]: any | null;
+    } | undefined;
     enfer?: {
         [k: string]: any | null;
     } | undefined;

package/esm/models/provideroptions.js

@@ -33,10 +33,13 @@ export const ProviderOptions$outboundSchema = z.object({
     cloudflare: z.record(z.string(), z.nullable(z.any())).optional(),
     cohere: z.record(z.string(), z.nullable(z.any())).optional(),
     crofai: z.record(z.string(), z.nullable(z.any())).optional(),
+    crucible: z.record(z.string(), z.nullable(z.any())).optional(),
     crusoe: z.record(z.string(), z.nullable(z.any())).optional(),
+    darkbloom: z.record(z.string(), z.nullable(z.any())).optional(),
     deepinfra: z.record(z.string(), z.nullable(z.any())).optional(),
     deepseek: z.record(z.string(), z.nullable(z.any())).optional(),
     dekallm: z.record(z.string(), z.nullable(z.any())).optional(),
+    digitalocean: z.record(z.string(), z.nullable(z.any())).optional(),
     enfer: z.record(z.string(), z.nullable(z.any())).optional(),
     fakeProvider: z.record(z.string(), z.nullable(z.any())).optional(),
     featherless: z.record(z.string(), z.nullable(z.any())).optional(),