@mistralai/mistralai 2.2.5 → 2.2.6

package/src/hooks/tracing.ts

@@ -0,0 +1,173 @@
+import type { Context, Span, Tracer } from "@opentelemetry/api";
+import { HTTPClient } from "../lib/http.js";
+import {
+  AfterErrorContext,
+  AfterErrorHook,
+  AfterSuccessContext,
+  AfterSuccessHook,
+  BeforeRequestContext,
+  BeforeRequestHook,
+  HookContext,
+  SDKInitHook,
+  SDKInitOptions,
+} from "./types.js";
+
+type ObservabilityModule = typeof import("../extra/observability/otel.js");
+
+let observabilityModule: ObservabilityModule | null | undefined;
+
+async function getObservabilityModule(): Promise<ObservabilityModule | null> {
+  if (observabilityModule !== undefined) {
+    return observabilityModule;
+  }
+
+  try {
+    observabilityModule = await import("../extra/observability/otel.js");
+  } catch {
+    // OpenTelemetry is an optional peer; without it, tracing is a no-op.
+    observabilityModule = null;
+  }
+
+  return observabilityModule;
+}
+
+export const TRACING_SPAN_KEY = "_tracingSpan";
+export const TRACING_BODY_KEY = "_tracingBody";
+export const TRACING_TRACER_KEY = "_tracingTracer";
+
+export type TracingContext = HookContext & {
+  [TRACING_SPAN_KEY]?: Span;
+  [TRACING_BODY_KEY]?: string | null;
+  [TRACING_TRACER_KEY]?: Tracer;
+};
+
+// Runs the actual HTTP send inside the GenAI span context so lower-level
+// fetch/http auto-instrumentation parents its spans correctly.
+class TracingHTTPClient extends HTTPClient {
+  constructor(
+    private readonly wrappedClient: HTTPClient,
+    private readonly requestContexts: WeakMap<Request, Context>
+  ) {
+    super();
+  }
+
+  override async request(request: Request): Promise<Response> {
+    const activeContext = this.requestContexts.get(request);
+    if (!activeContext) {
+      return this.wrappedClient.request(request);
+    }
+
+    let observability: ObservabilityModule | null = null;
+    try {
+      observability = await getObservabilityModule();
+      if (!observability) {
+        return await this.wrappedClient.request(request);
+      }
+
+      return await observability.runWithContext(
+        activeContext,
+        () => this.wrappedClient.request(request)
+      );
+    } catch (error) {
+      if (observability) {
+        await observability.recordRequestError(activeContext, error);
+      }
+      throw error;
+    } finally {
+      this.requestContexts.delete(request);
+    }
+  }
+
+  override clone(): HTTPClient {
+    return new TracingHTTPClient(
+      this.wrappedClient.clone(),
+      this.requestContexts
+    );
+  }
+}
+
+export class TracingHook implements SDKInitHook, BeforeRequestHook, AfterSuccessHook, AfterErrorHook {
+  readonly #requestContexts = new WeakMap<Request, Context>();
+
+  sdkInit(opts: SDKInitOptions): SDKInitOptions {
+    return {
+      ...opts,
+      client: new TracingHTTPClient(opts.client, this.#requestContexts),
+    };
+  }
+
+  async beforeRequest(
+    hookCtx: BeforeRequestContext,
+    request: Request
+  ): Promise<Request> {
+    const ctx = hookCtx as TracingContext;
+    const observability = await getObservabilityModule();
+    if (!observability) {
+      return request;
+    }
+
+    const tracer = observability.getOrCreateOtelTracer();
+
+    const { request: tracedRequest, span, body } = await observability.getTracedRequestAndSpan(
+      tracer,
+      hookCtx.operationID,
+      request
+    );
+
+    ctx[TRACING_TRACER_KEY] = tracer;
+    ctx[TRACING_SPAN_KEY] = span;
+    ctx[TRACING_BODY_KEY] = body;
+    this.#requestContexts.set(tracedRequest, observability.getSpanContext(span));
+
+    return tracedRequest;
+  }
+
+  async afterSuccess(
+    hookCtx: AfterSuccessContext,
+    response: Response
+  ): Promise<Response> {
+    const ctx = hookCtx as TracingContext;
+    const span = ctx[TRACING_SPAN_KEY];
+    const tracer = ctx[TRACING_TRACER_KEY];
+
+    if (!span || !tracer) {
+      return response;
+    }
+
+    const observability = await getObservabilityModule();
+    if (!observability) {
+      return response;
+    }
+
+    return observability.getTracedResponse(
+      tracer,
+      span,
+      hookCtx.operationID,
+      response
+    );
+  }
+
+  async afterError(
+    hookCtx: AfterErrorContext,
+    response: Response | null,
+    error: unknown
+  ): Promise<{ response: Response | null; error: unknown }> {
+    const ctx = hookCtx as TracingContext;
+    const span = ctx[TRACING_SPAN_KEY];
+
+    if (!span) {
+      return { response, error };
+    }
+
+    const observability = await getObservabilityModule();
+    if (!observability) {
+      return { response, error };
+    }
+
+    return observability.getResponseAndError(
+      span,
+      response,
+      error
+    );
+  }
+}

package/src/lib/config.ts

@@ -60,8 +60,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "2.2.5",
+  sdkVersion: "2.2.6",
   genVersion: "2.884.13",
   userAgent:
-    "speakeasy-sdk/typescript 2.2.5 2.884.13 1.0.0 @mistralai/mistralai",
+    "speakeasy-sdk/typescript 2.2.6 2.884.13 1.0.0 @mistralai/mistralai",
 } as const;

