@ekodb/ekodb-client 0.13.0 → 0.14.0

package/dist/client.test.js

@@ -1085,6 +1085,100 @@ function mockErrorResponse(status, message) {
     });
 });
 // ============================================================================
+// rawCompletionStream (SSE) Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient rawCompletionStream", () => {
+    (0, vitest_1.it)("parses SSE done event and returns content", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        // SSE response with token chunks and a done event
+        const sseBody = [
+            'data: {"token":"Hello"}',
+            'data: {"token":" world"}',
+            'data: {"content":"Hello world","done":true}',
+            "",
+        ].join("\n");
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers(),
+        });
+        const result = await client.rawCompletionStream({
+            system_prompt: "System.",
+            message: "User.",
+        });
+        (0, vitest_1.expect)(result.content).toBe("Hello world");
+    });
+    (0, vitest_1.it)("accumulates tokens when no done event", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = [
+            'data: {"token":"chunk1"}',
+            'data: {"token":"chunk2"}',
+            "",
+        ].join("\n");
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers(),
+        });
+        const result = await client.rawCompletionStream({
+            system_prompt: "System.",
+            message: "User.",
+        });
+        (0, vitest_1.expect)(result.content).toBe("chunk1chunk2");
+    });
+    (0, vitest_1.it)("throws on SSE error event", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'data: {"error":"LLM timeout"}\n';
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers(),
+        });
+        await (0, vitest_1.expect)(client.rawCompletionStream({
+            system_prompt: "System.",
+            message: "User.",
+        })).rejects.toThrow("LLM timeout");
+    });
+    (0, vitest_1.it)("throws on non-200 HTTP response", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            text: async () => "Unauthorized",
+            headers: new Headers(),
+        });
+        await (0, vitest_1.expect)(client.rawCompletionStream({
+            system_prompt: "System.",
+            message: "User.",
+        })).rejects.toThrow("401");
+    });
+    (0, vitest_1.it)("calls the /stream endpoint", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => 'data: {"content":"ok"}\n',
+            headers: new Headers(),
+        });
+        await client.rawCompletionStream({
+            system_prompt: "System.",
+            message: "User.",
+        });
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/complete/stream");
+        (0, vitest_1.expect)(dataCall[1]?.headers?.Accept).toBe("text/event-stream");
+    });
+});
+// ============================================================================
 // Token Management Tests
 // ============================================================================
 (0, vitest_1.describe)("refreshToken", () => {
@@ -1161,3 +1255,719 @@ function mockErrorResponse(status, message) {
         (0, vitest_1.expect)(dataCall[0]).toBe("http://localhost:8080/api/find/users/123");
     });
 });
