@openrouter/sdk 0.12.20 → 0.12.22

package/esm/models/outputmcpservertoolitem.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 OutputMcpServerToolItemType: {
+    readonly OpenrouterMcp: "openrouter:mcp";
+};
+export type OutputMcpServerToolItemType = ClosedEnum<typeof OutputMcpServerToolItemType>;
 /**
  * An openrouter:mcp server tool output item
  */
@@ -10,9 +15,24 @@ export type OutputMcpServerToolItem = {
     serverLabel?: string | undefined;
     status: ToolCallStatus;
     toolName?: string | undefined;
-    type: "openrouter:mcp";
+    type: OutputMcpServerToolItemType;
 };
 /** @internal */
+export declare const OutputMcpServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputMcpServerToolItemType>;
+/** @internal */
+export declare const OutputMcpServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputMcpServerToolItemType>;
+/** @internal */
 export declare const OutputMcpServerToolItem$inboundSchema: z.ZodType<OutputMcpServerToolItem, unknown>;
+/** @internal */
+export type OutputMcpServerToolItem$Outbound = {
+    id?: string | undefined;
+    serverLabel?: string | undefined;
+    status: string;
+    toolName?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OutputMcpServerToolItem$outboundSchema: z.ZodType<OutputMcpServerToolItem$Outbound, OutputMcpServerToolItem>;
+export declare function outputMcpServerToolItemToJSON(outputMcpServerToolItem: OutputMcpServerToolItem): string;
 export declare function outputMcpServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputMcpServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputmcpservertoolitem.d.ts.map

package/esm/models/outputmcpservertoolitem.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 OutputMcpServerToolItemType = {
+    OpenrouterMcp: "openrouter:mcp",
+};
+/** @internal */
+export const OutputMcpServerToolItemType$inboundSchema = z.enum(OutputMcpServerToolItemType);
+/** @internal */
+export const OutputMcpServerToolItemType$outboundSchema = OutputMcpServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputMcpServerToolItem$inboundSchema = z.object({
     id: z.string().optional(),
     serverLabel: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
     toolName: z.string().optional(),
-    type: z.literal("openrouter:mcp"),
+    type: OutputMcpServerToolItemType$inboundSchema,
+});
+/** @internal */
+export const OutputMcpServerToolItem$outboundSchema = z.object({
+    id: z.string().optional(),
+    serverLabel: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    toolName: z.string().optional(),
+    type: OutputMcpServerToolItemType$outboundSchema,
 });
+export function outputMcpServerToolItemToJSON(outputMcpServerToolItem) {
+    return JSON.stringify(OutputMcpServerToolItem$outboundSchema.parse(outputMcpServerToolItem));
+}
 export function outputMcpServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMcpServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMcpServerToolItem' from JSON`);
 }

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/outputmodality.d.ts

@@ -8,6 +8,7 @@ export declare const OutputModality: {
     readonly Video: "video";
     readonly Rerank: "rerank";
     readonly Speech: "speech";
+    readonly Transcription: "transcription";
 };
 export type OutputModality = OpenEnum<typeof OutputModality>;
 /** @internal */

package/esm/models/outputmodality.js

@@ -11,6 +11,7 @@ export const OutputModality = {
     Video: "video",
     Rerank: "rerank",
     Speech: "speech",
+    Transcription: "transcription",
 };
 /** @internal */
 export const OutputModality$inboundSchema = openEnums.inboundSchema(OutputModality);

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",