package/src/models/components/authdata.ts

@@ -8,20 +8,20 @@ import { remap as remap$ } from "../../lib/primitives.js";
 
 export type AuthData = {
   clientId: string;
-  clientSecret: string;
+  clientSecret?: string | null | undefined;
 };
 
 /** @internal */
 export type AuthData$Outbound = {
   client_id: string;
-  client_secret: string;
+  client_secret?: string | null | undefined;
 };
 
 /** @internal */
 export const AuthData$outboundSchema: z.ZodType<AuthData$Outbound, AuthData> = z
   .object({
     clientId: z.string(),
-    clientSecret: z.string(),
+    clientSecret: z.nullable(z.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
       clientId: "client_id",

package/src/models/components/authenticationconfiguration.ts

@@ -9,6 +9,10 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { ConsumerType, ConsumerType$inboundSchema } from "./consumertype.js";
+import {
+  CredentialsStatus,
+  CredentialsStatus$inboundSchema,
+} from "./credentialsstatus.js";
 import {
   OutboundAuthenticationType,
   OutboundAuthenticationType$inboundSchema,
@@ -18,6 +22,7 @@ export type AuthenticationConfiguration = {
   name: string;
   authenticationType: OutboundAuthenticationType;
   scope: ConsumerType;
+  status?: CredentialsStatus | null | undefined;
   isDefault: boolean;
 };
 
@@ -29,6 +34,7 @@ export const AuthenticationConfiguration$inboundSchema: z.ZodType<
   name: z.string(),
   authentication_type: OutboundAuthenticationType$inboundSchema,
   scope: ConsumerType$inboundSchema,
+  status: z.nullable(CredentialsStatus$inboundSchema).optional(),
   is_default: z.boolean().default(false),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/authstatus.ts

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f4b0162e26f3
+ */
+
+import * as z from "zod/v4";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const AuthStatus = {
+  Valid: "valid",
+  Invalid: "invalid",
+  Error: "error",
+} as const;
+export type AuthStatus = OpenEnum<typeof AuthStatus>;
+
+/** @internal */
+export const AuthStatus$inboundSchema: z.ZodType<AuthStatus, unknown> =
+  openEnums.inboundSchema(AuthStatus);

package/src/models/components/basefielddefinition.ts

@@ -23,7 +23,7 @@ export const BaseFieldDefinitionType = {
 } as const;
 export type BaseFieldDefinitionType = OpenEnum<typeof BaseFieldDefinitionType>;
 
-export const SupportedOperator = {
+export const BaseFieldDefinitionSupportedOperator = {
   Lt: "lt",
   Lte: "lte",
   Gt: "gt",
@@ -44,14 +44,16 @@ export const SupportedOperator = {
   Excludes: "excludes",
   LenEq: "len_eq",
 } as const;
-export type SupportedOperator = OpenEnum<typeof SupportedOperator>;
+export type BaseFieldDefinitionSupportedOperator = OpenEnum<
+  typeof BaseFieldDefinitionSupportedOperator
+>;
 
 export type BaseFieldDefinition = {
   name: string;
   label: string;
   type: BaseFieldDefinitionType;
   group?: string | null | undefined;
-  supportedOperators: Array<SupportedOperator>;
+  supportedOperators: Array<BaseFieldDefinitionSupportedOperator>;
 };
 
 /** @internal */
@@ -61,10 +63,10 @@ export const BaseFieldDefinitionType$inboundSchema: z.ZodType<
 > = openEnums.inboundSchema(BaseFieldDefinitionType);
 
 /** @internal */
-export const SupportedOperator$inboundSchema: z.ZodType<
-  SupportedOperator,
+export const BaseFieldDefinitionSupportedOperator$inboundSchema: z.ZodType<
+  BaseFieldDefinitionSupportedOperator,
   unknown
-> = openEnums.inboundSchema(SupportedOperator);
+> = openEnums.inboundSchema(BaseFieldDefinitionSupportedOperator);
 
 /** @internal */
 export const BaseFieldDefinition$inboundSchema: z.ZodType<
@@ -75,7 +77,9 @@ export const BaseFieldDefinition$inboundSchema: z.ZodType<
   label: z.string(),
   type: BaseFieldDefinitionType$inboundSchema,
   group: z.nullable(z.string()).optional(),
-  supported_operators: z.array(SupportedOperator$inboundSchema),
+  supported_operators: z.array(
+    BaseFieldDefinitionSupportedOperator$inboundSchema,
+  ),
 }).transform((v) => {
   return remap$(v, {
     "supported_operators": "supportedOperators",

package/src/models/components/completiontokensdetails.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 66cb476e3177
+ */
+
+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";
+
+/**
+ * Token usage details for the completion.
+ */
+export type CompletionTokensDetails = {
+  reasoningTokens: number;
+};
+
+/** @internal */
+export const CompletionTokensDetails$inboundSchema: z.ZodType<
+  CompletionTokensDetails,
+  unknown
+> = z.object({
+  reasoning_tokens: z.int().default(0),
+}).transform((v) => {
+  return remap$(v, {
+    "reasoning_tokens": "reasoningTokens",
+  });
+});
+
+export function completionTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<CompletionTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompletionTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompletionTokensDetails' from JSON`,
+  );
+}

package/src/models/components/connectioncredentials.ts

@@ -15,6 +15,7 @@ export type ConnectionCredentials = {
   oauth?: OAuth2Token | null | undefined;
   headers?: { [k: string]: string } | null | undefined;
   bearerToken?: string | null | undefined;
+  githubInstallationId?: string | null | undefined;
 };
 
 /** @internal */
@@ -22,6 +23,7 @@ export type ConnectionCredentials$Outbound = {
   oauth?: OAuth2Token$Outbound | null | undefined;
   headers?: { [k: string]: string } | null | undefined;
   bearer_token?: string | null | undefined;
+  github_installation_id?: string | null | undefined;
 };
 
 /** @internal */
@@ -32,9 +34,11 @@ export const ConnectionCredentials$outboundSchema: z.ZodType<
   oauth: z.nullable(OAuth2Token$outboundSchema).optional(),
   headers: z.nullable(z.record(z.string(), z.string())).optional(),
   bearerToken: z.nullable(z.string()).optional(),
+  githubInstallationId: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     bearerToken: "bearer_token",
+    githubInstallationId: "github_installation_id",
   });
 });
 

package/src/models/components/connectorprotocol.ts

@@ -19,8 +19,3 @@ export const ConnectorProtocol$inboundSchema: z.ZodType<
   ConnectorProtocol,
   unknown
 > = openEnums.inboundSchema(ConnectorProtocol);
-/** @internal */
-export const ConnectorProtocol$outboundSchema: z.ZodType<
-  string,
-  ConnectorProtocol
-> = openEnums.outboundSchema(ConnectorProtocol);

package/src/models/components/createconnectorrequest.ts

@@ -10,6 +10,11 @@ import {
   AuthData$Outbound,
   AuthData$outboundSchema,
 } from "./authdata.js";
+import {
+  ExtendedOAuthServerMetadata,
+  ExtendedOAuthServerMetadata$Outbound,
+  ExtendedOAuthServerMetadata$outboundSchema,
+} from "./extendedoauthservermetadata.js";
 import {
   ResourceVisibility,
   ResourceVisibility$outboundSchema,
@@ -46,6 +51,14 @@ export type CreateConnectorRequest = {
    * Optional additional authentication data for the connector.
    */
   authData?: AuthData | null | undefined;
+  /**
+   * Optional OAuth2 authorization server metadata (authorization_endpoint, token_endpoint, etc.). When provided, skips .well-known discovery and uses these endpoints directly.
+   */
+  oauth2ServerMetadata?: ExtendedOAuthServerMetadata | null | undefined;
+  /**
+   * Optional URL to fetch OAuth2 authorization server metadata from (RFC 8414). When provided, the metadata is fetched from this URL and used instead of .well-known discovery. Mutually exclusive with oauth2_server_metadata.
+   */
+  oauth2ServerMetadataUrl?: string | null | undefined;
   /**
    * Optional system prompt for the connector.
    */
@@ -63,6 +76,11 @@ export type CreateConnectorRequest$Outbound = {
   server: string;
   headers?: { [k: string]: any } | null | undefined;
   auth_data?: AuthData$Outbound | null | undefined;
+  oauth2_server_metadata?:
+    | ExtendedOAuthServerMetadata$Outbound
+    | null
+    | undefined;
+  oauth2_server_metadata_url?: string | null | undefined;
   system_prompt?: string | null | undefined;
 };
 
@@ -80,11 +98,16 @@ export const CreateConnectorRequest$outboundSchema: z.ZodType<
   server: z.string(),
   headers: z.nullable(z.record(z.string(), z.any())).optional(),
   authData: z.nullable(AuthData$outboundSchema).optional(),
+  oauth2ServerMetadata: z.nullable(ExtendedOAuthServerMetadata$outboundSchema)
+    .optional(),
+  oauth2ServerMetadataUrl: z.nullable(z.string()).optional(),
   systemPrompt: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     iconUrl: "icon_url",
     authData: "auth_data",
+    oauth2ServerMetadata: "oauth2_server_metadata",
+    oauth2ServerMetadataUrl: "oauth2_server_metadata_url",
     systemPrompt: "system_prompt",
   });
 });

