@mistralai/mistralai 1.9.18 → 1.10.0

package/src/models/components/conversationevents.ts

@@ -73,16 +73,16 @@ import {
 } from "./toolexecutionstartedevent.js";
 
 export type ConversationEventsData =
-  | (ResponseDoneEvent & { type: "conversation.response.done" })
-  | (ResponseStartedEvent & { type: "conversation.response.started" })
-  | (ResponseErrorEvent & { type: "conversation.response.error" })
+  | (FunctionCallEvent & { type: "function.call.delta" })
   | (AgentHandoffDoneEvent & { type: "agent.handoff.done" })
   | (AgentHandoffStartedEvent & { type: "agent.handoff.started" })
   | (ToolExecutionDeltaEvent & { type: "tool.execution.delta" })
-  | (ToolExecutionDoneEvent & { type: "tool.execution.done" })
   | (ToolExecutionStartedEvent & { type: "tool.execution.started" })
-  | (FunctionCallEvent & { type: "function.call.delta" })
-  | (MessageOutputEvent & { type: "message.output.delta" });
+  | (ResponseErrorEvent & { type: "conversation.response.error" })
+  | (MessageOutputEvent & { type: "message.output.delta" })
+  | (ToolExecutionDoneEvent & { type: "tool.execution.done" })
+  | (ResponseDoneEvent & { type: "conversation.response.done" })
+  | (ResponseStartedEvent & { type: "conversation.response.started" });
 
 export type ConversationEvents = {
   /**
@@ -90,16 +90,16 @@ export type ConversationEvents = {
    */
   event: SSETypes;
   data:
-    | (ResponseDoneEvent & { type: "conversation.response.done" })
-    | (ResponseStartedEvent & { type: "conversation.response.started" })
-    | (ResponseErrorEvent & { type: "conversation.response.error" })
+    | (FunctionCallEvent & { type: "function.call.delta" })
     | (AgentHandoffDoneEvent & { type: "agent.handoff.done" })
     | (AgentHandoffStartedEvent & { type: "agent.handoff.started" })
     | (ToolExecutionDeltaEvent & { type: "tool.execution.delta" })
-    | (ToolExecutionDoneEvent & { type: "tool.execution.done" })
     | (ToolExecutionStartedEvent & { type: "tool.execution.started" })
-    | (FunctionCallEvent & { type: "function.call.delta" })
-    | (MessageOutputEvent & { type: "message.output.delta" });
+    | (ResponseErrorEvent & { type: "conversation.response.error" })
+    | (MessageOutputEvent & { type: "message.output.delta" })
+    | (ToolExecutionDoneEvent & { type: "tool.execution.done" })
+    | (ResponseDoneEvent & { type: "conversation.response.done" })
+    | (ResponseStartedEvent & { type: "conversation.response.started" });
 };
 
 /** @internal */
