@mistralai/mistralai 2.2.1 → 2.2.6

package/src/models/components/jsonpatchappend.ts

@@ -6,7 +6,17 @@
 import * as z from "zod/v4";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  EncryptedPatchValue,
+  EncryptedPatchValue$inboundSchema,
+} from "./encryptedpatchvalue.js";
+
+/**
+ * The value to use for the operation. A string to append to the existing value, or an EncryptedPatchValue wrapper when encryption is applied.
+ */
+export type JSONPatchAppendValue = EncryptedPatchValue | string;
 
 export type JSONPatchAppend = {
   /**
@@ -14,22 +24,38 @@ export type JSONPatchAppend = {
    */
   path: string;
   /**
-   * The value to use for the operation. A string to append to the existing value
+   * The value to use for the operation. A string to append to the existing value, or an EncryptedPatchValue wrapper when encryption is applied.
    */
-  value: string;
+  value: EncryptedPatchValue | string;
   /**
    * 'append' is an extension for efficient string concatenation in streaming scenarios.
    */
   op: "append";
 };
 
+/** @internal */
+export const JSONPatchAppendValue$inboundSchema: z.ZodType<
+  JSONPatchAppendValue,
+  unknown
+> = smartUnion([EncryptedPatchValue$inboundSchema, z.string()]);
+
+export function jsonPatchAppendValueFromJSON(
+  jsonString: string,
+): SafeParseResult<JSONPatchAppendValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => JSONPatchAppendValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'JSONPatchAppendValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const JSONPatchAppend$inboundSchema: z.ZodType<
   JSONPatchAppend,
   unknown
 > = z.object({
   path: z.string(),
-  value: z.string(),
+  value: smartUnion([EncryptedPatchValue$inboundSchema, z.string()]),
   op: z.literal("append"),
 });
 

package/src/models/components/jsonpatchpayloadresponse.ts

@@ -4,31 +4,18 @@
  */
 
 import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
-import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import { JSONPatchAdd, JSONPatchAdd$inboundSchema } from "./jsonpatchadd.js";
 import {
-  JSONPatchAppend,
-  JSONPatchAppend$inboundSchema,
-} from "./jsonpatchappend.js";
+  EncodedPayloadOptions,
+  EncodedPayloadOptions$inboundSchema,
+} from "./encodedpayloadoptions.js";
 import {
-  JSONPatchRemove,
-  JSONPatchRemove$inboundSchema,
-} from "./jsonpatchremove.js";
-import {
-  JSONPatchReplace,
-  JSONPatchReplace$inboundSchema,
-} from "./jsonpatchreplace.js";
-
-export type JSONPatchPayloadResponseValue =
-  | JSONPatchAdd
-  | JSONPatchAppend
-  | JSONPatchRemove
-  | JSONPatchReplace
-  | discriminatedUnionTypes.Unknown<"op">;
+  JSONPatchPayloadValueResponse,
+  JSONPatchPayloadValueResponse$inboundSchema,
+} from "./jsonpatchpayloadvalueresponse.js";
 
 /**
  * A payload containing a list of JSON Patch operations.
@@ -36,59 +23,34 @@ export type JSONPatchPayloadResponseValue =
  * @remarks
  *
  * Used for streaming incremental updates to workflow state.
+ * When encrypted, the value field contains base64-encoded encrypted data
+ * and encoding_options indicates the type of encryption applied.
  */
 export type JSONPatchPayloadResponse = {
   /**
    * Discriminator indicating this is a JSON Patch payload.
    */
   type: "json_patch";
+  value: JSONPatchPayloadValueResponse;
   /**
-   * The list of JSON Patch operations to apply in order.
+   * Encoding options applied to the payload.
    */
-  value: Array<
-    | JSONPatchAdd
-    | JSONPatchAppend
-    | JSONPatchRemove
-    | JSONPatchReplace
-    | discriminatedUnionTypes.Unknown<"op">
-  >;
+  encodingOptions?: Array<EncodedPayloadOptions> | null | undefined;
 };
 
