@openrouter/sdk 1.3.21 → 1.3.23

package/esm/models/operations/updatebyokkey.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpdateBYOKKeyRequest$outboundSchema as models_UpdateBYOKKeyRequest$outboundSchema } from "../updatebyokkeyrequest.js";
 /** @internal */
 export const UpdateBYOKKeyRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     id: z.string(),
-    updateBYOKKeyRequest: models.UpdateBYOKKeyRequest$outboundSchema,
+    updateBYOKKeyRequest: models_UpdateBYOKKeyRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/operations/updateguardrail.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpdateGuardrailRequest$outboundSchema as models_UpdateGuardrailRequest$outboundSchema } from "../updateguardrailrequest.js";
 /** @internal */
 export const UpdateGuardrailRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     id: z.string(),
-    updateGuardrailRequest: models.UpdateGuardrailRequest$outboundSchema,
+    updateGuardrailRequest: models_UpdateGuardrailRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/operations/updateintern.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpdateInternRequest$outboundSchema as models_UpdateInternRequest$outboundSchema } from "../updateinternrequest.js";
 /** @internal */
 export const UpdateInternRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     internId: z.string(),
-    updateInternRequest: models.UpdateInternRequest$outboundSchema,
+    updateInternRequest: models_UpdateInternRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/operations/updateobservabilitydestination.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpdateObservabilityDestinationRequest$outboundSchema as models_UpdateObservabilityDestinationRequest$outboundSchema } from "../updateobservabilitydestinationrequest.js";
 /** @internal */
 export const UpdateObservabilityDestinationRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     id: z.string(),
-    updateObservabilityDestinationRequest: models.UpdateObservabilityDestinationRequest$outboundSchema,
+    updateObservabilityDestinationRequest: models_UpdateObservabilityDestinationRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/operations/updatescimgroupmapping.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpdateScimGroupMappingRequest$outboundSchema as models_UpdateScimGroupMappingRequest$outboundSchema } from "../updatescimgroupmappingrequest.js";
 /** @internal */
 export const UpdateScimGroupMappingRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     id: z.string(),
-    updateScimGroupMappingRequest: models.UpdateScimGroupMappingRequest$outboundSchema,
+    updateScimGroupMappingRequest: models_UpdateScimGroupMappingRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/operations/updateworkspace.js

@@ -4,14 +4,14 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpdateWorkspaceRequest$outboundSchema as models_UpdateWorkspaceRequest$outboundSchema } from "../updateworkspacerequest.js";
 /** @internal */
 export const UpdateWorkspaceRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     id: z.string(),
-    updateWorkspaceRequest: models.UpdateWorkspaceRequest$outboundSchema,
+    updateWorkspaceRequest: models_UpdateWorkspaceRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/operations/uploadfile.js

