@mistralai/mistralai 2.2.6 → 2.3.0

package/src/extra/observability/telemetry.ts

@@ -0,0 +1,561 @@
+import {
+  trace,
+  type Tracer,
+  type TracerOptions,
+  type TracerProvider,
+} from "@opentelemetry/api";
+
+import type { SDKOptions } from "../../lib/config.js";
+import type { SecurityState } from "../../lib/security.js";
+import { OTEL_SERVICE_NAME } from "./otel.js";
+import { getRegisteredTracerProvider } from "./provider.js";
+
+export const MISTRAL_SDK_TELEMETRY_ENV = "MISTRAL_SDK_TELEMETRY";
+export const MISTRAL_TELEMETRY_BASE_URL = "https://api.mistral.ai";
+export const MISTRAL_TELEMETRY_TRACES_PATH = "/telemetry/v1/traces";
+export const MISTRAL_TELEMETRY_ENDPOINT = createTelemetryEndpoint(MISTRAL_TELEMETRY_BASE_URL);
+export const MISTRAL_OTLP_TRACES_ENDPOINT_ENV = "MISTRAL_OTLP_TRACES_ENDPOINT";
+export const TELEMETRY_PROVIDER_DEDICATED = "dedicated";
+export const TELEMETRY_PROVIDER_GLOBAL = "global";
+
+const DISABLED_VALUE = "false";
+const PROVIDER_VALUES = [
+  TELEMETRY_PROVIDER_DEDICATED,
+  TELEMETRY_PROVIDER_GLOBAL,
+] as const;
+
+export type TelemetryProviderMode = typeof PROVIDER_VALUES[number];
+export type TelemetrySetting = boolean | string | null | undefined;
+export type TelemetryProvider = TelemetryProviderMode | TracerProvider;
+
+export type ManagedTelemetryTracerProvider = TracerProvider & {
+  shutdown?: () => void | Promise<void>;
+  forceFlush?: () => void | Promise<void>;
+};
+
+export type TelemetryCapableTracingHook = {
+  readonly _mistralTracingHook: true;
+  tracerProvider: TracerProvider | undefined;
+  _autoTelemetryProvider: ManagedTelemetryTracerProvider | undefined;
+  _telemetryInitialization: Promise<boolean> | undefined;
+  _telemetryConfigurationVersion: number;
+  _telemetryAutoDisabled: boolean;
+  _telemetryUseGlobalProvider: boolean;
+};
+
+type TelemetryContext = {
+  baseURL?: string | URL | null | undefined;
+  options?: SDKOptions | undefined;
+  resolvedSecurity?: SecurityState | null | undefined;
+};
+
+type ClientWithHooks = {
+  _baseURL?: string | URL | null | undefined;
+  _options?: (SDKOptions & { hooks?: { beforeRequestHooks?: unknown[] } }) | undefined;
+};
+
+export type ModuleLoader = (specifier: string) => Promise<Record<string, unknown>>;
+
+export type CreateTelemetryTracerProviderOptions = {
+  apiKey: string | null | undefined;
+  baseURL?: string | URL | null | undefined;
+  moduleLoader?: ModuleLoader | undefined;
+};
+
+type CreateTelemetryTracerProvider = (
+  options: CreateTelemetryTracerProviderOptions,
+) => Promise<ManagedTelemetryTracerProvider>;
+
+type ConfigureTelemetryForHookOptions = {
+  telemetry?: TelemetrySetting;
+  replaceExisting?: boolean | undefined;
+  createTelemetryTracerProvider?: CreateTelemetryTracerProvider;
+};
+
+type OtelResource = { merge?: (resource: unknown) => unknown };
+type OtelResourceConstructor = (new (attributes: Record<string, string>) => OtelResource) & {
+  default?: () => OtelResource;
+};
+
+export class TelemetryConfigurationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "TelemetryConfigurationError";
+  }
+}
+
+export async function configureTelemetry(
+  client: ClientWithHooks,
+  provider: TelemetryProvider = TELEMETRY_PROVIDER_DEDICATED,
+): Promise<boolean> {
+  const hook = getTracingHook(client);
+
+  if (typeof provider === "string") {
+    const providerMode = resolveProviderMode(provider);
+    if (providerMode === TELEMETRY_PROVIDER_GLOBAL) {
+      return useGlobalTracerProvider(hook, { replaceExisting: true });
+    }
+
+    return configureTelemetryForHook(
+      hook,
+      { baseURL: client._baseURL, options: client._options },
+      { telemetry: providerMode, replaceExisting: true },
+    );
+  }
+
+  markTelemetryConfigurationChanged(hook);
+  await attachCustomTracerProvider(hook, provider);
+  return true;
+}
+
+export async function setTracerProvider(
+  client: ClientWithHooks,
+  provider: TracerProvider,
+): Promise<boolean> {
+  return configureTelemetry(client, provider);
+}
+
+export function getTelemetryTracer(
+  client: ClientWithHooks,
+  name: string,
+  version?: string,
+  options?: TracerOptions,
+): Tracer {
+  const hook = getTracingHook(client);
+  const providerMode = resolveMistralTelemetryEnv();
+  return getClientTracerProvider(
+    hook,
+    providerMode === TELEMETRY_PROVIDER_GLOBAL,
+  ).getTracer(name, version, options);
+}
+
+export async function configureTelemetryForHook(
+  hook: TelemetryCapableTracingHook,
+  context: TelemetryContext,
+  options: ConfigureTelemetryForHookOptions = {},
+): Promise<boolean> {
+  const telemetryOverride = options.telemetry;
+  const hasTelemetryOverride = telemetryOverride != null;
+  const replaceExisting = options.replaceExisting === true;
+  if (!hasTelemetryOverride && hasConfiguredAutoTelemetry(hook)) {
+    return true;
+  }
+  if (!hasTelemetryOverride && hook._telemetryAutoDisabled) {
+    return false;
+  }
+
+  const providerMode = hasTelemetryOverride
+    ? resolveTelemetryMode(telemetryOverride)
+    : resolveMistralTelemetryEnv();
+
+  if (hook._telemetryInitialization !== undefined) {
+    if (!replaceExisting && providerMode === TELEMETRY_PROVIDER_DEDICATED) {
+      return hook._telemetryInitialization;
+    }
+    try {
+      await hook._telemetryInitialization;
+    } catch {
+      // Allow explicit disable/global/replacement calls to proceed after a
+      // failed in-flight auto-initialization.
+    }
+  }
+
+  if (providerMode == null) {
+    markTelemetryConfigurationChanged(hook);
+    await shutdownTelemetryProvider(hook);
+    markAutoTelemetryDisabled(hook);
+    return false;
+  }
+
+  if (providerMode === TELEMETRY_PROVIDER_GLOBAL) {
+    return useGlobalTracerProvider(hook, {
+      replaceExisting: replaceExisting || hasTelemetryOverride,
+    });
+  }
+
+  if (hook._autoTelemetryProvider !== undefined) {
+    return true;
+  }
+
+  if (hook.tracerProvider !== undefined) {
+    if (!replaceExisting) {
+      return false;
+    }
+    hook.tracerProvider = undefined;
+  }
+
+  if (getRegisteredTracerProvider() !== undefined && !replaceExisting) {
+    return false;
+  }
+
+  const configurationVersion = markTelemetryConfigurationChanged(hook);
+  const initialization = initializeTelemetryProvider(
+    hook,
+    context,
+    options,
+    configurationVersion,
+  );
+  hook._telemetryInitialization = initialization;
+  try {
+    return await initialization;
+  } finally {
+    if (hook._telemetryInitialization === initialization) {
+      hook._telemetryInitialization = undefined;
+    }
+  }
+}
+
+async function initializeTelemetryProvider(
+  hook: TelemetryCapableTracingHook,
+  context: TelemetryContext,
+  options: ConfigureTelemetryForHookOptions,
+  configurationVersion: number,
+): Promise<boolean> {
+  const createProvider = options.createTelemetryTracerProvider ?? _createTelemetryTracerProvider;
+  const provider = await createProvider({
+    apiKey: await resolveApiKey(context),
+    baseURL: context.baseURL ?? context.options?.serverURL,
+  });
+
+  if (hook._telemetryConfigurationVersion !== configurationVersion) {
+    await provider.shutdown?.();
+    return false;
+  }
+
+  await attachTelemetryProvider(hook, provider);
+  return true;
+}
+
+export async function _createTelemetryTracerProvider(
+  options: CreateTelemetryTracerProviderOptions,
+): Promise<ManagedTelemetryTracerProvider> {
+  if (options.apiKey == null || options.apiKey === "") {
+    throw new TelemetryConfigurationError(
+      "Mistral telemetry requires an API key. Pass apiKey to the client or set MISTRAL_API_KEY.",
+    );
+  }
+
+  const moduleLoader = options.moduleLoader ?? loadModule;
+  let sdkTraceBase: Record<string, unknown>;
+  let otlpExporterModule: Record<string, unknown>;
+  let resourcesModule: Record<string, unknown>;
+  try {
+    [sdkTraceBase, otlpExporterModule, resourcesModule] = await Promise.all([
+      moduleLoader("@opentelemetry/sdk-trace-base"),
+      moduleLoader("@opentelemetry/exporter-trace-otlp-http"),
+      moduleLoader("@opentelemetry/resources"),
+    ]);
+  } catch {
+    throw new TelemetryConfigurationError(
+      "Mistral telemetry requires optional OpenTelemetry SDK/exporter dependencies. " +
+        "Install @opentelemetry/sdk-trace-base, @opentelemetry/exporter-trace-otlp-http, " +
+        "and @opentelemetry/resources with your package manager.",
+    );
+  }
+
+  const BasicTracerProvider = requireExportConstructor(
+    sdkTraceBase,
+    "BasicTracerProvider",
+    "@opentelemetry/sdk-trace-base",
+  );
+  const BatchSpanProcessor = requireExportConstructor(
+    sdkTraceBase,
+    "BatchSpanProcessor",
+    "@opentelemetry/sdk-trace-base",
+  );
+  const OTLPTraceExporter = requireExportConstructor(
+    otlpExporterModule,
+    "OTLPTraceExporter",
+    "@opentelemetry/exporter-trace-otlp-http",
+  );
+
+  const exporter = new OTLPTraceExporter({
+    url: resolveMistralTelemetryEndpoint(options.baseURL),
+    headers: { Authorization: asBearerToken(options.apiKey) },
+  });
+  const spanProcessor = new BatchSpanProcessor(exporter);
+  const resource = createResource(resourcesModule, {
+    "service.name": OTEL_SERVICE_NAME,
+  });
+
+  const provider = new BasicTracerProvider({ resource }) as ManagedTelemetryTracerProvider & {
+    addSpanProcessor?: (processor: unknown) => void;
+  };
+  if (typeof provider.addSpanProcessor === "function") {
+    provider.addSpanProcessor(spanProcessor);
+    return provider;
+  }
+
+  return new BasicTracerProvider({
+    resource,
+    spanProcessors: [spanProcessor],
+  }) as ManagedTelemetryTracerProvider;
+}
+
+function getTracingHook(client: ClientWithHooks): TelemetryCapableTracingHook {
+  const hooks = client._options?.hooks;
+  const beforeRequestHooks = hooks?.beforeRequestHooks;
+  if (!Array.isArray(beforeRequestHooks)) {
+    throw new Error("Cannot configure telemetry: SDK hooks not initialised.");
+  }
+
+  const hook = beforeRequestHooks.find(isTelemetryCapableTracingHook);
+  if (hook === undefined) {
+    throw new Error("Cannot configure telemetry: TracingHook not found in the client's hooks.");
+  }
+  return hook;
+}
+
+function isTelemetryCapableTracingHook(
+  hook: unknown,
+): hook is TelemetryCapableTracingHook {
+  return Boolean(
+    hook &&
+      typeof hook === "object" &&
+      (hook as { _mistralTracingHook?: unknown })._mistralTracingHook === true,
+  );
+}
+
+function getClientTracerProvider(
+  hook: TelemetryCapableTracingHook,
+  usesGlobalProvider: boolean,
+): TracerProvider {
+  if (hook.tracerProvider !== undefined) {
+    return hook.tracerProvider;
+  }
+
+  if (!usesGlobalProvider && !hook._telemetryUseGlobalProvider) {
+    const registeredProvider = getRegisteredTracerProvider();
+    if (registeredProvider !== undefined) {
+      return registeredProvider;
+    }
+  }
+
+  return trace.getTracerProvider();
+}
+
+function resolveTelemetryMode(value: boolean | string): TelemetryProviderMode | null {
+  if (typeof value === "boolean") {
+    return value ? TELEMETRY_PROVIDER_DEDICATED : null;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  switch (normalized) {
+    case TELEMETRY_PROVIDER_DEDICATED:
+      return TELEMETRY_PROVIDER_DEDICATED;
+    case TELEMETRY_PROVIDER_GLOBAL:
+      return TELEMETRY_PROVIDER_GLOBAL;
+    case DISABLED_VALUE:
+      return null;
+  }
+
+  throw new TelemetryConfigurationError(
+    `Invalid telemetry setting ${JSON.stringify(value)}. Expected one of: dedicated, false, global.`,
+  );
+}
+
+function resolveProviderMode(value: string): TelemetryProviderMode {
+  const normalized = value.trim().toLowerCase();
+  switch (normalized) {
+    case TELEMETRY_PROVIDER_DEDICATED:
+      return TELEMETRY_PROVIDER_DEDICATED;
+    case TELEMETRY_PROVIDER_GLOBAL:
+      return TELEMETRY_PROVIDER_GLOBAL;
+  }
+
+  throw new TelemetryConfigurationError(
+    `Invalid telemetry provider ${JSON.stringify(value)}. Expected one of: dedicated, global.`,
+  );
+}
+
+function resolveMistralTelemetryEnv(): TelemetryProviderMode | null {
+  const envValue = readEnv(MISTRAL_SDK_TELEMETRY_ENV);
+  if (envValue == null || envValue === "") {
+    return null;
+  }
+
+  try {
+    return resolveTelemetryMode(envValue);
+  } catch {
+    throw new TelemetryConfigurationError(
+      `Invalid ${MISTRAL_SDK_TELEMETRY_ENV}=${JSON.stringify(envValue)}. ` +
+        "Expected one of: dedicated, false, global.",
+    );
+  }
+}
+
+async function resolveApiKey(context: TelemetryContext): Promise<string> {
+  const authHeader = context.resolvedSecurity?.headers?.["Authorization"];
+  if (authHeader) {
+    return authHeader;
+  }
+
+  const apiKey = await resolveApiKeySource(context.options?.apiKey);
+  if (apiKey) {
+    return apiKey;
+  }
+
+  const envApiKey = readEnv("MISTRAL_API_KEY");
+  if (envApiKey) {
+    return envApiKey;
+  }
+
+  throw new TelemetryConfigurationError(
+    "Mistral telemetry requires an API key. Pass apiKey to the client or set MISTRAL_API_KEY.",
+  );
+}
+
+async function resolveApiKeySource(
+  source: SDKOptions["apiKey"],
+): Promise<string | undefined> {
+  if (source == null) {
+    return undefined;
+  }
+  return typeof source === "function" ? source() : source;
+}
+
+function resolveMistralTelemetryEndpoint(baseURL?: string | URL | null): string {
+  const endpoint = readEnv(MISTRAL_OTLP_TRACES_ENDPOINT_ENV)?.trim();
+  if (endpoint) {
+    return endpoint;
+  }
+  if (baseURL != null && `${baseURL}`.trim() !== "") {
+    return createTelemetryEndpoint(baseURL);
+  }
+  return MISTRAL_TELEMETRY_ENDPOINT;
+}
+
+function createTelemetryEndpoint(baseURL: string | URL): string {
+  return new URL(MISTRAL_TELEMETRY_TRACES_PATH, baseURL).toString();
+}
+
+async function attachTelemetryProvider(
+  hook: TelemetryCapableTracingHook,
+  provider: ManagedTelemetryTracerProvider,
+): Promise<void> {
+  await shutdownTelemetryProvider(hook);
+  hook.tracerProvider = provider;
+  hook._autoTelemetryProvider = provider;
+  hook._telemetryUseGlobalProvider = false;
+  hook._telemetryAutoDisabled = false;
+}
+
+function hasConfiguredAutoTelemetry(hook: TelemetryCapableTracingHook): boolean {
+  return hook._autoTelemetryProvider !== undefined || hook._telemetryUseGlobalProvider;
+}
+
+function markAutoTelemetryDisabled(hook: TelemetryCapableTracingHook): void {
+  hook._telemetryUseGlobalProvider = false;
+  hook._telemetryAutoDisabled = true;
+}
+
+function markTelemetryConfigurationChanged(hook: TelemetryCapableTracingHook): number {
+  hook._telemetryConfigurationVersion += 1;
+  return hook._telemetryConfigurationVersion;
+}
+
+async function attachCustomTracerProvider(
+  hook: TelemetryCapableTracingHook,
+  provider: TracerProvider,
+): Promise<void> {
+  await shutdownTelemetryProvider(hook);
+  hook.tracerProvider = provider;
+  hook._telemetryUseGlobalProvider = false;
+  hook._telemetryAutoDisabled = false;
+}
+
+async function useGlobalTracerProvider(
+  hook: TelemetryCapableTracingHook,
+  options: { replaceExisting: boolean },
+): Promise<boolean> {
+  if (
+    hook.tracerProvider !== undefined &&
+    hook._autoTelemetryProvider === undefined &&
+    !options.replaceExisting
+  ) {
+    return false;
+  }
+
+  markTelemetryConfigurationChanged(hook);
+  await shutdownTelemetryProvider(hook);
+  hook.tracerProvider = undefined;
+  hook._telemetryUseGlobalProvider = true;
+  hook._telemetryAutoDisabled = true;
+  return true;
+}
+
+async function shutdownTelemetryProvider(
+  hook: TelemetryCapableTracingHook,
+): Promise<void> {
+  const provider = hook._autoTelemetryProvider;
+  if (provider === undefined) {
+    return;
+  }
+
+  hook._autoTelemetryProvider = undefined;
+  if (hook.tracerProvider === provider) {
+    hook.tracerProvider = undefined;
+  }
+  await provider.shutdown?.();
+}
+
+function asBearerToken(apiKey: string): string {
+  return apiKey.toLowerCase().startsWith("bearer ") ? apiKey : `Bearer ${apiKey}`;
+}
+
+function readEnv(name: string): string | undefined {
+  try {
+    const denoEnv = (globalThis as { Deno?: { env?: { get?: (key: string) => string | undefined } } })
+      .Deno?.env;
+    const denoValue = denoEnv?.get?.(name);
+    if (denoValue !== undefined) {
+      return denoValue;
+    }
+  } catch {
+    // Ignore unavailable Deno permissions.
+  }
+
+  try {
+    return (globalThis as { process?: { env?: Record<string, string | undefined> } })
+      .process?.env?.[name];
+  } catch {
+    return undefined;
+  }
+}
+
+async function loadModule(specifier: string): Promise<Record<string, unknown>> {
+  return await import(specifier) as Record<string, unknown>;
+}
+
+function requireExportConstructor(
+  moduleExports: Record<string, unknown>,
+  exportName: string,
+  moduleName: string,
+): new (...args: unknown[]) => unknown {
+  const value = moduleExports[exportName];
+  if (typeof value !== "function") {
+    throw new TelemetryConfigurationError(
+      `Mistral telemetry expected ${moduleName} to export ${exportName}.`,
+    );
+  }
+  return value as new (...args: unknown[]) => unknown;
+}
+
+function createResource(
+  moduleExports: Record<string, unknown>,
+  attributes: Record<string, string>,
+): unknown {
+  const resourceFromAttributes = moduleExports["resourceFromAttributes"];
+  if (typeof resourceFromAttributes === "function") {
+    return resourceFromAttributes(attributes);
+  }
+
+  const Resource = moduleExports["Resource"] as OtelResourceConstructor | undefined;
+  if (typeof Resource !== "function") {
+    return { attributes };
+  }
+
+  const resource = new Resource(attributes);
+  const defaultResource = Resource.default?.();
+  return defaultResource?.merge?.(resource) ?? resource;
+}

package/src/funcs/agentsComplete.ts

@@ -121,7 +121,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/agentsStream.ts

@@ -127,7 +127,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioSpeechComplete.ts

@@ -183,7 +183,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioTranscriptionsComplete.ts

@@ -181,7 +181,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioTranscriptionsStream.ts

@@ -184,7 +184,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioVoicesCreate.ts

@@ -124,7 +124,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioVoicesDelete.ts

@@ -132,7 +132,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioVoicesGet.ts

@@ -133,7 +133,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioVoicesGetSampleAudio.ts

@@ -133,7 +133,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioVoicesList.ts

@@ -133,7 +133,7 @@ async function $do(
     query: query,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/audioVoicesUpdate.ts

@@ -135,7 +135,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/batchJobsCancel.ts

@@ -130,7 +130,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];

package/src/funcs/batchJobsCreate.ts

@@ -121,7 +121,7 @@ async function $do(
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 60000,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 300000,
   }, options);
   if (!requestRes.ok) {
     return [requestRes, { status: "invalid" }];