-/** @internal */
-export const JSONPatchPayloadResponseValue$inboundSchema: z.ZodType<
-  JSONPatchPayloadResponseValue,
-  unknown
-> = discriminatedUnion("op", {
-  add: JSONPatchAdd$inboundSchema,
-  append: JSONPatchAppend$inboundSchema,
-  remove: JSONPatchRemove$inboundSchema,
-  replace: JSONPatchReplace$inboundSchema,
-});
-
-export function jsonPatchPayloadResponseValueFromJSON(
-  jsonString: string,
-): SafeParseResult<JSONPatchPayloadResponseValue, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => JSONPatchPayloadResponseValue$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'JSONPatchPayloadResponseValue' from JSON`,
-  );
-}
-
 /** @internal */
 export const JSONPatchPayloadResponse$inboundSchema: z.ZodType<
   JSONPatchPayloadResponse,
   unknown
 > = z.object({
   type: z.literal("json_patch"),
-  value: z.array(
-    discriminatedUnion("op", {
-      add: JSONPatchAdd$inboundSchema,
-      append: JSONPatchAppend$inboundSchema,
-      remove: JSONPatchRemove$inboundSchema,
-      replace: JSONPatchReplace$inboundSchema,
-    }),
-  ),
+  value: JSONPatchPayloadValueResponse$inboundSchema,
+  encoding_options: z.nullable(z.array(EncodedPayloadOptions$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "encoding_options": "encodingOptions",
+  });
 });
 
 export function jsonPatchPayloadResponseFromJSON(

package/src/models/components/jsonpatchpayloadvalueresponse.ts

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 90bea0602f9b
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { JSONPatch, JSONPatch$inboundSchema } from "./jsonpatch.js";
+
+export type JSONPatchPayloadValueResponse = Array<JSONPatch> | string;
+
+/** @internal */
+export const JSONPatchPayloadValueResponse$inboundSchema: z.ZodType<
+  JSONPatchPayloadValueResponse,
+  unknown
+> = smartUnion([z.array(JSONPatch$inboundSchema), z.string()]);
+
+export function jsonPatchPayloadValueResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<JSONPatchPayloadValueResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => JSONPatchPayloadValueResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'JSONPatchPayloadValueResponse' from JSON`,
+  );
+}

package/src/models/components/jsonpayloadresponse.ts

@@ -4,9 +4,14 @@
  */
 
 import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  EncodedPayloadOptions,
+  EncodedPayloadOptions$inboundSchema,
+} from "./encodedpayloadoptions.js";
 
 /**
  * A payload containing arbitrary JSON data.
@@ -14,6 +19,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * @remarks
  *
  * Used for complete state snapshots or final results.
+ * When encrypted, the value field contains base64-encoded encrypted data
+ * and encoding_options indicates the type of encryption applied.
  */
 export type JSONPayloadResponse = {
   /**
@@ -21,9 +28,13 @@ export type JSONPayloadResponse = {
    */
   type: "json";
   /**
-   * The JSON-serializable payload value.
+   * The JSON-serializable payload value. When encrypted, contains base64-encoded data.
    */
   value: any;
+  /**
+   * Encoding options applied to the payload.
+   */
+  encodingOptions?: Array<EncodedPayloadOptions> | null | undefined;
 };
 
 /** @internal */
@@ -33,6 +44,12 @@ export const JSONPayloadResponse$inboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("json").default("json"),
   value: z.any(),