@@ -5,7 +5,7 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { blobLikeSchema } from "../../types/blobs.js";
-import * as models from "../index.js";
+import { FileProvider$outboundSchema as models_FileProvider$outboundSchema } from "../fileprovider.js";
 /** @internal */
 export const UploadFileFile$outboundSchema = z.object({
     fileName: z.string(),
@@ -32,7 +32,7 @@ export const UploadFileRequest$outboundSchema = z.object({
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     workspaceId: z.string().optional(),
-    provider: models.FileProvider$outboundSchema.optional(),
+    provider: models_FileProvider$outboundSchema.optional(),
     requestBody: z.lazy(() => UploadFileRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/operations/upsertworkspacebudget.js

@@ -4,15 +4,15 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import * as models from "../index.js";
+import { UpsertWorkspaceBudgetRequest$outboundSchema as models_UpsertWorkspaceBudgetRequest$outboundSchema } from "../upsertworkspacebudgetrequest.js"; import { WorkspaceBudgetInterval$outboundSchema as models_WorkspaceBudgetInterval$outboundSchema } from "../workspacebudgetinterval.js";
 /** @internal */
 export const UpsertWorkspaceBudgetRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     workspaceRef: z.string(),
-    interval: models.WorkspaceBudgetInterval$outboundSchema,
-    upsertWorkspaceBudgetRequest: models.UpsertWorkspaceBudgetRequest$outboundSchema,
+    interval: models_WorkspaceBudgetInterval$outboundSchema,
+    upsertWorkspaceBudgetRequest: models_UpsertWorkspaceBudgetRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",

package/esm/models/outputcustomtoolcallitem.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export declare const OutputCustomToolCallItemStatus: {
@@ -8,10 +8,6 @@ export declare const OutputCustomToolCallItemStatus: {
     readonly Incomplete: "incomplete";
 };
 export type OutputCustomToolCallItemStatus = OpenEnum<typeof OutputCustomToolCallItemStatus>;
-export declare const OutputCustomToolCallItemType: {
-    readonly CustomToolCall: "custom_tool_call";
-};
-export type OutputCustomToolCallItemType = ClosedEnum<typeof OutputCustomToolCallItemType>;
 /**
  * A call to a custom (freeform-grammar) tool created by the model — distinct from `function_call`. Used for tools like Codex CLI's `apply_patch` whose payload is opaque text rather than JSON arguments.
  */
@@ -29,31 +25,11 @@ export type OutputCustomToolCallItem = {
      */
     namespace?: string | undefined;
     status?: OutputCustomToolCallItemStatus | undefined;
-    type: OutputCustomToolCallItemType;
+    type: "custom_tool_call";
 };
 /** @internal */
 export declare const OutputCustomToolCallItemStatus$inboundSchema: z.ZodType<OutputCustomToolCallItemStatus, unknown>;
 /** @internal */
-export declare const OutputCustomToolCallItemStatus$outboundSchema: z.ZodType<string, OutputCustomToolCallItemStatus>;
-/** @internal */
-export declare const OutputCustomToolCallItemType$inboundSchema: z.ZodEnum<typeof OutputCustomToolCallItemType>;
-/** @internal */
-export declare const OutputCustomToolCallItemType$outboundSchema: z.ZodEnum<typeof OutputCustomToolCallItemType>;
-/** @internal */
 export declare const OutputCustomToolCallItem$inboundSchema: z.ZodType<OutputCustomToolCallItem, unknown>;
-/** @internal */
-export type OutputCustomToolCallItem$Outbound = {
-    async?: boolean | undefined;
-    call_id: string;
-    id?: string | undefined;
-    input: string;
-    name: string;
-    namespace?: string | undefined;
-    status?: string | undefined;
-    type: string;
-};
-/** @internal */
-export declare const OutputCustomToolCallItem$outboundSchema: z.ZodType<OutputCustomToolCallItem$Outbound, OutputCustomToolCallItem>;
-export declare function outputCustomToolCallItemToJSON(outputCustomToolCallItem: OutputCustomToolCallItem): string;
 export declare function outputCustomToolCallItemFromJSON(jsonString: string): SafeParseResult<OutputCustomToolCallItem, SDKValidationError>;
 //# sourceMappingURL=outputcustomtoolcallitem.d.ts.map

package/esm/models/outputcustomtoolcallitem.js

@@ -11,18 +11,9 @@ export const OutputCustomToolCallItemStatus = {
     Completed: "completed",
     Incomplete: "incomplete",
 };
-export const OutputCustomToolCallItemType = {
-    CustomToolCall: "custom_tool_call",
-};
 /** @internal */
 export const OutputCustomToolCallItemStatus$inboundSchema = openEnums.inboundSchema(OutputCustomToolCallItemStatus);
 /** @internal */
-export const OutputCustomToolCallItemStatus$outboundSchema = openEnums.outboundSchema(OutputCustomToolCallItemStatus);
-/** @internal */
-export const OutputCustomToolCallItemType$inboundSchema = z.enum(OutputCustomToolCallItemType);
-/** @internal */
-export const OutputCustomToolCallItemType$outboundSchema = OutputCustomToolCallItemType$inboundSchema;
-/** @internal */
 export const OutputCustomToolCallItem$inboundSchema = z.object({
     async: z.boolean().optional(),
     call_id: z.string(),
@@ -31,30 +22,12 @@ export const OutputCustomToolCallItem$inboundSchema = z.object({
     name: z.string(),
     namespace: z.string().optional(),
     status: OutputCustomToolCallItemStatus$inboundSchema.optional(),
-    type: OutputCustomToolCallItemType$inboundSchema,
+    type: z.literal("custom_tool_call"),
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
     });
 });
-/** @internal */
-export const OutputCustomToolCallItem$outboundSchema = z.object({
-    async: z.boolean().optional(),
-    callId: z.string(),
-    id: z.string().optional(),
-    input: z.string(),
-    name: z.string(),
-    namespace: z.string().optional(),
-    status: OutputCustomToolCallItemStatus$outboundSchema.optional(),
-    type: OutputCustomToolCallItemType$outboundSchema,
-}).transform((v) => {
-    return remap$(v, {
-        callId: "call_id",
-    });
-});
-export function outputCustomToolCallItemToJSON(outputCustomToolCallItem) {
-    return JSON.stringify(OutputCustomToolCallItem$outboundSchema.parse(outputCustomToolCallItem));
-}
 export function outputCustomToolCallItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputCustomToolCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCustomToolCallItem' from JSON`);
 }

package/esm/models/outputfunctioncallitem.d.ts

@@ -15,10 +15,6 @@ export declare const OutputFunctionCallItemStatusCompleted: {
 };
 export type OutputFunctionCallItemStatusCompleted = ClosedEnum<typeof OutputFunctionCallItemStatusCompleted>;
 export type OutputFunctionCallItemStatusUnion = OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress;
-export declare const OutputFunctionCallItemType: {
-    readonly FunctionCall: "function_call";
-};
-export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
 export type OutputFunctionCallItemSubagentItem = {
     type: string;
     additionalProperties?: {
@@ -39,7 +35,7 @@ export type OutputFunctionCallItem = {
      */
     namespace?: string | undefined;
     status?: OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress | undefined;
-    type: OutputFunctionCallItemType;
+    type: "function_call";
     /**
      * EXPERIMENTAL — subject to change without notice. String id that matches the `call_id` of the `openrouter:subagent` server tool call that spawned the subagent. Present on every `function_call` item the subagent projects; absent on ordinary function calls.
      */
@@ -52,55 +48,16 @@ export type OutputFunctionCallItem = {
 /** @internal */
 export declare const OutputFunctionCallItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
 /** @internal */
-export declare const OutputFunctionCallItemStatusInProgress$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
 /** @internal */
-export declare const OutputFunctionCallItemStatusIncomplete$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
 /** @internal */
-export declare const OutputFunctionCallItemStatusCompleted$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusUnion$inboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion, unknown>;
-/** @internal */
-export type OutputFunctionCallItemStatusUnion$Outbound = string | string | string;
-/** @internal */
-export declare const OutputFunctionCallItemStatusUnion$outboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion$Outbound, OutputFunctionCallItemStatusUnion>;
-export declare function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion: OutputFunctionCallItemStatusUnion): string;
 export declare function outputFunctionCallItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemStatusUnion, SDKValidationError>;
 /** @internal */
-export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
-/** @internal */
-export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
-/** @internal */
 export declare const OutputFunctionCallItemSubagentItem$inboundSchema: z.ZodType<OutputFunctionCallItemSubagentItem, unknown>;
-/** @internal */
-export type OutputFunctionCallItemSubagentItem$Outbound = {
-    type: string;
-    [additionalProperties: string]: unknown;
-};
-/** @internal */
-export declare const OutputFunctionCallItemSubagentItem$outboundSchema: z.ZodType<OutputFunctionCallItemSubagentItem$Outbound, OutputFunctionCallItemSubagentItem>;
-export declare function outputFunctionCallItemSubagentItemToJSON(outputFunctionCallItemSubagentItem: OutputFunctionCallItemSubagentItem): string;
 export declare function outputFunctionCallItemSubagentItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemSubagentItem, SDKValidationError>;
 /** @internal */
 export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunctionCallItem, unknown>;
-/** @internal */
-export type OutputFunctionCallItem$Outbound = {
-    arguments: string;
-    async?: boolean | undefined;
-    call_id: string;
-    id?: string | undefined;
-    name: string;
-    namespace?: string | undefined;
-    status?: string | string | string | undefined;
-    type: string;
-    subagent_id?: string | undefined;
-    subagent_items?: Array<OutputFunctionCallItemSubagentItem$Outbound> | undefined;
-};
-/** @internal */
-export declare const OutputFunctionCallItem$outboundSchema: z.ZodType<OutputFunctionCallItem$Outbound, OutputFunctionCallItem>;
-export declare function outputFunctionCallItemToJSON(outputFunctionCallItem: OutputFunctionCallItem): string;
 export declare function outputFunctionCallItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItem, SDKValidationError>;
 //# sourceMappingURL=outputfunctioncallitem.d.ts.map

package/esm/models/outputfunctioncallitem.js

@@ -14,62 +14,25 @@ export const OutputFunctionCallItemStatusIncomplete = {
 export const OutputFunctionCallItemStatusCompleted = {
     Completed: "completed",
 };
-export const OutputFunctionCallItemType = {
-    FunctionCall: "function_call",
-};
 /** @internal */
 export const OutputFunctionCallItemStatusInProgress$inboundSchema = z.enum(OutputFunctionCallItemStatusInProgress);
 /** @internal */
-export const OutputFunctionCallItemStatusInProgress$outboundSchema = OutputFunctionCallItemStatusInProgress$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemStatusIncomplete$inboundSchema = z.enum(OutputFunctionCallItemStatusIncomplete);
 /** @internal */
-export const OutputFunctionCallItemStatusIncomplete$outboundSchema = OutputFunctionCallItemStatusIncomplete$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemStatusCompleted$inboundSchema = z.enum(OutputFunctionCallItemStatusCompleted);
 /** @internal */
-export const OutputFunctionCallItemStatusCompleted$outboundSchema = OutputFunctionCallItemStatusCompleted$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemStatusUnion$inboundSchema = z.union([
     OutputFunctionCallItemStatusCompleted$inboundSchema,
     OutputFunctionCallItemStatusIncomplete$inboundSchema,
     OutputFunctionCallItemStatusInProgress$inboundSchema,
 ]);
-/** @internal */
-export const OutputFunctionCallItemStatusUnion$outboundSchema = z.union([
-    OutputFunctionCallItemStatusCompleted$outboundSchema,
-    OutputFunctionCallItemStatusIncomplete$outboundSchema,
-    OutputFunctionCallItemStatusInProgress$outboundSchema,
-]);
-export function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion) {
-    return JSON.stringify(OutputFunctionCallItemStatusUnion$outboundSchema.parse(outputFunctionCallItemStatusUnion));
-}
 export function outputFunctionCallItemStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemStatusUnion' from JSON`);
 }
 /** @internal */
-export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCallItemType);
-/** @internal */
-export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemSubagentItem$inboundSchema = collectExtraKeys$(z.object({
     type: z.string(),
 }).catchall(z.any()), "additionalProperties", true);
-/** @internal */
-export const OutputFunctionCallItemSubagentItem$outboundSchema = z.object({
-    type: z.string(),
-    additionalProperties: z.record(z.string(), z.any()).optional(),
-}).transform((v) => {
-    return {
-        ...v.additionalProperties,
-        ...remap$(v, {
-            additionalProperties: null,
-        }),
-    };
-});
-export function outputFunctionCallItemSubagentItemToJSON(outputFunctionCallItemSubagentItem) {
-    return JSON.stringify(OutputFunctionCallItemSubagentItem$outboundSchema.parse(outputFunctionCallItemSubagentItem));
-}
 export function outputFunctionCallItemSubagentItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItemSubagentItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemSubagentItem' from JSON`);
 }
@@ -86,7 +49,7 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
         OutputFunctionCallItemStatusIncomplete$inboundSchema,
         OutputFunctionCallItemStatusInProgress$inboundSchema,
     ]).optional(),
-    type: OutputFunctionCallItemType$inboundSchema,
+    type: z.literal("function_call"),
     subagent_id: z.string().optional(),
     subagent_items: z.array(z.lazy(() => OutputFunctionCallItemSubagentItem$inboundSchema)).optional(),
 }).transform((v) => {
@@ -96,32 +59,6 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
         "subagent_items": "subagentItems",
     });
 });
