Merge branch 'main' of https://github.com/devforth/adminforth-agent

Author: ivictbor

agent/middleware/sequenceDebug.ts

@@ -1,4 +1,5 @@
 import { AIMessage } from "@langchain/core/messages";
+import { convertMessagesToResponsesInput } from "@langchain/openai";
 import { createMiddleware } from "langchain";
 import YAML from "yaml";
 import type { ToolCallEvent } from "../toolCallEvents.js";
@@ -120,44 +121,36 @@ function finalizeSequenceDebug(sequence: PendingSequenceDebug): SequenceDebug {
   };
 }
 
+type OpenAiResponsesDebugModel = {
+  model: string;
+  zdrEnabled?: boolean;
+  invocationParams: (options?: Record<string, unknown>) => Record<string, unknown>;
+};
+
 function stringifyPromptForDebug(params: {
-  systemMessage: { toDict(): unknown };
-  messages: Array<{ toDict(): unknown }>;
+  model: OpenAiResponsesDebugModel;
+  systemMessage: { text: string };
+  messages: unknown[];
   tools: unknown[];
+  toolChoice?: unknown;
   modelSettings?: Record<string, unknown>;
 }) {
-  const { systemMessage, messages, tools, modelSettings } = params;
+  const { model, systemMessage, messages, tools, toolChoice, modelSettings } = params;
 
   return YAML.stringify({
-    systemMessage: systemMessage.toDict(),
-    messages: messages.map((message) => message.toDict()),
-    tools: tools.map((tool) => {
-      if (
-        typeof tool === "object" &&
-        tool !== null &&
-        "name" in tool &&
-        typeof tool.name === "string"
-      ) {
-        return tool.name;
-      }
-
-      if (
-        typeof tool === "object" &&
-        tool !== null &&
-        "schema" in tool &&
-        typeof tool.schema === "object" &&
-        tool.schema !== null &&
-        "name" in tool.schema &&
-        typeof tool.schema.name === "string"
-      ) {
-        return tool.schema.name;
-      }
-
-      return "";
+    input: convertMessagesToResponsesInput({
+      messages: [
+        ...(systemMessage.text === "" ? [] : [systemMessage]),
+        ...messages,
+      ] as any[],
+      zdrEnabled: model.zdrEnabled ?? false,
+      model: model.model,
+    }),
+    ...model.invocationParams({
+    ...(modelSettings ?? {}),
+    ...(tools.length > 0 ? { tools } : {}),
+    ...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),
     }),
-    ...(modelSettings && Object.keys(modelSettings).length > 0
-      ? { modelSettings }
-      : {}),
   });
 }
 
@@ -356,9 +349,11 @@ export function createSequenceDebugMiddleware(
     name: "SequenceDebugMiddleware",
     async wrapModelCall(request, handler) {
       const prompt = stringifyPromptForDebug({
+        model: request.model as unknown as OpenAiResponsesDebugModel,
         systemMessage: request.systemMessage,
         messages: request.messages,
         tools: request.tools,
+        toolChoice: request.toolChoice,
         modelSettings: request.modelSettings,
       });
 

agent/simpleAgent.ts

@@ -187,7 +187,7 @@ export function createAgentChatModel(params: {
     maxTokens: params.maxTokens,
     useResponsesApi: true,
     outputVersion: "v1",
-
+    streaming: true,
     promptCacheKey: `adminforth-agent:${model}:system-v1:tools-v1`,
 
     promptCacheRetention: "in_memory", 

agent/toolCallEvents.ts

@@ -20,6 +20,46 @@ export type ToolCallEvent =
 
 export type ToolCallEventSink = (event: ToolCallEvent) => void;
 
+const TOOL_MESSAGE_DEBUG_KEYS = new Set([
+  "metadata",
+  "additional_kwargs",
+  "response_metadata",
+]);
+
+function getToolCallDebugPayload(outputRecord: Record<string, unknown>) {
+  const lcKwargs =
+    typeof outputRecord.lc_kwargs === "object" && outputRecord.lc_kwargs !== null
+      ? outputRecord.lc_kwargs as Record<string, unknown>
+      : null;
+
+  if (lcKwargs && "tool_call_id" in lcKwargs) {
+    return lcKwargs;
+  }
+
+  if ("tool_call_id" in outputRecord) {
+    return outputRecord;
+  }
+
+  return null;
+}
+
+function sanitizeToolCallOutputForDebug(output: unknown) {
+  if (typeof output !== "object" || output === null) {
+    return output;
+  }
+
+  const outputRecord = output as Record<string, unknown>;
+  const debugPayload = getToolCallDebugPayload(outputRecord);
+
+  if (!debugPayload) {
+    return output;
+  }
+
+  return Object.fromEntries(
+    Object.entries(debugPayload).filter(([key]) => !TOOL_MESSAGE_DEBUG_KEYS.has(key)),
+  );
+}
+
 export function createToolCallTracker(params: {
   emit: ToolCallEventSink;
   toolCallId?: string;
@@ -45,7 +85,7 @@ export function createToolCallTracker(params: {
         toolName: params.toolName,
         phase: "end",
         durationMs: Date.now() - startedAt,
-        output: YAML.stringify(output).trimEnd(),
+        output: YAML.stringify(sanitizeToolCallOutputForDebug(output)).trimEnd(),
         error: null,
       });
     },