@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/mcpservertool.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,45 +141,83 @@ export function requireApprovalFromJSON(jsonString) {
     return safeParse(jsonString, (x) => RequireApproval$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RequireApproval' from JSON`);
 }
 /** @internal */
+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({
-    type: z.literal("mcp"),
-    server_label: z.string(),
-    allowed_tools: z.nullable(z.any()).optional(),
+    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 McpServerTool$outboundSchema = z.object({
-    type: z.literal("mcp"),
-    serverLabel: z.string(),
-    allowedTools: z.nullable(z.any()).optional(),
+    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",
     });
 });

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,65 +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;
     /**
-     * Per-request token limits
+     * Related API endpoints and resources for this model.
      */
-    perRequestLimits: PerRequestLimits | null;
+    links: ModelLinks;
     /**
-     * List of supported parameters for this model
+     * Display name of the model
      */
-    supportedParameters: Array<Parameter>;
+    name: string;
     /**
-     * Default parameters for this model
+     * Per-request token limits
      */
-    defaultParameters: DefaultParameters | null;
+    perRequestLimits: PerRequestLimits | null;
     /**
-     * The date up to which the model was trained on data. ISO 8601 date string (YYYY-MM-DD) or null if unknown.
+     * Pricing information for the model
      */
-    knowledgeCutoff?: string | null | undefined;
+    pricing: PublicPricing;
     /**
-     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
+     * List of supported parameters for this model
      */
-    expirationDate?: string | null | undefined;
+    supportedParameters: Array<Parameter>;
+    /**
+     * Information about the top provider for this model
+     */
+    topProvider: TopProviderInfo;
 };
 /** @internal */
 export declare const Model$inboundSchema: z.ZodType<Model, unknown>;

package/esm/models/model.js

@@ -7,38 +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),
-    knowledge_cutoff: z.nullable(z.string()).optional(),
-    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",
-        "knowledge_cutoff": "knowledgeCutoff",
         "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",
     });
 });

package/esm/models/modelgroup.d.ts

@@ -10,6 +10,7 @@ export declare const ModelGroup: {
     readonly Gpt: "GPT";
     readonly Claude: "Claude";
     readonly Gemini: "Gemini";
+    readonly Gemma: "Gemma";
     readonly Grok: "Grok";
     readonly Cohere: "Cohere";
     readonly Nova: "Nova";

package/esm/models/modelgroup.js

@@ -13,6 +13,7 @@ export const ModelGroup = {
     Gpt: "GPT",
     Claude: "Claude",
     Gemini: "Gemini",
+    Gemma: "Gemma",
     Grok: "Grok",
     Cohere: "Cohere",
     Nova: "Nova",

package/esm/models/modellinks.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Related API endpoints and resources for this model.
+ */
+export type ModelLinks = {
+    /**
+     * URL for the model details/endpoints API
+     */
+    details: string;
+};
+/** @internal */
+export declare const ModelLinks$inboundSchema: z.ZodType<ModelLinks, unknown>;
+export declare function modelLinksFromJSON(jsonString: string): SafeParseResult<ModelLinks, SDKValidationError>;
+//# sourceMappingURL=modellinks.d.ts.map

package/esm/models/modellinks.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 965b10bc40c4
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ModelLinks$inboundSchema = z
+    .object({
+    details: z.string(),
+});
+export function modelLinksFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ModelLinks$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ModelLinks' from JSON`);
+}
+//# sourceMappingURL=modellinks.js.map

package/esm/models/modelscountresponse.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const Data$inboundSchema = z.object({
-    count: z.number(),
+    count: z.int(),
 });
 export function dataFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Data$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Data' from JSON`);

package/esm/models/moderationplugin.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+export type ModerationPlugin = {
+    id: "moderation";
+};
+/** @internal */
+export type ModerationPlugin$Outbound = {
+    id: "moderation";
+};
+/** @internal */
+export declare const ModerationPlugin$outboundSchema: z.ZodType<ModerationPlugin$Outbound, ModerationPlugin>;
+export declare function moderationPluginToJSON(moderationPlugin: ModerationPlugin): string;
+//# sourceMappingURL=moderationplugin.d.ts.map

package/esm/models/moderationplugin.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 309bb6cfc394
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ModerationPlugin$outboundSchema = z.object({
+    id: z.literal("moderation"),
+});
+export function moderationPluginToJSON(moderationPlugin) {
+    return JSON.stringify(ModerationPlugin$outboundSchema.parse(moderationPlugin));
+}
+//# sourceMappingURL=moderationplugin.js.map

package/esm/models/openairesponsefunctiontoolcall.d.ts

@@ -0,0 +1,23 @@
+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 OpenAIResponseFunctionToolCallType: {
+    readonly FunctionCall: "function_call";
+};
+export type OpenAIResponseFunctionToolCallType = ClosedEnum<typeof OpenAIResponseFunctionToolCallType>;
+export type OpenAIResponseFunctionToolCall = {
+    arguments: string;
+    callId: string;
+    id?: string | undefined;
+    name: string;
+    status?: ToolCallStatus | undefined;
+    type: OpenAIResponseFunctionToolCallType;
+};
+/** @internal */
+export declare const OpenAIResponseFunctionToolCallType$inboundSchema: z.ZodEnum<typeof OpenAIResponseFunctionToolCallType>;
+/** @internal */
+export declare const OpenAIResponseFunctionToolCall$inboundSchema: z.ZodType<OpenAIResponseFunctionToolCall, unknown>;
+export declare function openAIResponseFunctionToolCallFromJSON(jsonString: string): SafeParseResult<OpenAIResponseFunctionToolCall, SDKValidationError>;
+//# sourceMappingURL=openairesponsefunctiontoolcall.d.ts.map

package/esm/models/openairesponsefunctiontoolcall.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d27a63e0fb93
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+export const OpenAIResponseFunctionToolCallType = {
+    FunctionCall: "function_call",
+};
+/** @internal */
+export const OpenAIResponseFunctionToolCallType$inboundSchema = z.enum(OpenAIResponseFunctionToolCallType);
+/** @internal */
+export const OpenAIResponseFunctionToolCall$inboundSchema = z.object({
+    arguments: z.string(),
+    call_id: z.string(),
+    id: z.string().optional(),
+    name: z.string(),
+    status: ToolCallStatus$inboundSchema.optional(),
+    type: OpenAIResponseFunctionToolCallType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+export function openAIResponseFunctionToolCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenAIResponseFunctionToolCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponseFunctionToolCall' from JSON`);
+}
+//# sourceMappingURL=openairesponsefunctiontoolcall.js.map