@openrouter/sdk 0.12.20 → 0.12.21

package/esm/models/outputmemoryservertoolitem.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
@@ -9,6 +9,10 @@ export declare const ActionEnum: {
     readonly Delete: "delete";
 };
 export type ActionEnum = OpenEnum<typeof ActionEnum>;
+export declare const OutputMemoryServerToolItemType: {
+    readonly OpenrouterMemory: "openrouter:memory";
+};
+export type OutputMemoryServerToolItemType = ClosedEnum<typeof OutputMemoryServerToolItemType>;
 /**
  * An openrouter:memory server tool output item
  */
@@ -17,12 +21,30 @@ export type OutputMemoryServerToolItem = {
     id?: string | undefined;
     key?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:memory";
+    type: OutputMemoryServerToolItemType;
     value?: any | null | undefined;
 };
 /** @internal */
 export declare const ActionEnum$inboundSchema: z.ZodType<ActionEnum, unknown>;
 /** @internal */
+export declare const ActionEnum$outboundSchema: z.ZodType<string, ActionEnum>;
+/** @internal */
+export declare const OutputMemoryServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputMemoryServerToolItemType>;
+/** @internal */
+export declare const OutputMemoryServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputMemoryServerToolItemType>;
+/** @internal */
 export declare const OutputMemoryServerToolItem$inboundSchema: z.ZodType<OutputMemoryServerToolItem, unknown>;
+/** @internal */
+export type OutputMemoryServerToolItem$Outbound = {
+    action?: string | undefined;
+    id?: string | undefined;
+    key?: string | undefined;
+    status: string;
+    type: string;
+    value?: any | null | undefined;
+};
+/** @internal */
+export declare const OutputMemoryServerToolItem$outboundSchema: z.ZodType<OutputMemoryServerToolItem$Outbound, OutputMemoryServerToolItem>;
+export declare function outputMemoryServerToolItemToJSON(outputMemoryServerToolItem: OutputMemoryServerToolItem): string;
 export declare function outputMemoryServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputMemoryServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputmemoryservertoolitem.d.ts.map

package/esm/models/outputmemoryservertoolitem.js

@@ -5,23 +5,44 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
 export const ActionEnum = {
     Read: "read",
     Write: "write",
     Delete: "delete",
 };
+export const OutputMemoryServerToolItemType = {
+    OpenrouterMemory: "openrouter:memory",
+};
 /** @internal */
 export const ActionEnum$inboundSchema = openEnums.inboundSchema(ActionEnum);
 /** @internal */
+export const ActionEnum$outboundSchema = openEnums.outboundSchema(ActionEnum);
+/** @internal */
+export const OutputMemoryServerToolItemType$inboundSchema = z.enum(OutputMemoryServerToolItemType);
+/** @internal */
+export const OutputMemoryServerToolItemType$outboundSchema = OutputMemoryServerToolItemType$inboundSchema;
+/** @internal */
 export const OutputMemoryServerToolItem$inboundSchema = z.object({
     action: ActionEnum$inboundSchema.optional(),
     id: z.string().optional(),
     key: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:memory"),
+    type: OutputMemoryServerToolItemType$inboundSchema,
+    value: z.nullable(z.any()).optional(),
+});
+/** @internal */
+export const OutputMemoryServerToolItem$outboundSchema = z.object({
+    action: ActionEnum$outboundSchema.optional(),
+    id: z.string().optional(),
+    key: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputMemoryServerToolItemType$outboundSchema,
     value: z.nullable(z.any()).optional(),
 });
+export function outputMemoryServerToolItemToJSON(outputMemoryServerToolItem) {
+    return JSON.stringify(OutputMemoryServerToolItem$outboundSchema.parse(outputMemoryServerToolItem));
+}
 export function outputMemoryServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMemoryServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMemoryServerToolItem' from JSON`);
 }

package/esm/models/outputsearchmodelsservertoolitem.d.ts

@@ -1,7 +1,12 @@
 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";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputSearchModelsServerToolItemType: {
+    readonly OpenrouterExperimentalSearchModels: "openrouter:experimental__search_models";
+};
+export type OutputSearchModelsServerToolItemType = ClosedEnum<typeof OutputSearchModelsServerToolItemType>;
 /**
  * An openrouter:experimental__search_models server tool output item
  */
@@ -13,9 +18,24 @@ export type OutputSearchModelsServerToolItem = {
     id?: string | undefined;
     query?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:experimental__search_models";
+    type: OutputSearchModelsServerToolItemType;
 };
 /** @internal */
