@ekodb/ekodb-client 0.26.0 → 0.26.1

package/dist/client.d.ts

@@ -1246,9 +1246,21 @@ export declare class EkoDBClient {
     agentsByDeployment(deploymentId: string): Promise<Record>;
     /** Get documents linked to a KV key */
     kvGetLinks(key: string): Promise<Record>;
-    /** Link a document to a KV key */
-    kvLink(key: string, collection: string, documentId: string): Promise<Record>;
-    /** Unlink a document from a KV key */
+    /**
+     * Link a document to a KV key.
+     *
+     * The identifying triple goes in the path; the body carries the optional
+     * link payload (`keys`, `field_path`, `metadata`), and an empty object means
+     * "no extra link data".
+     */
+    kvLink(key: string, collection: string, documentId: string, linkData?: {
+        keys?: string[];
+        field_path?: string;
+        metadata?: {
+            [key: string]: string;
+        };
+    }): Promise<Record>;
+    /** Unlink a document from a KV key. DELETE, with the triple in the path. */
     kvUnlink(key: string, collection: string, documentId: string): Promise<Record>;
     /** Create a new schedule */
     createSchedule(data: Record): Promise<Record>;
@@ -1260,10 +1272,25 @@ export declare class EkoDBClient {
     updateSchedule(id: string, data: Record): Promise<Record>;
     /** Delete a schedule */
     deleteSchedule(id: string): Promise<void>;
-    /** Pause a schedule */
+    /**
+     * Pause a schedule.
+     *
+     * There is no `/pause` endpoint — pausing is a partial update of the
+     * schedule's `enabled` flag. This previously POSTed to
+     * `/api/schedules/{id}/pause`, which has never existed and always 404'd.
+     */
     pauseSchedule(id: string): Promise<Record>;
-    /** Resume a schedule */
+    /**
+     * Resume a paused schedule. See {@link pauseSchedule} for why this is an
+     * update rather than its own endpoint.
+     */
     resumeSchedule(id: string): Promise<Record>;
+    /**
+     * Shared implementation for pause/resume: a partial update carrying only
+     * `enabled`. The server recomputes the next execution time when `enabled`
+     * changes, so nothing else needs sending.
+     */
+    private setScheduleEnabled;
     /**
      * Check if a collection exists
      * @param collection - Collection name to check

package/dist/client.js

@@ -327,11 +327,11 @@ class EkoDBClient {
         // ONLY these operations support MessagePack
         const msgpackPaths = [
             "/api/insert/",
-            "/api/batch_insert/",
+            "/api/batch/insert/",
             "/api/update/",
-            "/api/batch_update/",
+            "/api/batch/update/",
             "/api/delete/",
-            "/api/batch_delete/",
+            "/api/batch/delete/",
         ];
         // Check if path starts with any MessagePack-supported operation
         for (const prefix of msgpackPaths) {
@@ -1910,15 +1910,21 @@ class EkoDBClient {
     // ========================================================================
     /** Get documents linked to a KV key */
     async kvGetLinks(key) {
-        return this.makeRequest("GET", `/api/kv/links/${encodeURIComponent(key)}`, undefined, 0, true);
+        return this.makeRequest("GET", `/api/kv/${encodeURIComponent(key)}/links`, undefined, 0, true);
     }
-    /** Link a document to a KV key */
-    async kvLink(key, collection, documentId) {
-        return this.makeRequest("POST", `/api/kv/link`, { key, collection, document_id: documentId }, 0, true);
+    /**
+     * Link a document to a KV key.
+     *
+     * The identifying triple goes in the path; the body carries the optional
+     * link payload (`keys`, `field_path`, `metadata`), and an empty object means
+     * "no extra link data".
+     */
+    async kvLink(key, collection, documentId, linkData = {}) {
+        return this.makeRequest("POST", `/api/kv/${encodeURIComponent(key)}/links/${encodeURIComponent(collection)}/${encodeURIComponent(documentId)}`, linkData, 0, true);
     }
-    /** Unlink a document from a KV key */
+    /** Unlink a document from a KV key. DELETE, with the triple in the path. */
     async kvUnlink(key, collection, documentId) {
-        return this.makeRequest("POST", `/api/kv/unlink`, { key, collection, document_id: documentId }, 0, true);
+        return this.makeRequest("DELETE", `/api/kv/${encodeURIComponent(key)}/links/${encodeURIComponent(collection)}/${encodeURIComponent(documentId)}`, undefined, 0, true);
     }
     // ========================================================================
     // SCHEDULE MANAGEMENT
@@ -1943,13 +1949,30 @@ class EkoDBClient {
     async deleteSchedule(id) {
         await this.makeRequest("DELETE", `/api/schedules/${encodeURIComponent(id)}`, undefined, 0, true);
     }
-    /** Pause a schedule */
+    /**
+     * Pause a schedule.
+     *
+     * There is no `/pause` endpoint — pausing is a partial update of the
+     * schedule's `enabled` flag. This previously POSTed to
+     * `/api/schedules/{id}/pause`, which has never existed and always 404'd.
+     */
     async pauseSchedule(id) {
-        return this.makeRequest("POST", `/api/schedules/${encodeURIComponent(id)}/pause`, undefined, 0, true);
+        return this.setScheduleEnabled(id, false);
     }
-    /** Resume a schedule */
+    /**
+     * Resume a paused schedule. See {@link pauseSchedule} for why this is an
+     * update rather than its own endpoint.
+     */
     async resumeSchedule(id) {
-        return this.makeRequest("POST", `/api/schedules/${encodeURIComponent(id)}/resume`, undefined, 0, true);
+        return this.setScheduleEnabled(id, true);
+    }
+    /**
+     * Shared implementation for pause/resume: a partial update carrying only
+     * `enabled`. The server recomputes the next execution time when `enabled`
+     * changes, so nothing else needs sending.
+     */
+    async setScheduleEnabled(id, enabled) {
+        return this.makeRequest("PUT", `/api/schedules/${encodeURIComponent(id)}`, { enabled }, 0, true);
     }
     // ========================================================================
     // COLLECTION UTILITIES

package/dist/client.test.js

@@ -2277,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();
@@ -2284,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 });
     });
 });
 // ============================================================================