@@ -108,20 +108,10 @@ export const ConversationEventsData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  ResponseDoneEvent$inboundSchema.and(
-    z.object({ type: z.literal("conversation.response.done") }).transform((
-      v,
-    ) => ({ type: v.type })),
-  ),
-  ResponseStartedEvent$inboundSchema.and(
-    z.object({ type: z.literal("conversation.response.started") }).transform((
-      v,
-    ) => ({ type: v.type })),
-  ),
-  ResponseErrorEvent$inboundSchema.and(
-    z.object({ type: z.literal("conversation.response.error") }).transform((
-      v,
-    ) => ({ type: v.type })),
+  FunctionCallEvent$inboundSchema.and(
+    z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
+      type: v.type,
+    })),
   ),
   AgentHandoffDoneEvent$inboundSchema.and(
     z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
@@ -138,40 +128,50 @@ export const ConversationEventsData$inboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
-  ToolExecutionDoneEvent$inboundSchema.and(
-    z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
   ToolExecutionStartedEvent$inboundSchema.and(
     z.object({ type: z.literal("tool.execution.started") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  FunctionCallEvent$inboundSchema.and(
-    z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
-      type: v.type,
-    })),
+  ResponseErrorEvent$inboundSchema.and(
+    z.object({ type: z.literal("conversation.response.error") }).transform((
+      v,
+    ) => ({ type: v.type })),
   ),
   MessageOutputEvent$inboundSchema.and(
     z.object({ type: z.literal("message.output.delta") }).transform((v) => ({
       type: v.type,
     })),
   ),
+  ToolExecutionDoneEvent$inboundSchema.and(
+    z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  ResponseDoneEvent$inboundSchema.and(
+    z.object({ type: z.literal("conversation.response.done") }).transform((
+      v,
+    ) => ({ type: v.type })),
+  ),
+  ResponseStartedEvent$inboundSchema.and(
+    z.object({ type: z.literal("conversation.response.started") }).transform((
+      v,
+    ) => ({ type: v.type })),
+  ),
 ]);
 
 /** @internal */
 export type ConversationEventsData$Outbound =
-  | (ResponseDoneEvent$Outbound & { type: "conversation.response.done" })
-  | (ResponseStartedEvent$Outbound & { type: "conversation.response.started" })
-  | (ResponseErrorEvent$Outbound & { type: "conversation.response.error" })
+  | (FunctionCallEvent$Outbound & { type: "function.call.delta" })
   | (AgentHandoffDoneEvent$Outbound & { type: "agent.handoff.done" })
   | (AgentHandoffStartedEvent$Outbound & { type: "agent.handoff.started" })
   | (ToolExecutionDeltaEvent$Outbound & { type: "tool.execution.delta" })
-  | (ToolExecutionDoneEvent$Outbound & { type: "tool.execution.done" })
   | (ToolExecutionStartedEvent$Outbound & { type: "tool.execution.started" })
-  | (FunctionCallEvent$Outbound & { type: "function.call.delta" })
-  | (MessageOutputEvent$Outbound & { type: "message.output.delta" });
+  | (ResponseErrorEvent$Outbound & { type: "conversation.response.error" })
+  | (MessageOutputEvent$Outbound & { type: "message.output.delta" })
+  | (ToolExecutionDoneEvent$Outbound & { type: "tool.execution.done" })
+  | (ResponseDoneEvent$Outbound & { type: "conversation.response.done" })
+  | (ResponseStartedEvent$Outbound & { type: "conversation.response.started" });
 
 /** @internal */
 export const ConversationEventsData$outboundSchema: z.ZodType<
@@ -179,20 +179,10 @@ export const ConversationEventsData$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ConversationEventsData
 > = z.union([
-  ResponseDoneEvent$outboundSchema.and(
-    z.object({ type: z.literal("conversation.response.done") }).transform((
-      v,
-    ) => ({ type: v.type })),
-  ),
-  ResponseStartedEvent$outboundSchema.and(
-    z.object({ type: z.literal("conversation.response.started") }).transform((
-      v,
-    ) => ({ type: v.type })),
-  ),
-  ResponseErrorEvent$outboundSchema.and(
-    z.object({ type: z.literal("conversation.response.error") }).transform((
-      v,
-    ) => ({ type: v.type })),
+  FunctionCallEvent$outboundSchema.and(
+    z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
+      type: v.type,
+    })),
   ),
   AgentHandoffDoneEvent$outboundSchema.and(
     z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
@@ -209,26 +199,36 @@ export const ConversationEventsData$outboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
-  ToolExecutionDoneEvent$outboundSchema.and(
-    z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
   ToolExecutionStartedEvent$outboundSchema.and(
     z.object({ type: z.literal("tool.execution.started") }).transform((v) => ({
       type: v.type,
     })),
   ),
-  FunctionCallEvent$outboundSchema.and(
-    z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
-      type: v.type,
-    })),
+  ResponseErrorEvent$outboundSchema.and(
+    z.object({ type: z.literal("conversation.response.error") }).transform((
+      v,
+    ) => ({ type: v.type })),
   ),
   MessageOutputEvent$outboundSchema.and(
     z.object({ type: z.literal("message.output.delta") }).transform((v) => ({
       type: v.type,
     })),
   ),
+  ToolExecutionDoneEvent$outboundSchema.and(
+    z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  ResponseDoneEvent$outboundSchema.and(
+    z.object({ type: z.literal("conversation.response.done") }).transform((
+      v,
+    ) => ({ type: v.type })),
+  ),
+  ResponseStartedEvent$outboundSchema.and(
+    z.object({ type: z.literal("conversation.response.started") }).transform((
+      v,
+    ) => ({ type: v.type })),
+  ),
 ]);
 
 /**
@@ -281,19 +281,10 @@ export const ConversationEvents$inboundSchema: z.ZodType<
     }
   }).pipe(
     z.union([
-      ResponseDoneEvent$inboundSchema.and(
-        z.object({ type: z.literal("conversation.response.done") }).transform((
-          v,
-        ) => ({ type: v.type })),
-      ),
-      ResponseStartedEvent$inboundSchema.and(
-        z.object({ type: z.literal("conversation.response.started") })
-          .transform((v) => ({ type: v.type })),
-      ),
-      ResponseErrorEvent$inboundSchema.and(
-        z.object({ type: z.literal("conversation.response.error") }).transform((
-          v,
-        ) => ({ type: v.type })),
+      FunctionCallEvent$inboundSchema.and(
+        z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
+          type: v.type,
+        })),
       ),
       AgentHandoffDoneEvent$inboundSchema.and(
         z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
@@ -310,26 +301,35 @@ export const ConversationEvents$inboundSchema: z.ZodType<
           v,
         ) => ({ type: v.type })),
       ),
-      ToolExecutionDoneEvent$inboundSchema.and(
-        z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
       ToolExecutionStartedEvent$inboundSchema.and(
         z.object({ type: z.literal("tool.execution.started") }).transform((
           v,
         ) => ({ type: v.type })),
       ),
-      FunctionCallEvent$inboundSchema.and(
-        z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
-          type: v.type,
-        })),
+      ResponseErrorEvent$inboundSchema.and(
+        z.object({ type: z.literal("conversation.response.error") }).transform((
+          v,
+        ) => ({ type: v.type })),
       ),
       MessageOutputEvent$inboundSchema.and(
         z.object({ type: z.literal("message.output.delta") }).transform((
           v,
         ) => ({ type: v.type })),
       ),
+      ToolExecutionDoneEvent$inboundSchema.and(
+        z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ResponseDoneEvent$inboundSchema.and(
+        z.object({ type: z.literal("conversation.response.done") }).transform((
+          v,
+        ) => ({ type: v.type })),
+      ),
+      ResponseStartedEvent$inboundSchema.and(
+        z.object({ type: z.literal("conversation.response.started") })
+          .transform((v) => ({ type: v.type })),
+      ),
     ]),
   ),
 });
@@ -338,18 +338,18 @@ export const ConversationEvents$inboundSchema: z.ZodType<
 export type ConversationEvents$Outbound = {
   event: string;
   data:
-    | (ResponseDoneEvent$Outbound & { type: "conversation.response.done" })
-    | (ResponseStartedEvent$Outbound & {
-      type: "conversation.response.started";
-    })
-    | (ResponseErrorEvent$Outbound & { type: "conversation.response.error" })
+    | (FunctionCallEvent$Outbound & { type: "function.call.delta" })
     | (AgentHandoffDoneEvent$Outbound & { type: "agent.handoff.done" })
     | (AgentHandoffStartedEvent$Outbound & { type: "agent.handoff.started" })
     | (ToolExecutionDeltaEvent$Outbound & { type: "tool.execution.delta" })
-    | (ToolExecutionDoneEvent$Outbound & { type: "tool.execution.done" })
     | (ToolExecutionStartedEvent$Outbound & { type: "tool.execution.started" })
-    | (FunctionCallEvent$Outbound & { type: "function.call.delta" })
-    | (MessageOutputEvent$Outbound & { type: "message.output.delta" });
+    | (ResponseErrorEvent$Outbound & { type: "conversation.response.error" })
+    | (MessageOutputEvent$Outbound & { type: "message.output.delta" })
+    | (ToolExecutionDoneEvent$Outbound & { type: "tool.execution.done" })
+    | (ResponseDoneEvent$Outbound & { type: "conversation.response.done" })
+    | (ResponseStartedEvent$Outbound & {
+      type: "conversation.response.started";
+    });
 };
 
 /** @internal */
@@ -360,20 +360,10 @@ export const ConversationEvents$outboundSchema: z.ZodType<
 > = z.object({
   event: SSETypes$outboundSchema,
   data: z.union([
-    ResponseDoneEvent$outboundSchema.and(
-      z.object({ type: z.literal("conversation.response.done") }).transform((
-        v,
-      ) => ({ type: v.type })),
-    ),
-    ResponseStartedEvent$outboundSchema.and(
-      z.object({ type: z.literal("conversation.response.started") }).transform((
-        v,
-      ) => ({ type: v.type })),
-    ),
-    ResponseErrorEvent$outboundSchema.and(
-      z.object({ type: z.literal("conversation.response.error") }).transform((
-        v,
-      ) => ({ type: v.type })),
+    FunctionCallEvent$outboundSchema.and(
+      z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
+        type: v.type,
+      })),
     ),
     AgentHandoffDoneEvent$outboundSchema.and(
       z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
@@ -390,26 +380,36 @@ export const ConversationEvents$outboundSchema: z.ZodType<
         type: v.type,
       })),
     ),
