@librechat/agents 3.5.1 → 3.6.1

package/src/run.ts

@@ -16,8 +16,11 @@ import {
   HumanMessage,
   SystemMessage,
 } from '@langchain/core/messages';
+import type {
+  MessageContentComplex,
+  UsageMetadata,
+} from '@langchain/core/messages';
 import type { StringPromptValue } from '@langchain/core/prompt_values';
-import type { MessageContentComplex } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
 import type { StandardGraph } from '@/graphs/Graph';
@@ -44,6 +47,12 @@ import {
   isLangfuseCallbackHandler,
   withLangfuseAttributes,
 } from '@/langfuse';
+import {
+  REASONING_LABEL_PROMPT,
+  buildReasoningLabelTraceSeed,
+  buildReasoningLabelPrompt,
+  normalizeReasoningLabel,
+} from '@/prompts/reasoningLabel';
 import {
   hasToolOutputTracingConfig,
   resolveLangfuseConfig,
@@ -59,6 +68,10 @@ import {
   resolveLangfuseRuntimeScope,
   withLangfuseRuntimeScope,
 } from '@/langfuseRuntimeScope';
+import {
+  getRunStepResumeState,
+  stripRunStepResumeState,
+} from '@/tools/runStepResume';
 import {
   Callback,
   GraphEvents,
@@ -72,6 +85,7 @@ import {
 import { applyGraphRuntimeConfig } from '@/graphs/applyGraphRuntimeConfig';
 import { createTokenCounter, encodingForModel } from '@/utils/tokens';
 import { initializeLangfuseTracing } from './instrumentation';
+import { seedRunInitialSessions } from '@/utils/toolSessions';
 import { getTraceIdSeed } from '@/langfuseRuntimeContext';
 import { createGraph } from '@/graphs/createGraph';
 import { resolveMaxSeals } from '@/llm/preempt';
@@ -95,6 +109,7 @@ export const defaultOmitOptions = new Set([
 
 const ACTIVITY_LABEL_TRACE_NAME = 'LibreChat Activity Label';
 const ACTIVITY_PHASE_TRACE_NAME = 'LibreChat Activity Phase';
+const REASONING_LABEL_TRACE_NAME = 'LibreChat Reasoning Label';
 
 const CUSTOM_GRAPH_EVENTS = new Set<string>([
   GraphEvents.ON_AGENT_UPDATE,
@@ -173,7 +188,9 @@ function isLangGraphResumeMapForInterrupt(
 }
 
 function getInterruptHookSessionId(payload: unknown): string | undefined {
-  const publicPayload = stripSubagentResumeManifest(payload);
+  const publicPayload = stripSubagentResumeManifest(
+    stripRunStepResumeState(payload)
+  );
   if (
     publicPayload == null ||
     typeof publicPayload !== 'object' ||
@@ -193,11 +210,15 @@ type InterruptStateSnapshot = {
   values?: { messages?: BaseMessage[] };
   tasks?: Array<{
     interrupts?: Array<{ id?: string; value?: unknown }>;
+    state?: RunnableConfig | InterruptStateSnapshot;
   }>;
 };
 
 type WorkflowWithStateHistory = {
-  getState?(config: RunnableConfig): Promise<InterruptStateSnapshot>;
+  getState?(
+    config: RunnableConfig,
+    options?: { subgraphs?: boolean }
+  ): Promise<InterruptStateSnapshot>;
   getStateHistory?(
     config: RunnableConfig
   ): AsyncIterableIterator<InterruptStateSnapshot>;
@@ -215,6 +236,17 @@ function getFirstPersistedInterrupt(
         return { id: pendingInterrupt.id, value: pendingInterrupt.value };
       }
     }
+    const nestedState = task.state;
+    if (
+      nestedState != null &&
+      'tasks' in nestedState &&
+      Array.isArray(nestedState.tasks)
+    ) {
+      const nestedInterrupt = getFirstPersistedInterrupt(nestedState);
+      if (nestedInterrupt != null) {
+        return nestedInterrupt;
+      }
+    }
   }
   return undefined;
 }
@@ -290,6 +322,8 @@ export class Run<_T extends t.BaseGraphState> {
   private activityLabelSeq = 0;
   /** Per-run sequence for parent activity-phase trace and invocation ids. */
   private activityPhaseLabelSeq = 0;
+  /** Per-run sequence for reasoning-label trace and invocation ids. */
+  private reasoningLabelSeq = 0;
   /** Latest user turn used to keep detached phase roots conversation-shaped. */
   private activityPhaseTraceInput?: string;
   /** Distinguishes sibling forks started from the same explicit checkpoint. */
@@ -351,9 +385,25 @@ export class Run<_T extends t.BaseGraphState> {
     }
 
     if (config.initialSessions && this.Graph) {
-      for (const [key, value] of config.initialSessions) {
-        this.Graph.sessions.set(key, value);
-      }
+      const configuredAgents =
+        'agents' in config.graphConfig &&
+        Array.isArray(config.graphConfig.agents)
+          ? config.graphConfig.agents
+          : undefined;
+      const agents: Array<Pick<t.AgentInputs, 'codeSessionKey'>> =
+        configuredAgents ?? [
+          {
+            codeSessionKey:
+              'codeSessionKey' in config.graphConfig
+                ? config.graphConfig.codeSessionKey
+                : undefined,
+          },
+        ];
+      seedRunInitialSessions({
+        sessions: this.Graph.sessions,
+        initialSessions: config.initialSessions,
+        agents,
+      });
     }
 
     this.returnContent = config.returnContent ?? false;
@@ -949,6 +999,12 @@ export class Run<_T extends t.BaseGraphState> {
       delete config.configurable?.[SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY];
       delete config.configurable?.[SUBAGENT_RESUME_MANIFEST_CONFIG_KEY];
     }
+    if (isResume) {
+      await this.restoreInterruptFromCheckpoint(
+        config,
+        (inputs as Command).update
+      );
+    }
 
     /**
      * Cancellation can arrive either at graph construction or per-call through
@@ -1503,7 +1559,9 @@ export class Run<_T extends t.BaseGraphState> {
     }
     return {
       ...this._interrupt,
-      payload: stripSubagentResumeManifest(this._interrupt.payload),
+      payload: stripSubagentResumeManifest(
+        stripRunStepResumeState(this._interrupt.payload)
+      ),
     } as t.RunInterruptResult<TPayload>;
   }
 
@@ -1622,7 +1680,7 @@ export class Run<_T extends t.BaseGraphState> {
     await this.restoreInterruptFromCheckpoint(callerConfig, resumeUpdate);
     const interrupt = this._interrupt;
     const resumeManifest = requireValidSubagentResumeManifest(
-      interrupt?.payload
+      stripRunStepResumeState(interrupt?.payload)
     );
     const resumeConfigurable = { ...callerConfig.configurable };
     delete resumeConfigurable[SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY];
@@ -1709,7 +1767,7 @@ export class Run<_T extends t.BaseGraphState> {
     callerConfig: t.RunStreamConfig,
     resumeUpdate?: ResumeCommandUpdate
   ): Promise<void> {
-    if (this._interrupt != null || this.humanInTheLoop?.enabled !== true) {
+    if (this._interrupt != null || !this.hasCheckpointer) {
       return;
     }
     const workflow = this.graphRunnable as
@@ -1719,11 +1777,16 @@ export class Run<_T extends t.BaseGraphState> {
       return;
     }
 
-    const snapshot = await workflow.getState(callerConfig as RunnableConfig);
+    const snapshot = await workflow.getState(callerConfig as RunnableConfig, {
+      subgraphs: true,
+    });
     const persistedInterrupt = getFirstPersistedInterrupt(snapshot);
     if (persistedInterrupt == null) {
       return;
     }
+    this.Graph?.restoreRunStepResumeState(
+      getRunStepResumeState(persistedInterrupt.value)
+    );
     const persistedMessages = getPersistedMessages(snapshot);
     if (persistedMessages != null) {
       const resumeMessages = getResumeUpdateMessages(resumeUpdate);
@@ -2303,6 +2366,261 @@ export class Run<_T extends t.BaseGraphState> {
     }
   }
 
+  /**
+   * Generates one replacement title for a user-visible reasoning step. Hosts
+   * own accumulation, scheduling, revision ordering, durable delivery, and
+   * billing; the SDK only performs one bounded, redaction-aware generation.
+   */
+  async generateReasoningLabel({
+    provider,
+    clientOptions,
+    visibleReasoning,
+    reasoningStepId,
+    revision,
+    status = 'streaming',
+    previousLabel,
+    agentId,
+    prompt,
+    charLimit = 6_000,
+    chainOptions,
+    traceSeed,
+    sourceRunId,
+    sourceTraceId,
+    responseId,
+  }: t.RunReasoningLabelOptions): Promise<t.ReasoningLabelResult> {
+    const normalizedStepId = reasoningStepId.trim();
+    const snapshotChars = visibleReasoning.trim().length;
+    if (
+      normalizedStepId === '' ||
+      snapshotChars === 0 ||
+      !Number.isInteger(revision) ||
+      revision < 0
+    ) {
+      return {};
+    }
+
+    const reasoningSeq = ++this.reasoningLabelSeq;
+    const requestedContext =
+      this.Graph == null || agentId == null
+        ? undefined
+        : this.Graph.agentContexts.get(agentId);
+    if (agentId != null && requestedContext == null) {
+      return {};
+    }
+    if (agentId == null && (this.Graph?.agentContexts.size ?? 0) > 1) {
+      return {};
+    }
+    const reasoningContext =
+      this.Graph == null
+        ? undefined
+        : (requestedContext ??
+          this.Graph.agentContexts.get(this.Graph.defaultAgentId));
+    const reasoningChainOptions = {
+      ...(chainOptions ?? {}),
+    } as Partial<RunnableConfig> & {
+      configurable?: Record<string, unknown> & {
+        requestBody?: { parentMessageId?: unknown };
+      };
+    };
+    const reasoningUserId =
+      typeof reasoningChainOptions.configurable?.user_id === 'string'
+        ? reasoningChainOptions.configurable.user_id
+        : undefined;
+    const reasoningSessionId =
+      typeof reasoningChainOptions.configurable?.thread_id === 'string'
+        ? reasoningChainOptions.configurable.thread_id
+        : undefined;
+    const reasoningParentMessageId =
+      reasoningChainOptions.configurable?.requestBody?.parentMessageId;
+    const reasoningAgentId =
+      agentId ??
+      (this.Graph?.agentContexts.size === 1
+        ? this.Graph.defaultAgentId
+        : undefined);
+    const reasoningAgentName =
+      reasoningAgentId == null ? undefined : reasoningContext?.name;
+    const resolvedSourceRunId = sourceRunId ?? this.id;
+    const reasoningResponseId = responseId ?? this.id;
+    const reasoningMetadata: Record<string, unknown> = {
+      sourceRunId: resolvedSourceRunId,
+      ...(sourceTraceId == null ? {} : { sourceTraceId }),
+      responseId: reasoningResponseId,
+      reasoningStepId: normalizedStepId,
+      revision,
+      status,
+      snapshotChars,
+      ...(typeof reasoningParentMessageId === 'string'
+        ? { parentMessageId: reasoningParentMessageId }
+        : {}),
+      ...(reasoningAgentId == null ? {} : { agentId: reasoningAgentId }),
+      ...(reasoningAgentName == null ? {} : { agentName: reasoningAgentName }),
+    };
+    const traceMetadata = {
+      ...createLangfuseTraceMetadata({
+        messageId: `reasoning-label-${reasoningResponseId}`,
+        parentMessageId: reasoningParentMessageId,
+        agentId: reasoningAgentId,
+        agentName: reasoningAgentName,
+      }),
+      sourceRunId: resolvedSourceRunId,
+      ...(sourceTraceId == null ? {} : { sourceTraceId }),
+      responseId: reasoningResponseId,
+      reasoningStepId: normalizedStepId,
+      revision: String(revision),
+      status,
+      snapshotChars: String(snapshotChars),
+    };
+    const reasoningRunName =
+      reasoningChainOptions.runName ?? REASONING_LABEL_TRACE_NAME;
+    const reasoningTags = ['librechat', 'reasoning-label', 'reasoning-step'];
+    const reasoningLangfuseConfig = resolveLangfuseConfig(
+      this.langfuse,
+      reasoningContext?.langfuse
+    );
+    initializeLangfuseTracing(reasoningLangfuseConfig);
+
+    const inheritedTraceSeed = getTraceIdSeed();
+    const reasoningTraceSeed =
+      reasoningLangfuseConfig?.deterministicTraceId === true ||
+      inheritedTraceSeed != null
+        ? (traceSeed ??
+          buildReasoningLabelTraceSeed(
+            resolvedSourceRunId,
+            normalizedStepId,
+            revision
+          ))
+        : undefined;
+    const reasoningScopeRunId = `reasoning-label:${this.id}:${reasoningSeq}:${nanoid()}`;
+    const reasoningRuntimeScope = resolveLangfuseRuntimeScope({
+      runLangfuse: this.langfuse,
+      langfuseOverlay: reasoningContext?.langfuse,
+      traceIdSeed: reasoningTraceSeed,
+      runId: reasoningScopeRunId,
+    });
+    let reasoningLangfuseHandler: CallbackEntry | undefined;
+    if (reasoningSessionId != null) {
+      reasoningLangfuseHandler = createLangfuseHandler({
+        langfuse: reasoningLangfuseConfig,
+        userId: reasoningUserId,
+        sessionId: reasoningSessionId,
+        traceMetadata,
+        tags: reasoningTags,
+        traceIdSeed:
+          reasoningLangfuseConfig?.deterministicTraceId === true
+            ? reasoningTraceSeed
+            : undefined,
+        runId: reasoningScopeRunId,
+        toolOutputTracing: reasoningRuntimeScope.toolOutputTracing,
+        traceName: reasoningRunName,
+      });
+    }
+    if (reasoningLangfuseHandler != null) {
+      reasoningChainOptions.callbacks = appendCallbacks(
+        reasoningChainOptions.callbacks,
+        [reasoningLangfuseHandler]
+      );
+    }
+
+    const redaction = hasToolOutputTracingConfig(
+      this.langfuse,
+      reasoningContext?.langfuse
+    )
+      ? resolveToolOutputTracingConfig(
+        this.langfuse,
+        reasoningContext?.langfuse
+      )
+      : undefined;
+    const userPrompt = buildReasoningLabelPrompt({
+      visibleReasoning,
+      status,
+      charLimit,
+      previousLabel,
+      redaction,
+    });
+    if (userPrompt === '') {
+      await disposeLangfuseHandler(reasoningLangfuseHandler);
+      return {};
+    }
+
+    const model = initializeModel({
+      provider,
+      clientOptions: {
+        ...(clientOptions ?? {}),
+        streaming: false,
+      } as t.ClientOptions,
+    }) as t.ChatModelInstance;
+    const reasoningRunId = `${this.id}-reasoning-${reasoningSeq}`;
+    const invokeConfig = Object.assign({}, reasoningChainOptions, {
+      run_id: reasoningRunId,
+      runId: reasoningRunId,
+      runName: reasoningRunName,
+      tags: [
+        ...new Set([...(reasoningChainOptions.tags ?? []), ...reasoningTags]),
+      ],
+      metadata: {
+        ...(reasoningChainOptions.metadata ?? {}),
+        ...reasoningMetadata,
+      },
+    }) as Partial<RunnableConfig>;
+    const invokeLabel = (
+      runtimeConfig: Partial<RunnableConfig>
+    ): Promise<unknown> =>
+      withLangfuseAttributes(
+        {
+          langfuse: reasoningLangfuseConfig,
+          userId: reasoningUserId,
+          sessionId: reasoningSessionId,
+          traceName: reasoningRunName,
+          traceMetadata,
+          tags: reasoningTags,
+        },
+        () =>
+          model.invoke(
+            [
+              new SystemMessage(prompt ?? REASONING_LABEL_PROMPT),
+              new HumanMessage(userPrompt),
+            ],
+            runtimeConfig
+          )
+      );
+    const extractResult = (response: unknown): t.ReasoningLabelResult => {
+      const result = response as {
+        content?: unknown;
+        usage_metadata?: UsageMetadata;
+      } | null;
+      const content = result?.content;
+      let text = '';
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content
+          .map((block) =>
+            typeof block === 'string'
+              ? block
+              : ((block as { text?: string }).text ?? '')
+          )
+          .join('');
+      }
+      const label = normalizeReasoningLabel(text);
+      return {
+        ...(label === '' ? {} : { label }),
+        ...(result?.usage_metadata == null
+          ? {}
+          : { usage: result.usage_metadata }),
+      };
+    };
+
+    try {
+      const response = await withLangfuseRuntimeScope(
+        reasoningRuntimeScope,
+        () => invokeLabel(invokeConfig)
+      );
+      return extractResult(response);
+    } finally {
+      await disposeLangfuseHandler(reasoningLangfuseHandler);
+    }
+  }
+
   /**
    * Generates one parent summary for two or more logical activities. The
    * summary model is traced as a dedicated activity-phase chain root in the
@@ -2661,8 +2979,8 @@ function findActivityPhaseTraceInput(
     const message = messages[i];
     if (
       message.getType() !== 'human' ||
-      message.additional_kwargs?.role === 'system' ||
-      message.additional_kwargs?.isMeta === true
+      message.additional_kwargs.role === 'system' ||
+      message.additional_kwargs.isMeta === true
     ) {
       continue;
     }

package/src/stream.ts

@@ -169,7 +169,8 @@ function hasToolOutputReference(value: unknown): boolean {
 
 function isEagerExecutionExcludedTool(
   name: string,
-  graph: StandardGraph
+  graph: StandardGraph,
+  agentContext?: AgentContext
 ): boolean {
   if (name === '') {
     return false;
@@ -200,9 +201,21 @@ function isEagerExecutionExcludedTool(
   // args, ToolNode discards the eager result but the mutation has already
   // landed in the session workspace, corrupting later runs. Stateless mode
   // uses a throwaway VM per call, so eager prestart stays safe there.
+  if (!CODE_EXECUTION_TOOLS.has(name)) {
+    return false;
+  }
+  if (graph.toolExecution?.sandbox?.statefulSessions === true) {
+    return true;
+  }
+  // A non-default code-session partition is the trusted per-agent signal that
+  // this call must remain isolated from the graph-wide stateless session. The
+  // actual tool factory may route it to a durable backend, which the stream
+  // layer cannot inspect in event-driven mode. Conservatively avoid speculative
+  // execution for these calls so discarded eager results cannot mutate that
+  // agent's workspace.
   return (
-    graph.toolExecution?.sandbox?.statefulSessions === true &&
-    CODE_EXECUTION_TOOLS.has(name)
+    agentContext?.codeSessionKey != null &&
+    agentContext.codeSessionKey !== Constants.EXECUTE_CODE
   );
 }
 
@@ -258,7 +271,8 @@ function toCodeEnvFile(file: t.FileRef, execSessionId: string): t.CodeEnvFile {
 
 function getCodeSessionContext(
   graph: StandardGraph,
-  name: string
+  name: string,
+  agentContext?: AgentContext
 ): t.ToolCallRequest['codeSessionContext'] | undefined {
   if (
     !CODE_EXECUTION_TOOLS.has(name) &&
@@ -269,9 +283,9 @@ function getCodeSessionContext(
     return undefined;
   }
 
-  const codeSession = graph.sessions.get(Constants.EXECUTE_CODE) as
-    | t.CodeSessionContext
-    | undefined;
+  const codeSession = graph.sessions.get(
+    agentContext?.codeSessionKey ?? Constants.EXECUTE_CODE
+  ) as t.CodeSessionContext | undefined;
   if (codeSession?.session_id == null || codeSession.session_id === '') {
     return undefined;
   }
@@ -716,7 +730,8 @@ function createEagerToolExecutionPlan(args: {
   // tool from `hasDirectToolCallInBatch`. Excluded calls fall through to normal
   // ToolNode execution; siblings may still eager-execute.
   const candidateToolCalls = unstartedToolCalls.filter(
-    (toolCall) => !isEagerExecutionExcludedTool(toolCall.name, graph)
+    (toolCall) =>
+      !isEagerExecutionExcludedTool(toolCall.name, graph, agentContext)
   );
   if (candidateToolCalls.length === 0) {
     return [];
@@ -748,7 +763,11 @@ function createEagerToolExecutionPlan(args: {
       name: toolCall.name,
       args: toolCall.args,
       stepId: graph.toolCallStepIds.get(toolCall.id!) ?? '',
-      codeSessionContext: getCodeSessionContext(graph, toolCall.name),
+      codeSessionContext: getCodeSessionContext(
+        graph,
+        toolCall.name,
+        agentContext
+      ),
     })),
     usageCount: graph.getEagerEventToolUsageCount(agentContext?.agentId),
   });

package/src/tools/BashExecutor.ts

@@ -8,12 +8,15 @@ import {
   appendFailedExecutionFileReminder,
   appendTmpScratchReminder,
   appendCodeSessionFileSummary,
+  addCodeApiExecutionProfileHeader,
   emptyOutputMessage,
   buildCodeApiHttpErrorMessage,
   CodeApiRequestError,
+  buildCodeApiEndpoint,
   getCodeBaseURL,
   normalizeCodeApiRequestError,
   resolveCodeApiAuthHeaders,
+  selectRuntimeSessionHint,
 } from './CodeExecutor';
 import { resolveFetchProxyAgent } from '@/utils/proxy';
 import { INTENT_PROPERTY } from '@/tools/intentArg';
@@ -21,9 +24,6 @@ import { Constants } from '@/common';
 
 config();
 
-const baseEndpoint = getCodeBaseURL();
-const EXEC_ENDPOINT = `${baseEndpoint}/exec`;
-
 export const BashExecutionToolSchema = {
   type: 'object',
   properties: {
@@ -177,15 +177,24 @@ export const BashExecutionToolDefinition = {
 function createBashExecutionTool(
   params: t.BashExecutionToolParams | null = {}
 ): DynamicStructuredTool {
+  const execEndpoint = buildCodeApiEndpoint(
+    params?.baseUrl ?? getCodeBaseURL(),
+    'exec'
+  );
+
   return tool(
     async (rawInput, config) => {
-      /* `statefulSessions` is prompt-only — keep it out of the wire body. */
+      /* `statefulSessions` drives the prompt and gates runtime affinity hints;
+       * keep the flag itself out of the wire body. */
       const {
         authHeaders,
-        statefulSessions: _statefulSessions,
+        baseUrl: _baseUrl,
+        executionProfile,
+        runtimeSessionHint,
+        statefulSessions,
         ...executionParams
       } = params ?? {};
-      void _statefulSessions;
+      void _baseUrl;
       /* Drop any model-supplied `runtime_session_hint` from the raw args: the
        * hint must only come from ToolNode's injected `_runtime_session_hint`
        * (below), never from the tool call itself. */
@@ -217,11 +226,17 @@ function createBashExecutionTool(
         ...executionParams,
       };
 
+      const effectiveRuntimeSessionHint = selectRuntimeSessionHint(
+        runtimeSessionHint,
+        _runtime_session_hint
+      );
       if (
-        typeof _runtime_session_hint === 'string' &&
-        _runtime_session_hint !== ''
+        statefulSessions === true &&
+        executionProfile !== 'default' &&
+        typeof effectiveRuntimeSessionHint === 'string' &&
+        effectiveRuntimeSessionHint !== ''
       ) {
-        postData.runtime_session_hint = _runtime_session_hint;
+        postData.runtime_session_hint = effectiveRuntimeSessionHint;
       }
 
       /* See `CodeExecutor.ts` for the rationale — `/files/<session_id>`
@@ -248,19 +263,22 @@ function createBashExecutionTool(
           headers: {
             'Content-Type': 'application/json',
             'User-Agent': 'LibreChat/1.0',
-            ...resolvedAuthHeaders,
+            ...addCodeApiExecutionProfileHeader(
+              resolvedAuthHeaders,
+              executionProfile
+            ),
           },
           body: JSON.stringify(postData),
         };
 
-        const proxyAgent = resolveFetchProxyAgent(EXEC_ENDPOINT);
+        const proxyAgent = resolveFetchProxyAgent(execEndpoint);
         if (proxyAgent) {
           fetchOptions.agent = proxyAgent;
         }
-        const response = await fetch(EXEC_ENDPOINT, fetchOptions);
+        const response = await fetch(execEndpoint, fetchOptions);
         if (!response.ok) {
           throw new CodeApiRequestError(
-            await buildCodeApiHttpErrorMessage('POST', EXEC_ENDPOINT, response)
+            await buildCodeApiHttpErrorMessage('POST', execEndpoint, response)
           );
         }