@abloatai/ablo 0.25.0 → 0.27.0

package/dist/wire/protocolVersion.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The sync protocol version — a single integer, increasing over time, that
+ * covers everything the client and server must agree on to talk to each other:
+ * the WebSocket frame shapes, the HTTP request and response envelopes, and the
+ * delta encodings a client replays. It is separate from the app-schema hash
+ * (WebSocket close code 4009), which detects drift in your data model; this
+ * detects drift in the protocol itself.
+ *
+ * Deploy ordering: the server is deployed first. It accepts every version in
+ * the inclusive range from {@link MIN_SUPPORTED_PROTOCOL_VERSION} to
+ * {@link PROTOCOL_VERSION}, and a client is never expected to connect to a
+ * server older than itself. If that does happen — for example a partial server
+ * rollback — {@link protocolVersionProblem} reports it as `too_new` so the
+ * mismatch is visible rather than undefined.
+ *
+ * To change the protocol:
+ *   1. Make the change backward-tolerant where you can. The server ignores
+ *      unknown payload keys, so an additive field usually needs no version bump.
+ *   2. For a breaking change, bump {@link PROTOCOL_VERSION}, add a changelog
+ *      entry below, and keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough
+ *      to cover every client still in use; raise it only after a deprecation
+ *      window.
+ *   3. The protocol-version contract test fails on any bump — update it in the
+ *      same change, deliberately.
+ *
+ * Changelog
+ *   v1 (2026-07-03) — the protocol as of this field's introduction: the
+ *      sync-request frame (`cursor`, `lastSyncId`, `capabilities`, optional
+ *      `protocolVersion`), the commit, mutation, claim, release, ack, and
+ *      presence-update frames, the bootstrap and delta batches, and the HTTP
+ *      error and list envelopes. A client that predates this field sends no
+ *      `protocolVersion` and is treated as v1, since introducing the field
+ *      changed no behavior.
+ */
+export declare const PROTOCOL_VERSION = 1;
+/**
+ * The oldest client protocol version this build still serves. Raising it cuts
+ * off clients that have not upgraded, so do it only after a deprecation window
+ * and with a changelog entry.
+ */
+export declare const MIN_SUPPORTED_PROTOCOL_VERSION = 1;
+/**
+ * The WebSocket close code the server sends to reject a protocol-version
+ * mismatch. It sits alongside the other application close codes (4001 for a
+ * credential problem, 4009 for app-schema drift), and its reason string is the
+ * error code `protocol_version_unsupported`. A client should treat this close
+ * as terminal: reconnecting cannot heal a version mismatch, but upgrading the
+ * client or rolling the server forward can.
+ */
+export declare const WS_CLOSE_PROTOCOL_VERSION = 4010;
+/**
+ * Classifies a peer's announced protocol version against what this build
+ * supports, returning `'too_old'`, `'too_new'`, or `null` when the versions are
+ * compatible. An `undefined` version — a client from before versioning existed
+ * — counts as v1. A non-integer value is treated as `'too_old'` so the check
+ * fails closed and visibly.
+ */
+export declare function protocolVersionProblem(announced: number | undefined): 'too_old' | 'too_new' | null;
+/** The HTTP request header a client uses to announce its protocol version. */
+export declare const PROTOCOL_VERSION_HEADER = "Ablo-Protocol-Version";

package/dist/wire/protocolVersion.js