@@ -2301,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();
@@ -2308,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();
@@ -2315,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");
     });
 });
 // ============================================================================
@@ -2338,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,
@@ -2360,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/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/package.json

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

package/src/client.test.ts

@@ -3021,6 +3021,16 @@ describe("EkoDBClient schedules", () => {
 
     const result = await client.pauseSchedule("sched_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 as ReturnType<typeof vi.fn>).mock.calls;
+    const dataCall = calls[1]; // calls[0] is the token exchange
+    expect(dataCall[0]).toContain("/api/schedules/sched_1");
+    expect(dataCall[0]).not.toContain("/pause");
+    expect(dataCall[1]?.method).toBe("PUT");
+    expect(JSON.parse(dataCall[1]?.body as string)).toEqual({ enabled: false });
   });
 
   it("resumes a schedule", async () => {
@@ -3030,6 +3040,13 @@ describe("EkoDBClient schedules", () => {
 
     const result = await client.resumeSchedule("sched_1");
     expect(result).toHaveProperty("status", "active");
+
+    const calls = (global.fetch as ReturnType<typeof vi.fn>).mock.calls;
+    const dataCall = calls[1];
+    expect(dataCall[0]).toContain("/api/schedules/sched_1");
+    expect(dataCall[0]).not.toContain("/resume");
+    expect(dataCall[1]?.method).toBe("PUT");
+    expect(JSON.parse(dataCall[1]?.body as string)).toEqual({ enabled: true });
   });
 });
 
@@ -3050,6 +3067,15 @@ describe("EkoDBClient kv links", () => {
 
     const result = await client.kvGetLinks("session:user123");
     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 as ReturnType<typeof vi.fn>).mock.calls;
+    const dataCall = calls[1]; // calls[0] is the token exchange
+    expect(dataCall[0]).toContain("/api/kv/session%3Auser123/links");
+    expect(dataCall[1]?.method).toBe("GET");
   });
 
   it("links a document to a KV key", async () => {
@@ -3059,6 +3085,32 @@ describe("EkoDBClient kv links", () => {
 
     const result = await client.kvLink("session:user123", "users", "user_1");
     expect(result).toHaveProperty("status", "linked");
+
+    const calls = (global.fetch as ReturnType<typeof vi.fn>).mock.calls;
+    const dataCall = calls[1];
+    // The identifying triple belongs in the PATH, not the body.
+    expect(dataCall[0]).toContain(
+      "/api/kv/session%3Auser123/links/users/user_1",
+    );
+    expect(dataCall[1]?.method).toBe("POST");
+  });
+
+  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 as ReturnType<typeof vi.fn>).mock.calls;
+    const body = JSON.parse(calls[1][1]?.body as string);
+    expect(body).toEqual({
+      field_path: "profile.avatar",
+      metadata: { source: "signup" },
+    });
   });
 
   it("unlinks a document from a KV key", async () => {
@@ -3068,6 +3120,14 @@ describe("EkoDBClient kv links", () => {
 
     const result = await client.kvUnlink("session:user123", "users", "user_1");
     expect(result).toHaveProperty("status", "unlinked");
+
+    const calls = (global.fetch as ReturnType<typeof vi.fn>).mock.calls;
+    const dataCall = calls[1];
+    expect(dataCall[0]).toContain(
+      "/api/kv/session%3Auser123/links/users/user_1",
+    );
+    // DELETE, not POST — the previous implementation used POST and 404'd.
+    expect(dataCall[1]?.method).toBe("DELETE");
   });
 });
 
