refactor: optimize interrupt handling and remove unnecessary logging in agent flow

Author: NoOne7135

application/runTurnUseCase.ts

@@ -244,15 +244,17 @@ export class RunTurnUseCase {
     interrupt: unknown,
     descriptors: PendingInterrupt[],
   ) {
-    const existing = this.pendingInterrupts.get(prepared.sessionId) ?? [];
-    const merged = new Map(existing.map((item) => [item.id, item.count]));
-    for (const item of descriptors) {
-      merged.set(item.id, item.count);
+    if (!this.deps.hasPersistentCheckpointer) {
+      const existing = this.pendingInterrupts.get(prepared.sessionId) ?? [];
+      const merged = new Map(existing.map((item) => [item.id, item.count]));
+      for (const item of descriptors) {
+        merged.set(item.id, item.count);
+      }
+      this.pendingInterrupts.set(
+        prepared.sessionId,
+        [...merged.entries()].map(([id, count]) => ({ id, count })),
+      );
     }
-    this.pendingInterrupts.set(
-      prepared.sessionId,
-      [...merged.entries()].map(([id, count]) => ({ id, count })),
-    );
     await prepared.observability.emit?.({
       type: "interrupt",
       sessionId: prepared.sessionId,
@@ -312,7 +314,7 @@ export class RunTurnUseCase {
       await textBuffer.flush(emit);
       return { text: fullResponse };
     } finally {
-      if (!interrupted) {
+      if (!this.deps.hasPersistentCheckpointer && !interrupted) {
         this.pendingInterrupts.delete(prepared.sessionId);
       }
     }

llm/agentModels.ts

@@ -1,6 +1,5 @@
 import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import {
-  logger,
   type CompletionAdapter,
 } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
@@ -35,19 +34,8 @@ type AgentChatModelSpec = {
   middleware: AgentMiddleware[];
 };
 
-type LlmOutputTokenUsage = {
-  promptTokens?: unknown;
-  completionTokens?: unknown;
-};
-
-type MessageUsageMetadata = {
-  input_tokens?: unknown;
-  output_tokens?: unknown;
-};
-
 type PendingLlmRun = {
   startedAt: number;
-  firstTokenAt?: number;
 };
 
 function isLangChainAgentCompletionAdapter(
@@ -73,61 +61,6 @@ async function getAgentChatModelSpec(params: {
   };
 }
 
-function getFiniteNumber(value: unknown) {
-  return typeof value === "number" && Number.isFinite(value)
-    ? value
-    : undefined;
-}
-
-function extractTokenUsage(output: LLMResult) {
-  const llmOutputTokenUsage = (
-    output.llmOutput as { tokenUsage?: LlmOutputTokenUsage } | undefined
-  )?.tokenUsage;
-
-  const promptTokens = getFiniteNumber(llmOutputTokenUsage?.promptTokens);
-  const completionTokens = getFiniteNumber(
-    llmOutputTokenUsage?.completionTokens,
-  );
-
-  if (promptTokens !== undefined || completionTokens !== undefined) {
-    return {
-      InputTokens: promptTokens ?? 0,
-      outputTokens: completionTokens ?? 0,
-    };
-  }
-
-  let InputTokens = 0;
-  let outputTokens = 0;
-
-  for (const generationBatch of output.generations) {
-    for (const generation of generationBatch) {
-      if (!("message" in generation) || !generation.message) {
-        continue;
-      }
-
-      const message = generation.message as {
-        usage_metadata?: MessageUsageMetadata;
-        response_metadata?: {
-          tokenUsage?: LlmOutputTokenUsage;
-        };
-      };
-
-      InputTokens +=
-        getFiniteNumber(message.usage_metadata?.input_tokens) ??
-        getFiniteNumber(message.response_metadata?.tokenUsage?.promptTokens) ??
-        0;
-      outputTokens +=
-        getFiniteNumber(message.usage_metadata?.output_tokens) ??
-        getFiniteNumber(
-          message.response_metadata?.tokenUsage?.completionTokens,
-        ) ??
-        0;
-    }
-  }
-
-  return { InputTokens, outputTokens };
-}
-
 class AgentLlmMetricsLogger extends BaseCallbackHandler {
   name = "AgentLlmMetricsLogger";
   lc_prefer_streaming = true;
@@ -138,41 +71,8 @@ class AgentLlmMetricsLogger extends BaseCallbackHandler {
     this.pendingRuns.set(runId, { startedAt: Date.now() });
   }
 
-  async handleLLMNewToken(
-    _token: string,
-    _chunk: unknown,
-    runId: string,
-  ) {
-    const pendingRun = this.pendingRuns.get(runId);
-
-    if (!pendingRun || pendingRun.firstTokenAt !== undefined) {
-      return;
-    }
-
-    pendingRun.firstTokenAt = Date.now();
-  }
-
-  async handleLLMEnd(output: LLMResult, runId: string) {
-    const pendingRun = this.pendingRuns.get(runId);
-
-    if (!pendingRun) {
-      return;
-    }
-
+  async handleLLMEnd(_output: LLMResult, runId: string) {
     this.pendingRuns.delete(runId);
-
-    const finishedAt = Date.now();
-    const rtt = finishedAt - pendingRun.startedAt;
-    const ttft =
-      pendingRun.firstTokenAt === undefined
-        ? rtt
-        : pendingRun.firstTokenAt - pendingRun.startedAt;
-    const { InputTokens, outputTokens } = extractTokenUsage(output);
-
-    logger.info(
-      { InputTokens, outputTokens, ttft, rtt },
-      "LLM call finished",
-    );
   }
 
   async handleLLMError(_error: unknown, runId: string) {

llm/middleware/apiToolsMiddleware.ts

@@ -72,18 +72,13 @@ export function createApiBasedToolsMiddleware(
         .map((toolName) => dynamicTools[toolName]);
       const availableTools = [...request.tools, ...tools];
 
-      logger.info(
-        `AdminForth Agent callable tools: ${availableTools.map((tool) => tool.name).join(", ")}`,
-      );
-
       return handler({
         ...request,
         tools: availableTools,
       });
     },
     async wrapToolCall(request, handler) {
       const startedAt = Date.now();
-      const toolInput = JSON.stringify(request.toolCall.args ?? {});
       if (!request.toolCall.id) {
         throw new Error(`Tool call "${request.toolCall.name}" has no id.`);
       }
@@ -128,9 +123,6 @@ export function createApiBasedToolsMiddleware(
         startedAt,
       });
       toolCallTracker.start();
-      logger.info(
-        `Invoking tool "${request.toolCall.name}" with input: ${toolInput}`,
-      );
 
       try {
 
@@ -164,10 +156,6 @@ export function createApiBasedToolsMiddleware(
           status: "error",
           content: `Error: ${message}`,
         })
-      } finally {
-        logger.info(
-          `Tool "${request.toolCall.name}" finished in ${Date.now() - startedAt}ms`,
-        );
       }
     },
   });

tools/apiBasedTools.ts

@@ -574,7 +574,6 @@ async function callOpenApiSchema(params: {
   }
 
   const response = createDirectToolResponse();
-  logger.info(`Calling OpenAPI tool "${toolName}" with direct handler`);
   const lang = acceptLanguage ?? "en";
   const tr = (
     msg: string,
@@ -659,15 +658,6 @@ export function prepareApiBasedTools(
     }
   }
 
-  logger.info(
-    `AdminForth Agent OpenAPI APIs: ${formatLogNameList(
-      adminforth.openApi.registeredSchemas.map((schema) => openApiSchemaPathToToolName(schema.path, adminforth)),
-    )}`,
-  );
-  logger.info(
-    `AdminForth Agent OpenAPI tools connected: ${formatLogNameList([...openApiSchemasByToolName.keys()])}`,
-  );
-
   for (const [toolName, schema] of openApiSchemasByToolName.entries()) {
     apiBasedTools[toolName] = {
       description: schema.description,