package/src/models/components/credentialsstatus.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 42337611c4b4
+ */
+
+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 { AuthStatus, AuthStatus$inboundSchema } from "./authstatus.js";
+import { HTTPStatus, HTTPStatus$inboundSchema } from "./httpstatus.js";
+
+export type CredentialsStatus = {
+  statusType: AuthStatus;
+  lastCheckedAt?: Date | null | undefined;
+  errorHttpCode?: HTTPStatus | null | undefined;
+  errorMessage?: string | null | undefined;
+};
+
+/** @internal */
+export const CredentialsStatus$inboundSchema: z.ZodType<
+  CredentialsStatus,
+  unknown
+> = z.object({
+  status_type: AuthStatus$inboundSchema,
+  last_checked_at: z.nullable(
+    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  error_http_code: z.nullable(HTTPStatus$inboundSchema).optional(),
+  error_message: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "status_type": "statusType",
+    "last_checked_at": "lastCheckedAt",
+    "error_http_code": "errorHttpCode",
+    "error_message": "errorMessage",
+  });
+});
+
+export function credentialsStatusFromJSON(
+  jsonString: string,
+): SafeParseResult<CredentialsStatus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CredentialsStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CredentialsStatus' from JSON`,
+  );
+}

package/src/models/components/deploymentdetailresponse.ts

