@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/{openresponsesmcptool.d.ts → mcpservertool.d.ts}

@@ -3,9 +3,10 @@ import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type AllowedTools = {
-    toolNames?: Array<string> | undefined;
     readOnly?: boolean | undefined;
+    toolNames?: Array<string> | undefined;
 };
+export type AllowedToolsUnion = Array<string> | AllowedTools | any;
 export declare const ConnectorId: {
     readonly ConnectorDropbox: "connector_dropbox";
     readonly ConnectorGmail: "connector_gmail";
@@ -25,44 +26,53 @@ export declare const RequireApprovalAlways: {
     readonly Always: "always";
 };
 export type RequireApprovalAlways = ClosedEnum<typeof RequireApprovalAlways>;
-export type Never = {
+export type Always = {
     toolNames?: Array<string> | undefined;
 };
-export type Always = {
+export type Never = {
     toolNames?: Array<string> | undefined;
 };
 export type RequireApproval = {
-    never?: Never | undefined;
     always?: Always | undefined;
+    never?: Never | undefined;
 };
+export type RequireApprovalUnion = RequireApproval | RequireApprovalAlways | RequireApprovalNever | any;
 /**
  * MCP (Model Context Protocol) tool configuration
  */
-export type OpenResponsesMcpTool = {
-    type: "mcp";
-    serverLabel: string;
-    allowedTools?: any | null | undefined;
+export type McpServerTool = {
+    allowedTools?: Array<string> | AllowedTools | any | null | undefined;
     authorization?: string | undefined;
     connectorId?: ConnectorId | undefined;
     headers?: {
         [k: string]: string;
     } | null | undefined;
-    requireApproval?: any | null | undefined;
+    requireApproval?: RequireApproval | RequireApprovalAlways | RequireApprovalNever | any | null | undefined;
     serverDescription?: string | undefined;
+    serverLabel: string;
     serverUrl?: string | undefined;
+    type: "mcp";
 };
 /** @internal */
 export declare const AllowedTools$inboundSchema: z.ZodType<AllowedTools, unknown>;
 /** @internal */
 export type AllowedTools$Outbound = {
-    tool_names?: Array<string> | undefined;
     read_only?: boolean | undefined;
+    tool_names?: Array<string> | undefined;
 };
 /** @internal */
 export declare const AllowedTools$outboundSchema: z.ZodType<AllowedTools$Outbound, AllowedTools>;
 export declare function allowedToolsToJSON(allowedTools: AllowedTools): string;
 export declare function allowedToolsFromJSON(jsonString: string): SafeParseResult<AllowedTools, SDKValidationError>;
 /** @internal */
+export declare const AllowedToolsUnion$inboundSchema: z.ZodType<AllowedToolsUnion, unknown>;
+/** @internal */
+export type AllowedToolsUnion$Outbound = Array<string> | AllowedTools$Outbound | any;
+/** @internal */
+export declare const AllowedToolsUnion$outboundSchema: z.ZodType<AllowedToolsUnion$Outbound, AllowedToolsUnion>;
+export declare function allowedToolsUnionToJSON(allowedToolsUnion: AllowedToolsUnion): string;
+export declare function allowedToolsUnionFromJSON(jsonString: string): SafeParseResult<AllowedToolsUnion, SDKValidationError>;
+/** @internal */
 export declare const ConnectorId$inboundSchema: z.ZodType<ConnectorId, unknown>;
 /** @internal */
 export declare const ConnectorId$outboundSchema: z.ZodType<string, ConnectorId>;
@@ -75,16 +85,6 @@ export declare const RequireApprovalAlways$inboundSchema: z.ZodEnum<typeof Requi
 /** @internal */
 export declare const RequireApprovalAlways$outboundSchema: z.ZodEnum<typeof RequireApprovalAlways>;
 /** @internal */
-export declare const Never$inboundSchema: z.ZodType<Never, unknown>;
-/** @internal */
-export type Never$Outbound = {
-    tool_names?: Array<string> | undefined;
-};
-/** @internal */
-export declare const Never$outboundSchema: z.ZodType<Never$Outbound, Never>;
-export declare function neverToJSON(never: Never): string;
-export declare function neverFromJSON(jsonString: string): SafeParseResult<Never, SDKValidationError>;
-/** @internal */
 export declare const Always$inboundSchema: z.ZodType<Always, unknown>;
 /** @internal */
 export type Always$Outbound = {
@@ -95,34 +95,52 @@ export declare const Always$outboundSchema: z.ZodType<Always$Outbound, Always>;
 export declare function alwaysToJSON(always: Always): string;
 export declare function alwaysFromJSON(jsonString: string): SafeParseResult<Always, SDKValidationError>;
 /** @internal */
+export declare const Never$inboundSchema: z.ZodType<Never, unknown>;
+/** @internal */
+export type Never$Outbound = {
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Never$outboundSchema: z.ZodType<Never$Outbound, Never>;
+export declare function neverToJSON(never: Never): string;
+export declare function neverFromJSON(jsonString: string): SafeParseResult<Never, SDKValidationError>;
+/** @internal */
 export declare const RequireApproval$inboundSchema: z.ZodType<RequireApproval, unknown>;
 /** @internal */
 export type RequireApproval$Outbound = {
-    never?: Never$Outbound | undefined;
     always?: Always$Outbound | undefined;
+    never?: Never$Outbound | undefined;
 };
 /** @internal */
 export declare const RequireApproval$outboundSchema: z.ZodType<RequireApproval$Outbound, RequireApproval>;
 export declare function requireApprovalToJSON(requireApproval: RequireApproval): string;
 export declare function requireApprovalFromJSON(jsonString: string): SafeParseResult<RequireApproval, SDKValidationError>;
 /** @internal */
-export declare const OpenResponsesMcpTool$inboundSchema: z.ZodType<OpenResponsesMcpTool, unknown>;
+export declare const RequireApprovalUnion$inboundSchema: z.ZodType<RequireApprovalUnion, unknown>;
 /** @internal */
-export type OpenResponsesMcpTool$Outbound = {
-    type: "mcp";
-    server_label: string;
-    allowed_tools?: any | null | undefined;
+export type RequireApprovalUnion$Outbound = RequireApproval$Outbound | string | string | any;
+/** @internal */
+export declare const RequireApprovalUnion$outboundSchema: z.ZodType<RequireApprovalUnion$Outbound, RequireApprovalUnion>;
+export declare function requireApprovalUnionToJSON(requireApprovalUnion: RequireApprovalUnion): string;
+export declare function requireApprovalUnionFromJSON(jsonString: string): SafeParseResult<RequireApprovalUnion, SDKValidationError>;
+/** @internal */
+export declare const McpServerTool$inboundSchema: z.ZodType<McpServerTool, unknown>;
+/** @internal */
+export type McpServerTool$Outbound = {
+    allowed_tools?: Array<string> | AllowedTools$Outbound | any | null | undefined;
     authorization?: string | undefined;
     connector_id?: string | undefined;
     headers?: {
         [k: string]: string;
     } | null | undefined;
-    require_approval?: any | null | undefined;
+    require_approval?: RequireApproval$Outbound | string | string | any | null | undefined;
     server_description?: string | undefined;
+    server_label: string;
     server_url?: string | undefined;
+    type: "mcp";
 };
 /** @internal */
-export declare const OpenResponsesMcpTool$outboundSchema: z.ZodType<OpenResponsesMcpTool$Outbound, OpenResponsesMcpTool>;
-export declare function openResponsesMcpToolToJSON(openResponsesMcpTool: OpenResponsesMcpTool): string;
-export declare function openResponsesMcpToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesMcpTool, SDKValidationError>;
-//# sourceMappingURL=openresponsesmcptool.d.ts.map
+export declare const McpServerTool$outboundSchema: z.ZodType<McpServerTool$Outbound, McpServerTool>;
+export declare function mcpServerToolToJSON(mcpServerTool: McpServerTool): string;
+export declare function mcpServerToolFromJSON(jsonString: string): SafeParseResult<McpServerTool, SDKValidationError>;
+//# sourceMappingURL=mcpservertool.d.ts.map

package/esm/models/{openresponsesmcptool.js → mcpservertool.js}

@@ -1,6 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 1693a27fc478
+ * @generated-id: 5e5a26b93ed7
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
@@ -25,22 +25,22 @@ export const RequireApprovalAlways = {
 /** @internal */
 export const AllowedTools$inboundSchema = z
     .object({
-    tool_names: z.array(z.string()).optional(),
     read_only: z.boolean().optional(),
+    tool_names: z.array(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
-        "tool_names": "toolNames",
         "read_only": "readOnly",
+        "tool_names": "toolNames",
     });
 });
 /** @internal */
 export const AllowedTools$outboundSchema = z.object({
-    toolNames: z.array(z.string()).optional(),
     readOnly: z.boolean().optional(),
+    toolNames: z.array(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
-        toolNames: "tool_names",
         readOnly: "read_only",
+        toolNames: "tool_names",
     });
 });
 export function allowedToolsToJSON(allowedTools) {
@@ -50,6 +50,24 @@ export function allowedToolsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => AllowedTools$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AllowedTools' from JSON`);
 }
 /** @internal */
+export const AllowedToolsUnion$inboundSchema = z.union([
+    z.array(z.string()),
+    z.lazy(() => AllowedTools$inboundSchema),
+    z.any(),
+]);
+/** @internal */
+export const AllowedToolsUnion$outboundSchema = z.union([
+    z.array(z.string()),
+    z.lazy(() => AllowedTools$outboundSchema),
+    z.any(),
+]);
+export function allowedToolsUnionToJSON(allowedToolsUnion) {
+    return JSON.stringify(AllowedToolsUnion$outboundSchema.parse(allowedToolsUnion));
+}
+export function allowedToolsUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AllowedToolsUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AllowedToolsUnion' from JSON`);
+}
+/** @internal */
 export const ConnectorId$inboundSchema = openEnums.inboundSchema(ConnectorId);
 /** @internal */
 export const ConnectorId$outboundSchema = openEnums.outboundSchema(ConnectorId);
@@ -62,7 +80,7 @@ export const RequireApprovalAlways$inboundSchema = z.enum(RequireApprovalAlways)
 /** @internal */
 export const RequireApprovalAlways$outboundSchema = RequireApprovalAlways$inboundSchema;
 /** @internal */
-export const Never$inboundSchema = z.object({
+export const Always$inboundSchema = z.object({
     tool_names: z.array(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -70,21 +88,22 @@ export const Never$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const Never$outboundSchema = z.object({
+export const Always$outboundSchema = z
+    .object({
     toolNames: z.array(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
         toolNames: "tool_names",
     });
 });
-export function neverToJSON(never) {
-    return JSON.stringify(Never$outboundSchema.parse(never));
+export function alwaysToJSON(always) {
+    return JSON.stringify(Always$outboundSchema.parse(always));
 }
-export function neverFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Never$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Never' from JSON`);
+export function alwaysFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Always$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Always' from JSON`);
 }
 /** @internal */
-export const Always$inboundSchema = z.object({
+export const Never$inboundSchema = z.object({
     tool_names: z.array(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -92,29 +111,28 @@ export const Always$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const Always$outboundSchema = z
-    .object({
+export const Never$outboundSchema = z.object({
     toolNames: z.array(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
         toolNames: "tool_names",
     });
 });
-export function alwaysToJSON(always) {
-    return JSON.stringify(Always$outboundSchema.parse(always));
+export function neverToJSON(never) {
+    return JSON.stringify(Never$outboundSchema.parse(never));
 }
-export function alwaysFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Always$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Always' from JSON`);
+export function neverFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Never$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Never' from JSON`);
 }
 /** @internal */
 export const RequireApproval$inboundSchema = z.object({
-    never: z.lazy(() => Never$inboundSchema).optional(),
     always: z.lazy(() => Always$inboundSchema).optional(),
+    never: z.lazy(() => Never$inboundSchema).optional(),
 });
 /** @internal */
 export const RequireApproval$outboundSchema = z.object({
-    never: z.lazy(() => Never$outboundSchema).optional(),
     always: z.lazy(() => Always$outboundSchema).optional(),
+    never: z.lazy(() => Never$outboundSchema).optional(),
 });
 export function requireApprovalToJSON(requireApproval) {
     return JSON.stringify(RequireApproval$outboundSchema.parse(requireApproval));
@@ -123,51 +141,90 @@ export function requireApprovalFromJSON(jsonString) {
     return safeParse(jsonString, (x) => RequireApproval$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequireApproval' from JSON`);
 }
 /** @internal */
-export const OpenResponsesMcpTool$inboundSchema = z.object({
-    type: z.literal("mcp"),
-    server_label: z.string(),
-    allowed_tools: z.nullable(z.any()).optional(),
+export const RequireApprovalUnion$inboundSchema = z.union([
+    z.lazy(() => RequireApproval$inboundSchema),
+    RequireApprovalAlways$inboundSchema,
+    RequireApprovalNever$inboundSchema,
+    z.any(),
+]);
+/** @internal */
+export const RequireApprovalUnion$outboundSchema = z.union([
+    z.lazy(() => RequireApproval$outboundSchema),
+    RequireApprovalAlways$outboundSchema,
+    RequireApprovalNever$outboundSchema,
+    z.any(),
+]);
+export function requireApprovalUnionToJSON(requireApprovalUnion) {
+    return JSON.stringify(RequireApprovalUnion$outboundSchema.parse(requireApprovalUnion));
+}
+export function requireApprovalUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RequireApprovalUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequireApprovalUnion' from JSON`);
+}
+/** @internal */
+export const McpServerTool$inboundSchema = z
+    .object({
+    allowed_tools: z.nullable(z.union([
+        z.array(z.string()),
+        z.lazy(() => AllowedTools$inboundSchema),
+        z.any(),
+    ])).optional(),
     authorization: z.string().optional(),
     connector_id: ConnectorId$inboundSchema.optional(),
     headers: z.nullable(z.record(z.string(), z.string())).optional(),
-    require_approval: z.nullable(z.any()).optional(),
+    require_approval: z.nullable(z.union([
+        z.lazy(() => RequireApproval$inboundSchema),
+        RequireApprovalAlways$inboundSchema,
+        RequireApprovalNever$inboundSchema,
+        z.any(),
+    ])).optional(),
     server_description: z.string().optional(),
+    server_label: z.string(),
     server_url: z.string().optional(),
+    type: z.literal("mcp"),
 }).transform((v) => {
     return remap$(v, {
-        "server_label": "serverLabel",
         "allowed_tools": "allowedTools",
         "connector_id": "connectorId",
         "require_approval": "requireApproval",
         "server_description": "serverDescription",
+        "server_label": "serverLabel",
         "server_url": "serverUrl",
     });
 });
 /** @internal */
-export const OpenResponsesMcpTool$outboundSchema = z.object({
-    type: z.literal("mcp"),
-    serverLabel: z.string(),
-    allowedTools: z.nullable(z.any()).optional(),
+export const McpServerTool$outboundSchema = z.object({
+    allowedTools: z.nullable(z.union([
+        z.array(z.string()),
+        z.lazy(() => AllowedTools$outboundSchema),
+        z.any(),
+    ])).optional(),
     authorization: z.string().optional(),
     connectorId: ConnectorId$outboundSchema.optional(),
     headers: z.nullable(z.record(z.string(), z.string())).optional(),
-    requireApproval: z.nullable(z.any()).optional(),
+    requireApproval: z.nullable(z.union([
+        z.lazy(() => RequireApproval$outboundSchema),
+        RequireApprovalAlways$outboundSchema,
+        RequireApprovalNever$outboundSchema,
+        z.any(),
+    ])).optional(),
     serverDescription: z.string().optional(),
+    serverLabel: z.string(),
     serverUrl: z.string().optional(),
+    type: z.literal("mcp"),
 }).transform((v) => {
     return remap$(v, {
-        serverLabel: "server_label",
         allowedTools: "allowed_tools",
         connectorId: "connector_id",
         requireApproval: "require_approval",
         serverDescription: "server_description",
+        serverLabel: "server_label",
         serverUrl: "server_url",
     });
 });
-export function openResponsesMcpToolToJSON(openResponsesMcpTool) {
-    return JSON.stringify(OpenResponsesMcpTool$outboundSchema.parse(openResponsesMcpTool));
+export function mcpServerToolToJSON(mcpServerTool) {
+    return JSON.stringify(McpServerTool$outboundSchema.parse(mcpServerTool));
 }
-export function openResponsesMcpToolFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesMcpTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesMcpTool' from JSON`);
+export function mcpServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => McpServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'McpServerTool' from JSON`);
 }
-//# sourceMappingURL=openresponsesmcptool.js.map
+//# sourceMappingURL=mcpservertool.js.map

package/esm/models/memberassignment.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type MemberAssignment = {
+    /**
+     * User ID of who made the assignment
+     */
+    assignedBy: string | null;
+    /**
+     * ISO 8601 timestamp of when the assignment was created
+     */
+    createdAt: string;
+    /**
+     * ID of the guardrail
+     */
+    guardrailId: string;
+    /**
+     * Unique identifier for the assignment
+     */
+    id: string;
+    /**
+     * Organization ID
+     */
+    organizationId: string;
+    /**
+     * Clerk user ID of the assigned member
+     */
+    userId: string;
+};
+/** @internal */
+export declare const MemberAssignment$inboundSchema: z.ZodType<MemberAssignment, unknown>;
+export declare function memberAssignmentFromJSON(jsonString: string): SafeParseResult<MemberAssignment, SDKValidationError>;
+//# sourceMappingURL=memberassignment.d.ts.map

package/esm/models/memberassignment.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5e100b48823e
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const MemberAssignment$inboundSchema = z.object({
+    assigned_by: z.nullable(z.string()),
+    created_at: z.string(),
+    guardrail_id: z.string(),
+    id: z.string(),
+    organization_id: z.string(),
+    user_id: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "assigned_by": "assignedBy",
+        "created_at": "createdAt",
+        "guardrail_id": "guardrailId",
+        "organization_id": "organizationId",
+        "user_id": "userId",
+    });
+});
+export function memberAssignmentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => MemberAssignment$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'MemberAssignment' from JSON`);
+}
+//# sourceMappingURL=memberassignment.js.map

package/esm/models/model.d.ts

@@ -3,6 +3,7 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { DefaultParameters } from "./defaultparameters.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ModelArchitecture } from "./modelarchitecture.js";
+import { ModelLinks } from "./modellinks.js";
 import { Parameter } from "./parameter.js";
 import { PerRequestLimits } from "./perrequestlimits.js";
 import { PublicPricing } from "./publicpricing.js";
@@ -12,61 +13,69 @@ import { TopProviderInfo } from "./topproviderinfo.js";
  */
 export type Model = {
     /**
-     * Unique identifier for the model
+     * Model architecture information
      */
-    id: string;
+    architecture: ModelArchitecture;
     /**
      * Canonical slug for the model
      */
     canonicalSlug: string;
     /**
-     * Hugging Face model identifier, if applicable
-     */
-    huggingFaceId?: string | null | undefined;
-    /**
-     * Display name of the model
+     * Maximum context length in tokens
      */
-    name: string;
+    contextLength: number;
     /**
      * Unix timestamp of when the model was created
      */
     created: number;
+    /**
+     * Default parameters for this model
+     */
+    defaultParameters: DefaultParameters | null;
     /**
      * Description of the model
      */
     description?: string | undefined;
     /**
-     * Pricing information for the model
+     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
      */
-    pricing: PublicPricing;
+    expirationDate?: string | null | undefined;
     /**
-     * Maximum context length in tokens
+     * Hugging Face model identifier, if applicable
      */
-    contextLength: number | null;
+    huggingFaceId?: string | null | undefined;
     /**
-     * Model architecture information
+     * Unique identifier for the model
      */
-    architecture: ModelArchitecture;
+    id: string;
     /**
-     * Information about the top provider for this model
+     * The date up to which the model was trained on data. ISO 8601 date string (YYYY-MM-DD) or null if unknown.
      */
-    topProvider: TopProviderInfo;
+    knowledgeCutoff?: string | null | undefined;
+    /**
+     * Related API endpoints and resources for this model.
+     */
+    links: ModelLinks;
+    /**
+     * Display name of the model
+     */
+    name: string;
     /**
      * Per-request token limits
      */
     perRequestLimits: PerRequestLimits | null;
     /**
-     * List of supported parameters for this model
+     * Pricing information for the model
      */
-    supportedParameters: Array<Parameter>;
+    pricing: PublicPricing;
     /**
-     * Default parameters for this model
+     * List of supported parameters for this model
      */
-    defaultParameters: DefaultParameters | null;
+    supportedParameters: Array<Parameter>;
     /**
-     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
+     * Information about the top provider for this model
      */
-    expirationDate?: string | null | undefined;
+    topProvider: TopProviderInfo;
 };
 /** @internal */
 export declare const Model$inboundSchema: z.ZodType<Model, unknown>;

package/esm/models/model.js

@@ -7,36 +7,40 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { DefaultParameters$inboundSchema, } from "./defaultparameters.js";
 import { ModelArchitecture$inboundSchema, } from "./modelarchitecture.js";
+import { ModelLinks$inboundSchema } from "./modellinks.js";
 import { Parameter$inboundSchema } from "./parameter.js";
 import { PerRequestLimits$inboundSchema, } from "./perrequestlimits.js";
 import { PublicPricing$inboundSchema } from "./publicpricing.js";
 import { TopProviderInfo$inboundSchema, } from "./topproviderinfo.js";
 /** @internal */
 export const Model$inboundSchema = z.object({
-    id: z.string(),
+    architecture: ModelArchitecture$inboundSchema,
     canonical_slug: z.string(),
+    context_length: z.int(),
+    created: z.int(),
+    default_parameters: z.nullable(DefaultParameters$inboundSchema),
+    description: z.string().optional(),
+    expiration_date: z.nullable(z.string()).optional(),
     hugging_face_id: z.nullable(z.string()).optional(),
+    id: z.string(),
+    knowledge_cutoff: z.nullable(z.string()).optional(),
+    links: ModelLinks$inboundSchema,
     name: z.string(),
-    created: z.number(),
-    description: z.string().optional(),
-    pricing: PublicPricing$inboundSchema,
-    context_length: z.nullable(z.number()),
-    architecture: ModelArchitecture$inboundSchema,
-    top_provider: TopProviderInfo$inboundSchema,
     per_request_limits: z.nullable(PerRequestLimits$inboundSchema),
+    pricing: PublicPricing$inboundSchema,
     supported_parameters: z.array(Parameter$inboundSchema),
-    default_parameters: z.nullable(DefaultParameters$inboundSchema),
-    expiration_date: z.nullable(z.string()).optional(),
+    top_provider: TopProviderInfo$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "canonical_slug": "canonicalSlug",
-        "hugging_face_id": "huggingFaceId",
         "context_length": "contextLength",
-        "top_provider": "topProvider",
-        "per_request_limits": "perRequestLimits",
-        "supported_parameters": "supportedParameters",
         "default_parameters": "defaultParameters",
         "expiration_date": "expirationDate",
+        "hugging_face_id": "huggingFaceId",
+        "knowledge_cutoff": "knowledgeCutoff",
+        "per_request_limits": "perRequestLimits",
+        "supported_parameters": "supportedParameters",
+        "top_provider": "topProvider",
     });
 });
 export function modelFromJSON(jsonString) {

package/esm/models/modelarchitecture.d.ts

@@ -41,9 +41,9 @@ export type ModelArchitectureInstructType = OpenEnum<typeof ModelArchitectureIns
  */
 export type ModelArchitecture = {
     /**
-     * Tokenizer type used by the model
+     * Supported input modalities
      */
-    tokenizer?: ModelGroup | undefined;
+    inputModalities: Array<InputModality>;
     /**
      * Instruction format type
      */
@@ -52,14 +52,14 @@ export type ModelArchitecture = {
      * Primary modality of the model
      */
     modality: string | null;
-    /**
-     * Supported input modalities
-     */
-    inputModalities: Array<InputModality>;
     /**
      * Supported output modalities
      */
     outputModalities: Array<OutputModality>;
+    /**
+     * Tokenizer type used by the model
+     */
+    tokenizer?: ModelGroup | undefined;
 };
 /** @internal */
 export declare const ModelArchitectureInstructType$inboundSchema: z.ZodType<ModelArchitectureInstructType, unknown>;

package/esm/models/modelarchitecture.js

@@ -40,16 +40,16 @@ export const ModelArchitectureInstructType = {
 export const ModelArchitectureInstructType$inboundSchema = openEnums.inboundSchema(ModelArchitectureInstructType);
 /** @internal */
 export const ModelArchitecture$inboundSchema = z.object({
-    tokenizer: ModelGroup$inboundSchema.optional(),
+    input_modalities: z.array(InputModality$inboundSchema),
     instruct_type: z.nullable(ModelArchitectureInstructType$inboundSchema)
         .optional(),
     modality: z.nullable(z.string()),
-    input_modalities: z.array(InputModality$inboundSchema),
     output_modalities: z.array(OutputModality$inboundSchema),
+    tokenizer: ModelGroup$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
-        "instruct_type": "instructType",
         "input_modalities": "inputModalities",
+        "instruct_type": "instructType",
         "output_modalities": "outputModalities",
     });
 });