-    ToolExecutionDoneEvent$outboundSchema.and(
-      z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
     ToolExecutionStartedEvent$outboundSchema.and(
       z.object({ type: z.literal("tool.execution.started") }).transform((
         v,
       ) => ({ type: v.type })),
     ),
-    FunctionCallEvent$outboundSchema.and(
-      z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
-        type: v.type,
-      })),
+    ResponseErrorEvent$outboundSchema.and(
+      z.object({ type: z.literal("conversation.response.error") }).transform((
+        v,
+      ) => ({ type: v.type })),
     ),
     MessageOutputEvent$outboundSchema.and(
       z.object({ type: z.literal("message.output.delta") }).transform((v) => ({
         type: v.type,
       })),
     ),
+    ToolExecutionDoneEvent$outboundSchema.and(
+      z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ResponseDoneEvent$outboundSchema.and(
+      z.object({ type: z.literal("conversation.response.done") }).transform((
+        v,
+      ) => ({ type: v.type })),
+    ),
+    ResponseStartedEvent$outboundSchema.and(
+      z.object({ type: z.literal("conversation.response.started") }).transform((
+        v,
+      ) => ({ type: v.type })),
+    ),
   ]),
 });
 

package/src/models/components/conversationhistory.ts

@@ -53,12 +53,12 @@ export type ConversationHistoryObject = ClosedEnum<
 >;
 
 export type Entries =
