@ekodb/ekodb-client 0.25.0 → 0.26.1

package/dist/client.test.js

@@ -1045,6 +1045,47 @@ function mockErrorResponse(status, message) {
         (0, vitest_1.expect)(result.anthropic).toHaveLength(2);
         (0, vitest_1.expect)(result.perplexity).toHaveLength(1);
     });
+    (0, vitest_1.it)("carries gemini and the per-provider status from the server", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            openai: [],
+            anthropic: ["claude-sonnet-4-5"],
+            perplexity: ["sonar"],
+            gemini: ["gemini-2.5-flash"],
+            providers: {
+                anthropic: { status: "ok", verified: true, model_count: 1 },
+                gemini: { status: "ok", verified: true, model_count: 1 },
+                openai: {
+                    status: "auth_failed",
+                    verified: true,
+                    http_status: 401,
+                    message: "Failed to fetch OpenAI models: 401 Unauthorized",
+                },
+                perplexity: {
+                    status: "ok",
+                    verified: false,
+                    message: "static model list; key not verified",
+                },
+            },
+        });
+        const result = await client.getChatModels();
+        (0, vitest_1.expect)(result.gemini).toEqual(["gemini-2.5-flash"]);
+        (0, vitest_1.expect)(result.providers?.openai.status).toBe("auth_failed");
+        (0, vitest_1.expect)(result.providers?.openai.http_status).toBe(401);
+        (0, vitest_1.expect)(result.providers?.openai.verified).toBe(true);
+        (0, vitest_1.expect)(result.providers?.perplexity.verified).toBe(false);
+        (0, vitest_1.expect)(result.providers?.anthropic.model_count).toBe(1);
+    });
+    (0, vitest_1.it)("tolerates a server that predates gemini and providers", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ openai: ["gpt-4o"], anthropic: [], perplexity: [] });
+        const result = await client.getChatModels();
+        (0, vitest_1.expect)(result.openai).toEqual(["gpt-4o"]);
+        (0, vitest_1.expect)(result.gemini).toBeUndefined();
+        (0, vitest_1.expect)(result.providers).toBeUndefined();
+    });
     (0, vitest_1.it)("gets models for specific provider", async () => {
         const client = createTestClient();
         mockTokenResponse();
@@ -1909,6 +1950,112 @@ function mockErrorResponse(status, message) {
         (0, vitest_1.expect)(events[2].messageId).toBe("msg_1");
         (0, vitest_1.expect)(events[2].executionTimeMs).toBe(42);
     });
+    (0, vitest_1.it)("treats a frame named error as an error even when its payload says message", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'event: token\ndata: {"token":"Hel"}\n\nevent: error\ndata: {"message":"boom"}\n\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).toEqual([
+            { type: "chunk", content: "Hel" },
+            { type: "error", error: "boom" },
+        ]);
+    });
+    (0, vitest_1.it)("stops reading after an error frame and emits nothing that follows it", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'event: error\ndata: {"message":"boom"}\n\nevent: token\ndata: {"token":"late"}\n\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).toEqual([{ type: "error", error: "boom" }]);
+    });
+    (0, vitest_1.it)("cancels the body reader after an error frame instead of waiting for the server to close", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const encoder = new TextEncoder();
+        const chunks = [
+            encoder.encode('event: error\ndata: {"message":"boom"}\n\n'),
+            encoder.encode('event: token\ndata: {"token":"late"}\n\n'),
+        ];
+        const cancel = vitest_1.vi.fn(async () => { });
+        let reads = 0;
+        const reader = {
+            read: vitest_1.vi.fn(async () => {
+                // A server (or proxy) that does not close after the error frame: it
+                // keeps sending frames. Bounded so a client that never stops fails
+                // the assertions below instead of looping forever.
+                if (reads >= 50)
+                    return { done: true, value: undefined };
+                const value = chunks[Math.min(reads, chunks.length - 1)];
+                reads += 1;
+                return { done: false, value };
+            }),
+            cancel,
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            body: { getReader: () => reader },
+            text: async () => "",
+            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).toEqual([{ type: "error", error: "boom" }]);
+        // One read delivered the error frame; the reader was cancelled rather
+        // than read until the server closed.
+        (0, vitest_1.expect)(reader.read).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(cancel).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("keeps the error text a string when the server sends a structured error", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'event: error\ndata: {"error":{"code":"upstream_down","status":503},"error_kind":"provider_unavailable","provider":"openai"}\n\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).toEqual([
+            {
+                type: "error",
+                error: "Unknown error",
+                errorKind: "provider_unavailable",
+                provider: "openai",
+            },
+        ]);
+    });
     (0, vitest_1.it)("emits error event on SSE error", async () => {
         const client = createTestClient();
         mockTokenResponse();
@@ -1928,6 +2075,36 @@ function mockErrorResponse(status, message) {
         (0, vitest_1.expect)(events).toHaveLength(1);
         (0, vitest_1.expect)(events[0]).toEqual({ type: "error", error: "LLM timeout" });
     });
+    (0, vitest_1.it)("carries the provider failure classification on an error event", async () => {
+        // The deployment classifies a provider failure (`error_kind`, `provider`,
+        // `provider_status`, `retry_after_secs` on the wire); the event carries
+        // every one of them, in this shape's camelCase, so a consumer can act on
+        // it without string-matching.
+        const client = createTestClient();
+        mockTokenResponse();
+        const sseBody = 'data: {"error":"OpenAI API error: Incorrect API key provided","error_kind":"provider_auth_failed","provider":"openai","provider_status":401}\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).toEqual([
+            {
+                type: "error",
+                error: "OpenAI API error: Incorrect API key provided",
+                errorKind: "provider_auth_failed",
+                provider: "openai",
+                providerStatus: 401,
+            },
+        ]);
+    });
     (0, vitest_1.it)("emits error event on non-200 HTTP response", async () => {
         const client = createTestClient();
         mockTokenResponse();
@@ -2100,6 +2277,15 @@ function mockErrorResponse(status, message) {
         mockJsonResponse({ id: "sched_1", status: "paused" });
         const result = await client.pauseSchedule("sched_1");
         (0, vitest_1.expect)(result).toHaveProperty("status", "paused");
+        // Assert the REQUEST. There is no /pause route; pausing is a partial
+        // update of `enabled`. A response-only assertion passed for as long as
+        // this method POSTed to a route that does not exist.
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1]; // calls[0] is the token exchange
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/schedules/sched_1");
+        (0, vitest_1.expect)(dataCall[0]).not.toContain("/pause");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("PUT");
+        (0, vitest_1.expect)(JSON.parse(dataCall[1]?.body)).toEqual({ enabled: false });
     });
     (0, vitest_1.it)("resumes a schedule", async () => {
         const client = createTestClient();
@@ -2107,6 +2293,12 @@ function mockErrorResponse(status, message) {
         mockJsonResponse({ id: "sched_1", status: "active" });
         const result = await client.resumeSchedule("sched_1");
         (0, vitest_1.expect)(result).toHaveProperty("status", "active");
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/schedules/sched_1");
+        (0, vitest_1.expect)(dataCall[0]).not.toContain("/resume");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("PUT");
+        (0, vitest_1.expect)(JSON.parse(dataCall[1]?.body)).toEqual({ enabled: true });
     });
 });
 // ============================================================================