+  encoding_options: z.nullable(z.array(EncodedPayloadOptions$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "encoding_options": "encodingOptions",
+  });
 });
 
 export function jsonPayloadResponseFromJSON(

package/src/models/components/library.ts

@@ -18,11 +18,26 @@ export type Library = {
   ownerType: string;
   totalSize: number;
   nbDocuments: number;
+  /**
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   chunkSize: number | null;
+  /**
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   emoji?: string | null | undefined;
   description?: string | null | undefined;
+  /**
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   generatedDescription?: string | null | undefined;
+  /**
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   explicitUserMembersCount?: number | null | undefined;
+  /**
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   explicitWorkspaceMembersCount?: number | null | undefined;
   /**
    * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
@@ -30,6 +45,8 @@ export type Library = {
   orgSharingRole?: string | null | undefined;
   /**
    * Generated Name
+   *
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
    */
   generatedName?: string | null | undefined;
 };

package/src/models/components/logicalexpression.ts

@@ -0,0 +1,132 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: aa256f7ecc7b
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ToolProperties,
+  ToolProperties$inboundSchema,
+  ToolProperties$Outbound,
+  ToolProperties$outboundSchema,
+} from "./toolproperties.js";
+
+export const LogicalExpressionType = {
+  And: "and",
+  Or: "or",
+} as const;
+export type LogicalExpressionType = OpenEnum<typeof LogicalExpressionType>;
+
+export type LogicalExpression = {
+  type: LogicalExpressionType;
+  expressions: Array<LogicalExpression | ToolProperties | Array<string>>;
+};
+
+export type Expression = LogicalExpression | ToolProperties | Array<string>;
+
+/** @internal */
+export const LogicalExpressionType$inboundSchema: z.ZodType<
+  LogicalExpressionType,
+  unknown
+> = openEnums.inboundSchema(LogicalExpressionType);
+/** @internal */
+export const LogicalExpressionType$outboundSchema: z.ZodType<
+  string,
+  LogicalExpressionType
+> = openEnums.outboundSchema(LogicalExpressionType);
+
+/** @internal */
+export const LogicalExpression$inboundSchema: z.ZodType<
+  LogicalExpression,
+  unknown
+> = z.object({
+  type: LogicalExpressionType$inboundSchema,
+  expressions: z.array(
+    smartUnion([
+      z.lazy(() => LogicalExpression$inboundSchema),
+      ToolProperties$inboundSchema,
+      z.array(z.string()),
+    ]),
+  ),
+});
+/** @internal */
+export type LogicalExpression$Outbound = {
+  type: string;
+  expressions: Array<
+    LogicalExpression$Outbound | ToolProperties$Outbound | Array<string>
+  >;
+};
+
+/** @internal */
+export const LogicalExpression$outboundSchema: z.ZodType<
+  LogicalExpression$Outbound,
+  LogicalExpression
+> = z.object({
+  type: LogicalExpressionType$outboundSchema,
+  expressions: z.array(
+    smartUnion([
+      z.lazy(() => LogicalExpression$outboundSchema),
+      ToolProperties$outboundSchema,
+      z.array(z.string()),
+    ]),
+  ),
+});
+
+export function logicalExpressionToJSON(
+  logicalExpression: LogicalExpression,
+): string {
+  return JSON.stringify(
+    LogicalExpression$outboundSchema.parse(logicalExpression),
+  );
+}
+export function logicalExpressionFromJSON(
+  jsonString: string,
+): SafeParseResult<LogicalExpression, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogicalExpression$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogicalExpression' from JSON`,
+  );
+}
+
+/** @internal */
+export const Expression$inboundSchema: z.ZodType<Expression, unknown> =
+  smartUnion([
+    z.lazy(() => LogicalExpression$inboundSchema),
+    ToolProperties$inboundSchema,
+    z.array(z.string()),
+  ]);
+/** @internal */
+export type Expression$Outbound =
+  | LogicalExpression$Outbound
+  | ToolProperties$Outbound
+  | Array<string>;
+
+/** @internal */
+export const Expression$outboundSchema: z.ZodType<
+  Expression$Outbound,
+  Expression
+> = smartUnion([
+  z.lazy(() => LogicalExpression$outboundSchema),
+  ToolProperties$outboundSchema,
+  z.array(z.string()),
+]);
+
+export function expressionToJSON(expression: Expression): string {
+  return JSON.stringify(Expression$outboundSchema.parse(expression));
+}
+export function expressionFromJSON(
+  jsonString: string,
+): SafeParseResult<Expression, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Expression$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Expression' from JSON`,
+  );
+}

package/src/models/components/logsrequest.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d8323e9df800
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const Order = {
+  Asc: "asc",
+  Desc: "desc",
+} as const;
+export type Order = ClosedEnum<typeof Order>;
+
+export type LogsRequest = {
+  searchExpression?: string | null | undefined;
+  order?: Order | undefined;
+};
+
+/** @internal */
+export const Order$outboundSchema: z.ZodEnum<typeof Order> = z.enum(Order);
+
+/** @internal */
+export type LogsRequest$Outbound = {
+  search_expression?: string | null | undefined;
+  order: string;
+};
+
+/** @internal */
+export const LogsRequest$outboundSchema: z.ZodType<
+  LogsRequest$Outbound,
+  LogsRequest
+> = z.object({
+  searchExpression: z.nullable(z.string()).optional(),
+  order: Order$outboundSchema.default("desc"),
+}).transform((v) => {
+  return remap$(v, {
+    searchExpression: "search_expression",
+  });
+});
+
+export function logsRequestToJSON(logsRequest: LogsRequest): string {
+  return JSON.stringify(LogsRequest$outboundSchema.parse(logsRequest));
+}