@@ -3093,7 +3153,7 @@ describe("EkoDBClient text and hybrid search", () => {
         },
       ],
       total: 2,
-      took_ms: 12,
+      execution_time_ms: 12,
     });
 
     const result = await client.textSearch("documents", "ownership", {
@@ -3118,7 +3178,7 @@ describe("EkoDBClient text and hybrid search", () => {
         },
       ],
       total: 1,
-      took_ms: 25,
+      execution_time_ms: 25,
     });
 
     const queryVector = [0.1, 0.2, 0.3, 0.4, 0.5];

package/src/client.ts

@@ -782,11 +782,11 @@ export class EkoDBClient {
     // ONLY these operations support MessagePack
     const msgpackPaths = [
       "/api/insert/",
-      "/api/batch_insert/",
+      "/api/batch/insert/",
       "/api/update/",
-      "/api/batch_update/",
+      "/api/batch/update/",
       "/api/delete/",
-      "/api/batch_delete/",
+      "/api/batch/delete/",
     ];
 
     // Check if path starts with any MessagePack-supported operation
@@ -3231,38 +3231,49 @@ export class EkoDBClient {
   async kvGetLinks(key: string): Promise<Record> {
     return this.makeRequest<Record>(
       "GET",
-      `/api/kv/links/${encodeURIComponent(key)}`,
+      `/api/kv/${encodeURIComponent(key)}/links`,
       undefined,
       0,
       true,
     );
   }
 
-  /** Link a document to a KV key */
+  /**
+   * Link a document to a KV key.
+   *
+   * The identifying triple goes in the path; the body carries the optional
+   * link payload (`keys`, `field_path`, `metadata`), and an empty object means
+   * "no extra link data".
+   */
   async kvLink(
     key: string,
     collection: string,
     documentId: string,
+    linkData: {
+      keys?: string[];
+      field_path?: string;
+      metadata?: { [key: string]: string };
+    } = {},
   ): Promise<Record> {
     return this.makeRequest<Record>(
       "POST",
-      `/api/kv/link`,
-      { key, collection, document_id: documentId },
+      `/api/kv/${encodeURIComponent(key)}/links/${encodeURIComponent(collection)}/${encodeURIComponent(documentId)}`,
+      linkData,
       0,
       true,
     );
   }
 
-  /** Unlink a document from a KV key */
+  /** Unlink a document from a KV key. DELETE, with the triple in the path. */
   async kvUnlink(
     key: string,
     collection: string,
     documentId: string,
   ): Promise<Record> {
     return this.makeRequest<Record>(
-      "POST",
-      `/api/kv/unlink`,
-      { key, collection, document_id: documentId },
+      "DELETE",
+      `/api/kv/${encodeURIComponent(key)}/links/${encodeURIComponent(collection)}/${encodeURIComponent(documentId)}`,
+      undefined,
       0,
       true,
     );
@@ -3321,23 +3332,38 @@ export class EkoDBClient {
     );
   }
 
-  /** Pause a schedule */
+  /**
+   * Pause a schedule.
+   *
+   * There is no `/pause` endpoint — pausing is a partial update of the
+   * schedule's `enabled` flag. This previously POSTed to
+   * `/api/schedules/{id}/pause`, which has never existed and always 404'd.
+   */
   async pauseSchedule(id: string): Promise<Record> {
-    return this.makeRequest<Record>(
-      "POST",
-      `/api/schedules/${encodeURIComponent(id)}/pause`,
-      undefined,
-      0,
-      true,
-    );
+    return this.setScheduleEnabled(id, false);
   }
 
-  /** Resume a schedule */
+  /**
+   * Resume a paused schedule. See {@link pauseSchedule} for why this is an
+   * update rather than its own endpoint.
+   */
   async resumeSchedule(id: string): Promise<Record> {
+    return this.setScheduleEnabled(id, true);
+  }
+
+  /**
+   * Shared implementation for pause/resume: a partial update carrying only
+   * `enabled`. The server recomputes the next execution time when `enabled`
+   * changes, so nothing else needs sending.
+   */
+  private async setScheduleEnabled(
+    id: string,
+    enabled: boolean,
+  ): Promise<Record> {
     return this.makeRequest<Record>(
-      "POST",
-      `/api/schedules/${encodeURIComponent(id)}/resume`,
-      undefined,
+      "PUT",
+      `/api/schedules/${encodeURIComponent(id)}`,
+      { enabled },
       0,
       true,
     );

package/src/functions.test.ts

@@ -722,4 +722,58 @@ describe("Crypto and concurrency stages", () => {
       expect(wire.type).toBe(s.type);
     }
   });
+
+  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.
+
+    it("filter emits a Query with only the filter set", () => {
+      const wire = JSON.parse(
+        JSON.stringify(Stage.filter("users", { status: "active" })),
+      );
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.filter).toEqual({ status: "active" });
+    });
+
+    it("sort emits a Query with only the sort set", () => {
+      const wire = JSON.parse(
+        JSON.stringify(
+          Stage.sort("users", [{ field: "created_at", ascending: false }]),
+        ),
+      );
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.sort).toEqual([{ field: "created_at", ascending: false }]);
+    });
+
+    it("limit emits a Query with only the limit set", () => {
+      const wire = JSON.parse(JSON.stringify(Stage.limit("users", 10)));
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.limit).toBe(10);
+    });
+
+    it("skip emits a Query with only the skip set", () => {
+      const wire = JSON.parse(JSON.stringify(Stage.skip("users", 5)));
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.skip).toBe(5);
+    });
+
+    it("never emits a stage type the server has no variant for", () => {
+      const wire = [
+        Stage.filter("users", {}),
+        Stage.sort("users", []),
+        Stage.limit("users", 1),
+        Stage.skip("users", 1),
+      ].map((s) => JSON.parse(JSON.stringify(s)).type);
+      expect(wire).not.toContain("Filter");
+      expect(wire).not.toContain("Sort");
+      expect(wire).not.toContain("Limit");
+      expect(wire).not.toContain("Skip");
+    });
+  });
 });

