@copilotkit/runtime 1.9.2-next.7 → 1.9.2-next.9

package/src/lib/runtime/remote-lg-action.ts

@@ -2,7 +2,9 @@ import {
   Client as LangGraphClient,
   EventsStreamEvent,
   GraphSchema,
+  Interrupt,
   StreamMode,
+  ThreadState,
 } from "@langchain/langgraph-sdk";
 import { createHash } from "node:crypto";
 import { isValidUUID, randomUUID } from "@copilotkit/shared";
@@ -17,9 +19,28 @@ import { CustomEventNames, LangGraphEventTypes } from "../../agents/langgraph/ev
 import telemetry from "../telemetry-client";
 import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
 import { MetaEventName } from "../../graphql/types/meta-events.type";
-import { parseJson, CopilotKitMisuseError } from "@copilotkit/shared";
+import {
+  parseJson,
+  CopilotKitMisuseError,
+  CopilotKitLowLevelError,
+  CopilotKitError,
+} from "@copilotkit/shared";
 import { RemoveMessage } from "@langchain/core/messages";
 import { RETRY_CONFIG, isRetryableError, sleep, calculateDelay } from "./retry-utils";
+import { generateHelpfulErrorMessage } from "../streaming";
+
+// Utility to determine if an error is a user configuration issue vs system error
+export function isUserConfigurationError(error: any): boolean {
+  return (
+    (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) &&
+    (error.code === "NETWORK_ERROR" ||
+      error.code === "AUTHENTICATION_ERROR" ||
+      error.statusCode === 401 ||
+      error.statusCode === 403 ||
+      error.message?.toLowerCase().includes("authentication") ||
+      error.message?.toLowerCase().includes("api key"))
+  );
+}
 
 type State = Record<string, any>;
 
@@ -84,8 +105,6 @@ type SchemaKeys = {
   config: string[] | null;
 } | null;
 