+export declare const OutputSearchModelsServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputSearchModelsServerToolItemType>;
+/** @internal */
+export declare const OutputSearchModelsServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputSearchModelsServerToolItemType>;
+/** @internal */
 export declare const OutputSearchModelsServerToolItem$inboundSchema: z.ZodType<OutputSearchModelsServerToolItem, unknown>;
+/** @internal */
+export type OutputSearchModelsServerToolItem$Outbound = {
+    arguments?: string | undefined;
+    id?: string | undefined;
+    query?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputSearchModelsServerToolItem$outboundSchema: z.ZodType<OutputSearchModelsServerToolItem$Outbound, OutputSearchModelsServerToolItem>;
+export declare function outputSearchModelsServerToolItemToJSON(outputSearchModelsServerToolItem: OutputSearchModelsServerToolItem): string;
 export declare function outputSearchModelsServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputSearchModelsServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputsearchmodelsservertoolitem.d.ts.map

package/esm/models/outputsearchmodelsservertoolitem.js

@@ -4,15 +4,33 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputSearchModelsServerToolItemType = {
+    OpenrouterExperimentalSearchModels: "openrouter:experimental__search_models",
+};
+/** @internal */
+export const OutputSearchModelsServerToolItemType$inboundSchema = z.enum(OutputSearchModelsServerToolItemType);
+/** @internal */
+export const OutputSearchModelsServerToolItemType$outboundSchema = OutputSearchModelsServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputSearchModelsServerToolItem$inboundSchema = z.object({
     arguments: z.string().optional(),
     id: z.string().optional(),
     query: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:experimental__search_models"),
+    type: OutputSearchModelsServerToolItemType$inboundSchema,
+});
+/** @internal */
+export const OutputSearchModelsServerToolItem$outboundSchema = z.object({
+    arguments: z.string().optional(),
+    id: z.string().optional(),
+    query: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputSearchModelsServerToolItemType$outboundSchema,
 });
+export function outputSearchModelsServerToolItemToJSON(outputSearchModelsServerToolItem) {
+    return JSON.stringify(OutputSearchModelsServerToolItem$outboundSchema.parse(outputSearchModelsServerToolItem));
+}
 export function outputSearchModelsServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputSearchModelsServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputSearchModelsServerToolItem' from JSON`);
 }

package/esm/models/outputtexteditorservertoolitem.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
@@ -10,6 +10,10 @@ export declare const Command: {
     readonly Insert: "insert";
 };
 export type Command = OpenEnum<typeof Command>;
+export declare const OutputTextEditorServerToolItemType: {
+    readonly OpenrouterTextEditor: "openrouter:text_editor";
+};
+export type OutputTextEditorServerToolItemType = ClosedEnum<typeof OutputTextEditorServerToolItemType>;
 /**
  * An openrouter:text_editor server tool output item
  */
@@ -18,11 +22,28 @@ export type OutputTextEditorServerToolItem = {
     filePath?: string | undefined;
     id?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:text_editor";
+    type: OutputTextEditorServerToolItemType;
 };
 /** @internal */
 export declare const Command$inboundSchema: z.ZodType<Command, unknown>;
 /** @internal */
+export declare const Command$outboundSchema: z.ZodType<string, Command>;
+/** @internal */
+export declare const OutputTextEditorServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputTextEditorServerToolItemType>;
+/** @internal */
+export declare const OutputTextEditorServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputTextEditorServerToolItemType>;
+/** @internal */
 export declare const OutputTextEditorServerToolItem$inboundSchema: z.ZodType<OutputTextEditorServerToolItem, unknown>;