-  | FunctionResultEntry
-  | MessageInputEntry
+  | AgentHandoffEntry
   | FunctionCallEntry
+  | MessageInputEntry
+  | FunctionResultEntry
   | ToolExecutionEntry
-  | MessageOutputEntry
-  | AgentHandoffEntry;
+  | MessageOutputEntry;
 
 /**
  * Retrieve all entries in a conversation.
@@ -67,12 +67,12 @@ export type ConversationHistory = {
   object?: ConversationHistoryObject | undefined;
   conversationId: string;
   entries: Array<
-    | FunctionResultEntry
-    | MessageInputEntry
+    | AgentHandoffEntry
     | FunctionCallEntry
+    | MessageInputEntry
+    | FunctionResultEntry
     | ToolExecutionEntry
     | MessageOutputEntry
-    | AgentHandoffEntry
   >;
 };
 
@@ -100,22 +100,22 @@ export namespace ConversationHistoryObject$ {
 /** @internal */
 export const Entries$inboundSchema: z.ZodType<Entries, z.ZodTypeDef, unknown> =
   z.union([
-    FunctionResultEntry$inboundSchema,
-    MessageInputEntry$inboundSchema,
+    AgentHandoffEntry$inboundSchema,
     FunctionCallEntry$inboundSchema,
+    MessageInputEntry$inboundSchema,
+    FunctionResultEntry$inboundSchema,
     ToolExecutionEntry$inboundSchema,
     MessageOutputEntry$inboundSchema,
-    AgentHandoffEntry$inboundSchema,
   ]);
 
 /** @internal */
 export type Entries$Outbound =
-  | FunctionResultEntry$Outbound
-  | MessageInputEntry$Outbound
+  | AgentHandoffEntry$Outbound
   | FunctionCallEntry$Outbound
+  | MessageInputEntry$Outbound
+  | FunctionResultEntry$Outbound
   | ToolExecutionEntry$Outbound
-  | MessageOutputEntry$Outbound
-  | AgentHandoffEntry$Outbound;
+  | MessageOutputEntry$Outbound;
 
 /** @internal */
 export const Entries$outboundSchema: z.ZodType<
