@abloatai/ablo 0.9.1 → 0.9.3

package/dist/client/ApiClient.js

@@ -8,8 +8,8 @@
 import { AbloClaimedError, AbloAuthenticationError, AbloConnectionError, AbloValidationError, translateHttpError, } from '../errors.js';
 import { assertBrowserSafety, readProcessEnv, resolveApiKey, resolveApiKeyValue, resolveAuthToken, resolveBaseURL, resolveBootstrapBaseUrl, } from './auth.js';
 import { toSeconds } from '../utils/duration.js';
+import { assertWriteOptions } from './writeOptionsSchema.js';
 const DEFAULT_AGENT_LEASE = '10m';
-const DEFAULT_INTENT_LEASE = '2m';
 export function createProtocolClient(options) {
     const env = readProcessEnv();
     const authInput = { options, env };
@@ -100,144 +100,6 @@ export function createProtocolClient(options) {
             schema: null,
         });
     }
-    function createAgent(id, agentOptions) {
-        return {
-            id,
-            async run(runOptions, handler) {
-                if (runOptions.signal?.aborted) {
-                    return { status: 'cancelled' };
-                }
-                let capability = null;
-                let task = null;
-                try {
-                    const leaseOptions = agentOptions.leaseSeconds !== undefined
-                        ? { leaseSeconds: agentOptions.leaseSeconds }
-                        : { lease: agentOptions.lease ?? DEFAULT_AGENT_LEASE };
-                    capability = await capabilities.create({
-                        participantKind: 'agent',
-                        participantId: id,
-                        syncGroups: agentOptions.syncGroups ?? ['default'],
-                        operations: agentOptions.can,
-                        label: agentOptions.label ?? id,
-                        userMeta: agentOptions.userMeta,
-                        ...leaseOptions,
-                    });
-                    const agentClient = capability.client();
-                    task = await agentClient.tasks.create({
-                        prompt: runOptions.prompt,
-                        parentTaskId: runOptions.parentTaskId,
-                        surface: runOptions.surface ?? 'agent',
-                        metadata: runOptions.metadata,
-                    });
-                    const context = createAgentRunContext(agentClient, task);
-                    const value = await handler(context);
-                    await task.close({
-                        costInputTokens: runOptions.costInputTokens,
-                        costOutputTokens: runOptions.costOutputTokens,
-                        costComputeMs: runOptions.costComputeMs,
-                    });
-                    return { status: 'done', task, value };
-                }
-                catch (error) {
-                    if (task) {
-                        await task.close({
-                            costInputTokens: runOptions.costInputTokens,
-                            costOutputTokens: runOptions.costOutputTokens,
-                            costComputeMs: runOptions.costComputeMs,
-                        }).catch(() => { });
-                    }
-                    if (isAbortError(error) || runOptions.signal?.aborted) {
-                        return { status: 'cancelled', task: task ?? undefined, error };
-                    }
-                    return { status: 'failed', task: task ?? undefined, error };
-                }
-                finally {
-                    if (capability) {
-                        await capabilities.revoke(capability.id).catch(() => { });
-                    }
-                }
-            },
-        };
-    }
-    function createAgentRunContext(agentClient, task) {
-        return {
-            task,
-            ablo: agentClient,
-            model(name) {
-                return createAgentModelClient(agentClient, name);
-            },
-        };
-    }
-    function createAgentModelClient(agentClient, name) {
-        const base = agentClient.model(name);
-        return {
-            retrieve(params) {
-                // Reads are never blocked by a claim (coordination.md): a claim
-                // serializes WRITERS, not readers. So — unlike the create/update/
-                // delete paths below — retrieve does NOT apply the agent claimed
-                // default; options pass through and the read path's `'return'`
-                // default keeps a claimed row readable. A caller can still opt into
-                // gating with an explicit `ifClaimed` (developer's choice).
-                return base.retrieve(params);
-            },
-            create(params) {
-                const id = params.id ?? createModelId();
-                return withAgentIntent(agentClient, name, id, params, (commitIntent) => base.create({
-                    ...stripAgentRuntimeOptions(params),
-                    id,
-                    data: params.data,
-                    intent: commitIntent,
-                }));
-            },
-            update(params) {
-                return withAgentIntent(agentClient, name, params.id, params, (commitIntent) => base.update({
-                    ...stripAgentRuntimeOptions(params),
-                    id: params.id,
-                    data: params.data,
-                    intent: commitIntent,
-                }));
-            },
-            delete(params) {
-                return withAgentIntent(agentClient, name, params.id, params, (commitIntent) => base.delete({
-                    ...stripAgentRuntimeOptions(params),
-                    id: params.id,
-                    intent: commitIntent,
-                }));
-            },
-        };
-    }
-    async function withAgentIntent(agentClient, modelName, id, mutationOptions, commit) {
-        const intentInput = mutationOptions?.intent;
-        const targetOverride = intentInput != null && typeof intentInput === 'object' && !isIntentHandleRef(intentInput)
-            ? intentInput.target ?? {}
-            : {};
-        const target = {
-            ...targetOverride,
-            model: targetOverride.model ?? modelName,
-            id: targetOverride.id ?? id,
-            ...(intentInput != null && typeof intentInput === 'object' && !isIntentHandleRef(intentInput) && intentInput.field
-                ? { field: intentInput.field }
-                : {}),
-        };
-        await applyClaimedPolicy(target, withAgentClaimedDefault(mutationOptions), 'wait');
-        if (intentInput == null || isIntentHandleRef(intentInput)) {
-            return commit(intentInput);
-        }
-        const action = typeof intentInput === 'string' ? intentInput : intentInput.action;
-        const intent = await agentClient.intents.create({
-            target,
-            action,
-            ttl: typeof intentInput === 'object'
-                ? intentInput.ttl ?? DEFAULT_INTENT_LEASE
-                : DEFAULT_INTENT_LEASE,
-        });
-        try {
-            return await commit(intent);
-        }
-        finally {
-            await intent.release().catch(() => { });
-        }
-    }
     function normalizeCommitOperation(op, defaults) {
         const model = op.model ?? op.target?.model;
         if (!model) {
@@ -362,15 +224,30 @@ export function createProtocolClient(options) {
     }
     const commits = {
         async create(commitOptions) {
+            // Same runtime contract as every other write door — one schema.
+            assertWriteOptions({
+                idempotencyKey: commitOptions.idempotencyKey,
+                readAt: commitOptions.readAt,
+                onStale: commitOptions.onStale,
+                wait: commitOptions.wait,
+                intent: commitOptions.intent,
+            }, 'commits.create');
             const clientTxId = createClientTxId(commitOptions.idempotencyKey);
-            const operations = normalizeCommitOperations(commitOptions);
+            // Same claim vocabulary as the WS client's `commits.create`: a handle
+            // supplies the batch stale-guard defaults; explicit options win.
+            const claim = commitOptions.claim ?? null;
+            const operations = normalizeCommitOperations({
+                ...commitOptions,
+                readAt: commitOptions.readAt ?? claim?.readAt ?? null,
+                onStale: commitOptions.onStale ?? (claim?.readAt !== undefined ? 'reject' : null),
+            });
             const body = await requestJson('/v1/commits', {
                 method: 'POST',
                 idempotencyKey: clientTxId,
                 body: JSON.stringify({
                     clientTxId,
                     idempotencyKey: clientTxId,
-                    intent: normalizeIntentId(commitOptions.intent),
+                    intent: normalizeIntentId(commitOptions.intent) ?? claim?.claimId,
                     operations,
                 }),
             });
@@ -476,51 +353,6 @@ export function createProtocolClient(options) {
             return capabilities.create(options);
         },
     };
-    const tasks = {
-        async create(taskOptions) {
-            const body = await requestJson('/v1/tasks', {
-                method: 'POST',
-                body: JSON.stringify({
-                    prompt: taskOptions.prompt,
-                    parentTaskId: taskOptions.parentTaskId,
-                    surface: taskOptions.surface,
-                    metadata: taskOptions.metadata,
-                }),
-            });
-            const id = body.id ?? body.taskId ?? body.turnId;
-            if (!id) {
-                throw new AbloValidationError('Task create response did not include an id.', { code: 'task_id_missing' });
-            }
-            return {
-                id,
-                turnId: id,
-                promptHash: body.promptHash,
-                openedAt: body.openedAt,
-                close: (stats) => tasks.close(id, stats),
-            };
-        },
-        async close(id, stats) {
-            const body = await requestJson(`/v1/tasks/${encodeURIComponent(id)}/close`, {
-                method: 'POST',
-                body: JSON.stringify({
-                    costInputTokens: stats?.costInputTokens ?? 0,
-                    costOutputTokens: stats?.costOutputTokens ?? 0,
-                    costComputeMs: stats?.costComputeMs ?? 0,
-                }),
-            });
-            const closedId = body.id ?? body.taskId ?? body.turnId ?? id;
-            return {
-                id: closedId,
-                turnId: closedId,
-                closed: body.closed ?? body.alreadyClosed ?? true,
-                alreadyClosed: body.alreadyClosed,
-                endedAt: body.endedAt,
-            };
-        },
-        open(options) {
-            return tasks.create(options);
-        },
-    };
     const intents = {
         async create(intentOptions) {
             const intentId = createIntentId();
@@ -619,17 +451,33 @@ export function createProtocolClient(options) {
      * envelopes — this helper is the one-op, one-record path only.
      */
     async function mutateModel(action, modelName, id, data, options) {
+        assertWriteOptions(options && {
+            idempotencyKey: options.idempotencyKey,
+            readAt: options.readAt,
+            onStale: options.onStale,
+            wait: options.wait,
+            intent: options.intent,
+        }, `${modelName} ${action}`);
         const clientTxId = createClientTxId(options?.idempotencyKey);
         const encModel = encodeURIComponent(modelName);
         const path = action === 'create'
             ? `/v1/models/${encModel}`
             : `/v1/models/${encModel}/${encodeURIComponent(id)}`;
         const method = action === 'create' ? 'POST' : action === 'update' ? 'PATCH' : 'DELETE';
+        // A carried claim handle supplies the stale-guard defaults — one claim
+        // vocabulary across the WS proxy, `commits.create`, and these routes.
+        const claimHandle = typeof options?.claim === 'object' &&
+            options?.claim !== null &&
+            options.claim.object === 'claim' &&
+            typeof options.claim.claimId === 'string'
+            ? options.claim
+            : undefined;
+        const readAt = options?.readAt ?? claimHandle?.readAt;
         const requestBody = {
             idempotencyKey: clientTxId,
-            intent: normalizeIntentId(options?.intent),
-            onStale: options?.onStale,
-            readAt: options?.readAt,
+            intent: normalizeIntentId(options?.intent) ?? claimHandle?.claimId,
+            onStale: options?.onStale ?? (claimHandle?.readAt !== undefined ? 'reject' : undefined),
+            readAt,
         };
         if (action === 'create')
             requestBody.id = id;
@@ -687,11 +535,12 @@ export function createProtocolClient(options) {
         const releaseClaim = (params) => requestJson(claimPath(isClaimHandle(params) ? params.target.id : params.id), { method: 'DELETE' }).then(() => undefined);
         async function claimImpl(params) {
             const claimId = await acquireClaim(params);
-            const { data } = await retrieveModel(name, { id: params.id });
+            const { data, stamp } = await retrieveModel(name, { id: params.id });
             const release = () => releaseClaim(params);
             return {
                 object: 'claim',
                 claimId,
+                readAt: stamp,
                 target: {
                     model: name,
                     id: params.id,
@@ -780,35 +629,14 @@ export function createProtocolClient(options) {
         async dispose() { },
         async purge() { },
         capabilities,
-        tasks,
         intents,
         commits,
         model,
-        agent: createAgent,
         async getAuthToken() {
             // Mirror `authHeaders()`: a configured API key wins, else the
             // construction-time auth token. Resolve the (possibly async) key setter.
             return (await resolveApiKeyValue(configuredApiKey)) ?? configuredAuthToken ?? null;
         },
-        async beginTurn(turnOptions) {
-            const task = await tasks.create(turnOptions);
-            let closed = false;
-            const close = async (stats) => {
-                if (closed)
-                    return;
-                closed = true;
-                await task.close(stats);
-            };
-            const dispose = () => {
-                closed = true;
-            };
-            return {
-                turnId: task.id,
-                close,
-                dispose,
-                [Symbol.asyncDispose]: close,
-            };
-        },
     };
 }
 function normalizeIntentId(intent) {
@@ -816,33 +644,6 @@ function normalizeIntentId(intent) {
         return intent;
     return intent?.id;
 }
-function withAgentClaimedDefault(options) {
-    return {
-        ifClaimed: 'fail',
-        ...(options ?? {}),
-    };
-}
-function stripAgentRuntimeOptions(options) {
-    if (!options)
-        return undefined;
-    const { intent: _intent, ifClaimed: _ifClaimed, claimedTimeout: _claimedTimeout, claimedPollInterval: _claimedPollInterval, maxQueueDepth: _maxQueueDepth, ...rest } = options;
-    return rest;
-}
-function isIntentHandleRef(input) {
-    return (typeof input === 'object' &&
-        input !== null &&
-        'id' in input &&
-        typeof input.id === 'string' &&
-        !('action' in input));
-}
-function isAbortError(error) {
-    return (typeof DOMException !== 'undefined' &&
-        error instanceof DOMException &&
-        error.name === 'AbortError') || (typeof error === 'object' &&
-        error !== null &&
-        'name' in error &&
-        error.name === 'AbortError');
-}
 function parseBody(bodyText) {
     if (bodyText.length === 0)
         return null;

package/dist/client/auth.js

@@ -146,8 +146,38 @@ export function resolveBootstrapBaseUrl(input) {
         // legitimately arrive as `wss://…` — normalize it here rather than
         // faceplanting at fetch time. The derive branch below already does this;
         // the override branch silently skipped it.
-        return normalizeAbloHostedBaseUrl(input.bootstrapBaseUrl).replace(/^ws/, 'http');
+        return ensureApiSuffix(normalizeAbloHostedBaseUrl(input.bootstrapBaseUrl).replace(/^ws/, 'http'));
     }
     const url = normalizeAbloHostedBaseUrl(input.url);
-    return `${url.replace(/^ws/, 'http')}/api`;
+    return ensureApiSuffix(url.replace(/^ws/, 'http'));
+}
+/**
+ * Guarantee the HTTP base ends in the `/api` route segment the sync-server
+ * mounts every endpoint under (`apps/sync-server/src/index.ts` — `app.route('/api', …)`).
+ *
+ * The derive branch always appended `/api`; the override branch did NOT,
+ * trusting the caller (apps/web passes `${baseUrl}/api`). But a hosted
+ * customer setting a custom `baseURL`/`bootstrapBaseUrl` (their own subdomain,
+ * staging, etc.) without the suffix sent every credential exchange to
+ * `…/auth/capability` instead of `…/api/auth/capability` → a 404 surfaced as
+ * `exchange_failed`. Since the SDK hardcodes routes relative to this base and
+ * there is no valid Ablo deployment that serves them off the root, normalizing
+ * to a single trailing `/api` here is always correct — and idempotent for
+ * callers who already include it.
+ */
+function ensureApiSuffix(httpBase) {
+    const trimmed = httpBase.replace(/\/+$/, '');
+    try {
+        const u = new URL(trimmed);
+        const segments = u.pathname.split('/').filter(Boolean);
+        if (segments[segments.length - 1] === 'api')
+            return trimmed;
+        u.pathname = `${u.pathname.replace(/\/+$/, '')}/api`;
+        return u.toString().replace(/\/+$/, '');
+    }
+    catch {
+        // Should be unreachable post-`normalizeAbloHostedBaseUrl` (which yields an
+        // absolute URL), but fall back to a string check rather than throwing.
+        return /\/api$/.test(trimmed) ? trimmed : `${trimmed}/api`;
+    }
 }

package/dist/client/createInternalComponents.js

@@ -42,7 +42,7 @@ export function createInternalComponents(input) {
     const database = new Database(modelRegistry, bootstrapHelper, {
         // Point-solution default: no browser-local durable store unless the
         // caller explicitly asks for it. Node/edge runtimes always use the
-        // volatile store because IndexedDB is unavailable there.
+        // in-memory store because IndexedDB is unavailable there.
         inMemory: shouldUseInMemoryPersistence(options),
     });
     const syncClient = new SyncClient(objectPool, database);

package/dist/client/createModelProxy.d.ts

@@ -212,6 +212,15 @@ export interface ClaimReorderParams<T = Record<string, unknown>> extends ClaimLo
 export interface ClaimHandle<T = Record<string, unknown>> extends AsyncDisposable {
     readonly object: 'claim';
     readonly claimId: string;
+    /**
+     * Sync watermark of the held snapshot (`data` was read at this stamp).
+     * Writes that carry the handle — `update({ id, data, claim })` or
+     * `commits.create({ claim, ... })` — use it as the `readAt` stale guard,
+     * so a concurrent commit between snapshot and write is rejected instead
+     * of clobbered. Optional for wire/duck-type compat with externally
+     * constructed handles.
+     */
+    readonly readAt?: number;
     readonly target: {
         readonly model: string;
         readonly id: string;

package/dist/client/createModelProxy.js

@@ -17,6 +17,7 @@
 import { autorun } from 'mobx';
 import { AbloClaimedError, AbloValidationError, toAbloError, } from '../errors.js';
 import { Model, modelAsRow } from '../Model.js';
+import { assertWriteOptions } from './writeOptionsSchema.js';
 import { ModelScope } from '../types/index.js';
 const modelClientMeta = new WeakMap();
 export function getModelClientMeta(modelClient) {
@@ -76,6 +77,10 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
     };
     const mutationOptions = (params) => {
         const { id: _id, data: _data, claim: _claim, ...rest } = params;
+        // THE write-options schema — runtime twin of the compile-time params.
+        // Catches plain-JS callers (`onStale: 'rejct'`) at the call site with
+        // a typed error instead of a silent no-op or a server 400.
+        assertWriteOptions(rest, `${schemaKey} write`);
         return rest;
     };
     const releaseClaim = async (id) => {
@@ -154,6 +159,7 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
         return {
             object: 'claim',
             claimId: lease.id,
+            readAt: snapshot.stamp,
             target,
             action: options?.action ?? 'editing',
             ...(options?.description ? { description: options.description } : {}),
@@ -235,8 +241,6 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
             return this.getAll(options).length;
         },
         create: guard(async (params) => {
-            // TODO(options-persistence): stash `params` alongside the
-            // queued transaction so idempotencyKey survives offline flush.
             const id = params.id ?? Model.generateId();
             const opts = mutationOptions(params);
             const claim = params.claim;
@@ -260,8 +264,15 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
                     maxQueueDepth: claim.maxQueueDepth,
                 });
             }
+            // Default `organizationId` from the client's identity exactly like the
+            // mutator path (`buildModelForCreate`) — without this, a caller that
+            // omits it creates an org-unscoped row on one write door but not the
+            // other. An explicit value in `data` still wins via the spread.
+            const orgDefault = params.data.organizationId ??
+                syncClient.getOrganizationId();
             const model = new ModelClass({
                 id,
+                ...(orgDefault != null ? { organizationId: orgDefault } : {}),
                 ...params.data,
                 createdAt: new Date(),
                 updatedAt: new Date(),
@@ -299,9 +310,7 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
             // watermark + lease so it's stale-rejected and attributed to the claim.
             const claimed = activeClaims.get(id);
             const opts = mutationOptions(params);
-            const handleIntent = isClaimHandle(params.claim)
-                ? { id: params.claim.claimId }
-                : undefined;
+            const handle = isClaimHandle(params.claim) ? params.claim : undefined;
             const effective = claimed
                 ? {
                     wait: 'confirmed',
@@ -311,8 +320,18 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
                     ...opts,
                 }
                 : {
+                    // A carried handle engages the same stale guard as a claim this
+                    // proxy took itself — the watermark rides on the handle, so it
+                    // works across clients (HTTP-minted handles included).
+                    ...(handle?.readAt !== undefined
+                        ? {
+                            wait: 'confirmed',
+                            readAt: handle.readAt,
+                            onStale: 'reject',
+                        }
+                        : {}),
                     ...opts,
-                    ...(handleIntent ? { intent: handleIntent } : {}),
+                    ...(handle ? { intent: { id: handle.claimId } } : {}),
                 };
             // Local user update: `applyChanges` keeps change tracking ON so
             // the edited fields land in `modifiedProperties` and actually get
@@ -341,9 +360,7 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
                 throw new AbloValidationError(`Entity not found: ${registeredModelName}/${id}`, { code: 'entity_not_found' });
             const claimed = activeClaims.get(id);
             const opts = mutationOptions(params);
-            const handleIntent = isClaimHandle(params.claim)
-                ? { id: params.claim.claimId }
-                : undefined;
+            const handle = isClaimHandle(params.claim) ? params.claim : undefined;
             const effective = claimed
                 ? {
                     wait: 'confirmed',
@@ -353,8 +370,15 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
                     ...opts,
                 }
                 : {
+                    ...(handle?.readAt !== undefined
+                        ? {
+                            wait: 'confirmed',
+                            readAt: handle.readAt,
+                            onStale: 'reject',
+                        }
+                        : {}),
                     ...opts,
-                    ...(handleIntent ? { intent: handleIntent } : {}),
+                    ...(handle ? { intent: { id: handle.claimId } } : {}),
                 };
             syncClient.delete(model, effective);
             await waitForMutation(model, effective);

package/dist/client/httpClient.d.ts

@@ -22,8 +22,8 @@
  * wraps it in a typed proxy facade so server code gets the SAME `client.<model>`
  * surface as the browser client — typed proxies, stateless transport.
  */
-import { type AbloApiClientOptions, type TaskCreateOptions } from './ApiClient.js';
-import type { CommitReceipt, CommitResource, HttpClaimApi, ModelRead, ModelReadOptions, Turn } from './Ablo.js';
+import { type AbloApiClientOptions } from './ApiClient.js';
+import type { CommitReceipt, CommitResource, HttpClaimApi, ModelRead, ModelReadOptions } from './Ablo.js';
 import type { ModelCreateParams, ModelDeleteParams, ModelLoadOptions, ModelRetrieveParams, ModelUpdateParams } from './createModelProxy.js';
 import type { Schema, SchemaRecord, InferModel, InferCreate } from '../schema/schema.js';
 export interface AbloHttpClientOptions<S extends SchemaRecord> extends Omit<AbloApiClientOptions, 'schema'> {
@@ -47,7 +47,7 @@ export interface HttpModelClient<T, C = T> {
 }
 /**
  * The honest type of the stateless HTTP client: typed model proxies (the
- * request/response subset) + `commits` + `beginTurn` + `dispose`. Reaching for a
+ * request/response subset) + `commits` + `dispose`. Reaching for a
  * stateful-only capability (`get`/`getAll`/`getCount`, `onChange`,
  * `claim.state`/`queue`/`reorder`) is a COMPILE error here, not a latent runtime
  * `undefined` — the type matches what the transport can actually do.
@@ -56,7 +56,6 @@ export type AbloHttpClient<S extends SchemaRecord> = {
     readonly [K in keyof S & string]: HttpModelClient<InferModel<Schema<S>, K>, InferCreate<Schema<S>, K>>;
 } & {
     readonly commits: CommitResource;
-    beginTurn(options: TaskCreateOptions): Promise<Turn>;
     dispose(): Promise<void>;
     /** Resolve the bearer credential this client authenticates with (see `AbloApi.getAuthToken`). */
     getAuthToken(): Promise<string | null>;
@@ -65,7 +64,7 @@ export type AbloHttpClient<S extends SchemaRecord> = {
 };
 /**
  * Stateless, typed HTTP client. Each `client.<model>` resolves to the protocol
- * client's `model(name)`; `commits`, `beginTurn`, `tasks`, `dispose`, etc. pass
- * through. No socket is ever opened; identity is the Bearer credential.
+ * client's `model(name)`; `commits`, `dispose`, etc. pass through. No socket is
+ * ever opened; identity is the Bearer credential.
  */
 export declare function createAbloHttpClient<S extends SchemaRecord>(options: AbloHttpClientOptions<S>): AbloHttpClient<S>;

package/dist/client/httpClient.js

@@ -36,14 +36,13 @@ const PROTOCOL_MEMBERS = new Set([
     'dispose',
     'purge',
     'commits',
-    'beginTurn',
     'model',
     'getAuthToken',
 ]);
 /**
  * Stateless, typed HTTP client. Each `client.<model>` resolves to the protocol
- * client's `model(name)`; `commits`, `beginTurn`, `tasks`, `dispose`, etc. pass
- * through. No socket is ever opened; identity is the Bearer credential.
+ * client's `model(name)`; `commits`, `dispose`, etc. pass through. No socket is
+ * ever opened; identity is the Bearer credential.
  */
 export function createAbloHttpClient(options) {
     // The schema is type-level only; the protocol client is schema-agnostic.

package/dist/client/index.d.ts

@@ -32,5 +32,5 @@
 export { Ablo, computeFKDepthPriority, type AbloOptions, type InternalAbloOptions, type ClaimedOptions, type IfClaimedPolicy, type IntentWaitOptions, type ModelCountOptions, type ModelListOptions, type ModelListScope, type ModelLoadOptions, 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, AbloApiIntents, Agent, AgentIntentInput, AgentIntentOptions, AgentOptions, AgentModelClient, AgentModelReadOptions, AgentModelMutationOptions, AgentRunContext, AgentRunDone, AgentRunFailed, AgentRunCancelled, AgentRunOptions, AgentRunResult, AgentRunStatus, Capability, CapabilityCreateOptions, CapabilityParticipantKind, CapabilityRecord, CapabilityResource, CapabilityRevocation, CapabilityScope, Task, TaskCloseOptions, TaskCloseResult, TaskCreateOptions, TaskResource, } from './ApiClient.js';
+export type { AbloApi, AbloApiClientOptions, AbloApiIntents, Capability, CapabilityCreateOptions, CapabilityParticipantKind, CapabilityRecord, CapabilityResource, CapabilityRevocation, CapabilityScope, } from './ApiClient.js';
 export type { EngineParticipant, JoinedParticipant, ParticipantJoinOptions, ParticipantManager, ParticipantScope, ParticipantStatus, ScopedIntents, ScopedPresence, } from '../sync/participants.js';

package/dist/client/persistence.d.ts

@@ -1,4 +1,9 @@
-export type AbloPersistence = 'volatile' | 'indexeddb';
+/**
+ * Local persistence modes. `'memory'` (the default everywhere outside the
+ * browser) keeps the local graph in process memory; `'indexeddb'` adds
+ * offline queueing and a reload-surviving cache in the browser.
+ */
+export type AbloPersistence = 'memory' | 'indexeddb';
 export interface PersistenceOptions {
     readonly persistence?: AbloPersistence | undefined;
     readonly inMemory?: boolean | undefined;

package/dist/client/persistence.js

@@ -2,7 +2,7 @@ export function shouldUseInMemoryPersistence(options) {
     if (typeof window === 'undefined')
         return true;
     if (options.persistence)
-        return options.persistence === 'volatile';
+        return options.persistence === 'memory';
     if (typeof options.inMemory === 'boolean')
         return options.inMemory;
     if (options.offline === true)

package/dist/client/registerDataSource.d.ts

@@ -11,9 +11,9 @@ export interface RegisterDataSourceInput {
     readonly fetchImpl?: typeof fetch;
 }
 /**
- * POST the connection string to the self-serve direct connector route. Resolves
- * on success (the org is now a dedicated tenant pointed at this DB); throws an
- * `AbloError` with `datasource_registration_failed` otherwise so `ready()`
- * surfaces it instead of silently bootstrapping against the wrong store.
+ * POST the connection string to the self-serve datasource route. Resolves on
+ * success (the org's data plane now points at this DB); throws an `AbloError`
+ * with `datasource_registration_failed` otherwise so `ready()` surfaces it
+ * instead of silently bootstrapping against the wrong store.
  */
 export declare function registerDataSource(input: RegisterDataSourceInput): Promise<void>;