+/** @internal */
+export type OutputTextEditorServerToolItem$Outbound = {
+    command?: string | undefined;
+    filePath?: string | undefined;
+    id?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputTextEditorServerToolItem$outboundSchema: z.ZodType<OutputTextEditorServerToolItem$Outbound, OutputTextEditorServerToolItem>;
+export declare function outputTextEditorServerToolItemToJSON(outputTextEditorServerToolItem: OutputTextEditorServerToolItem): string;
 export declare function outputTextEditorServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputTextEditorServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputtexteditorservertoolitem.d.ts.map

package/esm/models/outputtexteditorservertoolitem.js

@@ -5,24 +5,45 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
 export const Command = {
     View: "view",
     Create: "create",
     StrReplace: "str_replace",
     Insert: "insert",
 };
+export const OutputTextEditorServerToolItemType = {
+    OpenrouterTextEditor: "openrouter:text_editor",
+};
 /** @internal */
 export const Command$inboundSchema = openEnums
     .inboundSchema(Command);
 /** @internal */
+export const Command$outboundSchema = openEnums
+    .outboundSchema(Command);
+/** @internal */
+export const OutputTextEditorServerToolItemType$inboundSchema = z.enum(OutputTextEditorServerToolItemType);
+/** @internal */
+export const OutputTextEditorServerToolItemType$outboundSchema = OutputTextEditorServerToolItemType$inboundSchema;
+/** @internal */
 export const OutputTextEditorServerToolItem$inboundSchema = z.object({
     command: Command$inboundSchema.optional(),
     filePath: z.string().optional(),
     id: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:text_editor"),
+    type: OutputTextEditorServerToolItemType$inboundSchema,
 });
+/** @internal */
+export const OutputTextEditorServerToolItem$outboundSchema = z.object({
+    command: Command$outboundSchema.optional(),
+    filePath: z.string().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputTextEditorServerToolItemType$outboundSchema,
+});
+export function outputTextEditorServerToolItemToJSON(outputTextEditorServerToolItem) {
+    return JSON.stringify(OutputTextEditorServerToolItem$outboundSchema.parse(outputTextEditorServerToolItem));
+}
 export function outputTextEditorServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputTextEditorServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputTextEditorServerToolItem' from JSON`);
 }

package/esm/models/outputtoolsearchservertoolitem.d.ts

@@ -1,7 +1,12 @@
 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";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputToolSearchServerToolItemType: {
+    readonly OpenrouterToolSearch: "openrouter:tool_search";
+};
+export type OutputToolSearchServerToolItemType = ClosedEnum<typeof OutputToolSearchServerToolItemType>;
 /**
  * An openrouter:tool_search server tool output item
  */
@@ -9,9 +14,23 @@ export type OutputToolSearchServerToolItem = {
     id?: string | undefined;
     query?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:tool_search";
+    type: OutputToolSearchServerToolItemType;
 };
 /** @internal */
+export declare const OutputToolSearchServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputToolSearchServerToolItemType>;
+/** @internal */
+export declare const OutputToolSearchServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputToolSearchServerToolItemType>;
+/** @internal */
 export declare const OutputToolSearchServerToolItem$inboundSchema: z.ZodType<OutputToolSearchServerToolItem, unknown>;
+/** @internal */
+export type OutputToolSearchServerToolItem$Outbound = {
+    id?: string | undefined;
+    query?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputToolSearchServerToolItem$outboundSchema: z.ZodType<OutputToolSearchServerToolItem$Outbound, OutputToolSearchServerToolItem>;
+export declare function outputToolSearchServerToolItemToJSON(outputToolSearchServerToolItem: OutputToolSearchServerToolItem): string;
 export declare function outputToolSearchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputToolSearchServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputtoolsearchservertoolitem.d.ts.map

package/esm/models/outputtoolsearchservertoolitem.js

@@ -4,14 +4,31 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputToolSearchServerToolItemType = {
+    OpenrouterToolSearch: "openrouter:tool_search",
+};
+/** @internal */
+export const OutputToolSearchServerToolItemType$inboundSchema = z.enum(OutputToolSearchServerToolItemType);
+/** @internal */
+export const OutputToolSearchServerToolItemType$outboundSchema = OutputToolSearchServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputToolSearchServerToolItem$inboundSchema = z.object({
     id: z.string().optional(),
     query: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:tool_search"),
+    type: OutputToolSearchServerToolItemType$inboundSchema,
 });
+/** @internal */
+export const OutputToolSearchServerToolItem$outboundSchema = z.object({
+    id: z.string().optional(),
+    query: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputToolSearchServerToolItemType$outboundSchema,
+});
+export function outputToolSearchServerToolItemToJSON(outputToolSearchServerToolItem) {
+    return JSON.stringify(OutputToolSearchServerToolItem$outboundSchema.parse(outputToolSearchServerToolItem));
+}
 export function outputToolSearchServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputToolSearchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputToolSearchServerToolItem' from JSON`);
 }

package/esm/models/outputwebfetchservertoolitem.d.ts

@@ -1,7 +1,12 @@
 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";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputWebFetchServerToolItemType: {
+    readonly OpenrouterWebFetch: "openrouter:web_fetch";
+};
+export type OutputWebFetchServerToolItemType = ClosedEnum<typeof OutputWebFetchServerToolItemType>;
 /**
  * An openrouter:web_fetch server tool output item
  */