@@ -123,12 +123,12 @@ export const Entries$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Entries
 > = z.union([
-  FunctionResultEntry$outboundSchema,
-  MessageInputEntry$outboundSchema,
+  AgentHandoffEntry$outboundSchema,
   FunctionCallEntry$outboundSchema,
+  MessageInputEntry$outboundSchema,
+  FunctionResultEntry$outboundSchema,
   ToolExecutionEntry$outboundSchema,
   MessageOutputEntry$outboundSchema,
-  AgentHandoffEntry$outboundSchema,
 ]);
 
 /**
@@ -170,12 +170,12 @@ export const ConversationHistory$inboundSchema: z.ZodType<
   conversation_id: z.string(),
   entries: z.array(
     z.union([
-      FunctionResultEntry$inboundSchema,
-      MessageInputEntry$inboundSchema,
+      AgentHandoffEntry$inboundSchema,
       FunctionCallEntry$inboundSchema,
+      MessageInputEntry$inboundSchema,
+      FunctionResultEntry$inboundSchema,
       ToolExecutionEntry$inboundSchema,
       MessageOutputEntry$inboundSchema,
-      AgentHandoffEntry$inboundSchema,
     ]),
   ),
 }).transform((v) => {
@@ -189,12 +189,12 @@ export type ConversationHistory$Outbound = {
   object: string;
   conversation_id: string;
   entries: Array<
-    | FunctionResultEntry$Outbound
-    | MessageInputEntry$Outbound
+    | AgentHandoffEntry$Outbound
     | FunctionCallEntry$Outbound
+    | MessageInputEntry$Outbound
+    | FunctionResultEntry$Outbound
     | ToolExecutionEntry$Outbound
     | MessageOutputEntry$Outbound
-    | AgentHandoffEntry$Outbound
   >;
 };
 
@@ -210,12 +210,12 @@ export const ConversationHistory$outboundSchema: z.ZodType<
   conversationId: z.string(),
   entries: z.array(
     z.union([
-      FunctionResultEntry$outboundSchema,
-      MessageInputEntry$outboundSchema,
+      AgentHandoffEntry$outboundSchema,
       FunctionCallEntry$outboundSchema,
+      MessageInputEntry$outboundSchema,
+      FunctionResultEntry$outboundSchema,
       ToolExecutionEntry$outboundSchema,
       MessageOutputEntry$outboundSchema,
-      AgentHandoffEntry$outboundSchema,
     ]),
   ),
 }).transform((v) => {

package/src/models/components/conversationrequest.ts

@@ -64,12 +64,12 @@ export const HandoffExecution = {
 export type HandoffExecution = ClosedEnum<typeof HandoffExecution>;
 
 export type Tools =
+  | (DocumentLibraryTool & { type: "document_library" })
+  | (FunctionTool & { type: "function" })
   | (CodeInterpreterTool & { type: "code_interpreter" })
   | (ImageGenerationTool & { type: "image_generation" })
   | (WebSearchTool & { type: "web_search" })
-  | (WebSearchPremiumTool & { type: "web_search_premium" })
-  | (DocumentLibraryTool & { type: "document_library" })
-  | (FunctionTool & { type: "function" });
+  | (WebSearchPremiumTool & { type: "web_search_premium" });
 
 export type ConversationRequest = {
   inputs: ConversationInputs;
@@ -79,12 +79,12 @@ export type ConversationRequest = {
   instructions?: string | null | undefined;
   tools?:
     | Array<
+      | (DocumentLibraryTool & { type: "document_library" })
+      | (FunctionTool & { type: "function" })
       | (CodeInterpreterTool & { type: "code_interpreter" })
       | (ImageGenerationTool & { type: "image_generation" })
       | (WebSearchTool & { type: "web_search" })
       | (WebSearchPremiumTool & { type: "web_search_premium" })
-      | (DocumentLibraryTool & { type: "document_library" })
-      | (FunctionTool & { type: "function" })
     >
     | null
     | undefined;
@@ -119,6 +119,16 @@ export namespace HandoffExecution$ {
 /** @internal */
 export const Tools$inboundSchema: z.ZodType<Tools, z.ZodTypeDef, unknown> = z
   .union([
+    DocumentLibraryTool$inboundSchema.and(
+      z.object({ type: z.literal("document_library") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    FunctionTool$inboundSchema.and(
+      z.object({ type: z.literal("function") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
     CodeInterpreterTool$inboundSchema.and(
       z.object({ type: z.literal("code_interpreter") }).transform((v) => ({
         type: v.type,
@@ -139,26 +149,16 @@ export const Tools$inboundSchema: z.ZodType<Tools, z.ZodTypeDef, unknown> = z
         type: v.type,
       })),
     ),
-    DocumentLibraryTool$inboundSchema.and(
-      z.object({ type: z.literal("document_library") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    FunctionTool$inboundSchema.and(
-      z.object({ type: z.literal("function") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
   ]);
 
 /** @internal */
 export type Tools$Outbound =
+  | (DocumentLibraryTool$Outbound & { type: "document_library" })
+  | (FunctionTool$Outbound & { type: "function" })
   | (CodeInterpreterTool$Outbound & { type: "code_interpreter" })
   | (ImageGenerationTool$Outbound & { type: "image_generation" })
   | (WebSearchTool$Outbound & { type: "web_search" })
-  | (WebSearchPremiumTool$Outbound & { type: "web_search_premium" })
-  | (DocumentLibraryTool$Outbound & { type: "document_library" })
-  | (FunctionTool$Outbound & { type: "function" });
+  | (WebSearchPremiumTool$Outbound & { type: "web_search_premium" });
 
 /** @internal */
 export const Tools$outboundSchema: z.ZodType<
@@ -166,6 +166,16 @@ export const Tools$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Tools
 > = z.union([
+  DocumentLibraryTool$outboundSchema.and(
+    z.object({ type: z.literal("document_library") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  FunctionTool$outboundSchema.and(
+    z.object({ type: z.literal("function") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
   CodeInterpreterTool$outboundSchema.and(
     z.object({ type: z.literal("code_interpreter") }).transform((v) => ({
       type: v.type,
@@ -186,16 +196,6 @@ export const Tools$outboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
-  DocumentLibraryTool$outboundSchema.and(
-    z.object({ type: z.literal("document_library") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  FunctionTool$outboundSchema.and(
-    z.object({ type: z.literal("function") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
 ]);
 
 /**
@@ -239,6 +239,16 @@ export const ConversationRequest$inboundSchema: z.ZodType<
   tools: z.nullable(
     z.array(
       z.union([
+        DocumentLibraryTool$inboundSchema.and(
+          z.object({ type: z.literal("document_library") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        FunctionTool$inboundSchema.and(
+          z.object({ type: z.literal("function") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
         CodeInterpreterTool$inboundSchema.and(
           z.object({ type: z.literal("code_interpreter") }).transform((v) => ({
             type: v.type,
@@ -259,16 +269,6 @@ export const ConversationRequest$inboundSchema: z.ZodType<
             v,
           ) => ({ type: v.type })),
         ),
-        DocumentLibraryTool$inboundSchema.and(
-          z.object({ type: z.literal("document_library") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-        FunctionTool$inboundSchema.and(
-          z.object({ type: z.literal("function") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
       ]),
     ),
   ).optional(),
@@ -294,12 +294,12 @@ export type ConversationRequest$Outbound = {
   instructions?: string | null | undefined;
   tools?:
     | Array<
+      | (DocumentLibraryTool$Outbound & { type: "document_library" })
+      | (FunctionTool$Outbound & { type: "function" })
       | (CodeInterpreterTool$Outbound & { type: "code_interpreter" })
       | (ImageGenerationTool$Outbound & { type: "image_generation" })
       | (WebSearchTool$Outbound & { type: "web_search" })
       | (WebSearchPremiumTool$Outbound & { type: "web_search_premium" })
-      | (DocumentLibraryTool$Outbound & { type: "document_library" })
-      | (FunctionTool$Outbound & { type: "function" })
     >
     | null
     | undefined;
@@ -324,6 +324,16 @@ export const ConversationRequest$outboundSchema: z.ZodType<
   tools: z.nullable(
     z.array(
       z.union([
+        DocumentLibraryTool$outboundSchema.and(
+          z.object({ type: z.literal("document_library") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        FunctionTool$outboundSchema.and(
+          z.object({ type: z.literal("function") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
         CodeInterpreterTool$outboundSchema.and(
           z.object({ type: z.literal("code_interpreter") }).transform((v) => ({
             type: v.type,
@@ -344,16 +354,6 @@ export const ConversationRequest$outboundSchema: z.ZodType<
             v,
           ) => ({ type: v.type })),
         ),
-        DocumentLibraryTool$outboundSchema.and(
-          z.object({ type: z.literal("document_library") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-        FunctionTool$outboundSchema.and(
-          z.object({ type: z.literal("function") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
       ]),
     ),
   ).optional(),