package/src/models/components/mcpprompt.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 296526242b71
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { MCPServerIcon, MCPServerIcon$inboundSchema } from "./mcpservericon.js";
+import {
+  PromptArgument,
+  PromptArgument$inboundSchema,
+} from "./promptargument.js";
+
+export type MCPPrompt = {
+  name: string;
+  title?: string | null | undefined;
+  description?: string | null | undefined;
+  arguments?: Array<PromptArgument> | null | undefined;
+  icons?: Array<MCPServerIcon> | null | undefined;
+  meta?: { [k: string]: any } | null | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const MCPPrompt$inboundSchema: z.ZodType<MCPPrompt, unknown> = z.object({
+  name: z.string(),
+  title: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+  arguments: z.nullable(z.array(PromptArgument$inboundSchema)).optional(),
+  icons: z.nullable(z.array(MCPServerIcon$inboundSchema)).optional(),
+  _meta: z.nullable(z.record(z.string(), z.any())).optional(),
+}).catchall(z.any()).transform((v) => {
+  return remap$(v, {
+    "_meta": "meta",
+  });
+});
+
+export function mcpPromptFromJSON(
+  jsonString: string,
+): SafeParseResult<MCPPrompt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MCPPrompt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MCPPrompt' from JSON`,
+  );
+}

package/src/models/components/mcpresource.ts

@@ -0,0 +1,53 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7c3dd73f88ee
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { Annotations, Annotations$inboundSchema } from "./annotations.js";
+import { MCPServerIcon, MCPServerIcon$inboundSchema } from "./mcpservericon.js";
+
+export type MCPResource = {
+  name: string;
+  title?: string | null | undefined;
+  uri: string;
+  description?: string | null | undefined;
+  mimeType?: string | null | undefined;
+  size?: number | null | undefined;
+  icons?: Array<MCPServerIcon> | null | undefined;
+  annotations?: Annotations | null | undefined;
+  meta?: { [k: string]: any } | null | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const MCPResource$inboundSchema: z.ZodType<MCPResource, unknown> = z
+  .object({
+    name: z.string(),
+    title: z.nullable(z.string()).optional(),
+    uri: z.string(),
+    description: z.nullable(z.string()).optional(),
+    mimeType: z.nullable(z.string()).optional(),
+    size: z.nullable(z.int()).optional(),
+    icons: z.nullable(z.array(MCPServerIcon$inboundSchema)).optional(),
+    annotations: z.nullable(Annotations$inboundSchema).optional(),
+    _meta: z.nullable(z.record(z.string(), z.any())).optional(),
+  }).catchall(z.any()).transform((v) => {
+    return remap$(v, {
+      "_meta": "meta",
+    });
+  });
+
+export function mcpResourceFromJSON(
+  jsonString: string,
+): SafeParseResult<MCPResource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MCPResource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MCPResource' from JSON`,
+  );
+}

package/src/models/components/mcpserverauthenticationrequirement.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 071bf83ea99a
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Authentication requirements for a remote transport (SEP-2127).
+ */
+export type MCPServerAuthenticationRequirement = {
+  /**
+   * Whether authentication is mandatory
+   */
+  required: boolean;
+  /**
+   * Supported schemes (e.g. ['bearer', 'oauth2'])
+   */
+  schemes?: Array<string> | undefined;
+};
+
+/** @internal */
+export const MCPServerAuthenticationRequirement$inboundSchema: z.ZodType<
+  MCPServerAuthenticationRequirement,
+  unknown
+> = z.object({
+  required: z.boolean(),
+  schemes: z.array(z.string()).optional(),
+});
+
+export function mcpServerAuthenticationRequirementFromJSON(
+  jsonString: string,
+): SafeParseResult<MCPServerAuthenticationRequirement, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      MCPServerAuthenticationRequirement$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MCPServerAuthenticationRequirement' from JSON`,
+  );
+}