@@ -0,0 +1,67 @@
+/**
+ * The sync protocol version — a single integer, increasing over time, that
+ * covers everything the client and server must agree on to talk to each other:
+ * the WebSocket frame shapes, the HTTP request and response envelopes, and the
+ * delta encodings a client replays. It is separate from the app-schema hash
+ * (WebSocket close code 4009), which detects drift in your data model; this
+ * detects drift in the protocol itself.
+ *
+ * Deploy ordering: the server is deployed first. It accepts every version in
+ * the inclusive range from {@link MIN_SUPPORTED_PROTOCOL_VERSION} to
+ * {@link PROTOCOL_VERSION}, and a client is never expected to connect to a
+ * server older than itself. If that does happen — for example a partial server
+ * rollback — {@link protocolVersionProblem} reports it as `too_new` so the
+ * mismatch is visible rather than undefined.
+ *
+ * To change the protocol:
+ *   1. Make the change backward-tolerant where you can. The server ignores
+ *      unknown payload keys, so an additive field usually needs no version bump.
+ *   2. For a breaking change, bump {@link PROTOCOL_VERSION}, add a changelog
+ *      entry below, and keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough
+ *      to cover every client still in use; raise it only after a deprecation
+ *      window.
+ *   3. The protocol-version contract test fails on any bump — update it in the
+ *      same change, deliberately.
+ *
+ * Changelog
+ *   v1 (2026-07-03) — the protocol as of this field's introduction: the
+ *      sync-request frame (`cursor`, `lastSyncId`, `capabilities`, optional
+ *      `protocolVersion`), the commit, mutation, claim, release, ack, and
+ *      presence-update frames, the bootstrap and delta batches, and the HTTP
+ *      error and list envelopes. A client that predates this field sends no
+ *      `protocolVersion` and is treated as v1, since introducing the field
+ *      changed no behavior.
+ */
+export const PROTOCOL_VERSION = 1;
+/**
+ * The oldest client protocol version this build still serves. Raising it cuts
+ * off clients that have not upgraded, so do it only after a deprecation window
+ * and with a changelog entry.
+ */
+export const MIN_SUPPORTED_PROTOCOL_VERSION = 1;
+/**
+ * The WebSocket close code the server sends to reject a protocol-version
+ * mismatch. It sits alongside the other application close codes (4001 for a
+ * credential problem, 4009 for app-schema drift), and its reason string is the
+ * error code `protocol_version_unsupported`. A client should treat this close
+ * as terminal: reconnecting cannot heal a version mismatch, but upgrading the
+ * client or rolling the server forward can.
+ */
+export const WS_CLOSE_PROTOCOL_VERSION = 4010;
+/**
+ * Classifies a peer's announced protocol version against what this build
+ * supports, returning `'too_old'`, `'too_new'`, or `null` when the versions are
+ * compatible. An `undefined` version — a client from before versioning existed
+ * — counts as v1. A non-integer value is treated as `'too_old'` so the check
+ * fails closed and visibly.
+ */
+export function protocolVersionProblem(announced) {
+    const v = announced ?? 1;
+    if (!Number.isInteger(v) || v < MIN_SUPPORTED_PROTOCOL_VERSION)
+        return 'too_old';
+    if (v > PROTOCOL_VERSION)
+        return 'too_new';
+    return null;
+}
+/** The HTTP request header a client uses to announce its protocol version. */
+export const PROTOCOL_VERSION_HEADER = 'Ablo-Protocol-Version';

package/docs/api-keys.md

@@ -21,7 +21,7 @@ Pick your row:
 |---|---|---|
 | **Server / worker / CLI** (can hold a secret) | your secret `sk_` — it defaults to `ABLO_API_KEY`, so usually pass **nothing** | `Ablo({ schema })` |
 | **Browser — read-only** | a publishable `pk_` (safe to ship, like a Stripe `pk_`) | `Ablo({ schema, apiKey: process.env.NEXT_PUBLIC_ABLO_PUBLISHABLE_KEY })` |
-| **Browser — writing as the signed-in user** | a function that fetches a short-lived per-user token from your own backend | `Ablo({ schema, apiKey: () => fetch('/api/ablo-session').then((r) => r.text()) })` |
+| **Browser — writing as the signed-in user** | `authEndpoint` — the route on your own backend that mints a short-lived per-user token | `Ablo({ schema, authEndpoint: '/api/ablo-session' })` |
 
 That's the whole story: one knob, filled by audience.
 
