@mistralai/mistralai 1.13.0 → 1.14.1

package/src/models/components/conversationrestartstreamrequest.ts

@@ -24,11 +24,16 @@ export type ConversationRestartStreamRequestHandoffExecution = ClosedEnum<
   typeof ConversationRestartStreamRequestHandoffExecution
 >;
 
+/**
+ * Specific version of the agent to use when restarting. If not provided, uses the current version.
+ */
+export type ConversationRestartStreamRequestAgentVersion = string | number;
+
 /**
  * Request to restart a new conversation from a given entry in the conversation.
  */
 export type ConversationRestartStreamRequest = {
-  inputs: ConversationInputs;
+  inputs?: ConversationInputs | undefined;
   stream?: boolean | undefined;
   /**
    * Whether to store the results into our servers or not.
@@ -49,7 +54,7 @@ export type ConversationRestartStreamRequest = {
   /**
    * Specific version of the agent to use when restarting. If not provided, uses the current version.
    */
-  agentVersion?: number | null | undefined;
+  agentVersion?: string | number | null | undefined;
 };
 
 /** @internal */
@@ -57,16 +62,40 @@ export const ConversationRestartStreamRequestHandoffExecution$outboundSchema:
   z.ZodNativeEnum<typeof ConversationRestartStreamRequestHandoffExecution> = z
     .nativeEnum(ConversationRestartStreamRequestHandoffExecution);
 
+/** @internal */
+export type ConversationRestartStreamRequestAgentVersion$Outbound =
+  | string
+  | number;
+
+/** @internal */
+export const ConversationRestartStreamRequestAgentVersion$outboundSchema:
+  z.ZodType<
+    ConversationRestartStreamRequestAgentVersion$Outbound,
+    z.ZodTypeDef,
+    ConversationRestartStreamRequestAgentVersion
+  > = z.union([z.string(), z.number().int()]);
+
+export function conversationRestartStreamRequestAgentVersionToJSON(
+  conversationRestartStreamRequestAgentVersion:
+    ConversationRestartStreamRequestAgentVersion,
+): string {
+  return JSON.stringify(
+    ConversationRestartStreamRequestAgentVersion$outboundSchema.parse(
+      conversationRestartStreamRequestAgentVersion,
+    ),
+  );
+}
+
 /** @internal */
 export type ConversationRestartStreamRequest$Outbound = {
-  inputs: ConversationInputs$Outbound;
+  inputs?: ConversationInputs$Outbound | undefined;
   stream: boolean;
   store: boolean;
   handoff_execution: string;
   completion_args?: CompletionArgs$Outbound | undefined;
   metadata?: { [k: string]: any } | null | undefined;
   from_entry_id: string;
-  agent_version?: number | null | undefined;
+  agent_version?: string | number | null | undefined;
 };
 
 /** @internal */