@@ -30,6 +30,10 @@ export type DeploymentDetailResponse = {
    * Whether at least one worker is currently live
    */
   isActive: boolean;
+  /**
+   * Whether the deployment has at least one authorized credential
+   */
+  isHardened: boolean;
   /**
    * When the deployment was first registered
    */
@@ -56,6 +60,7 @@ export const DeploymentDetailResponse$inboundSchema: z.ZodType<
   id: z.string(),
   name: z.string(),
   is_active: z.boolean(),
+  is_hardened: z.boolean().default(false),
   created_at: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   updated_at: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   location: z.nullable(DeploymentLocation$inboundSchema).optional(),
@@ -63,6 +68,7 @@ export const DeploymentDetailResponse$inboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     "is_active": "isActive",
+    "is_hardened": "isHardened",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
   });

package/src/models/components/deploymentlistresponse.ts

@@ -4,6 +4,7 @@
  */
 
 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";
@@ -17,6 +18,14 @@ export type DeploymentListResponse = {
    * List of deployments
    */
   deployments: Array<DeploymentResponse>;
+  /**
+   * Cursor for the next page of results
+   */
+  nextCursor: string | null;
+  /**
+   * Workspace ID the results are scoped to
+   */
+  workspaceId: string;
 };
 
 /** @internal */