@@ -48,8 +48,9 @@ session model. For a read-only app you don't need any of this — just the `pk_`
 
 Server-side, because `apiKey` defaults to `process.env.ABLO_API_KEY`, most backend and agent
 code passes nothing. The secret `sk_` (and `databaseUrl`) are **server-only** — never in a
-browser bundle. There is no `getToken`, `authEndpoint`, or `as` option — `apiKey` (a string,
-or a function for the browser-write case) is the single credential knob.
+browser bundle. There is no `getToken` or `as` option — `apiKey` (the key a server holds)
+and `authEndpoint` (the mint route a browser points at) are the two credential
+knobs, and you set exactly one.
 
 ### Minting per-user / agent tokens (server-side, with your `sk_`)
 

package/docs/coordination.md

@@ -416,6 +416,65 @@ try {
 }
 ```
 
+### `heartbeat` — holding a claim for long-running work
+
+```ts
+held.heartbeat(ttl?: Duration): Promise<{ expiresAt: number }>
+```
+
+A claim's TTL is crash cleanup, not a work-duration estimate — so a task that
+outlives it (an agent run, a background worker's job) keeps its lease by
+**beating**, the same pattern as an SQS visibility heartbeat or a Temporal
+activity heartbeat. Each beat extends the lease from now (never shortens it,
+and each extension is clamped server-side); a crashed worker stops beating and
+its lease lapses within one beat window, promoting the next waiter.
+
+Usually **implicit** — pass `heartbeat` when claiming and the SDK beats every
+third of the TTL until release:
+
+```ts
+await using claim = await ablo.reports.claim({
+  id: 'report_q3',
+  reason: 'generating',
+  ttl: '5m',
+  heartbeat: true,               // or an explicit cadence: heartbeat: '2m'
+  onHeartbeatLost: () => abortWork(),
+});
+await runLongGeneration(claim.data); // lease held for the duration
+// scope exit releases; the loop stops with it
+```
+
+A beat that comes back with a definitive loss — the lease expired and the
+queue moved on — rejects with `AbloClaimedError` (`claim_lost`) and stops the
+auto-loop. For a worker with no socket, **the failed beat is the loss
+notification**; abandon or re-claim, and remember any write attempted under
+the old lease is independently rejected by its `readAt` guard. Transient
+failures (a connection blip) don't stop the loop — the next tick retries.
+
+Each beat's answer carries two more things:
+
+- **`queueDepth`** — how many participants wait in line behind the lease.
+  This is the cooperative-yield pressure signal: a worker that can checkpoint
+  may release early when others wait. Read it from the resolved beat, or pass
+  `onHeartbeat` when claiming to observe every auto-beat.
+- **progress `details`** — `held.heartbeat({ details: { pages: 42, of: 100 } })`
+  stores the payload as the claim's peer-visible `meta.progress` (last beat
+  wins, via `claim.state`). This is presence, not a checkpoint: it dies with
+  the lease. Durable progress belongs in the data itself — write a row, and
+  every subscriber already sees it.
+
+Works identically on both transports: the realtime client sends a
+`claim_heartbeat` frame; the HTTP client posts
+`POST /v1/models/{model}/{id}/claim/heartbeat` (`{ ttl?, claimId?, details? }`).
+Over HTTP, a **queued** claim can heartbeat too — it refreshes the waiter's
+slot in the line (a queued slot is TTL'd like a lease) and reports
+`{ status: 'queued', position }`.
+
+A stateless worker holding **many** rows beats them all in one round trip:
+`ablo.claims.heartbeatAll({ ttl: '5m' })` → `POST /v1/claims/heartbeat`, one
+entry per extended lease. This is the socketless twin of the realtime
+keepalive, which already renews every held lease on each ping.
+
 ### `watch` — presence for a set of rows
 
 Reading or claiming a row auto-enrolls you in its sync group, which is enough for

package/docs/examples/existing-python-backend.md

@@ -67,11 +67,11 @@ import Ablo from '@abloatai/ablo';
 import { AbloProvider } from '@abloatai/ablo/react';
 import { schema } from '@/ablo/schema';
 
-// Browser client: no secret key — the `apiKey` resolver fetches the session
-// token your server route mints (see the session route below).
+// Browser client: no secret key — `authEndpoint` points at the session route
+// your server exposes (below); the SDK fetches and refreshes the token.
 const ablo = Ablo({
   schema,
-  apiKey: () => fetch('/api/ablo-session').then((r) => r.text()),
+  authEndpoint: '/api/ablo-session',
 });
 
 export function Providers({ children }: { children: React.ReactNode }) {

package/docs/identity.md

@@ -359,10 +359,10 @@ import { schema } from '@/ablo/schema';
 export function makeAblo(user: { teamIds: string[] }) {
   return Ablo({
     schema,
-    // The browser holds no secret — the `apiKey` resolver fetches the
-    // short-lived session token your `/api/ablo-session` route minted, and the
-    // client keeps it fresh before expiry.
-    apiKey: () => fetch('/api/ablo-session').then((r) => r.text()),
+    // The browser holds no secret — `authEndpoint` points at the route that
+    // mints the short-lived session token, and the client keeps it fresh
+    // before expiry.
+    authEndpoint: '/api/ablo-session',
     teamIds: user.teamIds,
   });
 }

package/docs/integration-guide.md

@@ -190,7 +190,7 @@ import { schema } from '@/ablo/schema';
 // from your session route (see below) and refreshes it before expiry.
 export const ablo = Ablo({
   schema,
-  apiKey: () => fetch('/api/ablo-session').then((r) => r.text()),
+  authEndpoint: '/api/ablo-session',
 });
 ```
 