-let activeInterruptEvent = false;
-
 export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8Array>> {
   return new ReadableStream({
     async start(controller) {
@@ -128,6 +147,15 @@ export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8
             See more: https://docs.copilotkit.ai/troubleshooting/common-issues`,
         });
       } else {
+        // Preserve already structured CopilotKit errors with semantic information
+        if (
+          lastError instanceof CopilotKitError ||
+          lastError instanceof CopilotKitLowLevelError ||
+          (lastError instanceof Error && lastError.name && lastError.name.includes("CopilotKit"))
+        ) {
+          throw lastError; // Re-throw to preserve semantic information and visibility settings
+        }
+
         throw new CopilotKitMisuseError({
           message: `
             The LangGraph client threw unhandled error ${lastError}.
@@ -188,7 +216,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     await client.threads.create({ threadId });
   }
 
-  let agentState = { values: {} };
+  let agentState = { values: {} } as ThreadState;
   if (wasInitiatedWithExistingThread) {
     agentState = await client.threads.getState(threadId);
   }
@@ -218,16 +246,14 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const lgInterruptMetaEvent = metaEvents?.find(
     (ev) => ev.name === MetaEventName.LangGraphInterruptEvent,
   );
-  if (activeInterruptEvent && !lgInterruptMetaEvent) {
-    // state.messages includes only messages that were not processed by the agent, which are the interrupt messages
-    payload.command = { resume: state.messages };
-  }
+
   if (lgInterruptMetaEvent?.response) {
     let response = lgInterruptMetaEvent.response;
     payload.command = { resume: parseJson(response, response) };
   }
 
-  if (mode === "continue" && !activeInterruptEvent) {
+  const interrupts = (agentState.tasks?.[0]?.interrupts ?? []) as Interrupt[];
+  if (mode === "continue" && !interrupts.length) {
     await client.threads.updateState(threadId, { values: state, asNode: nodeName });
   }
 
@@ -311,17 +337,30 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let shouldExit = false;
   let externalRunId = null;
 
-  const streamResponse = client.runs.stream(threadId, assistantId, payload);
-
   const emit = (message: string) => controller.enqueue(new TextEncoder().encode(message));
 
+  // If there are still outstanding unresolved interrupts, we must force resolution of them before moving forward
+  if (interrupts?.length && !payload.command?.resume) {
+    // If the interrupt is "by message" we assume the upcoming user message is a resoluton for the interrupt
+    if (!lgInterruptMetaEvent) {
+      // state.messages includes only messages that were not processed by the agent, which are the interrupt messages
+      payload.command = { resume: state.messages };
+    } else {
+      interrupts.forEach((interrupt) => {
+        emitInterrupt(interrupt.value, emit);
+      });
+      return Promise.resolve();
+    }
+  }
+
+  const streamResponse = client.runs.stream(threadId, assistantId, payload);
+
   let latestStateValues = {};
   let updatedState = state;
   // If a manual emittance happens, it is the ultimate source of truth of state, unless a node has exited.
   // Therefore, this value should either hold null, or the only edition of state that should be used.
   let manuallyEmittedState = null;
 
-  activeInterruptEvent = false;
   try {
     telemetry.capture("oss.runtime.agent_execution_stream_started", {
       hashedLgcKey: streamInfo.hashedLgcKey,
@@ -330,7 +369,43 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
       if (!["events", "values", "error", "updates"].includes(streamResponseChunk.event)) continue;
 
       if (streamResponseChunk.event === "error") {
-        throw new Error(`Error event thrown: ${streamResponseChunk.data.message}`);
+        const errorData = streamResponseChunk.data;
+
+        // Check if this is a structured error from our Python agent
+        if (errorData && typeof errorData === "object" && "error_details" in errorData) {
+          const errorDetails = (errorData as any).error_details;
+
+          // Create a structured error with preserved semantic information
+          const preservedError = new CopilotKitLowLevelError({
+            error: new Error(errorDetails.message),
+            url: "langgraph platform agent",
+            message: `${errorDetails.type}: ${errorDetails.message}`,
+          });
+
+          // Add additional error context
+          if (errorDetails.status_code) {
+            (preservedError as any).statusCode = errorDetails.status_code;
+          }
+          if (errorDetails.response_data) {
+            (preservedError as any).responseData = errorDetails.response_data;
+          }
+          (preservedError as any).agentName = errorDetails.agent_name;
+          (preservedError as any).originalErrorType = errorDetails.type;
+
+          throw preservedError;
+        }
+
+        // Fallback for generic error messages
+        const helpfulMessage = generateHelpfulErrorMessage(
+          new Error(errorData.message),
+          "LangGraph Platform agent",
+        );
+
+        throw new CopilotKitLowLevelError({
+          error: new Error(errorData.message),
+          url: "langgraph platform agent",
+          message: helpfulMessage,
+        });
       }
 
       // Force event type, as data is not properly defined on the LG side.
@@ -345,33 +420,8 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
       const interruptEvents = chunk.data.__interrupt__;
       if (interruptEvents?.length) {
-        activeInterruptEvent = true;
         const interruptValue = interruptEvents?.[0].value;
-        if (
-          typeof interruptValue != "string" &&
-          "__copilotkit_interrupt_value__" in interruptValue
-        ) {
-          const evValue = interruptValue.__copilotkit_interrupt_value__;
-          emit(
-            JSON.stringify({
-              event: LangGraphEventTypes.OnCopilotKitInterrupt,
-              data: {
-                value: typeof evValue === "string" ? evValue : JSON.stringify(evValue),
-                messages: langchainMessagesToCopilotKit(interruptValue.__copilotkit_messages__),
-              },
-            }) + "\n",
-          );
-        } else {
-          emit(
-            JSON.stringify({
-              event: LangGraphEventTypes.OnInterrupt,
-              value:
-                typeof interruptValue === "string"
-                  ? interruptValue
-                  : JSON.stringify(interruptValue),
-            }) + "\n",
-          );
-        }
+        emitInterrupt(interruptValue, emit);
         continue;
       }
       if (streamResponseChunk.event === "updates") continue;
@@ -521,11 +571,29 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
     return Promise.resolve();
   } catch (e) {
-    logger.error(e);
+    // Distinguish between user errors and system errors for logging
+    if (isUserConfigurationError(e)) {
+      // Log user errors at debug level to reduce noise
+      logger.debug({ error: e.message, code: e.code }, "User configuration error");
+    } else {
+      // Log actual system errors at error level
+      logger.error(e);
+    }
+
     telemetry.capture("oss.runtime.agent_execution_stream_errored", {
       ...streamInfo,
       error: e.message,
     });
+
+    // Re-throw CopilotKit errors so they can be handled properly at higher levels
+    if (
+      e instanceof CopilotKitError ||
+      e instanceof CopilotKitLowLevelError ||
+      (e instanceof Error && e.name && e.name.includes("CopilotKit"))
+    ) {
+      throw e;
+    }
+
     return Promise.resolve();
   }
 }
@@ -909,3 +977,25 @@ function getSchemaKeys(graphSchema: GraphSchema): SchemaKeys {
 function filterObjectBySchemaKeys(obj: Record<string, any>, schemaKeys: string[]) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => schemaKeys.includes(key)));
 }
+
+function emitInterrupt(interruptValue: any, emit: (data: string) => void) {
+  if (typeof interruptValue != "string" && "__copilotkit_interrupt_value__" in interruptValue) {
+    const evValue = interruptValue.__copilotkit_interrupt_value__;
+    emit(
+      JSON.stringify({
+        event: LangGraphEventTypes.OnCopilotKitInterrupt,
+        data: {
+          value: typeof evValue === "string" ? evValue : JSON.stringify(evValue),
+          messages: langchainMessagesToCopilotKit(interruptValue.__copilotkit_messages__),
+        },
+      }) + "\n",
+    );
+  } else {
+    emit(
+      JSON.stringify({
+        event: LangGraphEventTypes.OnInterrupt,
+        value: typeof interruptValue === "string" ? interruptValue : JSON.stringify(interruptValue),
+      }) + "\n",
+    );
+  }
+}

package/src/lib/streaming.ts

@@ -1,5 +1,11 @@
 import { ReplaySubject } from "rxjs";
-import { CopilotKitLowLevelError, CopilotKitError, CopilotKitErrorCode } from "@copilotkit/shared";
+import {
+  CopilotKitLowLevelError,
+  CopilotKitError,
+  CopilotKitErrorCode,
+  ensureStructuredError,
+} from "@copilotkit/shared";
+import { errorConfig, getFallbackMessage } from "./error-messages";
 
 export async function writeJsonLineResponseToEventStream<T>(
   response: ReadableStream<Uint8Array>,
@@ -52,10 +58,8 @@ export async function writeJsonLineResponseToEventStream<T>(
       }
     }
   } catch (error) {
-    console.error("Error in stream", error);
-
-    // Convert network termination errors to structured errors
-    const structuredError = convertStreamingErrorToStructured(error);
+    // Preserve already structured CopilotKit errors, only convert unstructured errors
+    const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
     eventStream$.error(structuredError);
     return;
   }
@@ -63,50 +67,135 @@ export async function writeJsonLineResponseToEventStream<T>(
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {
-  // Handle network termination errors
-  if (
-    error?.message?.includes("terminated") ||
-    error?.cause?.code === "UND_ERR_SOCKET" ||
-    error?.message?.includes("other side closed") ||
-    error?.code === "UND_ERR_SOCKET"
-  ) {
-    return new CopilotKitError({
-      message:
-        "Connection to agent was unexpectedly terminated. This is likely due to the agent service being down or experiencing issues. Please check your agent logs and try again.",
-      code: CopilotKitErrorCode.NETWORK_ERROR,
-    });
-  }
+  // Determine a more helpful error message based on context
+  let helpfulMessage = generateHelpfulErrorMessage(error);
 
-  // Handle other network-related errors
+  // For network-related errors, use CopilotKitLowLevelError to preserve the original error
   if (
     error?.message?.includes("fetch failed") ||
     error?.message?.includes("ECONNREFUSED") ||
     error?.message?.includes("ENOTFOUND") ||
-    error?.message?.includes("ETIMEDOUT")
+    error?.message?.includes("ETIMEDOUT") ||
+    error?.message?.includes("terminated") ||
+    error?.cause?.code === "UND_ERR_SOCKET" ||
+    error?.message?.includes("other side closed") ||
+    error?.code === "UND_ERR_SOCKET"
   ) {
     return new CopilotKitLowLevelError({
       error: error instanceof Error ? error : new Error(String(error)),
       url: "streaming connection",
-      message:
-        "Network error occurred during streaming. Please check your connection and try again.",
-    });
-  }
-
-  // Handle abort/cancellation errors (these are usually normal)
-  if (
-    error?.message?.includes("aborted") ||
-    error?.message?.includes("canceled") ||
-    error?.message?.includes("signal is aborted")
-  ) {
-    return new CopilotKitError({
-      message: "Request was cancelled",
-      code: CopilotKitErrorCode.UNKNOWN,
+      message: helpfulMessage,
     });
   }
 
-  // Default: convert unknown streaming errors
+  // For all other errors, preserve the raw error in a basic CopilotKitError
   return new CopilotKitError({
-    message: `Streaming error: ${error?.message || String(error)}`,
+    message: helpfulMessage,
     code: CopilotKitErrorCode.UNKNOWN,
   });
 }
+
+/**
+ * Generates a helpful error message based on error patterns and context
+ */
+export function generateHelpfulErrorMessage(error: any, context: string = "connection"): string {
+  const baseMessage = error?.message || String(error);
+
+  // Check for preserved error information from Python agent
+  const originalErrorType = error?.originalErrorType || error?.extensions?.originalErrorType;
+  const statusCode = error?.statusCode || error?.extensions?.statusCode;
+  const responseData = error?.responseData || error?.extensions?.responseData;
+
+  // First, try to match by original error type if available (more specific)
+  if (originalErrorType) {
+    const typeConfig = errorConfig.errorPatterns[originalErrorType];
+    if (typeConfig) {
+      return typeConfig.message.replace("{context}", context);
+    }
+  }
+
+  // Check for specific error patterns from configuration
+  for (const [pattern, config] of Object.entries(errorConfig.errorPatterns)) {
+    const shouldMatch =
+      baseMessage?.includes(pattern) ||
+      error?.cause?.code === pattern ||
+      error?.code === pattern ||
+      statusCode === parseInt(pattern) ||
+      (pattern === "other_side_closed" && baseMessage?.includes("other side closed")) ||
+      (pattern === "fetch_failed" && baseMessage?.includes("fetch failed")) ||
+      (responseData && JSON.stringify(responseData).includes(pattern));
+
+    if (shouldMatch) {
+      // Replace {context} placeholder with actual context
+      return config.message.replace("{context}", context);
+    }
+  }
+
+  // Try to match by category for fallback messages
+  if (isNetworkError(error)) {
+    return getFallbackMessage("network");
+  }
+
+  if (isConnectionError(error)) {
+    return getFallbackMessage("connection");
+  }
+
+  if (isAuthenticationError(error)) {
+    return getFallbackMessage("authentication");
+  }
+
+  // Default fallback
+  return getFallbackMessage("default");
+}
+
+/**
+ * Determines if an error is network-related
+ */
+function isNetworkError(error: any): boolean {
+  const networkPatterns = ["ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "fetch_failed"];
+  return networkPatterns.some(
+    (pattern) =>
+      error?.message?.includes(pattern) ||
+      error?.cause?.code === pattern ||
+      error?.code === pattern,
+  );
+}
+
+/**
+ * Determines if an error is connection-related
+ */
+function isConnectionError(error: any): boolean {
+  const connectionPatterns = ["terminated", "UND_ERR_SOCKET", "other side closed"];
+  return connectionPatterns.some(
+    (pattern) =>
+      error?.message?.includes(pattern) ||
+      error?.cause?.code === pattern ||
+      error?.code === pattern,
+  );
+}
+
+/**
+ * Determines if an error is authentication-related
+ */
+function isAuthenticationError(error: any): boolean {
+  const authPatterns = [
+    "401",
+    "api key",
+    "unauthorized",
+    "authentication",
+    "AuthenticationError",
+    "PermissionDeniedError",
+  ];
+  const baseMessage = error?.message || String(error);
+  const originalErrorType = error?.originalErrorType || error?.extensions?.originalErrorType;
+  const statusCode = error?.statusCode || error?.extensions?.statusCode;
+
+  return authPatterns.some(
+    (pattern) =>
+      baseMessage?.toLowerCase().includes(pattern.toLowerCase()) ||
+      originalErrorType === pattern ||
+      statusCode === 401 ||
+      error?.status === 401 ||
+      error?.statusCode === 401,
+  );
+}

package/src/service-adapters/anthropic/anthropic-adapter.ts

@@ -29,6 +29,7 @@ import {
 } from "./utils";
 
 import { randomId, randomUUID } from "@copilotkit/shared";
+import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "claude-3-5-sonnet-latest";
 
@@ -220,15 +221,13 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             }
           }
         } catch (error) {
-          console.error("[Anthropic] Error processing stream:", error);
-          throw error;
+          throw convertServiceAdapterError(error, "Anthropic");
         }
 
         eventStream$.complete();
       });
     } catch (error) {
-      console.error("[Anthropic] Error during API call:", error);
-      throw error;
+      throw convertServiceAdapterError(error, "Anthropic");
     }
 
     return {

package/src/service-adapters/events.ts

@@ -1,37 +1,32 @@
 import {
   Action,
-  randomId,
   CopilotKitError,
   CopilotKitErrorCode,
   CopilotKitLowLevelError,
+  ensureStructuredError,
+  randomId,
+  Severity,
 } from "@copilotkit/shared";
+import { plainToInstance } from "class-transformer";
 import {
-  of,
+  catchError,
   concat,
-  scan,
   concatMap,
-  ReplaySubject,
-  Subject,
+  EMPTY,
   firstValueFrom,
   from,
-  catchError,
-  EMPTY,
-  BehaviorSubject,
+  of,
+  ReplaySubject,
+  scan,
+  Subject,
 } from "rxjs";
-import { streamLangChainResponse } from "./langchain/utils";
+import { ActionInput } from "../graphql/inputs/action.input";
+import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
 import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
-import telemetry from "../lib/telemetry-client";
 import { isRemoteAgentAction } from "../lib/runtime/remote-actions";
-import { ActionInput } from "../graphql/inputs/action.input";
-import {
-  ActionExecutionMessage,
-  ResultMessage,
-  TextMessage,
-  Message,
-} from "../graphql/types/converted";
-import { plainToInstance } from "class-transformer";
-import { MessageRole } from "../graphql/types/enums";
-import { parseJson, tryMap } from "@copilotkit/shared";
+import { generateHelpfulErrorMessage } from "../lib/streaming";
+import telemetry from "../lib/telemetry-client";
+import { streamLangChainResponse } from "./langchain/utils";
 
 export enum RuntimeEventTypes {
   TextMessageStart = "TextMessageStart",
@@ -273,10 +268,8 @@ export class RuntimeEventSource {
     threadId: string;
   }) {
     this.callback(this.eventStream$).catch((error) => {
-      console.error("Error in event source callback", error);
-
-      // Convert streaming errors to structured errors
-      const structuredError = convertStreamingErrorToStructured(error);
+      // Convert streaming errors to structured errors, but preserve already structured ones
+      const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
       this.eventStream$.error(structuredError);
       this.eventStream$.complete();
     });
@@ -330,17 +323,16 @@ export class RuntimeEventSource {
             eventWithState.actionExecutionId,
             actionInputsWithoutAgents,
             threadId,
-          ).catch((error) => {
-            console.error(error);
-          });
+          ).catch((error) => {});
 
           telemetry.capture("oss.runtime.server_action_executed", {});
           return concat(of(eventWithState.event!), toolCallEventStream$).pipe(
             catchError((error) => {
-              console.error("Error in tool call stream", error);
-
-              // Convert streaming errors to structured errors and send as action result
-              const structuredError = convertStreamingErrorToStructured(error);
+              // Convert streaming errors to structured errors and send as action result, but preserve already structured ones
+              const structuredError = ensureStructuredError(
+                error,
+                convertStreamingErrorToStructured,
+              );
               toolCallEventStream$.sendActionExecutionResult({
                 actionExecutionId: eventWithState.actionExecutionId!,
                 actionName: eventWithState.action!.name,
@@ -436,10 +428,8 @@ async function executeAction(
     from(stream).subscribe({
       next: (event) => eventStream$.next(event),
       error: (err) => {
-        console.error("Error in stream", err);
-
-        // Convert streaming errors to structured errors
-        const structuredError = convertStreamingErrorToStructured(err);
+        // Preserve already structured CopilotKit errors, only convert unstructured errors
+        const structuredError = ensureStructuredError(err, convertStreamingErrorToStructured);
         eventStream$.sendActionExecutionResult({
           actionExecutionId,
           actionName: action.name,
@@ -480,65 +470,31 @@ async function executeAction(
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {
-  // Handle network termination errors
-  if (
-    error?.message?.includes("terminated") ||
-    error?.cause?.code === "UND_ERR_SOCKET" ||
-    error?.message?.includes("other side closed") ||
-    error?.code === "UND_ERR_SOCKET"
-  ) {
-    return new CopilotKitError({
-      message:
-        "Connection to agent was unexpectedly terminated. This may be due to the agent service being restarted or network issues. Please try again.",
-      code: CopilotKitErrorCode.NETWORK_ERROR,
-    });
-  }
+  // Determine a more helpful error message based on context
+  let helpfulMessage = generateHelpfulErrorMessage(error, "event streaming connection");
 
-  // Handle other network-related errors
+  // For network-related errors, use CopilotKitLowLevelError to preserve the original error
   if (
     error?.message?.includes("fetch failed") ||
     error?.message?.includes("ECONNREFUSED") ||
     error?.message?.includes("ENOTFOUND") ||
-    error?.message?.includes("ETIMEDOUT")
+    error?.message?.includes("ETIMEDOUT") ||
+    error?.message?.includes("terminated") ||
+    error?.cause?.code === "UND_ERR_SOCKET" ||
+    error?.message?.includes("other side closed") ||
+    error?.code === "UND_ERR_SOCKET"
   ) {
     return new CopilotKitLowLevelError({
       error: error instanceof Error ? error : new Error(String(error)),
       url: "event streaming connection",
-      message:
-        "Network error occurred during event streaming. Please check your connection and try again.",
-    });
-  }
-
-  // Handle abort/cancellation errors (these are usually normal)
-  if (
-    error?.message?.includes("aborted") ||
-    error?.message?.includes("canceled") ||
-    error?.message?.includes("signal is aborted")
-  ) {
-    return new CopilotKitError({
-      message: "Request was cancelled",
-      code: CopilotKitErrorCode.UNKNOWN,
-    });
-  }
-
-  // Handle API key errors (authentication/authorization issues)
-  const errorMessage = error?.message || String(error);
-  if (
-    errorMessage.includes("401") ||
-    errorMessage.toLowerCase().includes("api key") ||
-    errorMessage.toLowerCase().includes("unauthorized") ||
-    errorMessage.toLowerCase().includes("authentication") ||
-    errorMessage.toLowerCase().includes("incorrect api key")
-  ) {
-    return new CopilotKitError({
-      message: `Event streaming error: ${errorMessage}`,
-      code: CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR,
+      message: helpfulMessage,
     });
   }
 
-  // Default: convert unknown streaming errors
+  // For all other errors, preserve the raw error in a basic CopilotKitError
   return new CopilotKitError({
-    message: `Event streaming error: ${errorMessage}`,
+    message: helpfulMessage,
     code: CopilotKitErrorCode.UNKNOWN,
+    severity: Severity.CRITICAL,
   });
 }