@@ -10,10 +15,26 @@ export type OutputWebFetchServerToolItem = {
     id?: string | undefined;
     status: ToolCallStatus;
     title?: string | undefined;
-    type: "openrouter:web_fetch";
+    type: OutputWebFetchServerToolItemType;
     url?: string | undefined;
 };
 /** @internal */
+export declare const OutputWebFetchServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputWebFetchServerToolItemType>;
+/** @internal */
+export declare const OutputWebFetchServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputWebFetchServerToolItemType>;
+/** @internal */
 export declare const OutputWebFetchServerToolItem$inboundSchema: z.ZodType<OutputWebFetchServerToolItem, unknown>;
+/** @internal */
+export type OutputWebFetchServerToolItem$Outbound = {
+    content?: string | undefined;
+    id?: string | undefined;
+    status: string;
+    title?: string | undefined;
+    type: string;
+    url?: string | undefined;
+};
+/** @internal */
+export declare const OutputWebFetchServerToolItem$outboundSchema: z.ZodType<OutputWebFetchServerToolItem$Outbound, OutputWebFetchServerToolItem>;
+export declare function outputWebFetchServerToolItemToJSON(outputWebFetchServerToolItem: OutputWebFetchServerToolItem): string;
 export declare function outputWebFetchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputWebFetchServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputwebfetchservertoolitem.d.ts.map

package/esm/models/outputwebfetchservertoolitem.js

@@ -4,16 +4,35 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputWebFetchServerToolItemType = {
+    OpenrouterWebFetch: "openrouter:web_fetch",
+};
+/** @internal */
+export const OutputWebFetchServerToolItemType$inboundSchema = z.enum(OutputWebFetchServerToolItemType);
+/** @internal */
+export const OutputWebFetchServerToolItemType$outboundSchema = OutputWebFetchServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputWebFetchServerToolItem$inboundSchema = z.object({
     content: z.string().optional(),
     id: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
     title: z.string().optional(),
-    type: z.literal("openrouter:web_fetch"),
+    type: OutputWebFetchServerToolItemType$inboundSchema,
     url: z.string().optional(),
 });
+/** @internal */
+export const OutputWebFetchServerToolItem$outboundSchema = z.object({
+    content: z.string().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    title: z.string().optional(),
+    type: OutputWebFetchServerToolItemType$outboundSchema,
+    url: z.string().optional(),
+});
+export function outputWebFetchServerToolItemToJSON(outputWebFetchServerToolItem) {
+    return JSON.stringify(OutputWebFetchServerToolItem$outboundSchema.parse(outputWebFetchServerToolItem));
+}
 export function outputWebFetchServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputWebFetchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputWebFetchServerToolItem' from JSON`);
 }

package/esm/models/providername.d.ts

