@abloatai/ablo 0.9.0 → 0.9.2

package/dist/client/ApiClient.d.ts

@@ -5,7 +5,7 @@
  * IndexedDB, no WebSocket. It maps the public Model / Claim / Commit
  * nouns directly to HTTP routes on sync-server.
  */
-import type { AbloOptions, CommitReceipt, CommitResource, IntentCreateOptions, IntentHandle, IntentWaitOptions, ModelClient, ModelClaim, ModelMutationOptions, ModelReadOptions, ModelRead, ModelTarget, Turn } from './Ablo.js';
+import type { AbloOptions, CommitResource, IntentCreateOptions, IntentHandle, IntentWaitOptions, ModelClient, ModelClaim, ModelTarget } from './Ablo.js';
 import type { Duration } from '../utils/duration.js';
 export type AbloApiClientOptions = Omit<AbloOptions, 'schema'> & {
     readonly schema?: null | undefined;
@@ -115,133 +115,21 @@ export interface CapabilityResource {
      */
     mint(options: CapabilityCreateOptions): Promise<Capability>;
 }
-export interface TaskCreateOptions {
-    readonly prompt: string;
-    readonly parentTaskId?: string;
-    readonly surface?: string;
-    readonly metadata?: Record<string, unknown>;
-}
-export interface TaskCloseOptions {
-    readonly costInputTokens?: number;
-    readonly costOutputTokens?: number;
-    readonly costComputeMs?: number;
-}
-export interface Task {
-    readonly id: string;
-    readonly turnId: string;
-    readonly promptHash?: string;
-    readonly openedAt?: string;
-    close(stats?: TaskCloseOptions): Promise<TaskCloseResult>;
-}
-export interface TaskCloseResult {
-    readonly id: string;
-    readonly turnId: string;
-    readonly closed: boolean;
-    readonly alreadyClosed?: boolean;
-    readonly endedAt?: string;
-}
-export interface TaskResource {
-    create(options: TaskCreateOptions): Promise<Task>;
-    close(id: string, stats?: TaskCloseOptions): Promise<TaskCloseResult>;
-    /**
-     * Alias for `create`. Kept for the agent-run vocabulary; `create` is
-     * the canonical SDK verb.
-     */
-    open(options: TaskCreateOptions): Promise<Task>;
-}
-export interface AgentOptions {
-    readonly can: readonly string[];
-    readonly syncGroups?: readonly string[];
-    readonly label?: string;
-    readonly userMeta?: Record<string, unknown>;
-    /**
-     * Internal lease for the run capability. Most callers should omit it.
-     * The SDK revokes the capability when `run` finishes; the lease exists
-     * to clean up crashed or abandoned runs.
-     */
-    readonly lease?: Duration;
-    readonly leaseSeconds?: number;
-}
-export interface AgentRunOptions extends TaskCreateOptions {
-    readonly signal?: AbortSignal;
-    readonly costInputTokens?: number;
-    readonly costOutputTokens?: number;
-    readonly costComputeMs?: number;
-}
-export type AgentRunStatus = 'done' | 'failed' | 'cancelled';
-export interface AgentRunDone<T> {
-    readonly status: 'done';
-    readonly task: Task;
-    readonly value: T;
-}
-export interface AgentRunFailed {
-    readonly status: 'failed';
-    readonly task?: Task;
-    readonly error: unknown;
-}
-export interface AgentRunCancelled {
-    readonly status: 'cancelled';
-    readonly task?: Task;
-    readonly error?: unknown;
-}
-export type AgentRunResult<T> = AgentRunDone<T> | AgentRunFailed | AgentRunCancelled;
-export interface AgentIntentOptions {
-    readonly action: string;
-    readonly field?: string;
-    readonly ttl?: Duration;
-    readonly target?: Partial<ModelTarget>;
-}
-export type AgentIntentInput = string | AgentIntentOptions;
-export interface AgentModelReadOptions extends ModelReadOptions {
-}
-export interface AgentModelMutationOptions extends Omit<ModelMutationOptions, 'intent'> {
-    readonly intent?: AgentIntentInput | {
-        readonly id: string;
-    } | null;
-}
-export interface AgentModelClient<T = Record<string, unknown>> {
-    retrieve(params: AgentModelReadOptions & {
-        readonly id: string;
-    }): Promise<ModelRead<T>>;
-    create(params: AgentModelMutationOptions & {
-        readonly data: Record<string, unknown>;
-        readonly id?: string | null;
-    }): Promise<CommitReceipt>;
-    update(params: AgentModelMutationOptions & {
-        readonly id: string;
-        readonly data: Record<string, unknown>;
-    }): Promise<CommitReceipt>;
-    delete(params: AgentModelMutationOptions & {
-        readonly id: string;
-    }): Promise<CommitReceipt>;
-}
-export interface AgentRunContext {
-    readonly task: Task;
-    readonly ablo: AbloApi;
-    model<T = Record<string, unknown>>(name: string): AgentModelClient<T>;
-}
-export interface Agent {
-    readonly id: string;
-    run<T>(options: AgentRunOptions, handler: (context: AgentRunContext) => Promise<T> | T): Promise<AgentRunResult<T>>;
-}
 export interface AbloApi {
     ready(): Promise<void>;
     waitForFlush(): Promise<void>;
     dispose(): Promise<void>;
     purge(): Promise<void>;
     readonly capabilities: CapabilityResource;
-    readonly tasks: TaskResource;
     readonly intents: AbloApiIntents;
     readonly commits: CommitResource;
-    agent(id: string, options: AgentOptions): Agent;
     model<T = Record<string, unknown>>(name: string): ModelClient<T>;
-    beginTurn(options: TaskCreateOptions): Promise<Turn>;
     /**
      * Resolve the active bearer credential this client authenticates with — the
      * same token its own requests carry in `Authorization`. Returns `null` when
      * no credential is configured. Async because the API key may be supplied as
-     * an async setter. Use it to authenticate side-band requests to the same
-     * sync-server (e.g. the S3 presign endpoint) without re-minting.
+     * an async setter. Use it to authenticate a side-band request to the same
+     * server with the credential this client already holds — no re-mint.
      */
     getAuthToken(): Promise<string | null>;
 }

package/dist/client/ApiClient.js

@@ -9,7 +9,6 @@ import { AbloClaimedError, AbloAuthenticationError, AbloConnectionError, AbloVal
 import { assertBrowserSafety, readProcessEnv, resolveApiKey, resolveApiKeyValue, resolveAuthToken, resolveBaseURL, resolveBootstrapBaseUrl, } from './auth.js';
 import { toSeconds } from '../utils/duration.js';
 const DEFAULT_AGENT_LEASE = '10m';
-const DEFAULT_INTENT_LEASE = '2m';
 export function createProtocolClient(options) {
     const env = readProcessEnv();
     const authInput = { options, env };
@@ -100,144 +99,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) {
@@ -476,51 +337,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();
@@ -780,35 +596,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 +611,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/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/errorCodes.js

@@ -176,8 +176,8 @@ export const ERROR_CODES = {
     check_violation: wire('validation', 400, false, 'A value violates a database check constraint.'),
     constraint_violation: wire('validation', 400, false, 'A database integrity constraint was violated.'),
     // ── tenant / unknown model (400) ───────────────────────────────────
-    server_execute_unknown_model: wire('tenant', 400, false, 'The server-execute request named a model not in the tenant schema.'),
-    mutate_create_unknown_model: wire('tenant', 400, false, 'A create targeted a model not in the tenant schema.'),
+    server_execute_unknown_model: wire('tenant', 400, false, 'Wrote to a model the server does not know. The server keeps its own copy of the schema — run `ablo push` (or keep `ablo dev` running) to upload `ablo/schema.ts` before writing to new or changed models.'),
+    mutate_create_unknown_model: wire('tenant', 400, false, 'Created a model the server does not know. Run `ablo push` (or keep `ablo dev` running) to upload `ablo/schema.ts` first — the server keeps its own copy of the schema.'),
     tenant_model_columns_unknown: wire('tenant', 400, false, "The tenant model's columns could not be resolved."),
     tenant_model_missing_organization_id: wire('tenant', 400, false, 'The tenant model is missing the organization_id column required for isolation.'),
     // ── schema migration / declaration (validation) ────────────────────
@@ -286,7 +286,7 @@ export const ERROR_CODES = {
     provisioner_unavailable: wire('server', 503, false, 'No database provisioner is configured.'),
     invalid_model: wire('validation', 400, false, 'The request named an invalid model.'),
     invalid_id: wire('validation', 400, false, 'The request carried an invalid id.'),
-    unknown_model: wire('tenant', 400, false, 'The request named a model not in the tenant schema.'),
+    unknown_model: wire('tenant', 400, false, 'Named a model the server does not know. Run `ablo push` (or keep `ablo dev` running) to upload `ablo/schema.ts` — the server keeps its own copy of the schema.'),
     model_not_tenant_scoped: wire('tenant', 400, false, 'The model is not tenant-scoped and cannot be queried this way.'),
     schema_table_invalid: wire('schema', 500, false, "The model's table identifier is invalid."),
     schema_scope_invalid: wire('schema', 500, false, "The model's scope predicate could not be built."),

package/dist/index.js

@@ -61,7 +61,7 @@ export { ABLO_DEFAULT_BASE_URL, ABLO_HOSTED_API_DOMAIN, ABLO_HOSTED_HTTP_BASE_UR
 // Participant types live under `Ablo.Participant.*` —
 // `Ablo.Participant.Joined`, `Ablo.Participant.Manager`,
 // `Ablo.Participant.JoinOptions`, etc. Same dot-access shape as
-// `Ablo.Peer`, `Ablo.Claim`, `Ablo.Turn`. No flat re-exports.
+// `Ablo.Peer`, `Ablo.Claim`. No flat re-exports.
 // Advanced — most apps never import this. Principal constructors for
 // delegated agent paths (`Ablo({ kind: 'agent', as: session({...}) })`).
 // The default `Ablo({ schema, apiKey })` resolves identity from the key;

package/dist/interfaces/index.d.ts

@@ -164,10 +164,10 @@ export interface MutationOptions {
         readonly id: string;
     } | null;
     /**
-     * Active agent turn id to stamp on every delta row produced by this
-     * commit. Forwarded as the wire-level `causedByTaskId` field on the
-     * `{ type: 'commit' }` envelope. Set automatically by the SDK while
-     * `beginTurn(...)` is open.
+     * Dormant agent-task lineage field, forwarded as the wire-level
+     * `causedByTaskId`. Turns/tasks were removed from the SDK; nothing
+     * populates this anymore (write attribution rides on the claim/intent
+     * id). Kept optional for wire-compat; always `null` from the client.
      */
     causedByTaskId?: string | null;
 }