agentxjs 2.9.0-dev-20260317033749 → 2.9.0-dev-20260317035728

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxjs",
-  "version": "2.9.0-dev-20260317033749",
+  "version": "2.9.0-dev-20260317035728",
   "description": "AgentX Client SDK - Local and remote AI agent management",
   "license": "MIT",
   "type": "module",
@@ -23,12 +23,12 @@
     "test": "bun test bdd/"
   },
   "dependencies": {
-    "@agentxjs/core": "2.9.0-dev-20260317033749",
+    "@agentxjs/core": "2.9.0-dev-20260317035728",
     "@deepracticex/id": "^0.2.0",
     "@deepracticex/logger": "^1.2.0"
   },
   "devDependencies": {
-    "@agentxjs/devtools": "2.2.2-dev-20260317033749",
+    "@agentxjs/devtools": "2.2.2-dev-20260317035728",
     "@deepracticex/bdd": "^0.3.0",
     "tsx": "^4.19.0",
     "typescript": "^5.3.3"

package/src/presentation/__tests__/tool-e2e.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tool Call End-to-End Round-Trip Test
+ *
+ * Uses REAL MonoDriver + Runtime + SQLite persistence.
+ * Sends a message that triggers a tool call, then restores
+ * from persistence and verifies tool calls survive.
+ *
+ * Requires ANTHROPIC_API_KEY or DEEPRACTICE_API_KEY in .env.local
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Message } from "@agentxjs/core/agent";
+import type { DriverConfig } from "@agentxjs/core/driver";
+import { EventBusImpl } from "@agentxjs/core/event";
+import { createAgentXRuntime } from "@agentxjs/core/runtime";
+import { createMonoDriver } from "@agentxjs/mono-driver";
+import { createPersistence, sqliteDriver } from "@agentxjs/node-platform/persistence";
+import { messagesToConversations } from "../reducer";
+import type { AssistantConversation, ToolBlock } from "../types";
+
+let tempDir: string;
+let persistence: Awaited<ReturnType<typeof createPersistence>>;
+
+const apiKey = process.env.ANTHROPIC_API_KEY || process.env.DEEPRACTICE_API_KEY;
+const baseUrl = process.env.DEEPRACTICE_BASE_URL;
+
+beforeAll(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "agentx-tool-e2e-"));
+  persistence = await createPersistence(sqliteDriver({ path: join(tempDir, "test.db") }));
+});
+
+afterAll(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("Tool call E2E round-trip", () => {
+  test("tool call survives persist → restore", async () => {
+    if (!apiKey) {
+      console.log("Skipping: no API key");
+      return;
+    }
+
+    // Create runtime with a simple bash tool
+    const createDriver = (config: DriverConfig) =>
+      createMonoDriver({
+        ...config,
+        apiKey: apiKey!,
+        baseUrl,
+        model: process.env.DEEPRACTICE_MODEL || "claude-sonnet-4-20250514",
+        provider: "anthropic",
+        maxSteps: 5,
+      });
+
+    const eventBus = new EventBusImpl();
+    const runtime = createAgentXRuntime(
+      {
+        containerRepository: persistence.containers,
+        imageRepository: persistence.images,
+        sessionRepository: persistence.sessions,
+        eventBus,
+        bashProvider: {
+          type: "test",
+          execute: async (cmd: string) => ({
+            stdout: `executed: ${cmd}`,
+            stderr: "",
+            exitCode: 0,
+          }),
+        },
+      },
+      createDriver
+    );
+
+    // Create image
+    const { createImage } = await import("@agentxjs/core/image");
+    const image = await createImage(
+      {
+        containerId: "default",
+        name: "Tool Test Agent",
+        embody: {
+          systemPrompt:
+            "You have a bash tool. When asked to run a command, use the bash tool. Be brief.",
+        },
+      },
+      {
+        imageRepository: persistence.images,
+        sessionRepository: persistence.sessions,
+      }
+    );
+
+    const imageId = image.toRecord().imageId;
+    const sessionId = image.toRecord().sessionId;
+
+    // Create agent and send a message that should trigger tool use
+    const agent = await runtime.createAgent({ imageId });
+
+    // Debug: track ALL events
+    const allEvents: string[] = [];
+    eventBus.onAny((event: any) => {
+      allEvents.push(event.type);
+      if (event.type === "assistant_message") {
+        const content = event.data?.content;
+        const hasToolCall =
+          Array.isArray(content) && content.some((p: any) => p.type === "tool-call");
+        console.log(
+          `  [EVENT] assistant_message: hasToolCall=${hasToolCall}, content=${JSON.stringify(content).substring(0, 80)}`
+        );
+      }
+    });
+
+    // Wait for response completion
+    const responsePromise = new Promise<void>((resolve) => {
+      eventBus.onAny((event: any) => {
+        if (event.type === "message_stop" && event.data?.stopReason === "end_turn") {
+          setTimeout(resolve, 500);
+        }
+      });
+    });
+
+    // Send message that triggers bash tool
+    await runtime.receive(
+      agent.instanceId,
+      'Run the command "echo hello world" using the bash tool.'
+    );
+
+    // Wait for completion
+    await responsePromise;
+
+    // Debug: show event sequence
+    console.log("\n=== Event sequence ===");
+    console.log(`  ${allEvents.join(" → ")}`);
+
+    // === Phase 1: Check persisted messages ===
+    const messages = await persistence.sessions.getMessages(sessionId);
+
+    console.log("\n=== Persisted messages ===");
+    for (const msg of messages) {
+      const content = (msg as any).content ?? (msg as any).toolResult;
+      const preview =
+        typeof content === "string"
+          ? content.substring(0, 80)
+          : JSON.stringify(content).substring(0, 120);
+      console.log(`  ${msg.subtype}: ${preview}`);
+    }
+
+    // Should have: user + assistant(tool-call) + tool-result + assistant(text)
+    const assistantMsgs = messages.filter((m) => m.subtype === "assistant");
+    const toolResultMsgs = messages.filter((m) => m.subtype === "tool-result");
+
+    console.log(
+      `\n  Total: ${messages.length} messages (${assistantMsgs.length} assistant, ${toolResultMsgs.length} tool-result)`
+    );
+
+    // Verify assistant message has tool-call content parts
+    const assistantWithToolCall = assistantMsgs.find((m) => {
+      const content = (m as any).content;
+      if (Array.isArray(content)) {
+        return content.some((p: any) => p.type === "tool-call");
+      }
+      return false;
+    });
+
+    console.log(
+      `  Assistant with tool-call: ${assistantWithToolCall ? "YES" : "NO - BUG IN PERSISTENCE"}`
+    );
+
+    // === Phase 2: Restore from persistence (simulate page refresh) ===
+    const conversations = messagesToConversations(messages);
+
+    console.log("\n=== Restored conversations ===");
+    for (const conv of conversations) {
+      if (conv.role !== "error") {
+        const blocks = (conv as any).blocks;
+        console.log(
+          `  ${conv.role}: [${blocks.map((b: any) => `${b.type}${b.type === "tool" ? `(${b.toolName})` : ""}`).join(", ")}]`
+        );
+      }
+    }
+
+    // Find tool blocks
+    const assistantConvs = conversations.filter(
+      (c) => c.role === "assistant"
+    ) as AssistantConversation[];
+    const allBlocks = assistantConvs.flatMap((c) => c.blocks);
+    const toolBlocks = allBlocks.filter((b) => b.type === "tool") as ToolBlock[];
+
+    console.log(`\n  Tool blocks after restore: ${toolBlocks.length}`);
+    for (const tb of toolBlocks) {
+      console.log(
+        `    ${tb.toolName}: status=${tb.status}, result=${tb.toolResult?.substring(0, 50)}`
+      );
+    }
+
+    // THE CRITICAL ASSERTION
+    expect(toolBlocks.length).toBeGreaterThanOrEqual(1);
+    expect(toolBlocks[0].status).toBe("completed");
+    expect(toolBlocks[0].toolResult).toBeDefined();
+
+    // Cleanup
+    await runtime.destroyAgent(agent.instanceId);
+    await runtime.shutdown();
+  }, 60_000);
+});

package/src/presentation/__tests__/tool-roundtrip.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Tool Call Round-Trip Test
+ *
+ * Simulates the FULL lifecycle:
+ * 1. MonoDriver emits stream events (tool call flow)
+ * 2. MessageAssembler processes into Messages
+ * 3. Messages are "persisted" (collected)
+ * 4. messagesToConversations restores from "persistence"
+ * 5. Verify tool calls survive the round-trip
+ *
+ * This reproduces the page-refresh bug: tool calls lost after reconnection.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { Message } from "@agentxjs/core/agent";
+import {
+  createInitialMessageAssemblerState,
+  messageAssemblerProcessor,
+} from "@agentxjs/core/agent";
+import { messagesToConversations } from "../reducer";
+import type { AssistantConversation, ToolBlock } from "../types";
+
+/**
+ * Helper: create a stream event
+ */
+function streamEvent(type: string, data: Record<string, unknown>) {
+  return { type, timestamp: Date.now(), data };
+}
+
+/**
+ * Helper: process events through MessageAssembler, collect output messages
+ */
+function processEvents(events: Array<{ type: string; timestamp: number; data: any }>) {
+  let state = createInitialMessageAssemblerState();
+  const allMessages: Message[] = [];
+
+  for (const event of events) {
+    const [newState, outputs] = messageAssemblerProcessor(state, event);
+    state = newState;
+
+    for (const output of outputs) {
+      // Collect message-type outputs (these are what Runtime persists)
+      if (output.type === "assistant_message" || output.type === "tool_result_message") {
+        allMessages.push(output.data as Message);
+      }
+    }
+  }
+
+  return allMessages;
+}
+
+describe("Tool call round-trip (persist → restore)", () => {
+  test("single tool call: events → messages → conversations", () => {
+    // Simulate MonoDriver event sequence for a tool call
+    const events = [
+      // Step 1: LLM decides to call a tool
+      streamEvent("message_start", { messageId: "msg_1", model: "claude" }),
+      streamEvent("text_delta", { text: "Let me check that." }),
+      streamEvent("tool_use_start", { toolCallId: "call_1", toolName: "bash" }),
+      streamEvent("input_json_delta", { partialJson: '{"command":' }),
+      streamEvent("input_json_delta", { partialJson: '"ls /tmp"}' }),
+      streamEvent("tool_use_stop", {
+        toolCallId: "call_1",
+        toolName: "bash",
+        input: { command: "ls /tmp" },
+      }),
+      // MonoDriver injects message_stop before tool_result
+      streamEvent("message_stop", { stopReason: "tool_use" }),
+      // Tool result
+      streamEvent("tool_result", {
+        toolCallId: "call_1",
+        result: "file1.txt\nfile2.txt",
+        isError: false,
+      }),
+      // Step 2: LLM responds with text
+      streamEvent("message_start", { messageId: "msg_2", model: "claude" }),
+      streamEvent("text_delta", { text: "Found 2 files." }),
+      streamEvent("message_stop", { stopReason: "end_turn" }),
+    ];
+
+    // Phase 1: Process events → get persisted messages
+    const messages: Message[] = [
+      // User message (always persisted separately by Runtime)
+      {
+        id: "msg_user",
+        role: "user",
+        subtype: "user",
+        content: "List files in /tmp",
+        timestamp: Date.now(),
+      } as any,
+      // Messages from MessageAssembler
+      ...processEvents(events),
+    ];
+
+    console.log("\n=== Persisted messages ===");
+    for (const msg of messages) {
+      console.log(
+        `  ${msg.subtype}: ${JSON.stringify((msg as any).content ?? (msg as any).toolResult).substring(0, 100)}`
+      );
+    }
+
+    // Phase 2: Restore from "persistence" (page refresh scenario)
+    const conversations = messagesToConversations(messages);
+
+    console.log("\n=== Restored conversations ===");
+    for (const conv of conversations) {
+      console.log(
+        `  ${conv.role}: blocks=[${conv.role !== "error" ? (conv as any).blocks.map((b: any) => b.type).join(", ") : conv.message}]`
+      );
+    }
+
+    // Verify: user message exists
+    expect(conversations[0].role).toBe("user");
+
+    // Verify: assistant conversation has tool block
+    const assistantConvs = conversations.filter(
+      (c) => c.role === "assistant"
+    ) as AssistantConversation[];
+    expect(assistantConvs.length).toBeGreaterThan(0);
+
+    // Find tool block in any assistant conversation
+    const allBlocks = assistantConvs.flatMap((c) => c.blocks);
+    const toolBlocks = allBlocks.filter((b) => b.type === "tool") as ToolBlock[];
+
+    console.log("\n=== Tool blocks ===");
+    for (const tb of toolBlocks) {
+      console.log(
+        `  ${tb.toolName}: id=${tb.toolUseId}, status=${tb.status}, result=${tb.toolResult}`
+      );
+    }
+
+    // THIS IS THE CRITICAL ASSERTION
+    // If this fails, tool calls are lost on page refresh
+    expect(toolBlocks.length).toBeGreaterThanOrEqual(1);
+    expect(toolBlocks[0].toolName).toBe("bash");
+    expect(toolBlocks[0].toolUseId).toBe("call_1");
+    expect(toolBlocks[0].status).toBe("completed");
+    expect(toolBlocks[0].toolResult).toBe("file1.txt\nfile2.txt");
+
+    // Verify text is also present
+    const textBlocks = allBlocks.filter((b) => b.type === "text");
+    expect(textBlocks.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test("multi-step tool call: second step text survives", () => {
+    // This tests the MonoDriver multi-step flow where message_start
+    // is only emitted once but there are multiple steps
+    const events = [
+      // Single message_start for entire multi-step
+      streamEvent("message_start", { messageId: "msg_1", model: "claude" }),
+      // Step 1: tool call
+      streamEvent("tool_use_start", { toolCallId: "call_1", toolName: "write" }),
+      streamEvent("input_json_delta", { partialJson: '{"path":"test.txt","content":"hello"}' }),
+      streamEvent("tool_use_stop", {
+        toolCallId: "call_1",
+        toolName: "write",
+        input: { path: "test.txt", content: "hello" },
+      }),
+      // MonoDriver injects message_stop before tool_result
+      streamEvent("message_stop", { stopReason: "tool_use" }),
+      streamEvent("tool_result", {
+        toolCallId: "call_1",
+        result: { success: true },
+        isError: false,
+      }),
+      // Step 2: NO new message_start (MonoDriver only emits once)
+      // This is where the bug might be
+      streamEvent("message_start", { messageId: "msg_2", model: "claude" }),
+      streamEvent("text_delta", { text: "File written successfully." }),
+      streamEvent("message_stop", { stopReason: "end_turn" }),
+    ];
+
+    const messages: Message[] = [
+      {
+        id: "msg_user",
+        role: "user",
+        subtype: "user",
+        content: "Write hello to test.txt",
+        timestamp: Date.now(),
+      } as any,
+      ...processEvents(events),
+    ];
+
+    console.log("\n=== Multi-step persisted messages ===");
+    for (const msg of messages) {
+      console.log(
+        `  ${msg.subtype}: ${JSON.stringify((msg as any).content ?? (msg as any).toolResult).substring(0, 120)}`
+      );
+    }
+
+    const conversations = messagesToConversations(messages);
+
+    console.log("\n=== Multi-step restored conversations ===");
+    for (const conv of conversations) {
+      if (conv.role !== "error") {
+        const ac = conv as any;
+        console.log(
+          `  ${conv.role}: blocks=[${ac.blocks.map((b: any) => `${b.type}${b.type === "tool" ? `(${b.toolName})` : ""}`).join(", ")}]`
+        );
+      }
+    }
+
+    // User + at least one assistant
+    expect(conversations[0].role).toBe("user");
+
+    const assistantConvs = conversations.filter(
+      (c) => c.role === "assistant"
+    ) as AssistantConversation[];
+    const allBlocks = assistantConvs.flatMap((c) => c.blocks);
+
+    // Tool call should be present
+    const toolBlocks = allBlocks.filter((b) => b.type === "tool") as ToolBlock[];
+    expect(toolBlocks.length).toBe(1);
+    expect(toolBlocks[0].toolName).toBe("write");
+
+    // Final text should also be present
+    const textBlocks = allBlocks.filter((b) => b.type === "text");
+    expect(textBlocks.length).toBeGreaterThanOrEqual(1);
+    const hasSuccessText = textBlocks.some((b) => (b as any).content.includes("successfully"));
+    expect(hasSuccessText).toBe(true);
+  });
+});