+// ============================================================================
+// Goal CRUD Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient goals", () => {
+    (0, vitest_1.it)("creates a goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1", title: "Test Goal", status: "active" });
+        const result = await client.goalCreate({ title: "Test Goal" });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "goal_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+    });
+    (0, vitest_1.it)("lists goals", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ goals: [{ id: "goal_1" }, { id: "goal_2" }] });
+        const result = await client.goalList();
+        (0, vitest_1.expect)(result).toHaveProperty("goals");
+    });
+    (0, vitest_1.it)("gets a goal by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1", title: "Test Goal" });
+        const result = await client.goalGet("goal_1");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "goal_1");
+    });
+    (0, vitest_1.it)("updates a goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1", title: "Updated" });
+        const result = await client.goalUpdate("goal_1", { title: "Updated" });
+        (0, vitest_1.expect)(result).toHaveProperty("title", "Updated");
+    });
+    (0, vitest_1.it)("deletes a goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({});
+        await (0, vitest_1.expect)(client.goalDelete("goal_1")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("searches goals", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ goals: [{ id: "goal_1" }] });
+        const result = await client.goalSearch("test query");
+        (0, vitest_1.expect)(result).toHaveProperty("goals");
+    });
+    (0, vitest_1.it)("completes a goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1", status: "pending_review" });
+        const result = await client.goalComplete("goal_1", { summary: "Done" });
+        (0, vitest_1.expect)(result).toHaveProperty("status", "pending_review");
+    });
+    (0, vitest_1.it)("approves a goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1", status: "in_progress" });
+        const result = await client.goalApprove("goal_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "in_progress");
+    });
+    (0, vitest_1.it)("rejects a goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1", status: "failed" });
+        const result = await client.goalReject("goal_1", { reason: "Bad plan" });
+        (0, vitest_1.expect)(result).toHaveProperty("status", "failed");
+    });
+    (0, vitest_1.it)("starts a goal step", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1" });
+        const result = await client.goalStepStart("goal_1", 0);
+        (0, vitest_1.expect)(result).toHaveProperty("id", "goal_1");
+    });
+    (0, vitest_1.it)("completes a goal step", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1" });
+        const result = await client.goalStepComplete("goal_1", 0, {
+            result: "Step done",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "goal_1");
+    });
+    (0, vitest_1.it)("fails a goal step", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "goal_1" });
+        const result = await client.goalStepFail("goal_1", 0, {
+            error: "Step failed",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "goal_1");
+    });
+    (0, vitest_1.it)("returns error for non-existent goal", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockErrorResponse(404, "Not Found");
+        await (0, vitest_1.expect)(client.goalGet("nonexistent")).rejects.toThrow();
+    });
+});
+// ============================================================================
+// Task CRUD Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient tasks", () => {
+    (0, vitest_1.it)("creates a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", name: "Test Task", status: "active" });
+        const result = await client.taskCreate({
+            name: "Test Task",
+            cron: "0 * * * *",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "task_1");
+    });
+    (0, vitest_1.it)("lists tasks", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ tasks: [] });
+        const result = await client.taskList();
+        (0, vitest_1.expect)(result).toHaveProperty("tasks");
+    });
+    (0, vitest_1.it)("gets a task by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", name: "Test Task" });
+        const result = await client.taskGet("task_1");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "task_1");
+    });
+    (0, vitest_1.it)("updates a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", name: "Updated" });
+        const result = await client.taskUpdate("task_1", { name: "Updated" });
+        (0, vitest_1.expect)(result).toHaveProperty("name", "Updated");
+    });
+    (0, vitest_1.it)("deletes a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({});
+        await (0, vitest_1.expect)(client.taskDelete("task_1")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("gets due tasks", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ tasks: [] });
+        const result = await client.taskDue("2026-03-20T00:00:00Z");
+        (0, vitest_1.expect)(result).toHaveProperty("tasks");
+    });
+    (0, vitest_1.it)("starts a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", status: "running" });
+        const result = await client.taskStart("task_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "running");
+    });
+    (0, vitest_1.it)("succeeds a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", status: "active" });
+        const result = await client.taskSucceed("task_1", { output: "Success" });
+        (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+    });
+    (0, vitest_1.it)("fails a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", status: "active" });
+        const result = await client.taskFail("task_1", { error: "Timeout" });
+        (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+    });
+    (0, vitest_1.it)("pauses a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", status: "paused" });
+        const result = await client.taskPause("task_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "paused");
+    });
+    (0, vitest_1.it)("resumes a task", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "task_1", status: "active" });
+        const result = await client.taskResume("task_1", {});
+        (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+    });
+});
+// ============================================================================
+// Agent CRUD Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient agents", () => {
+    (0, vitest_1.it)("creates an agent", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "agent_1", name: "TestAgent" });
+        const result = await client.agentCreate({
+            name: "TestAgent",
+            system_prompt: "You help.",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("name", "TestAgent");
+    });
+    (0, vitest_1.it)("lists agents", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ agents: [] });
+        const result = await client.agentList();
+        (0, vitest_1.expect)(result).toHaveProperty("agents");
+    });
+    (0, vitest_1.it)("gets an agent by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "agent_1", name: "TestAgent" });
+        const result = await client.agentGet("agent_1");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "agent_1");
+    });
+    (0, vitest_1.it)("gets an agent by name", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "agent_1", name: "TestAgent" });
+        const result = await client.agentGetByName("TestAgent");
+        (0, vitest_1.expect)(result).toHaveProperty("name", "TestAgent");
+    });
+    (0, vitest_1.it)("updates an agent", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "agent_1", name: "Updated" });
+        const result = await client.agentUpdate("agent_1", { name: "Updated" });
+        (0, vitest_1.expect)(result).toHaveProperty("name", "Updated");
+    });
+    (0, vitest_1.it)("deletes an agent", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({});
+        await (0, vitest_1.expect)(client.agentDelete("agent_1")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("gets agents by deployment", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ agents: [{ id: "agent_1" }] });
+        const result = await client.agentsByDeployment("deploy_1");
+        (0, vitest_1.expect)(result).toHaveProperty("agents");
+    });
+    (0, vitest_1.it)("returns error for non-existent agent", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockErrorResponse(404, "Not Found");
+        await (0, vitest_1.expect)(client.agentGet("nonexistent")).rejects.toThrow();
+    });
+});
+// ============================================================================
+// rawCompletionStreamWithProgress Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient rawCompletionStreamWithProgress", () => {
+    (0, vitest_1.it)("calls onToken for each token", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        // Mock SSE response
+        const sseBody = [
+            'data: {"token": "Hello"}',
+            'data: {"token": " World"}',
+            'data: {"content": "Hello World"}',
+        ].join("\n");
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        const tokens = [];
+        const result = await client.rawCompletionStreamWithProgress({ system_prompt: "test", message: "test" }, (token) => tokens.push(token));
+        (0, vitest_1.expect)(tokens).toEqual(["Hello", " World"]);
+        (0, vitest_1.expect)(result.content).toBe("Hello World");
+    });
+    (0, vitest_1.it)("throws on SSE error event", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'data: {"error": "Model overloaded"}';
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        const tokens = [];
+        await (0, vitest_1.expect)(client.rawCompletionStreamWithProgress({ system_prompt: "test", message: "test" }, (token) => tokens.push(token))).rejects.toThrow("Model overloaded");
+    });
+});
+// ============================================================================
+// Goal Template CRUD Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient goal templates", () => {
+    (0, vitest_1.it)("creates a goal template", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "gt_1", title: "Deploy Checklist" });
+        const result = await client.goalTemplateCreate({
+            title: "Deploy Checklist",
+            steps: [{ title: "Run tests" }],
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "gt_1");
+        (0, vitest_1.expect)(result).toHaveProperty("title", "Deploy Checklist");
+    });
+    (0, vitest_1.it)("creates a goal template and verifies POST method", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "gt_2", title: "Onboarding" });
+        await client.goalTemplateCreate({ title: "Onboarding" });
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1]; // calls[0] is token
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/goal-templates");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("POST");
+    });
+    (0, vitest_1.it)("lists goal templates", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            templates: [{ id: "gt_1" }, { id: "gt_2" }],
+        });
+        const result = await client.goalTemplateList();
+        (0, vitest_1.expect)(result).toHaveProperty("templates");
+    });
+    (0, vitest_1.it)("lists goal templates and verifies GET method", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ templates: [] });
+        await client.goalTemplateList();
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/goal-templates");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("GET");
+    });
+    (0, vitest_1.it)("gets a goal template by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "gt_1", title: "Deploy Checklist" });
+        const result = await client.goalTemplateGet("gt_1");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "gt_1");
+        (0, vitest_1.expect)(result).toHaveProperty("title", "Deploy Checklist");
+    });
+    (0, vitest_1.it)("gets a goal template and verifies endpoint", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "gt_1", title: "Deploy Checklist" });
+        await client.goalTemplateGet("gt_1");
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/goal-templates/gt_1");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("GET");
+    });
+    (0, vitest_1.it)("updates a goal template", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "gt_1", title: "Updated Checklist" });
+        const result = await client.goalTemplateUpdate("gt_1", {
+            title: "Updated Checklist",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("title", "Updated Checklist");
+    });
+    (0, vitest_1.it)("updates a goal template and verifies PUT method", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "gt_1", title: "Updated" });
+        await client.goalTemplateUpdate("gt_1", { title: "Updated" });
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/goal-templates/gt_1");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("PUT");
+    });
+    (0, vitest_1.it)("deletes a goal template", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({});
+        await (0, vitest_1.expect)(client.goalTemplateDelete("gt_1")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("deletes a goal template and verifies DELETE method", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({});
+        await client.goalTemplateDelete("gt_1");
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/goal-templates/gt_1");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("DELETE");
+    });
+    (0, vitest_1.it)("returns error for non-existent goal template", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockErrorResponse(404, "Not Found");
+        await (0, vitest_1.expect)(client.goalTemplateGet("nonexistent")).rejects.toThrow();
+    });
+});
+// ============================================================================
+// chatMessageStream (SSE) Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient chatMessageStream", () => {
+    (0, vitest_1.it)("emits chunk and end events from SSE stream", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = [
+            'data: {"token":"Hello"}',
+            'data: {"token":" world"}',
+            'data: {"content":"Hello world","message_id":"msg_1","execution_time_ms":42}',
+            "",
+        ].join("\n");
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        const events = [];
+        const stream = client.chatMessageStream("chat_123", {
+            message: "Hello",
+        });
+        stream.on("event", (evt) => events.push(evt));
+        // Wait for the async SSE processing to complete
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        (0, vitest_1.expect)(events).toHaveLength(3);
+        (0, vitest_1.expect)(events[0]).toEqual({ type: "chunk", content: "Hello" });
+        (0, vitest_1.expect)(events[1]).toEqual({ type: "chunk", content: " world" });
+        (0, vitest_1.expect)(events[2].type).toBe("end");
+        (0, vitest_1.expect)(events[2].messageId).toBe("msg_1");
+        (0, vitest_1.expect)(events[2].executionTimeMs).toBe(42);
+    });
+    (0, vitest_1.it)("emits error event on SSE error", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'data: {"error":"LLM timeout"}\n';
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => sseBody,
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        const events = [];
+        const stream = client.chatMessageStream("chat_123", {
+            message: "Hello",
+        });
+        stream.on("event", (evt) => events.push(evt));
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        (0, vitest_1.expect)(events).toHaveLength(1);
+        (0, vitest_1.expect)(events[0]).toEqual({ type: "error", error: "LLM timeout" });
+    });
+    (0, vitest_1.it)("emits error event on non-200 HTTP response", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            text: async () => "Unauthorized",
+            headers: new Headers(),
+        });
+        const events = [];
+        const stream = client.chatMessageStream("chat_123", {
+            message: "Hello",
+        });
+        stream.on("event", (evt) => events.push(evt));
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        (0, vitest_1.expect)(events).toHaveLength(1);
+        (0, vitest_1.expect)(events[0].type).toBe("error");
+        (0, vitest_1.expect)(events[0].error).toContain("401");
+    });
+    (0, vitest_1.it)("calls the correct stream endpoint", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => 'data: {"token":"ok"}\n',
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        client.chatMessageStream("chat_456", { message: "Test" });
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/chat/chat_456/messages/stream");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("POST");
+        (0, vitest_1.expect)(dataCall[1]?.headers?.Accept).toBe("text/event-stream");
+    });
+});
+// ============================================================================
+// Schedule CRUD Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient schedules", () => {
+    (0, vitest_1.it)("creates a schedule", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            id: "sched_1",
+            name: "Nightly Backup",
+            cron: "0 2 * * *",
+            status: "active",
+        });
+        const result = await client.createSchedule({
+            name: "Nightly Backup",
+            cron: "0 2 * * *",
+            action: "backup",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "sched_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+    });
+    (0, vitest_1.it)("lists schedules", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            schedules: [
+                { id: "sched_1", name: "Nightly Backup" },
+                { id: "sched_2", name: "Hourly Sync" },
+            ],
+        });
+        const result = await client.listSchedules();
+        (0, vitest_1.expect)(result).toHaveProperty("schedules");
+    });
+    (0, vitest_1.it)("gets a schedule by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            id: "sched_1",
+            name: "Nightly Backup",
+            cron: "0 2 * * *",
+        });
+        const result = await client.getSchedule("sched_1");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "sched_1");
+        (0, vitest_1.expect)(result).toHaveProperty("name", "Nightly Backup");
+    });
+    (0, vitest_1.it)("updates a schedule", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            id: "sched_1",
+            name: "Updated Backup",
+            cron: "0 3 * * *",
+        });
+        const result = await client.updateSchedule("sched_1", {
+            name: "Updated Backup",
+            cron: "0 3 * * *",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("name", "Updated Backup");
+        (0, vitest_1.expect)(result).toHaveProperty("cron", "0 3 * * *");
+    });
+    (0, vitest_1.it)("deletes a schedule", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({});
+        await (0, vitest_1.expect)(client.deleteSchedule("sched_1")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("pauses a schedule", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "sched_1", status: "paused" });
+        const result = await client.pauseSchedule("sched_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "paused");
+    });
+    (0, vitest_1.it)("resumes a schedule", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "sched_1", status: "active" });
+        const result = await client.resumeSchedule("sched_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+    });
+});
+// ============================================================================
+// KV Links Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient kv links", () => {
+    (0, vitest_1.it)("gets links for a KV key", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            links: [
+                { collection: "users", document_id: "user_1" },
+                { collection: "orders", document_id: "order_1" },
+            ],
+        });
+        const result = await client.kvGetLinks("session:user123");
+        (0, vitest_1.expect)(result).toHaveProperty("links");
+    });
+    (0, vitest_1.it)("links a document to a KV key", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "linked" });
+        const result = await client.kvLink("session:user123", "users", "user_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "linked");
+    });
+    (0, vitest_1.it)("unlinks a document from a KV key", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "unlinked" });
+        const result = await client.kvUnlink("session:user123", "users", "user_1");
+        (0, vitest_1.expect)(result).toHaveProperty("status", "unlinked");
+    });
+});
+// ============================================================================
+// Text Search and Hybrid Search Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient text and hybrid search", () => {
+    (0, vitest_1.it)("performs text search", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            results: [
+                {
+                    record: { id: "doc_1", title: "Ownership Guide" },
+                    score: 0.92,
+                    matched_fields: ["title"],
+                },
+                {
+                    record: { id: "doc_2", title: "Property Ownership" },
+                    score: 0.85,
+                    matched_fields: ["title"],
+                },
+            ],
+            total: 2,
+            took_ms: 12,
+        });
+        const result = await client.textSearch("documents", "ownership", {
+            limit: 10,
+            select_fields: ["title", "content"],
+        });
+        (0, vitest_1.expect)(result.results).toHaveLength(2);
+        (0, vitest_1.expect)(result.total).toBe(2);
+        (0, vitest_1.expect)(result.results[0].score).toBe(0.92);
+    });
+    (0, vitest_1.it)("performs hybrid search", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            results: [
+                {
+                    record: { id: "doc_1", title: "ML Guide", content: "Learn ML" },
+                    score: 0.95,
+                    matched_fields: ["title", "content"],
+                },
+            ],
+            total: 1,
+            took_ms: 25,
+        });
+        const queryVector = [0.1, 0.2, 0.3, 0.4, 0.5];
+        const result = await client.hybridSearch("documents", "machine learning", queryVector, 5);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0]).toHaveProperty("id", "doc_1");
+        (0, vitest_1.expect)(result[0]).toHaveProperty("title", "ML Guide");
+    });
+});
+// ============================================================================
+// Auth Token Management
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient auth token management", () => {
+    (0, vitest_1.beforeEach)(() => {
+        mockFetch.mockReset();
+    });
+    (0, vitest_1.it)("getToken auto-refreshes when token is about to expire", async () => {
+        const client = createTestClient();
+        // First init — get a token with a short expiry (30s from now)
+        const shortExp = Math.floor(Date.now() / 1000) + 30;
+        const shortPayload = btoa(JSON.stringify({ exp: shortExp }))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+        const shortJwt = `eyJhbGciOiJIUzI1NiJ9.${shortPayload}.fakesig`;
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => ({ token: shortJwt }),
+            headers: new Headers(),
+        });
+        await client.init();
+        // Now getToken should see it's about to expire and refresh
+        const newExp = Math.floor(Date.now() / 1000) + 3600;
+        const newPayload = btoa(JSON.stringify({ exp: newExp }))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+        const newJwt = `eyJhbGciOiJIUzI1NiJ9.${newPayload}.fakesig`;
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => ({ token: newJwt }),
+            headers: new Headers(),
+        });
+        const token = await client.getToken();
+        (0, vitest_1.expect)(token).toBe(newJwt);
+        // 2 fetch calls: init + proactive refresh
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledTimes(2);
+    });
+    (0, vitest_1.it)("getToken returns cached token when not expired", async () => {
+        const client = createTestClient();
+        // Token with expiry far in the future
+        const farExp = Math.floor(Date.now() / 1000) + 7200;
+        const payload = btoa(JSON.stringify({ exp: farExp }))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+        const jwt = `eyJhbGciOiJIUzI1NiJ9.${payload}.fakesig`;
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => ({ token: jwt }),
+            headers: new Headers(),
+        });
+        await client.init();
+        // getToken should return cached — no extra fetch
+        const token = await client.getToken();
+        (0, vitest_1.expect)(token).toBe(jwt);
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledTimes(1); // only init
+    });
+    (0, vitest_1.it)("clearTokenCache resets token and expiry", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        await client.init();
+        (0, vitest_1.expect)(await client.getToken()).toBeTruthy();
+        client.clearTokenCache();
+        // After clear, getToken will auto-refresh (fetch a new token)
+        mockTokenResponse();
+        const token = await client.getToken();
+        (0, vitest_1.expect)(token).toBe("test-jwt-token");
+        // 2 fetch calls: init + post-clear getToken refresh
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledTimes(2);
+    });
+});