package/src/functions.ts

@@ -55,10 +55,6 @@ export type FunctionStageConfig =
       functions: GroupFunctionConfig[];
     }
   | { 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;
@@ -742,23 +738,45 @@ export const Stage = {
     bypass_ripple: bypassRipple,
   }),
 
-  filter: (filter: Record<string, any>): FunctionStageConfig => ({
-    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: string,
+    filter: Record<string, any>,
+  ): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     filter,
   }),
 
-  sort: (sort: SortFieldConfig[]): FunctionStageConfig => ({
-    type: "Sort",
+  /** Sort a collection. Shorthand for a `Query` carrying only `sort`. */
+  sort: (collection: string, sort: SortFieldConfig[]): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     sort,
   }),
 
-  limit: (limit: number): FunctionStageConfig => ({
-    type: "Limit",
+  /** Limit a collection read. Shorthand for a `Query` carrying only `limit`. */
+  limit: (collection: string, limit: number): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     limit,
   }),
 
-  skip: (skip: number): FunctionStageConfig => ({
-    type: "Skip",
+  /** Skip rows of a collection read. Shorthand for a `Query` with only `skip`. */
+  skip: (collection: string, skip: number): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     skip,
   }),
 

package/src/search.ts

@@ -90,7 +90,7 @@ export interface SearchResponse {
   /** Total number of results found */
   total: number;
   /** Query execution time in milliseconds */
-  took_ms?: number;
+  execution_time_ms?: number;
 }
 
 /**