@@ -75,7 +104,7 @@ export const ConversationRestartStreamRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ConversationRestartStreamRequest
 > = z.object({
-  inputs: ConversationInputs$outboundSchema,
+  inputs: ConversationInputs$outboundSchema.optional(),
   stream: z.boolean().default(true),
   store: z.boolean().default(true),
   handoffExecution:
@@ -85,7 +114,7 @@ export const ConversationRestartStreamRequest$outboundSchema: z.ZodType<
   completionArgs: CompletionArgs$outboundSchema.optional(),
   metadata: z.nullable(z.record(z.any())).optional(),
   fromEntryId: z.string(),
-  agentVersion: z.nullable(z.number().int()).optional(),
+  agentVersion: z.nullable(z.union([z.string(), z.number().int()])).optional(),
 }).transform((v) => {
   return remap$(v, {
     handoffExecution: "handoff_execution",

package/src/models/components/conversationstreamrequest.ts

@@ -62,6 +62,8 @@ export type ConversationStreamRequestTools =
   | (WebSearchTool & { type: "web_search" })
   | (WebSearchPremiumTool & { type: "web_search_premium" });
 
+export type ConversationStreamRequestAgentVersion = string | number;
+
 export type ConversationStreamRequest = {
   inputs: ConversationInputs;
   stream?: boolean | undefined;
@@ -89,7 +91,7 @@ export type ConversationStreamRequest = {
   description?: string | null | undefined;
   metadata?: { [k: string]: any } | null | undefined;
   agentId?: string | null | undefined;
-  agentVersion?: number | null | undefined;
+  agentVersion?: string | number | null | undefined;
   model?: string | null | undefined;
 };
 
@@ -139,6 +141,26 @@ export function conversationStreamRequestToolsToJSON(
   );
 }
 
+/** @internal */
+export type ConversationStreamRequestAgentVersion$Outbound = string | number;
+
+/** @internal */
+export const ConversationStreamRequestAgentVersion$outboundSchema: z.ZodType<
+  ConversationStreamRequestAgentVersion$Outbound,
+  z.ZodTypeDef,
+  ConversationStreamRequestAgentVersion
+> = z.union([z.string(), z.number().int()]);
+
+export function conversationStreamRequestAgentVersionToJSON(
+  conversationStreamRequestAgentVersion: ConversationStreamRequestAgentVersion,
+): string {
+  return JSON.stringify(
+    ConversationStreamRequestAgentVersion$outboundSchema.parse(
+      conversationStreamRequestAgentVersion,
+    ),
+  );
+}
+
 /** @internal */
 export type ConversationStreamRequest$Outbound = {
   inputs: ConversationInputs$Outbound;
@@ -161,7 +183,7 @@ export type ConversationStreamRequest$Outbound = {
   description?: string | null | undefined;
   metadata?: { [k: string]: any } | null | undefined;
   agent_id?: string | null | undefined;
-  agent_version?: number | null | undefined;
+  agent_version?: string | number | null | undefined;
   model?: string | null | undefined;
 };
 
@@ -205,7 +227,7 @@ export const ConversationStreamRequest$outboundSchema: z.ZodType<
   description: z.nullable(z.string()).optional(),
   metadata: z.nullable(z.record(z.any())).optional(),
   agentId: z.nullable(z.string()).optional(),
-  agentVersion: z.nullable(z.number().int()).optional(),
+  agentVersion: z.nullable(z.union([z.string(), z.number().int()])).optional(),
   model: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/documentlibrarytool.ts

@@ -8,6 +8,12 @@ import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ToolConfiguration,
+  ToolConfiguration$inboundSchema,
+  ToolConfiguration$Outbound,
+  ToolConfiguration$outboundSchema,
+} from "./toolconfiguration.js";
 
 export const DocumentLibraryToolType = {
   DocumentLibrary: "document_library",
@@ -17,6 +23,7 @@ export type DocumentLibraryToolType = ClosedEnum<
 >;
 
 export type DocumentLibraryTool = {
+  toolConfiguration?: ToolConfiguration | null | undefined;
   type?: DocumentLibraryToolType | undefined;
   /**
    * Ids of the library in which to search.
@@ -39,15 +46,18 @@ export const DocumentLibraryTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  tool_configuration: z.nullable(ToolConfiguration$inboundSchema).optional(),
   type: DocumentLibraryToolType$inboundSchema.default("document_library"),
   library_ids: z.array(z.string()),
 }).transform((v) => {
   return remap$(v, {
+    "tool_configuration": "toolConfiguration",
     "library_ids": "libraryIds",
   });
 });
 /** @internal */
 export type DocumentLibraryTool$Outbound = {
+  tool_configuration?: ToolConfiguration$Outbound | null | undefined;
   type: string;
   library_ids: Array<string>;
 };
@@ -58,10 +68,12 @@ export const DocumentLibraryTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DocumentLibraryTool
 > = z.object({
+  toolConfiguration: z.nullable(ToolConfiguration$outboundSchema).optional(),
   type: DocumentLibraryToolType$outboundSchema.default("document_library"),
   libraryIds: z.array(z.string()),
 }).transform((v) => {
   return remap$(v, {
+    toolConfiguration: "tool_configuration",
     libraryIds: "library_ids",
   });
 });

package/src/models/components/documentout.ts

@@ -20,13 +20,13 @@ export type DocumentOut = {
   createdAt: Date;
   lastProcessedAt?: Date | null | undefined;
   numberOfPages?: number | null | undefined;
-  processingStatus: string;
   uploadedById: string | null;
   uploadedByType: string;
   tokensProcessingMainContent?: number | null | undefined;
   tokensProcessingSummary?: number | null | undefined;
   url?: string | null | undefined;
   attributes?: { [k: string]: any } | null | undefined;
+  processingStatus: string;
   tokensProcessingTotal: number;
 };
 
@@ -49,13 +49,13 @@ export const DocumentOut$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ).optional(),
   number_of_pages: z.nullable(z.number().int()).optional(),
-  processing_status: z.string(),
   uploaded_by_id: z.nullable(z.string()),
   uploaded_by_type: z.string(),
   tokens_processing_main_content: z.nullable(z.number().int()).optional(),
   tokens_processing_summary: z.nullable(z.number().int()).optional(),
   url: z.nullable(z.string()).optional(),
   attributes: z.nullable(z.record(z.any())).optional(),
+  processing_status: z.string(),
   tokens_processing_total: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
@@ -64,11 +64,11 @@ export const DocumentOut$inboundSchema: z.ZodType<
     "created_at": "createdAt",
     "last_processed_at": "lastProcessedAt",
     "number_of_pages": "numberOfPages",
-    "processing_status": "processingStatus",
     "uploaded_by_id": "uploadedById",
     "uploaded_by_type": "uploadedByType",
     "tokens_processing_main_content": "tokensProcessingMainContent",
     "tokens_processing_summary": "tokensProcessingSummary",
+    "processing_status": "processingStatus",
     "tokens_processing_total": "tokensProcessingTotal",
   });
 });

package/src/models/components/documenturlchunk.ts

@@ -5,42 +5,27 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const DocumentURLChunkType = {
-  DocumentUrl: "document_url",
-} as const;
-export type DocumentURLChunkType = ClosedEnum<typeof DocumentURLChunkType>;
-
 export type DocumentURLChunk = {
+  type?: "document_url" | undefined;
   documentUrl: string;
   /**
    * The filename of the document
    */
   documentName?: string | null | undefined;
-  type?: DocumentURLChunkType | undefined;
 };
 
-/** @internal */
-export const DocumentURLChunkType$inboundSchema: z.ZodNativeEnum<
-  typeof DocumentURLChunkType
-> = z.nativeEnum(DocumentURLChunkType);
-/** @internal */
-export const DocumentURLChunkType$outboundSchema: z.ZodNativeEnum<
-  typeof DocumentURLChunkType
-> = DocumentURLChunkType$inboundSchema;
-
 /** @internal */
 export const DocumentURLChunk$inboundSchema: z.ZodType<
   DocumentURLChunk,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  type: z.literal("document_url").default("document_url"),
   document_url: z.string(),
   document_name: z.nullable(z.string()).optional(),
-  type: DocumentURLChunkType$inboundSchema.default("document_url"),
 }).transform((v) => {
   return remap$(v, {
     "document_url": "documentUrl",
@@ -49,9 +34,9 @@ export const DocumentURLChunk$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type DocumentURLChunk$Outbound = {
+  type: "document_url";
   document_url: string;
   document_name?: string | null | undefined;
-  type: string;
 };
 
 /** @internal */
@@ -60,9 +45,9 @@ export const DocumentURLChunk$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DocumentURLChunk
 > = z.object({
+  type: z.literal("document_url").default("document_url" as const),
   documentUrl: z.string(),
   documentName: z.nullable(z.string()).optional(),
-  type: DocumentURLChunkType$outboundSchema.default("document_url"),
 }).transform((v) => {
   return remap$(v, {
     documentUrl: "document_url",

package/src/models/components/ftmodelcard.ts

@@ -5,7 +5,6 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -13,11 +12,6 @@ import {
   ModelCapabilities$inboundSchema,
 } from "./modelcapabilities.js";
 
-export const FTModelCardType = {
-  FineTuned: "fine-tuned",
-} as const;
-export type FTModelCardType = ClosedEnum<typeof FTModelCardType>;
-
 /**
  * Extra fields for fine-tuned models.
  */
@@ -40,11 +34,6 @@ export type FTModelCard = {
   archived: boolean | undefined;
 };
 
-/** @internal */
-export const FTModelCardType$inboundSchema: z.ZodNativeEnum<
-  typeof FTModelCardType
-> = z.nativeEnum(FTModelCardType);
-
 /** @internal */
 export const FTModelCard$inboundSchema: z.ZodType<
   FTModelCard,

package/src/models/components/functioncallentry.ts

@@ -15,46 +15,33 @@ import {
   FunctionCallEntryArguments$outboundSchema,
 } from "./functioncallentryarguments.js";
 
-export const FunctionCallEntryObject = {
-  Entry: "entry",
+export const ConfirmationStatus = {
+  Pending: "pending",
+  Allowed: "allowed",
+  Denied: "denied",
 } as const;
-export type FunctionCallEntryObject = ClosedEnum<
-  typeof FunctionCallEntryObject
->;
-
-export const FunctionCallEntryType = {
-  FunctionCall: "function.call",
-} as const;
-export type FunctionCallEntryType = ClosedEnum<typeof FunctionCallEntryType>;
+export type ConfirmationStatus = ClosedEnum<typeof ConfirmationStatus>;
 
 export type FunctionCallEntry = {
-  object?: FunctionCallEntryObject | undefined;
-  type?: FunctionCallEntryType | undefined;
+  object?: "entry" | undefined;
+  type?: "function.call" | undefined;
   createdAt?: Date | undefined;
   completedAt?: Date | null | undefined;
   id?: string | undefined;
   toolCallId: string;
   name: string;
   arguments: FunctionCallEntryArguments;
+  confirmationStatus?: ConfirmationStatus | null | undefined;
 };
 
 /** @internal */
-export const FunctionCallEntryObject$inboundSchema: z.ZodNativeEnum<
-  typeof FunctionCallEntryObject
-> = z.nativeEnum(FunctionCallEntryObject);
-/** @internal */
-export const FunctionCallEntryObject$outboundSchema: z.ZodNativeEnum<
-  typeof FunctionCallEntryObject
-> = FunctionCallEntryObject$inboundSchema;
-
-/** @internal */
-export const FunctionCallEntryType$inboundSchema: z.ZodNativeEnum<
-  typeof FunctionCallEntryType
-> = z.nativeEnum(FunctionCallEntryType);
+export const ConfirmationStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ConfirmationStatus
+> = z.nativeEnum(ConfirmationStatus);
 /** @internal */
-export const FunctionCallEntryType$outboundSchema: z.ZodNativeEnum<
-  typeof FunctionCallEntryType
-> = FunctionCallEntryType$inboundSchema;
+export const ConfirmationStatus$outboundSchema: z.ZodNativeEnum<
+  typeof ConfirmationStatus
+> = ConfirmationStatus$inboundSchema;
 
 /** @internal */
 export const FunctionCallEntry$inboundSchema: z.ZodType<
@@ -62,8 +49,8 @@ export const FunctionCallEntry$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  object: FunctionCallEntryObject$inboundSchema.default("entry"),
-  type: FunctionCallEntryType$inboundSchema.default("function.call"),
+  object: z.literal("entry").default("entry"),
+  type: z.literal("function.call").default("function.call"),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   completed_at: z.nullable(
@@ -73,23 +60,26 @@ export const FunctionCallEntry$inboundSchema: z.ZodType<
   tool_call_id: z.string(),
   name: z.string(),
   arguments: FunctionCallEntryArguments$inboundSchema,
+  confirmation_status: z.nullable(ConfirmationStatus$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
     "completed_at": "completedAt",
     "tool_call_id": "toolCallId",
+    "confirmation_status": "confirmationStatus",
   });
 });
 /** @internal */
 export type FunctionCallEntry$Outbound = {
-  object: string;
-  type: string;
+  object: "entry";
+  type: "function.call";
   created_at?: string | undefined;
   completed_at?: string | null | undefined;
   id?: string | undefined;
   tool_call_id: string;
   name: string;
   arguments: FunctionCallEntryArguments$Outbound;
+  confirmation_status?: string | null | undefined;
 };
 
 /** @internal */
@@ -98,19 +88,21 @@ export const FunctionCallEntry$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FunctionCallEntry
 > = z.object({
-  object: FunctionCallEntryObject$outboundSchema.default("entry"),
-  type: FunctionCallEntryType$outboundSchema.default("function.call"),
+  object: z.literal("entry").default("entry" as const),
+  type: z.literal("function.call").default("function.call" as const),
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   completedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   id: z.string().optional(),
   toolCallId: z.string(),
   name: z.string(),
   arguments: FunctionCallEntryArguments$outboundSchema,
+  confirmationStatus: z.nullable(ConfirmationStatus$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",
     completedAt: "completed_at",
     toolCallId: "tool_call_id",
+    confirmationStatus: "confirmation_status",
   });
 });
 

package/src/models/components/functioncallevent.ts

@@ -9,25 +9,30 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const FunctionCallEventType = {
-  FunctionCallDelta: "function.call.delta",
+export const FunctionCallEventConfirmationStatus = {
+  Pending: "pending",
+  Allowed: "allowed",
+  Denied: "denied",
 } as const;
-export type FunctionCallEventType = ClosedEnum<typeof FunctionCallEventType>;
+export type FunctionCallEventConfirmationStatus = ClosedEnum<
+  typeof FunctionCallEventConfirmationStatus
+>;
 
 export type FunctionCallEvent = {
-  type: FunctionCallEventType | undefined;
+  type?: "function.call.delta" | undefined;
   createdAt?: Date | undefined;
   outputIndex: number | undefined;
   id: string;
   name: string;
   toolCallId: string;
   arguments: string;
+  confirmationStatus?: FunctionCallEventConfirmationStatus | null | undefined;
 };
 
 /** @internal */
-export const FunctionCallEventType$inboundSchema: z.ZodNativeEnum<
-  typeof FunctionCallEventType
-> = z.nativeEnum(FunctionCallEventType);
+export const FunctionCallEventConfirmationStatus$inboundSchema: z.ZodNativeEnum<
+  typeof FunctionCallEventConfirmationStatus
+> = z.nativeEnum(FunctionCallEventConfirmationStatus);
 
 /** @internal */
 export const FunctionCallEvent$inboundSchema: z.ZodType<
@@ -35,7 +40,7 @@ export const FunctionCallEvent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: FunctionCallEventType$inboundSchema.default("function.call.delta"),
+  type: z.literal("function.call.delta").default("function.call.delta"),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   output_index: z.number().int().default(0),
@@ -43,11 +48,15 @@ export const FunctionCallEvent$inboundSchema: z.ZodType<
   name: z.string(),
   tool_call_id: z.string(),
   arguments: z.string(),
+  confirmation_status: z.nullable(
+    FunctionCallEventConfirmationStatus$inboundSchema,
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
     "output_index": "outputIndex",
     "tool_call_id": "toolCallId",
+    "confirmation_status": "confirmationStatus",
   });
 });
 

package/src/models/components/functionresultentry.ts

@@ -5,27 +5,12 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const FunctionResultEntryObject = {
-  Entry: "entry",
-} as const;
-export type FunctionResultEntryObject = ClosedEnum<
-  typeof FunctionResultEntryObject
->;
-
-export const FunctionResultEntryType = {
-  FunctionResult: "function.result",
-} as const;
-export type FunctionResultEntryType = ClosedEnum<
-  typeof FunctionResultEntryType
->;
-
 export type FunctionResultEntry = {
-  object?: FunctionResultEntryObject | undefined;
-  type?: FunctionResultEntryType | undefined;
+  object?: "entry" | undefined;
+  type?: "function.result" | undefined;
   createdAt?: Date | undefined;
   completedAt?: Date | null | undefined;
   id?: string | undefined;
@@ -33,32 +18,14 @@ export type FunctionResultEntry = {
   result: string;
 };
 
-/** @internal */
-export const FunctionResultEntryObject$inboundSchema: z.ZodNativeEnum<
-  typeof FunctionResultEntryObject
-> = z.nativeEnum(FunctionResultEntryObject);
-/** @internal */
-export const FunctionResultEntryObject$outboundSchema: z.ZodNativeEnum<
-  typeof FunctionResultEntryObject
-> = FunctionResultEntryObject$inboundSchema;
-
-/** @internal */
-export const FunctionResultEntryType$inboundSchema: z.ZodNativeEnum<
-  typeof FunctionResultEntryType
-> = z.nativeEnum(FunctionResultEntryType);
-/** @internal */
-export const FunctionResultEntryType$outboundSchema: z.ZodNativeEnum<
-  typeof FunctionResultEntryType
-> = FunctionResultEntryType$inboundSchema;
-
 /** @internal */
 export const FunctionResultEntry$inboundSchema: z.ZodType<
   FunctionResultEntry,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  object: FunctionResultEntryObject$inboundSchema.default("entry"),
-  type: FunctionResultEntryType$inboundSchema.default("function.result"),
+  object: z.literal("entry").default("entry"),
+  type: z.literal("function.result").default("function.result"),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   completed_at: z.nullable(
@@ -76,8 +43,8 @@ export const FunctionResultEntry$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type FunctionResultEntry$Outbound = {
-  object: string;
-  type: string;
+  object: "entry";
+  type: "function.result";
   created_at?: string | undefined;
   completed_at?: string | null | undefined;
   id?: string | undefined;
@@ -91,8 +58,8 @@ export const FunctionResultEntry$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FunctionResultEntry
 > = z.object({
-  object: FunctionResultEntryObject$outboundSchema.default("entry"),
-  type: FunctionResultEntryType$outboundSchema.default("function.result"),
+  object: z.literal("entry").default("entry" as const),
+  type: z.literal("function.result").default("function.result" as const),
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   completedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   id: z.string().optional(),

package/src/models/components/functiontool.ts

@@ -14,24 +14,23 @@ import {
   FunctionT$outboundSchema,
 } from "./function.js";
 
-export const FunctionToolType = {
+export const Type = {
   Function: "function",
 } as const;
-export type FunctionToolType = ClosedEnum<typeof FunctionToolType>;
+export type Type = ClosedEnum<typeof Type>;
 
 export type FunctionTool = {
-  type?: FunctionToolType | undefined;
+  type?: Type | undefined;
   function: FunctionT;
 };
 
 /** @internal */
-export const FunctionToolType$inboundSchema: z.ZodNativeEnum<
-  typeof FunctionToolType
-> = z.nativeEnum(FunctionToolType);
+export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
 /** @internal */
-export const FunctionToolType$outboundSchema: z.ZodNativeEnum<
-  typeof FunctionToolType
-> = FunctionToolType$inboundSchema;
+export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> =
+  Type$inboundSchema;
 
 /** @internal */
 export const FunctionTool$inboundSchema: z.ZodType<
@@ -39,7 +38,7 @@ export const FunctionTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: FunctionToolType$inboundSchema.default("function"),
+  type: Type$inboundSchema.default("function"),
   function: FunctionT$inboundSchema,
 });
 /** @internal */
@@ -54,7 +53,7 @@ export const FunctionTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   FunctionTool
 > = z.object({
-  type: FunctionToolType$outboundSchema.default("function"),
+  type: Type$outboundSchema.default("function"),
   function: FunctionT$outboundSchema,
 });