-/** @internal */
-export const OutputFunctionCallItem$outboundSchema = z.object({
-    arguments: z.string(),
-    async: z.boolean().optional(),
-    callId: z.string(),
-    id: z.string().optional(),
-    name: z.string(),
-    namespace: z.string().optional(),
-    status: z.union([
-        OutputFunctionCallItemStatusCompleted$outboundSchema,
-        OutputFunctionCallItemStatusIncomplete$outboundSchema,
-        OutputFunctionCallItemStatusInProgress$outboundSchema,
-    ]).optional(),
-    type: OutputFunctionCallItemType$outboundSchema,
-    subagentId: z.string().optional(),
-    subagentItems: z.array(z.lazy(() => OutputFunctionCallItemSubagentItem$outboundSchema)).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        callId: "call_id",
-        subagentId: "subagent_id",
-        subagentItems: "subagent_items",
-    });
-});
-export function outputFunctionCallItemToJSON(outputFunctionCallItem) {
-    return JSON.stringify(OutputFunctionCallItem$outboundSchema.parse(outputFunctionCallItem));
-}
 export function outputFunctionCallItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItem' from JSON`);
 }

package/esm/models/outputitems.d.ts

@@ -40,13 +40,9 @@ export type OutputItems = OutputApplyPatchCallItem | (OutputCodeInterpreterCallI
     type: "code_interpreter_call";
 }) | (OutputComputerCallItem & {
     type: "computer_call";
-}) | (OutputCustomToolCallItem & {
-    type: "custom_tool_call";
-}) | (OutputFileSearchCallItem & {
+}) | OutputCustomToolCallItem | (OutputFileSearchCallItem & {
     type: "file_search_call";
-}) | (OutputFunctionCallItem & {
-    type: "function_call";
-}) | (OutputImageGenerationCallItem & {
+}) | OutputFunctionCallItem | (OutputImageGenerationCallItem & {
     type: "image_generation_call";
 }) | OutputMessageItem | (OutputAdvisorServerToolItem & {
     type: "openrouter:advisor";

package/esm/models/outputitems.js

@@ -41,9 +41,9 @@ 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") })),
+    custom_tool_call: OutputCustomToolCallItem$inboundSchema,
     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") })),
+    function_call: OutputFunctionCallItem$inboundSchema,
     image_generation_call: OutputImageGenerationCallItem$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
     message: OutputMessageItem$inboundSchema,
     ["openrouter:advisor"]: OutputAdvisorServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:advisor") })),

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 400+ language models through a unified API.",
   "keywords": [
@@ -71,19 +71,21 @@
   },
   "scripts": {
     "lint": "eslint --cache --max-warnings=0 src",
-    "build": "tsc",
+    "build": "tsc && node scripts/unbarrel-imports.js",
     "prepublishOnly": "npm run build",
-    "compile": "tsc",
-    "test:e2e": "vitest --run --project e2e",
     "test:transit": "exit 0",
-    "test:watch": "vitest --watch --project unit",
     "typecheck": "tsc --noEmit",
-    "typecheck:transit": "exit 0",
     "postinstall": "node scripts/check-types.js || true",
     "prepare": "npm run build",
-    "test": "vitest --run --project unit"
+    "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e",
+    "test:watch": "vitest --watch --project unit",
+    "typecheck:transit": "exit 0",
+    "compile": "tsc && node scripts/unbarrel-imports.js"
+  },
+  "peerDependencies": {
+    
   },
-  "peerDependencies": {},
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@types/node": "^22.13.12",