package/docs/react.md

@@ -31,7 +31,7 @@ import { schema } from '@/ablo/schema';
 // from your own server route (see Identity below).
 export const ablo = Ablo({
   schema,
-  apiKey: () => fetch('/api/ablo-session').then((r) => r.text()),
+  authEndpoint: '/api/ablo-session',
 });
 ```
 

package/docs/sessions.md

@@ -53,7 +53,7 @@ return Response.json({ token });  // return ONLY the token to the browser
 A user session has **full data authority** within its org — no operation
 allowlist. It's the human acting as themselves.
 
-Build a browser `Ablo` client whose `getToken` fetches from that route, and pass
+Point a browser `Ablo` client's `authEndpoint` at that route, and pass
 the **instance** to [`<AbloProvider>`](/react). The client fetches the token,
 opens the connection, and re-mints before expiry — your app writes no token
 plumbing:
@@ -67,10 +67,7 @@ import { schema } from '@/ablo.schema';
 
 const ablo = Ablo({
   schema,
-  getToken: () =>
-    fetch('/api/ablo-session', { method: 'POST' })
-      .then((r) => r.json())
-      .then((d) => d.token),
+  authEndpoint: '/api/ablo-session',
 });
 
 export function Providers({ children }: { children: React.ReactNode }) {
@@ -81,8 +78,9 @@ export function Providers({ children }: { children: React.ReactNode }) {
 The client owns auth, the credential lifecycle, and the connection; the provider
 is the thin reactive binding over it (Stripe's `<Elements stripe={...}>` model).
 Build the client **once** at module scope — a new instance per render tears down
-the socket. `authEndpoint: '/api/ablo-session'` is accepted as sugar for the
-`getToken` fetch above if you prefer a URL.
+the socket. Need custom headers or a
+body on the exchange? `authEndpoint` also accepts an async resolver that
+returns the token.
 
 ## Agent sessions (`rk_`)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "description": "The Collaboration Layer For AI Agents",
   "license": "Apache-2.0",
   "type": "module",
@@ -108,11 +108,6 @@
       "import": "./dist/server/index.js",
       "default": "./dist/server/index.js"
     },
-    "./server/next": {
-      "types": "./dist/server/next.d.ts",
-      "import": "./dist/server/next.js",
-      "default": "./dist/server/next.js"
-    },
     "./webhooks": {
       "types": "./dist/webhooks/index.d.ts",
       "import": "./dist/webhooks/index.js",
@@ -121,7 +116,6 @@
   },
   "files": [
     "dist",
-    "!dist/internal/**",
     "!dist/__type_probe.*",
     "docs/*.md",
     "docs/examples/*.md",
@@ -139,7 +133,9 @@
     "build": "npm run clean && tsc -p tsconfig.build.json && npm run build:cli",
     "build:cli": "tsup --config tsup.cli.config.ts",
     "typecheck:cli": "tsc -p tsconfig.cli.json",
-    "pack:check": "npm_config_cache=${TMPDIR:-/tmp}/ablo-npm-cache npm pack --dry-run",
+    "prepack": "node scripts/strip-source-condition.mjs",
+    "postpack": "node scripts/restore-source-condition.mjs",
+    "pack:check": "node scripts/pack-check.mjs",
     "lint": "npm run lint:imports && npm run lint:errors && npm run lint:docs && npm run lint:mintlify",
     "build:docs": "node scripts/build-mintlify-docs.mjs",
     "lint:mintlify": "node scripts/build-mintlify-docs.mjs --check",
@@ -147,16 +143,17 @@
     "generate:errors": "tsx scripts/generate-error-docs.mts",
     "lint:errors": "tsx scripts/check-error-docs.mts",
     "lint:docs": "node scripts/check-doc-drift.mjs",
+    "lint:eslint": "eslint . --cache",
     "lint:pkg": "publint",
     "prepublishOnly": "npm run build && npm run lint:pkg",
     "check:dist": "node scripts/check-dist-fresh.mjs",
     "pretest": "node scripts/check-dist-fresh.mjs",
     "test": "jest",
     "test:quickstart": "node scripts/test-quickstart.mjs",
-    "test:unit": "jest --testPathPattern=__tests__/unit",
-    "test:integration": "jest --testPathPattern=__tests__/integration",
-    "test:contract": "jest --testPathPattern=__tests__/contract",
-    "test:property": "jest --testPathPattern=__tests__/property",
+    "test:unit": "jest --testPathPatterns __tests__/unit",
+    "test:integration": "jest --testPathPatterns __tests__/integration",
+    "test:contract": "jest --testPathPatterns __tests__/contract",
+    "test:property": "jest --testPathPatterns __tests__/property",
     "test:coverage": "jest --coverage",
     "test:e2e": "E2E_TEST=true jest --config jest.e2e.config.ts",
     "test:e2e:up": "docker compose -f docker-compose.test.yml up -d --wait",
@@ -191,7 +188,8 @@
   },
   "peerDependencies": {
     "react": "^19.0.0",
-    "drizzle-orm": ">=0.44.0"
+    "drizzle-orm": ">=0.44.0",
+    "ai": "^6.0.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -199,6 +197,9 @@
     },
     "drizzle-orm": {
       "optional": true
+    },
+    "ai": {
+      "optional": true
     }
   },
   "dependencies": {
@@ -211,30 +212,32 @@
   "devDependencies": {
     "@ai-sdk/provider": "^3.0.0",
     "@clack/prompts": "^0.11.0",
+    "@jest/globals": "^30.2.0",
     "@prisma/client": "^7.3.0",
-    "@types/jest": "^29.5.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/uuid": "^10.0.0",
     "@testing-library/react": "^16.0.0",
-    "@testing-library/jest-dom": "^6.6.0",
     "ai": "^6.0.0",
     "drizzle-orm": "^0.45.2",
+    "eslint-plugin-react-hooks": "^7.0.1",
     "fake-indexeddb": "^6.0.0",
     "fast-check": "^3.0.0",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jiti": "^2.7.0",
-    "mobx": "^6.13.7",
+    "globals": "^16.5.0",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jest-environment-node": "^30.2.0",
     "picocolors": "^1.1.0",
     "postgres": "^3.4.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "ts-jest": "^29.4.0",
+    "ts-jest": "^29.4.5",
     "ts-morph": "^26.0.0",
     "tsup": "^8.0.0",
+    "tsx": "^4.19.0",
     "typescript": "^5.8.3",
     "publint": "^0.3.21",
-    "yjs": "^13.6.29"
+    "ws": "^8.18.0"
   }
 }

package/dist/ai-sdk/coordinated-tool.d.ts

@@ -1,101 +0,0 @@
-/**
- * `coordinatedTool` — the one-liner that turns an Ablo model write into a Vercel
- * AI SDK tool with multi-agent coordination already handled, so an AI agent can
- * contribute to shared state without ever silently clobbering a concurrent
- * writer.
- *
- * The base `./ai-sdk` pattern (see index.ts) is "write your own `tool()` and
- * call `ablo.<model>.update({ id, data, claim })` inside `execute`". That's the
- * right amount of control when a tool does something bespoke. But the *common*
- * case — "the agent produced some content; save it into the shared row" — should
- * not require every integration to re-derive optimistic concurrency by hand. This
- * collapses it to a declaration:
- *
- * ```ts
- * import { coordinatedTool } from '@abloatai/ablo/ai-sdk';
- * import { z } from 'zod';
- *
- * const saveSection = coordinatedTool(ablo.documents, {
- *   description: 'Save your section into the shared document.',
- *   inputSchema: z.object({ text: z.string() }),
- *   id: () => DOC_ID,
- *   apply: (current, { text }) => ({ content: appendBlock(current.content, text) }),
- *   // strategy: 'merge'  ← the default
- * });
- *
- * await streamText({ model, messages, tools: { saveSection } });
- * ```
- *
- * `apply` is the whole API: a pure function of `(freshest row, tool input) →
- * patch`, exactly like React's `setState(prev => next)`. Everything underneath —
- * reading the latest row, the compare-and-swap, the jittered backoff between
- * reconcile rounds, releasing claims — is the runtime's job, not yours.
- *
- * ## Strategies (pick by how writers should relate; all verified to converge
- * under N-way agent contention)
- *
- * - `'merge'` *(default)* — delegates straight to the functional update
- *   `ablo.<model>.update(id, current => apply(current, input))`. The SDK re-reads
- *   and re-applies `apply` on top of every concurrent write and backs off between
- *   rounds, so N agents *accumulate* into one row and the model never sees a
- *   conflict. **Requires the model's agent conflict policy to be `reject`** (the
- *   default, or `agentsReject()`); a model declaring `agentsNotify()` HOLDS the
- *   losing write instead of rejecting it, which defeats the reconcile — use
- *   `claim`/`queue` there, or switch the policy.
- *
- * - `'claim'` — mutual exclusion. Takes a fail-fast claim; if another participant
- *   holds the row it returns `{ status: 'claimed' }` so the *model* decides to
- *   retry (a legible signal beats a hidden wait when the agent might do something
- *   better with its turn). Works regardless of conflict policy.
- *
- * - `'queue'` — fair-ish serialization over stateless HTTP, the SQS shape: a
- *   client poll-acquire loop (true FIFO needs a socket) until the claim is granted
- *   or `poll.timeoutMs` elapses. The model calls once and the tool waits its turn.
- */
-import type { z } from 'zod';
-import type { ModelOperations } from '../client/createModelProxy.js';
-export type CoordinationStrategy = 'merge' | 'claim' | 'queue';
-/** The structured result the tool hands back to the model (or the caller). */
-export interface CoordinatedWriteResult<T> {
-    /**
-     * `'written'` — saved. `'claimed'` — another participant holds the row; NOT
-     * saved, the model should try again. `'timeout'` — the queue strategy could not
-     * acquire the row within `poll.timeoutMs`.
-     */
-    status: 'written' | 'claimed' | 'timeout';
-    /** The reconciled row, on `'written'`. */
-    row?: T;
-    message?: string;
-    /** On `'written'` via the `queue` strategy, how long the tool waited in line. */
-    waitedMs?: number;
-}
-export interface CoordinatedToolOptions<TInput, T> {
-    /** Tool description shown to the model. */
-    description: string;
-    /** What the model may send — a normal AI SDK / zod input schema. */
-    inputSchema: z.ZodType<TInput>;
-    /** Which row this write targets, derived from the tool input. */
-    id: (input: TInput) => string;
-    /**
-     * Produce the write patch from the freshest current row + the tool input — a
-     * pure `(prev, input) => next`. Under `merge` it re-runs on every concurrent
-     * write, so it must be idempotent w.r.t. its own contribution (e.g. skip if its
-     * marker is already present) to be safe across reconcile rounds.
-     */
-    apply: (current: T, input: TInput) => Partial<T>;
-    /** How concurrent writers relate. Defaults to `'merge'`. */
-    strategy?: CoordinationStrategy;
-    /** Human-legible coordination metadata attached to the claim (`claim`/`queue`). */
-    claim?: {
-        reason?: string;
-        description?: string;
-    };
-    /** Reconcile budget for `merge` (rounds before `AbloContentionError`). */
-    retries?: number;
-    /** Poll cadence / ceiling for `queue` (defaults 250ms / 30s). */
-    poll?: {
-        intervalMs?: number;
-        timeoutMs?: number;
-    };
-}
-export declare function coordinatedTool<TInput, T = Record<string, unknown>, CreateInput = Partial<T>>(model: ModelOperations<T, CreateInput>, options: CoordinatedToolOptions<TInput, T>): import("ai").Tool<TInput, CoordinatedWriteResult<T>>;

package/dist/ai-sdk/coordination-context.d.ts

@@ -1,52 +0,0 @@
-/**
- * Coordination context middleware — reads peer claims on the same
- * entity from the sync engine's presence stream and injects a brief
- * coordination note into the prompt before the LLM call.
- *
- * The complement of `claim-broadcast.ts`: that one declares what
- * THIS agent is about to do; this one reads what OTHERS are doing
- * and tells the LLM about it. Together they make multiplayer-with-
- * AI structurally real — the AI knows when a human or another
- * agent is mid-edit and can defer / phrase its work as
- * "while you finish that, I'll …" / suggest waiting / coordinate
- * explicitly.
- *
- * Open-source-clean: depends only on `@ai-sdk/provider` types and
- * the package's own `SyncAgent`. Consumers compose via the AI
- * SDK's `wrapLanguageModel`.
- *
- * Cost: zero extra LLM calls (read happens locally from the agent's
- * cached presence stream — already in memory from the WS subscription).
- * Adds a few sentences to the system prompt (typically <100 tokens)
- * only when peers are actively editing.
- */
-import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
-import type { Ablo } from '../client/Ablo.js';
-import type { SchemaRecord } from '../schema/schema.js';
-import type { ClaimTarget } from '../types/streams.js';
-export type { ClaimTarget };
-export interface CoordinationContextMiddlewareOptions<R extends SchemaRecord = SchemaRecord> {
-    readonly agent: Ablo<R> | null;
-    readonly target: ClaimTarget | null;
-    /**
-     * Optional claimId(s) to exclude from the read — typically this
-     * agent's own active claim so the coordination note doesn't tell
-     * the AI "you yourself are editing this." When middleware is
-     * composed with `claimBroadcastMiddleware` in the standard order,
-     * `transformParams` runs BEFORE the broadcast's `wrapStream`
-     * declares its claim, so the agent's own claim isn't yet in the
-     * cached presence and self-filtering isn't needed. The hook is
-     * here for callers that compose differently or for fleet
-     * coordination (filter sibling worker claims).
-     */
-    readonly excludeClaimIds?: readonly string[];
-}
-/**
- * Build the middleware. When `agent` or `target` is null, returns a
- * pass-through.
- *
- * Generic over the schema record — see `claimBroadcastMiddleware`
- * for why `Ablo<S>` and `Ablo<SchemaRecord>` aren't structurally
- * assignable.
- */
-export declare function coordinationContextMiddleware<R extends SchemaRecord = SchemaRecord>(options: CoordinationContextMiddlewareOptions<R>): LanguageModelV3Middleware;

package/dist/client/index.d.ts

@@ -1,36 +0,0 @@
-/**
- * @abloatai/ablo/client — Consumer API
- *
- * The one-liner entry point for external consumers.
- *
- * `Ablo({ apiKey })` is the stateless HTTP API client. Add `schema`
- * when you want the realtime sync engine with typed model proxies.
- *
- * ```ts
- * import { Ablo } from '@abloatai/ablo/client';
- * import { schema } from './schema';
- *
- * const ablo = Ablo({
- *   schema,
- *   apiKey: process.env.ABLO_API_KEY,
- * });
- *
- * const reports = ablo.weatherReports.list({ where: { status: 'pending' } });
- * await ablo.weatherReports.create({ location: 'Stockholm', status: 'pending' });
- * ```
- *
- * For headless agents (workers, bots), pass the same schema and an API key
- * scoped for that server runtime:
- *
- * ```ts
- * const bot = Ablo({
- *   schema,
- *   apiKey: process.env.ABLO_API_KEY,
- * });
- * ```
- */
-export { Ablo, computeFKDepthPriority, type AbloOptions, type InternalAbloOptions, type ClaimedOptions, type IfClaimedPolicy, type ClaimWaitOptions, type LocalCountOptions, type LocalReadOptions, type ModelListScope, type ServerReadOptions, type ModelOperations, type ModelReadOptions, } from './Ablo.js';
-export { ABLO_DEFAULT_BASE_URL, ABLO_HOSTED_API_DOMAIN, ABLO_HOSTED_HTTP_BASE_URL, normalizeAbloHostedBaseUrl, } from './auth.js';
-export type { AbloPersistence } from './persistence.js';
-export type { AbloApi, AbloApiClientOptions, AbloApiClaims, Capability, CapabilityCreateOptions, CapabilityParticipantKind, CapabilityRecord, CapabilityResource, CapabilityRevocation, CapabilityScope, } from './ApiClient.js';
-export type { EngineParticipant, JoinedParticipant, ParticipantJoinOptions, ParticipantManager, ParticipantScope, ParticipantStatus, ScopedClaims, ScopedPresence, } from '../sync/participants.js';

package/dist/client/index.js

@@ -1,33 +0,0 @@
-/**
- * @abloatai/ablo/client — Consumer API
- *
- * The one-liner entry point for external consumers.
- *
- * `Ablo({ apiKey })` is the stateless HTTP API client. Add `schema`
- * when you want the realtime sync engine with typed model proxies.
- *
- * ```ts
- * import { Ablo } from '@abloatai/ablo/client';
- * import { schema } from './schema';
- *
- * const ablo = Ablo({
- *   schema,
- *   apiKey: process.env.ABLO_API_KEY,
- * });
- *
- * const reports = ablo.weatherReports.list({ where: { status: 'pending' } });
- * await ablo.weatherReports.create({ location: 'Stockholm', status: 'pending' });
- * ```
- *
- * For headless agents (workers, bots), pass the same schema and an API key
- * scoped for that server runtime:
- *
- * ```ts
- * const bot = Ablo({
- *   schema,
- *   apiKey: process.env.ABLO_API_KEY,
- * });
- * ```
- */
-export { Ablo, computeFKDepthPriority, } from './Ablo.js';
-export { ABLO_DEFAULT_BASE_URL, ABLO_HOSTED_API_DOMAIN, ABLO_HOSTED_HTTP_BASE_URL, normalizeAbloHostedBaseUrl, } from './auth.js';