@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

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

@@ -1,623 +0,0 @@
-/**
- * @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

@@ -1,8 +0,0 @@
-/**
- * @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