@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/session/session-message-converter.test.js

@@ -0,0 +1,623 @@
+/**
+ * @fileoverview Session Message Converter Tests
+ *
+ * Tests for SessionMessage <-> AI SDK ModelMessage conversion functions.
+ * Following TDD: These tests define the expected behavior.
+ */
+import { describe, test, expect } from "bun:test";
+// ============================================================================
+// Test Utilities
+// ============================================================================
+function createSessionMessage(overrides = {}) {
+    return {
+        id: `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+        sessionID: "session_test",
+        role: "user",
+        content: "",
+        timestamp: Date.now(),
+        ...overrides,
+    };
+}
+// ============================================================================
+// RED Phase: Write tests that define expected behavior
+// ============================================================================
+describe("Session Part Types", () => {
+    describe("TextPart", () => {
+        test("should have correct structure", () => {
+            const textPart = {
+                type: "text",
+                content: "Hello, world!",
+                synthetic: false,
+                ignored: false,
+            };
+            expect(textPart.type).toBe("text");
+            expect(textPart.content).toBe("Hello, world!");
+            expect(textPart.synthetic).toBe(false);
+            expect(textPart.ignored).toBe(false);
+        });
+        test("should support optional fields", () => {
+            const textPart = {
+                type: "text",
+                content: "Simple text",
+            };
+            expect(textPart.type).toBe("text");
+            expect(textPart.content).toBe("Simple text");
+            expect(textPart.synthetic).toBeUndefined();
+            expect(textPart.ignored).toBeUndefined();
+        });
+    });
+    describe("ToolCallPart", () => {
+        test("should have correct structure", () => {
+            const toolCallPart = {
+                type: "tool-call",
+                toolCallId: "call_abc123",
+                toolName: "grep",
+                arguments: { pattern: "TODO", path: "/src" },
+                state: "pending",
+            };
+            expect(toolCallPart.type).toBe("tool-call");
+            expect(toolCallPart.toolCallId).toBe("call_abc123");
+            expect(toolCallPart.toolName).toBe("grep");
+            expect(toolCallPart.arguments).toEqual({ pattern: "TODO", path: "/src" });
+            expect(toolCallPart.state).toBe("pending");
+        });
+        test("should support string arguments", () => {
+            const toolCallPart = {
+                type: "tool-call",
+                toolCallId: "call_xyz",
+                toolName: "bash",
+                arguments: '{"command": "ls -la"}',
+                state: "pending",
+            };
+            expect(typeof toolCallPart.arguments).toBe("string");
+        });
+        test("should support running state", () => {
+            const toolCallPart = {
+                type: "tool-call",
+                toolCallId: "call_running",
+                toolName: "search",
+                arguments: {},
+                state: "running",
+            };
+            expect(toolCallPart.state).toBe("running");
+        });
+    });
+    describe("ToolResultPart", () => {
+        test("should have correct structure", () => {
+            const toolResultPart = {
+                type: "tool-result",
+                toolCallId: "call_abc123",
+                toolName: "grep",
+                output: "Found 3 matches",
+                state: "completed",
+            };
+            expect(toolResultPart.type).toBe("tool-result");
+            expect(toolResultPart.toolCallId).toBe("call_abc123");
+            expect(toolResultPart.toolName).toBe("grep");
+            expect(toolResultPart.output).toBe("Found 3 matches");
+            expect(toolResultPart.state).toBe("completed");
+        });
+        test("should support error state", () => {
+            const toolResultPart = {
+                type: "tool-result",
+                toolCallId: "call_error",
+                toolName: "bash",
+                output: "",
+                error: "Command failed: exit code 1",
+                state: "error",
+            };
+            expect(toolResultPart.error).toBe("Command failed: exit code 1");
+            expect(toolResultPart.state).toBe("error");
+        });
+    });
+    describe("ReasoningPart", () => {
+        test("should have correct structure", () => {
+            const reasoningPart = {
+                type: "reasoning",
+                content: "Let me think about this problem...",
+                reasoningType: "core",
+                state: "completed",
+            };
+            expect(reasoningPart.type).toBe("reasoning");
+            expect(reasoningPart.content).toBe("Let me think about this problem...");
+            expect(reasoningPart.reasoningType).toBe("core");
+            expect(reasoningPart.state).toBe("completed");
+        });
+        test("should support optional metadata", () => {
+            const reasoningPart = {
+                type: "reasoning",
+                content: "Thinking...",
+                reasoningType: "effort",
+                state: "thinking",
+                isCollapsed: true,
+                metadata: {
+                    tokenCount: 150,
+                    time: { start: Date.now(), end: Date.now() + 1000 },
+                },
+            };
+            expect(reasoningPart.isCollapsed).toBe(true);
+            expect(reasoningPart.metadata?.tokenCount).toBe(150);
+        });
+    });
+    describe("FilePart", () => {
+        test("should have correct structure", () => {
+            const filePart = {
+                type: "file",
+                mime: "image/png",
+                url: "file:///path/to/image.png",
+                filename: "screenshot.png",
+            };
+            expect(filePart.type).toBe("file");
+            expect(filePart.mime).toBe("image/png");
+            expect(filePart.url).toBe("file:///path/to/image.png");
+            expect(filePart.filename).toBe("screenshot.png");
+        });
+    });
+    describe("CheckpointPart", () => {
+        test("should have correct structure", () => {
+            const checkpointPart = {
+                type: "checkpoint",
+                checkpointId: "chk_abc123",
+                summary: "Session compacted",
+                processKeyPoints: ["Analyzed requirements", "Created test files"],
+                currentState: "Implementing feature X",
+                nextSteps: ["Write implementation", "Test edge cases"],
+            };
+            expect(checkpointPart.type).toBe("checkpoint");
+            expect(checkpointPart.checkpointId).toBe("chk_abc123");
+            expect(checkpointPart.summary).toBe("Session compacted");
+            expect(checkpointPart.processKeyPoints).toHaveLength(2);
+            expect(checkpointPart.nextSteps).toHaveLength(2);
+        });
+    });
+    describe("SessionPart Union Type", () => {
+        test("should allow all part types in union", () => {
+            const parts = [
+                { type: "text", content: "Hello" },
+                { type: "tool-call", toolCallId: "c1", toolName: "t1", arguments: {}, state: "pending" },
+                { type: "tool-result", toolCallId: "c1", toolName: "t1", output: "ok", state: "completed" },
+                { type: "reasoning", content: "thinking" },
+                { type: "file", mime: "text/plain", url: "file://test.txt" },
+                { type: "checkpoint", checkpointId: "chk1", summary: "test" },
+            ];
+            expect(parts).toHaveLength(6);
+        });
+    });
+});
+// ============================================================================
+// SessionMessage Structure Tests
+// ============================================================================
+describe("SessionMessage Structure", () => {
+    test("should support parts array", () => {
+        const message = createSessionMessage({
+            role: "assistant",
+            parts: [
+                { type: "text", content: "Hello!" },
+                { type: "reasoning", content: "Let me think...", reasoningType: "core" },
+            ],
+        });
+        expect(message.parts).toBeDefined();
+        expect(message.parts).toHaveLength(2);
+        expect(message.parts[0].type).toBe("text");
+        expect(message.parts[1].type).toBe("reasoning");
+    });
+    test("should support metadata", () => {
+        const message = createSessionMessage({
+            role: "assistant",
+            metadata: {
+                model: "gpt-4",
+                isCheckpoint: true,
+                checkpointId: "chk_123",
+            },
+        });
+        expect(message.metadata).toBeDefined();
+        expect(message.metadata?.model).toBe("gpt-4");
+        expect(message.metadata?.isCheckpoint).toBe(true);
+    });
+    test("should support backward compatibility with content field", () => {
+        const message = createSessionMessage({
+            role: "user",
+            content: "Simple text message",
+        });
+        expect(message.content).toBe("Simple text message");
+        expect(message.parts).toBeUndefined();
+    });
+});
+// ============================================================================
+// Import tests (will be implemented in GREEN phase)
+// ============================================================================
+describe("toModelMessage", () => {
+    test("should convert user message to ModelMessage", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "user",
+            content: "Hello, AI!",
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.role).toBe("user");
+        expect(modelMsg.content).toBe("Hello, AI!");
+    });
+    test("should convert assistant text message to ModelMessage", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "assistant",
+            content: "Hello, human!",
+            parts: [{ type: "text", content: "Hello, human!" }],
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.role).toBe("assistant");
+        expect(modelMsg.content).toHaveLength(1);
+        expect(modelMsg.content[0]).toEqual({ type: "text", text: "Hello, human!" });
+    });
+    test("should convert reasoning part to ModelMessage", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "assistant",
+            parts: [
+                { type: "reasoning", content: "Let me analyze this...", reasoningType: "core" },
+                { type: "text", content: "Here's my answer." },
+            ],
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.role).toBe("assistant");
+        expect(modelMsg.content).toHaveLength(2);
+        expect(modelMsg.content[0]).toMatchObject({
+            type: "reasoning",
+            text: "Let me analyze this..."
+        });
+    });
+    test("should convert tool-call part to ModelMessage", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "assistant",
+            parts: [
+                { type: "text", content: "Searching..." },
+                {
+                    type: "tool-call",
+                    toolCallId: "call_123",
+                    toolName: "grep",
+                    arguments: { pattern: "TODO" },
+                    state: "pending",
+                },
+            ],
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.content).toHaveLength(2);
+        const toolCall = modelMsg.content.find(c => c.type === "tool-call");
+        expect(toolCall).toMatchObject({
+            type: "tool-call",
+            toolCallId: "call_123",
+            toolName: "grep",
+            input: { pattern: "TODO" },
+        });
+    });
+    test("should convert tool message to ModelMessage", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "tool",
+            content: "Found 5 matches",
+            parts: [
+                {
+                    type: "tool-result",
+                    toolCallId: "call_123",
+                    toolName: "grep",
+                    output: "Found 5 matches",
+                    state: "completed",
+                },
+            ],
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.role).toBe("tool");
+        expect(modelMsg.content).toHaveLength(1);
+        expect(modelMsg.content[0]).toMatchObject({
+            type: "tool-result",
+            toolCallId: "call_123",
+            toolName: "grep",
+            output: "Found 5 matches",
+        });
+    });
+    test("should convert file part in assistant message", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "assistant",
+            parts: [
+                { type: "text", content: "Here's the file" },
+                { type: "file", mime: "image/png", url: "file:///tmp/image.png", filename: "screenshot.png" },
+            ],
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.role).toBe("assistant");
+        expect(Array.isArray(modelMsg.content)).toBe(true);
+        const content = modelMsg.content;
+        const filePart = content.find(c => c.type === "file");
+        expect(filePart).toBeDefined();
+        expect(filePart.url).toBe("file:///tmp/image.png");
+        expect(filePart.mimeType).toBe("image/png");
+    });
+    test("should skip checkpoint parts in assistant message", async () => {
+        const { toModelMessage } = await import("./session-message-converter");
+        const sessionMsg = createSessionMessage({
+            role: "assistant",
+            parts: [
+                { type: "text", content: "Response after checkpoint" },
+                { type: "checkpoint", checkpointId: "chk_123", summary: "Checkpoint summary" },
+            ],
+        });
+        const modelMsg = toModelMessage(sessionMsg);
+        expect(modelMsg.role).toBe("assistant");
+        expect(Array.isArray(modelMsg.content)).toBe(true);
+        const content = modelMsg.content;
+        // Checkpoint should be skipped
+        expect(content).toHaveLength(1);
+        expect(content[0].type).toBe("text");
+    });
+});
+describe("fromModelMessage", () => {
+    test("should convert text ModelMessage to SessionMessage", async () => {
+        const { fromModelMessage } = await import("./session-message-converter");
+        const modelMsg = {
+            role: "user",
+            content: "Hello!",
+        };
+        const sessionMsg = fromModelMessage(modelMsg);
+        expect(sessionMsg.role).toBe("user");
+        expect(sessionMsg.content).toBe("Hello!");
+        expect(sessionMsg.parts).toEqual([{ type: "text", content: "Hello!" }]);
+    });
+    test("should convert assistant ModelMessage with multiple parts", async () => {
+        const { fromModelMessage } = await import("./session-message-converter");
+        const modelMsg = {
+            role: "assistant",
+            content: [
+                { type: "reasoning", text: "Thinking..." },
+                { type: "text", text: "Here's my response." },
+                { type: "tool-call", toolCallId: "c1", toolName: "bash", input: { cmd: "ls" } },
+            ],
+        };
+        const sessionMsg = fromModelMessage(modelMsg);
+        expect(sessionMsg.role).toBe("assistant");
+        expect(sessionMsg.parts).toHaveLength(3);
+        expect(sessionMsg.parts[0]).toMatchObject({ type: "reasoning", content: "Thinking..." });
+        expect(sessionMsg.parts[1]).toMatchObject({ type: "text", content: "Here's my response." });
+        expect(sessionMsg.parts[2]).toMatchObject({
+            type: "tool-call",
+            toolCallId: "c1",
+            toolName: "bash",
+            arguments: { cmd: "ls" },
+        });
+    });
+    test("should convert tool-result ModelMessage to SessionMessage", async () => {
+        const { fromModelMessage } = await import("./session-message-converter");
+        const modelMsg = {
+            role: "tool",
+            content: [
+                {
+                    type: "tool-result",
+                    toolCallId: "call_abc",
+                    toolName: "grep",
+                    output: "Match 1\nMatch 2",
+                },
+            ],
+        };
+        const sessionMsg = fromModelMessage(modelMsg);
+        expect(sessionMsg.role).toBe("tool");
+        expect(sessionMsg.parts[0]).toMatchObject({
+            type: "tool-result",
+            toolCallId: "call_abc",
+            toolName: "grep",
+            output: "Match 1\nMatch 2",
+            state: "completed",
+        });
+        // tool messages should have metadata.type = "tool_result"
+        expect(sessionMsg.metadata).toEqual({ type: "tool_result" });
+    });
+    test("should set metadata.type to tool_call for assistant messages with tool-call parts", async () => {
+        const { fromModelMessage } = await import("./session-message-converter");
+        const modelMsg = {
+            role: "assistant",
+            content: [
+                { type: "text", text: "I'll search for that." },
+                { type: "tool-call", toolCallId: "c1", toolName: "search", input: { query: "test" } },
+            ],
+        };
+        const sessionMsg = fromModelMessage(modelMsg);
+        expect(sessionMsg.role).toBe("assistant");
+        expect(sessionMsg.metadata).toEqual({ type: "tool_call" });
+    });
+    test("should not set metadata.type for assistant messages without tool-call parts", async () => {
+        const { fromModelMessage } = await import("./session-message-converter");
+        const modelMsg = {
+            role: "assistant",
+            content: "Just a regular text response.",
+        };
+        const sessionMsg = fromModelMessage(modelMsg);
+        expect(sessionMsg.role).toBe("assistant");
+        expect(sessionMsg.metadata).toBeUndefined();
+    });
+    test("should set metadata.type to tool_result for tool messages", async () => {
+        const { fromModelMessage } = await import("./session-message-converter");
+        const modelMsg = {
+            role: "tool",
+            content: [
+                { type: "tool-result", toolCallId: "c1", toolName: "search", output: "result" },
+            ],
+        };
+        const sessionMsg = fromModelMessage(modelMsg);
+        expect(sessionMsg.metadata).toEqual({ type: "tool_result" });
+    });
+});
+describe("sessionToHistory", () => {
+    test("should convert session messages to ModelMessage array", async () => {
+        const { sessionToHistory } = await import("./session-message-converter");
+        const messages = [
+            createSessionMessage({ role: "user", content: "Hello!" }),
+            createSessionMessage({
+                role: "assistant",
+                parts: [{ type: "text", content: "Hi there!" }]
+            }),
+        ];
+        const history = sessionToHistory(messages);
+        expect(history).toHaveLength(2);
+        expect(history[0].role).toBe("user");
+        expect(history[1].role).toBe("assistant");
+    });
+    test("should filter out archived messages", async () => {
+        const { sessionToHistory } = await import("./session-message-converter");
+        const messages = [
+            createSessionMessage({ role: "user", content: "Message 1" }),
+            createSessionMessage({ role: "user", content: "Message 2", isArchived: true }),
+            createSessionMessage({ role: "user", content: "Message 3" }),
+        ];
+        const history = sessionToHistory(messages);
+        expect(history).toHaveLength(2);
+        expect(history[0].content).toBe("Message 1");
+        expect(history[1].content).toBe("Message 3");
+    });
+});
+describe("extractProviderOptions", () => {
+    test("should extract reasoning options from reasoning parts", async () => {
+        const { extractProviderOptions } = await import("./session-message-converter");
+        const message = createSessionMessage({
+            role: "assistant",
+            parts: [
+                { type: "reasoning", content: "Thinking...", reasoningType: "core" },
+            ],
+        });
+        const options = extractProviderOptions(message);
+        expect(options).toHaveProperty("openai");
+        expect(options.openai).toHaveProperty("thinking");
+    });
+});
+describe("migrateMessage", () => {
+    test("should migrate old format message to new format", async () => {
+        const { migrateMessage } = await import("./session-message-converter");
+        // Old format: content is plain text, no parts
+        const oldMsg = {
+            id: "msg_old",
+            sessionID: "session_test",
+            role: "user",
+            content: "Hello, old world!",
+            timestamp: Date.now(),
+        };
+        const migrated = migrateMessage(oldMsg);
+        expect(migrated.content).toBe("Hello, old world!");
+        expect(migrated.parts).toBeDefined();
+        expect(migrated.parts).toHaveLength(1);
+        expect(migrated.parts[0]).toEqual({ type: "text", content: "Hello, old world!" });
+    });
+    test("should keep new format message as is", async () => {
+        const { migrateMessage } = await import("./session-message-converter");
+        // New format: already has proper parts
+        const newMsg = {
+            id: "msg_new",
+            sessionID: "session_test",
+            role: "assistant",
+            content: "Hello!",
+            timestamp: Date.now(),
+            parts: [
+                { type: "text", content: "Hello!" },
+                { type: "reasoning", content: "Thinking...", reasoningType: "core" },
+            ],
+        };
+        const migrated = migrateMessage(newMsg);
+        expect(migrated.parts).toHaveLength(2);
+        expect(migrated.parts[0].type).toBe("text");
+        expect(migrated.parts[1].type).toBe("reasoning");
+    });
+    test("should migrate message with empty parts array", async () => {
+        const { migrateMessage } = await import("./session-message-converter");
+        // Old format with empty parts (malformed)
+        const oldMsg = {
+            id: "msg_empty_parts",
+            sessionID: "session_test",
+            role: "user",
+            content: "Content without parts field",
+            timestamp: Date.now(),
+            parts: [],
+        };
+        const migrated = migrateMessage(oldMsg);
+        expect(migrated.content).toBe("Content without parts field");
+        expect(migrated.parts).toHaveLength(1);
+        expect(migrated.parts[0]).toEqual({ type: "text", content: "Content without parts field" });
+    });
+});
+describe("Storage Integration", () => {
+    test("SQLite storage should handle new part format", async () => {
+        const { SQLiteSessionStore } = await import("./storage/sqlite");
+        const { toModelMessage } = await import("./session-message-converter");
+        const store = new SQLiteSessionStore(":memory:");
+        // Create session
+        const session = await store.create({ title: "Test Storage" });
+        // Add message with new format parts
+        await store.addMessage(session.id, {
+            role: "user",
+            content: "Test message",
+            parts: [
+                { type: "text", content: "Test message" },
+            ],
+        });
+        // Add assistant message with reasoning
+        await store.addMessage(session.id, {
+            role: "assistant",
+            content: "I'll help you!",
+            parts: [
+                { type: "reasoning", content: "Analyzing the request...", reasoningType: "core" },
+                { type: "text", content: "I'll help you!" },
+            ],
+        });
+        // Retrieve and verify
+        const messages = await store.getMessages(session.id);
+        expect(messages).toHaveLength(2);
+        expect(messages[0].role).toBe("user");
+        expect(messages[0].parts).toHaveLength(1);
+        expect(messages[1].role).toBe("assistant");
+        expect(messages[1].parts).toHaveLength(2);
+        expect(messages[1].parts[0].type).toBe("reasoning");
+        expect(messages[1].parts[1].type).toBe("text");
+        // Convert to ModelMessage
+        const modelMsg = toModelMessage(messages[1]);
+        expect(modelMsg.role).toBe("assistant");
+        expect(modelMsg.content).toHaveLength(2);
+        await store.close();
+    });
+    test("Memory storage should handle new part format", async () => {
+        const { MemorySessionStore } = await import("./storage/memory");
+        const { sessionToHistory } = await import("./session-message-converter");
+        const store = new MemorySessionStore();
+        // Create session
+        const session = await store.create({ title: "Test Memory" });
+        // Add user message
+        await store.addMessage(session.id, {
+            role: "user",
+            content: "Find TODO comments",
+        });
+        // Add assistant message with tool call
+        await store.addMessage(session.id, {
+            role: "assistant",
+            content: "Let me search...",
+            parts: [
+                { type: "text", content: "Let me search..." },
+                { type: "tool-call", toolCallId: "call_1", toolName: "grep", arguments: { pattern: "TODO" }, state: "pending" },
+            ],
+        });
+        await store.addMessage(session.id, {
+            role: "tool",
+            content: "Found 3 matches",
+            parts: [
+                { type: "tool-result", toolCallId: "call_1", toolName: "grep", output: "Found 3 matches", state: "completed" },
+            ],
+        });
+        // Retrieve and convert to history
+        const messages = await store.getMessages(session.id);
+        const history = sessionToHistory(messages);
+        expect(messages).toHaveLength(3);
+        expect(history).toHaveLength(3);
+        expect(history[1].role).toBe("assistant");
+        expect(history[1].content).toHaveLength(2);
+        const toolCall = history[1].content.find((c) => c.type === "tool-call");
+        expect(toolCall).toBeDefined();
+        expect(toolCall.toolCallId).toBe("call_1");
+        expect(toolCall.toolName).toBe("grep");
+    });
+});
+//# sourceMappingURL=session-message-converter.test.js.map

package/dist/core/src/env/session/session-message-e2e.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Session Message Format E2E Tests
+ *
+ * End-to-end tests for the new Session message format with AI SDK v6 support.
+ * Tests the complete flow from adding messages to converting for LLM calls.
+ */
+export {};
+//# sourceMappingURL=session-message-e2e.test.d.ts.map