@librechat/agents 3.8.0 → 3.8.1

package/src/session/AgentSession.ts

@@ -21,9 +21,12 @@ import type {
   SessionEntry,
   SessionForkOptions,
 } from './types';
-import { isFadingTier } from '@/messages/fading';
 import type { HookRegistry } from '@/hooks';
 import type * as t from '@/types';
+import {
+  deriveSessionMessages,
+  releaseSessionProjection,
+} from './sessionProjection';
 import { createSummarizeNode } from '@/summarization/node';
 import { resolveStreamLimits } from '@/llm/streamLimits';
 import { JsonlSessionStore } from './JsonlSessionStore';
@@ -31,6 +34,7 @@ import { AgentContext } from '@/agents/AgentContext';
 import { ContentTypes, GraphEvents } from '@/common';
 import { createRunId, createSessionId } from './ids';
 import { deriveMessages } from './deriveMessages';
+import { isFadingTier } from '@/messages/fading';
 import { createRunHandlers } from './handlers';
 import { Run } from '@/run';
 
@@ -377,7 +381,9 @@ function fadingGenerationKey(scopeKey: string, agentKey: string): string {
 
 function fadingGenerationScope(generationKey: string): string {
   const parsed: unknown = JSON.parse(generationKey);
-  return Array.isArray(parsed) && typeof parsed[0] === 'string' ? parsed[0] : '';
+  return Array.isArray(parsed) && typeof parsed[0] === 'string'
+    ? parsed[0]
+    : '';
 }
 
 /** What a run saw when it started, so its capture can tell stale from current. */
@@ -404,10 +410,7 @@ function mergeFadingTier(
   if (incoming == null) {
     return { ...current };
   }
-  const budgetTokens = Math.min(
-    current.budgetTokens,
-    incoming.budgetTokens
-  );
+  const budgetTokens = Math.min(current.budgetTokens, incoming.budgetTokens);
   const masked = current.masked || incoming.masked;
   const latched =
     current.latched === true ||
@@ -1010,6 +1013,9 @@ export class AgentSession {
   }
 
   getSessionStore(): JsonlSessionStore | undefined {
+    if (this.store) {
+      releaseSessionProjection(this.store);
+    }
     return this.store;
   }
 
@@ -1017,7 +1023,10 @@ export class AgentSession {
     return this.checkpointing.checkpointer;
   }
 
-  private getFadingState(threadId: string, checkpointNs = ''): {
+  private getFadingState(
+    threadId: string,
+    checkpointNs = ''
+  ): {
     fadingTier?: t.FadingTier;
     fadingTiers?: t.FadingTiers;
   } {
@@ -1058,8 +1067,7 @@ export class AgentSession {
 
   private trimAlternateFadingStates(): void {
     while (
-      this.alternateThreadFadingState.size >
-      MAX_ALTERNATE_THREAD_FADING_STATES
+      this.alternateThreadFadingState.size > MAX_ALTERNATE_THREAD_FADING_STATES
     ) {
       const oldestThreadId = this.alternateThreadFadingState.keys().next();
       if (oldestThreadId.done === true) {
@@ -1172,7 +1180,10 @@ export class AgentSession {
     };
     const advanceGeneration = (agentKey: string): void => {
       const key = fadingGenerationKey(scopeKey, agentKey);
-      this.fadingGenerations.set(key, (this.fadingGenerations.get(key) ?? 0) + 1);
+      this.fadingGenerations.set(
+        key,
+        (this.fadingGenerations.get(key) ?? 0) + 1
+      );
     };
     const mergeCapturedTier = (
       existing: t.FadingTier | undefined,
@@ -1218,7 +1229,11 @@ export class AgentSession {
       if (didResetTier) {
         advanceGeneration('');
       }
-      nextTier = mergeCapturedTier(current.fadingTier, incomingTier, didResetTier);
+      nextTier = mergeCapturedTier(
+        current.fadingTier,
+        incomingTier,
+        didResetTier
+      );
     }
     if (threadId === this.threadId && checkpointNs === '') {
       this.fadingTier = nextTier;
@@ -1408,8 +1423,8 @@ export class AgentSession {
       handlerResult.events.push(streamEvent);
       onEvent?.(streamEvent);
     };
-    const sessionState = deriveMessages(
-      isSessionThread ? (this.store?.getPath() ?? []) : []
+    const sessionState = deriveSessionMessages(
+      isSessionThread ? this.store : undefined
     );
     const fadingState = this.getFadingState(threadId, checkpointNs);
     let run: Run<t.IState> | undefined;
@@ -1690,7 +1705,9 @@ export class AgentSession {
       throw new Error('Cannot compact an ephemeral session');
     }
     const activePath = path ?? store.getPath();
-    const sessionState = deriveMessages(activePath);
+    const sessionState = path
+      ? deriveMessages(path)
+      : deriveSessionMessages(store);
     const messageEntries = activePath.filter(isMessageEntry);
     if (sessionState.messages.length === 0) {
       return undefined;
@@ -1819,8 +1836,8 @@ export class AgentSession {
       threadId,
       userHandlers: this.runConfig.customHandlers,
     });
-    const sessionState = deriveMessages(
-      isSessionThread ? (this.store?.getPath() ?? []) : []
+    const sessionState = deriveSessionMessages(
+      isSessionThread ? this.store : undefined
     );
     const fadingState = this.getFadingState(threadId, checkpointNs);
     let run: Run<t.IState> | undefined;

package/src/session/JsonlSessionStore.ts

@@ -35,6 +35,10 @@ import {
   serializeMessage,
   toJsonValue,
 } from './messageSerialization';
+import {
+  initializeSessionProjection,
+  shareSessionProjectionOwnership,
+} from './sessionProjection';
 import { createEntryId, createSessionId, createTimestamp } from './ids';
 
 const SESSION_VERSION = 1;
@@ -126,6 +130,7 @@ export class JsonlSessionStore {
     this.path = params.path;
     this.header = params.header;
     this.entries = sortEntries(params.entries);
+    initializeSessionProjection(this, this.entries);
   }
 
   static getDefaultRoot(): string {
@@ -573,6 +578,7 @@ export class JsonlSessionStore {
       name: options.name ?? this.header.name,
       parentSession: this.path,
     });
+    shareSessionProjectionOwnership(this, newStore);
     const pathEntries = target ? this.getPath(target.id) : [];
     for (const entry of pathEntries) {
       await newStore.appendExistingEntry(entry);

package/src/session/sessionProjection.ts

@@ -0,0 +1,126 @@
+import type { DerivedSessionMessages } from './deriveMessages';
+import type { SessionEntry, SessionStateEntry } from './types';
+import type { JsonlSessionStore } from './JsonlSessionStore';
+import { deriveMessages } from './deriveMessages';
+
+interface SessionProjection {
+  entries: readonly SessionEntry[];
+  ownership: { exposed: boolean };
+  indexedCount: number;
+  byId: Map<string, SessionEntry>;
+  lastState?: SessionStateEntry;
+  lastMessage?: SessionEntry;
+  leaf?: SessionEntry;
+  projected: SessionEntry[];
+}
+
+const projections = new WeakMap<JsonlSessionStore, SessionProjection>();
+
+/** Internal: only AgentSession's unexposed stores may reuse log topology. */
+export function initializeSessionProjection(
+  store: JsonlSessionStore,
+  entries: readonly SessionEntry[]
+): void {
+  projections.set(store, {
+    entries,
+    ownership: { exposed: false },
+    indexedCount: 0,
+    byId: new Map(),
+    projected: [],
+  });
+}
+
+/** Forks share entry references, so exposing either disables the whole family. */
+export function shareSessionProjectionOwnership(
+  source: JsonlSessionStore,
+  target: JsonlSessionStore
+): void {
+  const sourceProjection = projections.get(source);
+  const targetProjection = projections.get(target);
+  if (sourceProjection && targetProjection) {
+    targetProjection.ownership = sourceProjection.ownership;
+  }
+}
+
+export function releaseSessionProjection(store: JsonlSessionStore): void {
+  const projection = projections.get(store);
+  if (projection) {
+    projection.ownership.exposed = true;
+    projection.byId.clear();
+    projection.projected = [];
+    projection.leaf = undefined;
+  }
+}
+
+function indexAppends(projection: SessionProjection): boolean {
+  for (
+    ;
+    projection.indexedCount < projection.entries.length;
+    projection.indexedCount++
+  ) {
+    const entry = projection.entries[projection.indexedCount];
+    if (projection.byId.has(entry.id)) {
+      return false;
+    }
+    projection.byId.set(entry.id, entry);
+    if (entry.type === 'session_state') {
+      projection.lastState = entry;
+    } else if (entry.type === 'message' || entry.type === 'summary') {
+      projection.lastMessage = entry;
+    }
+  }
+  return true;
+}
+
+function projectLeaf(projection: SessionProjection): void {
+  const leafId = projection.lastState
+    ? projection.lastState.data.leafId
+    : projection.lastMessage?.id;
+  const leaf =
+    leafId != null && leafId !== '' ? projection.byId.get(leafId) : undefined;
+  if (leaf === projection.leaf) {
+    return;
+  }
+  const delta: SessionEntry[] = [];
+  let current = leaf;
+  while (current && current !== projection.leaf) {
+    if (current.type === 'message' || current.type === 'summary') {
+      delta.push(current);
+    }
+    if (current.type === 'summary') {
+      current = undefined;
+      break;
+    }
+    current =
+      current.parentId == null
+        ? undefined
+        : projection.byId.get(current.parentId);
+  }
+  if (!current) {
+    projection.projected = [];
+  }
+  for (let i = delta.length - 1; i >= 0; i--) {
+    projection.projected.push(delta[i]);
+  }
+  projection.leaf = leaf;
+}
+
+/** Reuses log topology, but materializes fresh mutable messages for every run. */
+export function deriveSessionMessages(
+  store: JsonlSessionStore | undefined
+): DerivedSessionMessages {
+  if (!store) {
+    return { messages: [] };
+  }
+  const projection = projections.get(store);
+  if (!projection || projection.ownership.exposed) {
+    releaseSessionProjection(store);
+    return deriveMessages(store.getPath());
+  }
+  if (!indexAppends(projection)) {
+    releaseSessionProjection(store);
+    return deriveMessages(store.getPath());
+  }
+  projectLeaf(projection);
+  return deriveMessages(projection.projected);
+}

package/src/stream.ts

@@ -1014,18 +1014,6 @@ function pruneEagerToolCallChunkStates(args: {
   }
 }
 
-function isEagerToolChunkStateComplete(
-  state: t.EagerEventToolCallChunkState
-): boolean {
-  return (
-    state.id != null &&
-    state.id !== '' &&
-    state.name != null &&
-    state.name !== '' &&
-    coerceRecordArgs(state.argsText) != null
-  );
-}
-
 function mergeToolCallArgsText(existing: string, incoming: string): string {
   if (incoming === '') {
     return existing;
@@ -1180,6 +1168,7 @@ function getStreamedReadyToolCalls(args: {
     key: string;
     state: t.EagerEventToolCallChunkState;
     sealedByAdapter: boolean;
+    parsedArgs: ToolCall['args'];
   }> = [];
 
   for (const [key, state] of graph.eagerEventToolCallChunks) {
@@ -1190,7 +1179,12 @@ function getStreamedReadyToolCalls(args: {
       graph.eagerEventToolCallChunks.delete(key);
       continue;
     }
-    if (!isEagerToolChunkStateComplete(state)) {
+    if (
+      state.id == null ||
+      state.id === '' ||
+      state.name == null ||
+      state.name === ''
+    ) {
       continue;
     }
     const isSealedByLaterChunk =
@@ -1209,10 +1203,15 @@ function getStreamedReadyToolCalls(args: {
       isSealedByLaterChunk ||
       isSealedExplicitly
     ) {
+      const parsedArgs = coerceRecordArgs(state.argsText);
+      if (parsedArgs == null) {
+        continue;
+      }
       readyEntries.push({
         key,
         state,
         sealedByAdapter: isSealedExplicitly || seal?.kind === 'all',
+        parsedArgs,
       });
     }
   }
@@ -1232,11 +1231,7 @@ function getStreamedReadyToolCalls(args: {
 
   return readyEntries
     .sort((left, right) => (left.state.index ?? 0) - (right.state.index ?? 0))
-    .flatMap(({ state, sealedByAdapter }) => {
-      const args = coerceRecordArgs(state.argsText);
-      if (args == null) {
-        return [];
-      }
+    .flatMap(({ state, sealedByAdapter, parsedArgs }) => {
       // The final request's args come from LangChain's canonical verbatim
       // concatenation of fragments, while `argsText` reconciles provider
       // quirks with lossy heuristics that can also swallow legitimately
@@ -1267,7 +1262,7 @@ function getStreamedReadyToolCalls(args: {
         {
           id: state.id,
           name: state.name ?? '',
-          args,
+          args: parsedArgs,
         },
       ];
     });

package/src/summarization/index.ts

@@ -9,7 +9,9 @@ export {
   buildSummarizationInstruction,
   buildSummaryCarrierText,
   separateSummarizationParameters,
+  ManualSummarizationSkippedError,
 } from './shared';
+export type { ManualSummarizationSkipReason } from './shared';
 
 const VALID_TRIGGER_TYPES = [
   'token_ratio',

package/src/summarization/node.ts

@@ -14,6 +14,7 @@ import {
   buildSummaryCarrierText,
   separateSummarizationParameters,
   buildSummarizationInstruction,
+  ManualSummarizationSkippedError,
 } from './shared';
 import {
   addTailCacheControl,
@@ -1026,6 +1027,14 @@ function findStreamLimitAbortReason(
   return undefined;
 }
 
+/** Wording for the history-preserved log and completion, by request reason. */
+const PRESERVATION_REASONS: Partial<
+  Record<NonNullable<t.SummarizationNodeInput['reason']>, string>
+> = {
+  overflow: 'overflow recovery',
+  manual: 'manual compaction',
+};
+
 export function createSummarizeNode({
   agentContext,
   graph: adapterGraph,
@@ -1037,7 +1046,11 @@ export function createSummarizeNode({
       summarizationRequest?: t.SummarizationNodeInput;
     },
     config?: RunnableConfig
-  ): Promise<{ summarizationRequest: undefined; messages?: BaseMessage[] }> => {
+  ): Promise<{
+    summarizationRequest: undefined;
+    messages?: BaseMessage[];
+    manualSummary?: string;
+  }> => {
     /** The breaker signal is captured at node ENTRY, before dispatchRunStep,
      * ON_SUMMARIZE_START, or PreCompact awaits: a sibling's trip plus a
      * prompt next run can reset the controller during one of those awaits,
@@ -1114,6 +1127,12 @@ export function createSummarizeNode({
      * its recursion budget dispatching empty summary steps.
      */
     if (agentContext.summarizationExhausted) {
+      if (request.reason === 'manual') {
+        throw new ManualSummarizationSkippedError(
+          'exhausted',
+          'Compaction skipped: consecutive summarization attempts produced no usable summary'
+        );
+      }
       emitAgentLog(
         config,
         'warn',
@@ -1131,6 +1150,12 @@ export function createSummarizeNode({
 
     const maxCtx = agentContext.maxContextTokens ?? 0;
     if (maxCtx > 0 && agentContext.instructionTokens >= maxCtx) {
+      if (request.reason === 'manual') {
+        throw new ManualSummarizationSkippedError(
+          'instructions_exceed_budget',
+          'Compaction skipped: instructions and tool definitions exceed the context budget'
+        );
+      }
       emitAgentLog(
         config,
         'warn',
@@ -1167,6 +1192,16 @@ export function createSummarizeNode({
     const runnableConfig = config ?? graph.config;
 
     const retainRecent = agentContext.summarizationConfig?.retainRecent;
+    /**
+     * A manual summary is the user asking for the whole history to become a
+     * checkpoint, so the default recency window does not apply to it. A
+     * `retainRecent` the host configured explicitly still keeps its tail,
+     * with the ordinary turn default when it only sets a token cap.
+     */
+    const retainTurns =
+      request.reason === 'manual' && retainRecent == null
+        ? 0
+        : (retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS);
     const recencyTokenCounter =
       agentContext.contextPressureTokenCounts?.count ??
       agentContext.tokenCounter;
@@ -1175,7 +1210,8 @@ export function createSummarizeNode({
       tailStartIndex,
       usedIntraTurnFallback,
     } = splitAtRecencyBoundary(restoredMessages, {
-      turns: retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS,
+      provider: agentContext.provider,
+      turns: retainTurns,
       tokens: retainRecent?.tokens,
       tokenCounter: recencyTokenCounter,
       intraTurnTokens: resolveIntraTurnRetainTokens({
@@ -1198,6 +1234,12 @@ export function createSummarizeNode({
     const messagesToRetain = state.messages.slice(tailStartIndex);
 
     if (messagesToRefine.length === 0) {
+      if (request.reason === 'manual') {
+        throw new ManualSummarizationSkippedError(
+          'nothing_to_summarize',
+          'Nothing to compact: the retained recent turns cover the whole conversation'
+        );
+      }
       /**
        * Recency window covers the entire conversation — there is no
        * older content to summarize.  Skipping prevents the model from
@@ -1213,7 +1255,7 @@ export function createSummarizeNode({
         'Summarization skipped — recency window retains all messages',
         {
           messagesRetained: messagesToRetain.length,
-          retainTurns: retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS,
+          retainTurns,
         },
         { runId: graph.runId, agentId: request.agentId }
       );
@@ -1290,7 +1332,10 @@ export function createSummarizeNode({
           threadId,
           agentId: request.agentId,
           messagesBeforeCount: messagesToRefine.length,
-          trigger: agentContext.summarizationConfig?.trigger?.type ?? 'default',
+          trigger:
+            request.reason === 'manual'
+              ? 'manual'
+              : (agentContext.summarizationConfig?.trigger?.type ?? 'default'),
         },
         sessionId,
       }).catch(() => {
@@ -1340,7 +1385,7 @@ export function createSummarizeNode({
           compaction_semantic_index_entries: semanticIndex.entryCount,
           compaction_semantic_index_chars: semanticIndex.charCount,
           compaction_semantic_index_omitted_entries:
-            semanticIndex.omittedEntryCount,
+              semanticIndex.omittedEntryCount,
           /**
              * Per-call model attribution for usage consumers (the subagent
              * usage-capture handler): the summarizer's model can differ from
@@ -1398,19 +1443,21 @@ export function createSummarizeNode({
     /**
      * The metadata stub describes the history rather than summarizing it, so
      * committing it means removing the head and keeping nothing of what it
-     * said. That trade is never worth making to paper over an overflow: the
-     * recovery would "succeed" only by destroying the conversation it was
-     * supposed to preserve. Leave state untouched and let the provider error
-     * surface instead.
+     * said. That trade is never worth making to paper over an overflow, and
+     * never for a manual compaction, which would replace the whole history
+     * with a message count: the recovery would "succeed" only by destroying
+     * the conversation it was supposed to preserve. Leave state untouched
+     * and let the provider error surface instead.
      */
     if (
       usedMetadataStub === true &&
-      (request.reason === 'overflow' || usedIntraTurnFallback)
+      (request.reason === 'overflow' ||
+        request.reason === 'manual' ||
+        usedIntraTurnFallback)
     ) {
       const preservationReason =
-        request.reason === 'overflow'
-          ? 'overflow recovery'
-          : 'intra-turn compaction';
+        PRESERVATION_REASONS[request.reason ?? 'trigger'] ??
+        'intra-turn compaction';
       log(
         'warn',
         `Summarization failed during ${preservationReason}; keeping history rather than replacing it with a metadata stub`
@@ -1570,6 +1617,8 @@ export function createSummarizeNode({
         messagesToRetain.length > 0
           ? [createRemoveAllMessage(), ...messagesToRetain]
           : [createRemoveAllMessage()],
+      /** The run's result, for trace roots that otherwise see no reply. */
+      ...(request.reason === 'manual' ? { manualSummary: summaryText } : {}),
     };
   };
 }

package/src/summarization/shared.ts

@@ -128,3 +128,26 @@ export function buildSummarizationInstruction(
   }
   return parts.join('');
 }
+
+/** Why a summarize-only run could not attempt its summary. */
+export type ManualSummarizationSkipReason =
+  | 'disabled'
+  | 'exhausted'
+  | 'instructions_exceed_budget'
+  | 'nothing_to_summarize';
+
+/**
+ * A summarize-only run asked for a summary the graph could not attempt.
+ * Thrown rather than ending the run quietly: the summary is the whole result
+ * of such a run, so a host left with neither a summary nor an error would
+ * have nothing to show the user.
+ */
+export class ManualSummarizationSkippedError extends Error {
+  readonly reason: ManualSummarizationSkipReason;
+
+  constructor(reason: ManualSummarizationSkipReason, message: string) {
+    super(message);
+    this.name = 'ManualSummarizationSkippedError';
+    this.reason = reason;
+  }
+}

package/src/types/graph.ts

@@ -81,6 +81,13 @@ export type SystemCallbacks = {
 export type BaseGraphState = {
   messages: BaseMessage[];
   runStepState?: RunStepResumeState;
+  /**
+   * The summary a summarize-only run produced. Kept in state because such a
+   * run has no assistant reply: trace roots report it as the run's output
+   * instead of the retained tail or the raw state. Empty once any later run
+   * on the same checkpointed thread starts, so it never outlives its run.
+   */
+  manualSummary?: string;
 };
 
 export type AgentSubgraphState = BaseGraphState & {
@@ -906,6 +913,19 @@ interface AgentInputFields {
    */
   discoveredTools?: string[];
   summarizationEnabled?: boolean;
+  /**
+   * Runs this agent as a summarize-only pass: the first model step requests
+   * summarization outright instead of consulting the trigger, and the step
+   * after the summary emits its context snapshot and ends the run without a
+   * model call. Hosts use it for user-initiated compaction, where the summary
+   * is the whole response. Requires `summarizationEnabled`: a run that cannot
+   * attempt the summary rejects with `ManualSummarizationSkippedError`
+   * rather than ending with nothing, and one whose provider calls all fail
+   * keeps the history and reports the failure on the summary step. A
+   * multi-agent workflow compiles to the agent that opted in alone; no other
+   * agent runs.
+   */
+  summarizeOnly?: boolean;
   summarizationConfig?: SummarizationConfig;
   /**
    * Optional host-supplied, user-visible guidance for compaction. The SDK

package/src/types/run.ts

@@ -475,6 +475,10 @@ export type TokenBudgetBreakdown = {
   toolTokenCounts?: Record<string, number>;
   /** Names of counted tools that are deferred (`defer_loading`) and discovered. */
   deferredToolNames?: string[];
+  /** Calibrated retained tool traffic: tool results plus assistant turns made only of tool calls, inline provider tool results and reasoning. A subset of messageTokens, not an additional budget category. */
+  toolMessageTokens?: number;
+  /** Per-tool result-message share; excludes assistant invocation overhead. */
+  toolMessageTokenCounts?: Record<string, number>;
 };
 
 export type EventStreamOptions = {

package/src/types/summarize.ts

@@ -127,8 +127,11 @@ export interface SummarizationNodeInput {
    *   is compacting to recover. When summarization is not enabled, this
    *   variant performs no model call — the corrected budget alone is what the
    *   retry needs.
+   * - `manual`: the host asked for a summary outright (a summarize-only run).
+   *   The recency window is not applied unless the host configured
+   *   `retainRecent` explicitly, so the summary replaces the whole history.
    */
-  reason?: 'trigger' | 'overflow';
+  reason?: 'trigger' | 'overflow' | 'manual';
   /**
    * Whether an overflow recovery may spend a summarization model call.
    *

package/src/utils/events.ts

@@ -2,7 +2,9 @@
 // src/utils/events.ts
 import { dispatchCustomEvent } from '@langchain/core/callbacks/dispatch';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolExecuteBatchRequest } from '@/types/tools';
 import type { AgentLogEvent } from '@/types/graph';
+import { traceHostToolResults } from '@/langfuse';
 import { GraphEvents } from '@/common';
 
 /**
@@ -15,6 +17,23 @@ export async function safeDispatchCustomEvent(
   config?: RunnableConfig
 ): Promise<boolean | void> {
   try {
+    if (event === GraphEvents.ON_TOOL_EXECUTE) {
+      const request = payload as ToolExecuteBatchRequest;
+      payload = {
+        ...request,
+        resolve: (
+          results: Parameters<ToolExecuteBatchRequest['resolve']>[0]
+        ): void => {
+          void traceHostToolResults(request, results, config).then(
+            () => request.resolve(results),
+            () => {
+              console.warn('Failed to record host tool execution metadata');
+              request.resolve(results);
+            }
+          );
+        },
+      } satisfies ToolExecuteBatchRequest;
+    }
     await dispatchCustomEvent(event, payload, config);
     return true;
   } catch (e) {