@@ -2124,6 +2316,14 @@ function mockErrorResponse(status, message) {
         });
         const result = await client.kvGetLinks("session:user123");
         (0, vitest_1.expect)(result).toHaveProperty("links");
+        // Assert the REQUEST, not just the mocked response. These three methods
+        // shipped pointing at routes that do not exist, and every one of these
+        // tests passed the whole time, because a mocked response says nothing
+        // about the URL the client actually asked for.
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1]; // calls[0] is the token exchange
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/kv/session%3Auser123/links");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("GET");
     });
     (0, vitest_1.it)("links a document to a KV key", async () => {
         const client = createTestClient();
@@ -2131,6 +2331,26 @@ function mockErrorResponse(status, message) {
         mockJsonResponse({ status: "linked" });
         const result = await client.kvLink("session:user123", "users", "user_1");
         (0, vitest_1.expect)(result).toHaveProperty("status", "linked");
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        // The identifying triple belongs in the PATH, not the body.
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/kv/session%3Auser123/links/users/user_1");
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("POST");
+    });
+    (0, vitest_1.it)("passes optional link data in the body", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "linked" });
+        await client.kvLink("session:user123", "users", "user_1", {
+            field_path: "profile.avatar",
+            metadata: { source: "signup" },
+        });
+        const calls = global.fetch.mock.calls;
+        const body = JSON.parse(calls[1][1]?.body);
+        (0, vitest_1.expect)(body).toEqual({
+            field_path: "profile.avatar",
+            metadata: { source: "signup" },
+        });
     });
     (0, vitest_1.it)("unlinks a document from a KV key", async () => {
         const client = createTestClient();
@@ -2138,6 +2358,11 @@ function mockErrorResponse(status, message) {
         mockJsonResponse({ status: "unlinked" });
         const result = await client.kvUnlink("session:user123", "users", "user_1");
         (0, vitest_1.expect)(result).toHaveProperty("status", "unlinked");
+        const calls = global.fetch.mock.calls;
+        const dataCall = calls[1];
+        (0, vitest_1.expect)(dataCall[0]).toContain("/api/kv/session%3Auser123/links/users/user_1");
+        // DELETE, not POST — the previous implementation used POST and 404'd.
+        (0, vitest_1.expect)(dataCall[1]?.method).toBe("DELETE");
     });
 });
 // ============================================================================