@@ -60,6 +60,7 @@ export declare const ProviderName: {
     readonly OpenAI: "OpenAI";
     readonly OpenInference: "OpenInference";
     readonly Parasail: "Parasail";
+    readonly Poolside: "Poolside";
     readonly Perplexity: "Perplexity";
     readonly Phala: "Phala";
     readonly Recraft: "Recraft";

package/esm/models/providername.js

@@ -63,6 +63,7 @@ export const ProviderName = {
     OpenAI: "OpenAI",
     OpenInference: "OpenInference",
     Parasail: "Parasail",
+    Poolside: "Poolside",
     Perplexity: "Perplexity",
     Phala: "Phala",
     Recraft: "Recraft",

package/esm/models/providerresponse.d.ts

@@ -93,6 +93,7 @@ export declare const ProviderResponseProviderName: {
     readonly OpenAI: "OpenAI";
     readonly OpenInference: "OpenInference";
     readonly Parasail: "Parasail";
+    readonly Poolside: "Poolside";
     readonly Perplexity: "Perplexity";
     readonly Phala: "Phala";
     readonly Recraft: "Recraft";

package/esm/models/providerresponse.js

@@ -97,6 +97,7 @@ export const ProviderResponseProviderName = {
     OpenAI: "OpenAI",
     OpenInference: "OpenInference",
     Parasail: "Parasail",
+    Poolside: "Poolside",
     Perplexity: "Perplexity",
     Phala: "Phala",
     Recraft: "Recraft",

package/esm/models/speechrequest.d.ts

@@ -250,6 +250,9 @@ export type SpeechRequestOptions = {
     phala?: {
         [k: string]: any | null;
     } | undefined;
+    poolside?: {
+        [k: string]: any | null;
+    } | undefined;
     recraft?: {
         [k: string]: any | null;
     } | undefined;
@@ -626,6 +629,9 @@ export type SpeechRequestOptions$Outbound = {
     phala?: {
         [k: string]: any | null;
     } | undefined;
+    poolside?: {
+        [k: string]: any | null;
+    } | undefined;
     recraft?: {
         [k: string]: any | null;
     } | undefined;

package/esm/models/speechrequest.js

@@ -96,6 +96,7 @@ export const SpeechRequestOptions$outboundSchema = z.object({
     parasail: z.record(z.string(), z.nullable(z.any())).optional(),
     perplexity: z.record(z.string(), z.nullable(z.any())).optional(),
     phala: z.record(z.string(), z.nullable(z.any())).optional(),
+    poolside: z.record(z.string(), z.nullable(z.any())).optional(),
     recraft: z.record(z.string(), z.nullable(z.any())).optional(),
     recursal: z.record(z.string(), z.nullable(z.any())).optional(),
     reflection: z.record(z.string(), z.nullable(z.any())).optional(),

package/esm/models/updateworkspacerequest.d.ts

@@ -16,6 +16,14 @@ export type UpdateWorkspaceRequest = {
      * New description for the workspace
      */
     description?: string | null | undefined;
+    /**
+     * Optional array of API key IDs to filter I/O logging
+     */
+    ioLoggingApiKeyIds?: Array<number> | null | undefined;
+    /**
+     * Sampling rate for I/O logging (0.0001-1)
+     */
+    ioLoggingSamplingRate?: number | undefined;
     /**
      * Whether data discount logging is enabled
      */
@@ -43,6 +51,8 @@ export type UpdateWorkspaceRequest$Outbound = {
     default_provider_sort?: string | null | undefined;
     default_text_model?: string | null | undefined;
     description?: string | null | undefined;
+    io_logging_api_key_ids?: Array<number> | null | undefined;
+    io_logging_sampling_rate?: number | undefined;
     is_data_discount_logging_enabled?: boolean | undefined;
     is_observability_broadcast_enabled?: boolean | undefined;
     is_observability_io_logging_enabled?: boolean | undefined;

package/esm/models/updateworkspacerequest.js

@@ -10,6 +10,8 @@ export const UpdateWorkspaceRequest$outboundSchema = z.object({
     defaultProviderSort: z.nullable(z.string()).optional(),
     defaultTextModel: z.nullable(z.string()).optional(),
     description: z.nullable(z.string()).optional(),
+    ioLoggingApiKeyIds: z.nullable(z.array(z.int())).optional(),
+    ioLoggingSamplingRate: z.number().optional(),
     isDataDiscountLoggingEnabled: z.boolean().optional(),
     isObservabilityBroadcastEnabled: z.boolean().optional(),
     isObservabilityIoLoggingEnabled: z.boolean().optional(),
@@ -20,6 +22,8 @@ export const UpdateWorkspaceRequest$outboundSchema = z.object({
         defaultImageModel: "default_image_model",
         defaultProviderSort: "default_provider_sort",
         defaultTextModel: "default_text_model",
+        ioLoggingApiKeyIds: "io_logging_api_key_ids",
+        ioLoggingSamplingRate: "io_logging_sampling_rate",
         isDataDiscountLoggingEnabled: "is_data_discount_logging_enabled",
         isObservabilityBroadcastEnabled: "is_observability_broadcast_enabled",
         isObservabilityIoLoggingEnabled: "is_observability_io_logging_enabled",

package/esm/models/videogenerationrequest.d.ts

@@ -268,6 +268,9 @@ export type VideoGenerationRequestOptions = {
     phala?: {
         [k: string]: any | null;
     } | undefined;
+    poolside?: {
+        [k: string]: any | null;
+    } | undefined;
     recraft?: {
         [k: string]: any | null;
     } | undefined;
@@ -376,6 +379,10 @@ export type VideoGenerationRequest = {
      * Aspect ratio of the generated video
      */
     aspectRatio?: AspectRatio | undefined;
+    /**
+     * URL to receive a webhook notification when the video generation job completes. Overrides the workspace-level default callback URL if set. Must be HTTPS.
+     */
+    callbackUrl?: string | undefined;
     /**
      * Duration of the generated video in seconds
      */
@@ -661,6 +668,9 @@ export type VideoGenerationRequestOptions$Outbound = {
     phala?: {
         [k: string]: any | null;
     } | undefined;
+    poolside?: {
+        [k: string]: any | null;
+    } | undefined;
     recraft?: {
         [k: string]: any | null;
     } | undefined;
@@ -755,6 +765,7 @@ export declare const Resolution$outboundSchema: z.ZodType<string, Resolution>;
 /** @internal */
 export type VideoGenerationRequest$Outbound = {
     aspect_ratio?: string | undefined;
+    callback_url?: string | undefined;
     duration?: number | undefined;
     frame_images?: Array<FrameImage$Outbound> | undefined;
     generate_audio?: boolean | undefined;

package/esm/models/videogenerationrequest.js

@@ -116,6 +116,7 @@ export const VideoGenerationRequestOptions$outboundSchema = z.object({
     parasail: z.record(z.string(), z.nullable(z.any())).optional(),
     perplexity: z.record(z.string(), z.nullable(z.any())).optional(),
     phala: z.record(z.string(), z.nullable(z.any())).optional(),
+    poolside: z.record(z.string(), z.nullable(z.any())).optional(),
     recraft: z.record(z.string(), z.nullable(z.any())).optional(),
     recursal: z.record(z.string(), z.nullable(z.any())).optional(),
     reflection: z.record(z.string(), z.nullable(z.any())).optional(),
@@ -183,6 +184,7 @@ export const Resolution$outboundSchema = openEnums.outboundSchema(Resolution);
 /** @internal */
 export const VideoGenerationRequest$outboundSchema = z.object({
     aspectRatio: AspectRatio$outboundSchema.optional(),
+    callbackUrl: z.string().optional(),
     duration: z.int().optional(),
     frameImages: z.array(FrameImage$outboundSchema).optional(),
     generateAudio: z.boolean().optional(),
@@ -197,6 +199,7 @@ export const VideoGenerationRequest$outboundSchema = z.object({
 }).transform((v) => {
     return remap$(v, {
         aspectRatio: "aspect_ratio",
+        callbackUrl: "callback_url",
         frameImages: "frame_images",
         generateAudio: "generate_audio",
         inputReferences: "input_references",

package/esm/models/websearchplugin.d.ts

@@ -1,5 +1,20 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { WebSearchEngine } from "./websearchengine.js";
+export declare const WebSearchPluginType: {
+    readonly Approximate: "approximate";
+};
+export type WebSearchPluginType = ClosedEnum<typeof WebSearchPluginType>;
+/**
+ * Approximate user location for location-biased search results. Passed through to native providers that support it (e.g. Anthropic).
+ */
+export type UserLocation = {
+    city?: string | null | undefined;
+    country?: string | null | undefined;
+    region?: string | null | undefined;
+    timezone?: string | null | undefined;
+    type: WebSearchPluginType;
+};
 export type WebSearchPlugin = {
     /**
      * Set to false to disable the web-search plugin for this request. Defaults to true.
@@ -19,9 +34,27 @@ export type WebSearchPlugin = {
      */
     includeDomains?: Array<string> | undefined;
     maxResults?: number | undefined;
+    /**
+     * Maximum number of times the model can invoke web search in a single turn. Passed through to native providers that support it (e.g. Anthropic).
+     */
+    maxUses?: number | undefined;
     searchPrompt?: string | undefined;
+    userLocation?: UserLocation | null | undefined;
 };
 /** @internal */
+export declare const WebSearchPluginType$outboundSchema: z.ZodEnum<typeof WebSearchPluginType>;
+/** @internal */
+export type UserLocation$Outbound = {
+    city?: string | null | undefined;
+    country?: string | null | undefined;
+    region?: string | null | undefined;
+    timezone?: string | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const UserLocation$outboundSchema: z.ZodType<UserLocation$Outbound, UserLocation>;
+export declare function userLocationToJSON(userLocation: UserLocation): string;
+/** @internal */
 export type WebSearchPlugin$Outbound = {
     enabled?: boolean | undefined;
     engine?: string | undefined;
@@ -29,7 +62,9 @@ export type WebSearchPlugin$Outbound = {
     id: "web";
     include_domains?: Array<string> | undefined;
     max_results?: number | undefined;
+    max_uses?: number | undefined;
     search_prompt?: string | undefined;
+    user_location?: UserLocation$Outbound | null | undefined;
 };
 /** @internal */
 export declare const WebSearchPlugin$outboundSchema: z.ZodType<WebSearchPlugin$Outbound, WebSearchPlugin>;