@@ -25,6 +34,13 @@ export const DeploymentListResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   deployments: z.array(DeploymentResponse$inboundSchema),
+  next_cursor: z.nullable(z.string()),
+  workspace_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "next_cursor": "nextCursor",
+    "workspace_id": "workspaceId",
+  });
 });
 
 export function deploymentListResponseFromJSON(

package/src/models/components/deploymentresponse.ts

@@ -26,6 +26,10 @@ export type DeploymentResponse = {
    * Whether at least one worker is currently live
    */
   isActive: boolean;
+  /**
+   * Whether the deployment has at least one authorized credential
+   */
+  isHardened: boolean;
   /**
    * When the deployment was first registered
    */
@@ -48,12 +52,14 @@ export const DeploymentResponse$inboundSchema: z.ZodType<
   id: z.string(),
   name: z.string(),
   is_active: z.boolean(),
+  is_hardened: z.boolean().default(false),
   created_at: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   updated_at: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   location: z.nullable(DeploymentLocation$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "is_active": "isActive",
+    "is_hardened": "isHardened",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
   });

package/src/models/components/encodedpayloadoptions.ts

@@ -11,6 +11,7 @@ export const EncodedPayloadOptions = {
   Offloaded: "offloaded",
   Encrypted: "encrypted",
   EncryptedPartial: "encrypted-partial",
+  Compressed: "compressed",
 } as const;
 export type EncodedPayloadOptions = OpenEnum<typeof EncodedPayloadOptions>;
 

package/src/models/components/executionlogrecord.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 44424769d595
+ */
+
+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";
+
+export type ExecutionLogRecord = {
+  timestamp: Date;
+  traceId: string;
+  spanId: string;
+  severityText: string;
+  body: string;
+  logAttributes: { [k: string]: string };
+};
+
+/** @internal */
+export const ExecutionLogRecord$inboundSchema: z.ZodType<
+  ExecutionLogRecord,
+  unknown
+> = z.object({
+  timestamp: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+  trace_id: z.string(),
+  span_id: z.string(),
+  severity_text: z.string(),
+  body: z.string(),
+  log_attributes: z.record(z.string(), z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "trace_id": "traceId",
+    "span_id": "spanId",
+    "severity_text": "severityText",
+    "log_attributes": "logAttributes",
+  });
+});
+
+export function executionLogRecordFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionLogRecord, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionLogRecord$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionLogRecord' from JSON`,
+  );
+}

package/src/models/components/executionlogsearchresponse.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a77d9a00d78b
+ */
+
+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 {
+  ExecutionLogRecord,
+  ExecutionLogRecord$inboundSchema,
+} from "./executionlogrecord.js";
+
+export type ExecutionLogSearchResponse = {
+  results: Array<ExecutionLogRecord>;
+  nextCursor?: string | null | undefined;
+};
+
+/** @internal */
+export const ExecutionLogSearchResponse$inboundSchema: z.ZodType<
+  ExecutionLogSearchResponse,
+  unknown
+> = z.object({
+  results: z.array(ExecutionLogRecord$inboundSchema),
+  next_cursor: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "next_cursor": "nextCursor",
+  });
+});
+
+export function executionLogSearchResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionLogSearchResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionLogSearchResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionLogSearchResponse' from JSON`,
+  );
+}