@@ -2161,7 +2386,7 @@ function mockErrorResponse(status, message) {
                 },
             ],
             total: 2,
-            took_ms: 12,
+            execution_time_ms: 12,
         });
         const result = await client.textSearch("documents", "ownership", {
             limit: 10,
@@ -2183,7 +2408,7 @@ function mockErrorResponse(status, message) {
                 },
             ],
             total: 1,
-            took_ms: 25,
+            execution_time_ms: 25,
         });
         const queryVector = [0.1, 0.2, 0.3, 0.4, 0.5];
         const result = await client.hybridSearch("documents", "machine learning", queryVector, 5);

package/dist/functions.d.ts

@@ -56,18 +56,6 @@ export type FunctionStageConfig = {
 } | {
     type: "Count";
     output_field: string;
-} | {
-    type: "Filter";
-    filter: Record<string, any>;
-} | {
-    type: "Sort";
-    sort: SortFieldConfig[];
-} | {
-    type: "Limit";
-    limit: number;
-} | {
-    type: "Skip";
-    skip: number;
 } | {
     type: "Insert";
     collection: string;
@@ -581,10 +569,25 @@ export declare const Stage: {
     deleteById: (collection: string, record_id: string, bypassRipple?: boolean) => FunctionStageConfig;
     batchInsert: (collection: string, records: Record<string, any>[], bypassRipple?: boolean) => FunctionStageConfig;
     batchDelete: (collection: string, record_ids: string[], bypassRipple?: boolean) => FunctionStageConfig;
-    filter: (filter: Record<string, any>) => FunctionStageConfig;
-    sort: (sort: SortFieldConfig[]) => FunctionStageConfig;
-    limit: (limit: number) => FunctionStageConfig;
-    skip: (skip: number) => FunctionStageConfig;
+    /**
+     * Filter a collection.
+     *
+     * Shorthand for a `Query` stage carrying only `filter`. There is no separate
+     * `Filter` stage server-side — filtering, sorting, limiting and skipping are
+     * all fields on `Query`. This previously emitted `{ type: "Filter" }`, which
+     * the server has no variant for; because a function's stage array
+     * deserializes as a unit, one such stage rejected the ENTIRE function.
+     *
+     * Use {@link Stage.query} when you need more than one of these at once — it
+     * takes them together and produces a single stage.
+     */
+    filter: (collection: string, filter: Record<string, any>) => FunctionStageConfig;
+    /** Sort a collection. Shorthand for a `Query` carrying only `sort`. */
+    sort: (collection: string, sort: SortFieldConfig[]) => FunctionStageConfig;
+    /** Limit a collection read. Shorthand for a `Query` carrying only `limit`. */
+    limit: (collection: string, limit: number) => FunctionStageConfig;
+    /** Skip rows of a collection read. Shorthand for a `Query` with only `skip`. */
+    skip: (collection: string, skip: number) => FunctionStageConfig;
     httpRequest: (url: string, method?: string, headers?: Record<string, string>, body?: any) => FunctionStageConfig;
     vectorSearch: (collection: string, query_vector: number[], limit?: number, threshold?: number) => FunctionStageConfig;
     textSearch: (collection: string, query_text: string, options?: {

package/dist/functions.js

@@ -103,20 +103,39 @@ exports.Stage = {
         record_ids,
         bypass_ripple: bypassRipple,
     }),
-    filter: (filter) => ({
-        type: "Filter",
+    /**
+     * Filter a collection.
+     *
+     * Shorthand for a `Query` stage carrying only `filter`. There is no separate
+     * `Filter` stage server-side — filtering, sorting, limiting and skipping are
+     * all fields on `Query`. This previously emitted `{ type: "Filter" }`, which
+     * the server has no variant for; because a function's stage array
+     * deserializes as a unit, one such stage rejected the ENTIRE function.
+     *
+     * Use {@link Stage.query} when you need more than one of these at once — it
+     * takes them together and produces a single stage.
+     */
+    filter: (collection, filter) => ({
+        type: "Query",
+        collection,
         filter,
     }),
-    sort: (sort) => ({
-        type: "Sort",
+    /** Sort a collection. Shorthand for a `Query` carrying only `sort`. */
+    sort: (collection, sort) => ({
+        type: "Query",
+        collection,
         sort,
     }),
-    limit: (limit) => ({
-        type: "Limit",
+    /** Limit a collection read. Shorthand for a `Query` carrying only `limit`. */
+    limit: (collection, limit) => ({
+        type: "Query",
+        collection,
         limit,
     }),
-    skip: (skip) => ({
-        type: "Skip",
+    /** Skip rows of a collection read. Shorthand for a `Query` with only `skip`. */
+    skip: (collection, skip) => ({
+        type: "Query",
+        collection,
         skip,
     }),
     httpRequest: (url, method = "GET", headers, body) => ({

package/dist/functions.test.js

@@ -538,4 +538,46 @@ const functions_1 = require("./functions");
             (0, vitest_1.expect)(wire.type).toBe(s.type);
         }
     });
+    (0, vitest_1.describe)("filter/sort/limit/skip emit Query stages", () => {
+        // These four used to emit { type: "Filter" | "Sort" | "Limit" | "Skip" },
+        // none of which the server has a variant for. Because a function's stage
+        // array deserializes as a unit, a single one of them rejected the ENTIRE
+        // function. They are shorthands for a Query carrying that one field.
+        (0, vitest_1.it)("filter emits a Query with only the filter set", () => {
+            const wire = JSON.parse(JSON.stringify(functions_1.Stage.filter("users", { status: "active" })));
+            (0, vitest_1.expect)(wire.type).toBe("Query");
+            (0, vitest_1.expect)(wire.collection).toBe("users");
+            (0, vitest_1.expect)(wire.filter).toEqual({ status: "active" });
+        });
+        (0, vitest_1.it)("sort emits a Query with only the sort set", () => {
+            const wire = JSON.parse(JSON.stringify(functions_1.Stage.sort("users", [{ field: "created_at", ascending: false }])));
+            (0, vitest_1.expect)(wire.type).toBe("Query");
+            (0, vitest_1.expect)(wire.collection).toBe("users");
+            (0, vitest_1.expect)(wire.sort).toEqual([{ field: "created_at", ascending: false }]);
+        });
+        (0, vitest_1.it)("limit emits a Query with only the limit set", () => {
+            const wire = JSON.parse(JSON.stringify(functions_1.Stage.limit("users", 10)));
+            (0, vitest_1.expect)(wire.type).toBe("Query");
+            (0, vitest_1.expect)(wire.collection).toBe("users");
+            (0, vitest_1.expect)(wire.limit).toBe(10);
+        });
+        (0, vitest_1.it)("skip emits a Query with only the skip set", () => {
+            const wire = JSON.parse(JSON.stringify(functions_1.Stage.skip("users", 5)));
+            (0, vitest_1.expect)(wire.type).toBe("Query");
+            (0, vitest_1.expect)(wire.collection).toBe("users");
+            (0, vitest_1.expect)(wire.skip).toBe(5);
+        });
+        (0, vitest_1.it)("never emits a stage type the server has no variant for", () => {
+            const wire = [
+                functions_1.Stage.filter("users", {}),
+                functions_1.Stage.sort("users", []),
+                functions_1.Stage.limit("users", 1),
+                functions_1.Stage.skip("users", 1),
+            ].map((s) => JSON.parse(JSON.stringify(s)).type);
+            (0, vitest_1.expect)(wire).not.toContain("Filter");
+            (0, vitest_1.expect)(wire).not.toContain("Sort");
+            (0, vitest_1.expect)(wire).not.toContain("Limit");
+            (0, vitest_1.expect)(wire).not.toContain("Skip");
+        });
+    });
 });

package/dist/index.d.ts

@@ -13,4 +13,4 @@ export type { Schema, FieldTypeSchema, IndexConfig, CollectionMetadata, } from "
 export type { JoinConfig } from "./join";
 export type { UserFunction, ParameterDefinition, FunctionStageConfig, GroupFunctionConfig, SortFieldConfig, FunctionResult, FunctionStats, StageStats, } from "./functions";
 export type { MutationNotification, ChatStreamEvent, ClientToolDefinition, ChatSendOptions, SubscribeOptions, } from "./client";
-export type { Record, Query, BatchOperationResult, ClientConfig, RateLimitInfo, CollectionConfig, ChatRequest, CreateChatSessionRequest, ChatMessageRequest, TokenUsage, ChatResponse, ChatSession, ChatSessionResponse, ListSessionsQuery, ListSessionsResponse, GetMessagesQuery, GetMessagesResponse, UpdateSessionRequest, MergeSessionsRequest, ChatModels, CompactChatRequest, CompactChatResponse, EmbedRequest, EmbedResponse, RawCompletionRequest, RawCompletionResponse, ToolChoice, ToolConfig, } from "./client";
+export type { Record, Query, BatchOperationResult, ClientConfig, RateLimitInfo, CollectionConfig, ChatRequest, CreateChatSessionRequest, ChatMessageRequest, TokenUsage, ChatResponse, ChatSession, ChatSessionResponse, ListSessionsQuery, ListSessionsResponse, GetMessagesQuery, GetMessagesResponse, UpdateSessionRequest, MergeSessionsRequest, ChatModels, ChatProviderState, ChatProviderStatus, CompactChatRequest, CompactChatResponse, EmbedRequest, EmbedResponse, RawCompletionRequest, RawCompletionResponse, ToolChoice, ToolConfig, } from "./client";

package/dist/search.d.ts

@@ -79,7 +79,7 @@ export interface SearchResponse {
     /** Total number of results found */
     total: number;
     /** Query execution time in milliseconds */
-    took_ms?: number;
+    execution_time_ms?: number;
 }
 /**
  * Builder for constructing search queries with fluent API

package/dist/websocket.test.js

@@ -300,6 +300,72 @@ function waitForMessage(ws) {
             (0, vitest_1.expect)(stream.closed).toBe(true);
             client.close();
         });
+        // The WebSocket route carries the provider-failure classification like
+        // the SSE route does, in the event's camelCase shape.
+        (0, vitest_1.it)("carries the provider failure classification on a chat stream error", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token");
+            const streamPromise = client.chatSend("chat-4", "test");
+            await new Promise((r) => wss.once("connection", r));
+            const ws = getLastConnection();
+            await waitForMessage(ws);
+            const stream = await streamPromise;
+            const events = [];
+            stream.on("event", (e) => events.push(e));
+            ws.send(JSON.stringify({
+                type: "ChatStreamError",
+                payload: {
+                    chat_id: "chat-4",
+                    error: "OpenAI API error 429 Too Many Requests",
+                    error_kind: "provider_rate_limited",
+                    provider: "openai",
+                    provider_status: 429,
+                    retry_after_secs: 7,
+                },
+            }));
+            await new Promise((r) => stream.on("close", r));
+            (0, vitest_1.expect)(events).toEqual([
+                {
+                    type: "error",
+                    error: "OpenAI API error 429 Too Many Requests",
+                    errorKind: "provider_rate_limited",
+                    provider: "openai",
+                    providerStatus: 429,
+                    retryAfterSecs: 7,
+                },
+            ]);
+            client.close();
+        });
+        // A structured `error` value is still an error, with string text — the
+        // WebSocket route guards the shape exactly as the SSE route does.
+        (0, vitest_1.it)("keeps the error text a string when the payload's error is an object", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token");
+            const streamPromise = client.chatSend("chat-5", "test");
+            await new Promise((r) => wss.once("connection", r));
+            const ws = getLastConnection();
+            await waitForMessage(ws);
+            const stream = await streamPromise;
+            const events = [];
+            stream.on("event", (e) => events.push(e));
+            ws.send(JSON.stringify({
+                type: "ChatStreamError",
+                payload: {
+                    chat_id: "chat-5",
+                    error: { code: "upstream_down", status: 503 },
+                    error_kind: "provider_unavailable",
+                    provider: "gemini",
+                },
+            }));
+            await new Promise((r) => stream.on("close", r));
+            (0, vitest_1.expect)(events).toEqual([
+                {
+                    type: "error",
+                    error: "Unknown error",
+                    errorKind: "provider_unavailable",
+                    provider: "gemini",
+                },
+            ]);
+            client.close();
+        });
         (0, vitest_1.it)("sends options with ChatSend", async () => {
             const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token");
             const streamPromise = client.chatSend("chat-3", "Hello", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekodb/ekodb-client",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "description": "Official TypeScript/JavaScript client for ekoDB",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,9 +20,9 @@
   "author": "ekoDB",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^24.13.2",
+    "@types/node": "^26.4.0",
     "@types/ws": "^8.18.1",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vitest": "^4.0.18"
   },
   "dependencies": {