@abloatai/ablo 0.36.0 → 0.37.1

package/dist/adapters/alwaysOnline.d.ts

@@ -1,14 +0,0 @@
-/**
- * An {@link OnlineStatusProvider} that always reports the client as online.
- * Server-side runtimes — Node processes, agents, and sidecars — have no
- * browser network stack to lose, so there is no offline state to track. A
- * dropped database connection surfaces as a database error, not a network
- * transition. This is the server-side counterpart to the browser's
- * connectivity-aware provider, which watches the real online/offline signal.
- */
-import type { OnlineStatusProvider } from '../interfaces/index.js';
-/**
- * Returns an OnlineStatusProvider that always reports online.
- * `onStatusChange` never fires — the network never transitions.
- */
-export declare function alwaysOnline(): OnlineStatusProvider;

package/dist/adapters/alwaysOnline.js

@@ -1,17 +0,0 @@
-/**
- * An {@link OnlineStatusProvider} that always reports the client as online.
- * Server-side runtimes — Node processes, agents, and sidecars — have no
- * browser network stack to lose, so there is no offline state to track. A
- * dropped database connection surfaces as a database error, not a network
- * transition. This is the server-side counterpart to the browser's
- * connectivity-aware provider, which watches the real online/offline signal.
- */
-/**
- * Returns an OnlineStatusProvider that always reports online.
- * `onStatusChange` never fires — the network never transitions.
- */
-export function alwaysOnline() {
-    return {
-        isOnline: () => true,
-    };
-}

package/dist/adapters/inMemoryStorage.d.ts

@@ -1,31 +0,0 @@
-/**
- * An in-memory {@link ObjectStoreContract} implementation for runtimes
- * without IndexedDB, such as Node processes, agents, and tests. It keeps
- * records in a map and maintains simple secondary indexes, satisfying the
- * same contract the IndexedDB-backed store implements — so if the two ever
- * diverge, the mismatch becomes a typecheck error here rather than a silent
- * failure at a call site.
- *
- * Nothing is persisted; the data is cleared on process restart. That is
- * deliberate: server-side runtimes and agent workers rebuild their state from
- * the server's delta stream rather than from a local cache.
- */
-import type { ObjectStoreContract } from '../stores/ObjectStoreContract.js';
-export declare class InMemoryObjectStore implements ObjectStoreContract {
-    readonly modelName: string;
-    readonly storeName: string;
-    private data;
-    private indexes;
-    constructor(modelName: string, storeName: string, indexNames?: string[]);
-    add(record: Record<string, unknown>): Promise<void>;
-    put(record: Record<string, unknown>): Promise<void>;
-    get(id: string): Promise<Record<string, unknown> | undefined>;
-    getAll(): Promise<Record<string, unknown>[]>;
-    delete(id: string): Promise<void>;
-    getAllFromIndex(indexName: string, value: IDBValidKey): Promise<Record<string, unknown>[]>;
-    clear(): Promise<void>;
-    /** No-op — in-memory stores don't need closing. */
-    markAsClosing(): void;
-    private addToIndexes;
-    private removeFromIndexes;
-}

package/dist/adapters/inMemoryStorage.js

@@ -1,110 +0,0 @@
-/**
- * An in-memory {@link ObjectStoreContract} implementation for runtimes
- * without IndexedDB, such as Node processes, agents, and tests. It keeps
- * records in a map and maintains simple secondary indexes, satisfying the
- * same contract the IndexedDB-backed store implements — so if the two ever
- * diverge, the mismatch becomes a typecheck error here rather than a silent
- * failure at a call site.
- *
- * Nothing is persisted; the data is cleared on process restart. That is
- * deliberate: server-side runtimes and agent workers rebuild their state from
- * the server's delta stream rather than from a local cache.
- */
-export class InMemoryObjectStore {
-    modelName;
-    storeName;
-    data = new Map();
-    indexes = new Map();
-    constructor(modelName, storeName, indexNames = []) {
-        this.modelName = modelName;
-        this.storeName = storeName;
-        for (const name of indexNames) {
-            this.indexes.set(name, new Map());
-        }
-    }
-    add(record) {
-        const id = record.id;
-        if (!id)
-            throw new TypeError('In-memory record must carry an id');
-        if (this.data.has(id)) {
-            const error = new Error(`Record already exists: ${id}`);
-            error.name = 'ConstraintError';
-            throw error;
-        }
-        this.data.set(id, { ...record });
-        this.addToIndexes(id, record);
-        return Promise.resolve();
-    }
-    put(record) {
-        const id = record.id;
-        if (!id)
-            return Promise.resolve();
-        // Remove from old index entries if updating
-        const existing = this.data.get(id);
-        if (existing) {
-            this.removeFromIndexes(id, existing);
-        }
-        this.data.set(id, { ...record });
-        this.addToIndexes(id, record);
-        return Promise.resolve();
-    }
-    get(id) {
-        return Promise.resolve(this.data.get(id));
-    }
-    getAll() {
-        return Promise.resolve([...this.data.values()]);
-    }
-    delete(id) {
-        const existing = this.data.get(id);
-        if (existing) {
-            this.removeFromIndexes(id, existing);
-            this.data.delete(id);
-        }
-        return Promise.resolve();
-    }
-    getAllFromIndex(indexName, value) {
-        const index = this.indexes.get(indexName);
-        if (!index)
-            return Promise.resolve([]);
-        // The in-memory index stores values as strings (it doesn't support
-        // the full IDB key range — Date / BufferSource / arrays). For the
-        // overwhelmingly-common case of string FK ids, coercing through
-        // String() preserves the existing behavior while satisfying the
-        // shared `ObjectStoreContract` signature.
-        const ids = index.get(String(value));
-        if (!ids)
-            return Promise.resolve([]);
-        return Promise.resolve([...ids]
-            .map((id) => this.data.get(id))
-            .filter((r) => r != null));
-    }
-    clear() {
-        this.data.clear();
-        for (const index of this.indexes.values()) {
-            index.clear();
-        }
-        return Promise.resolve();
-    }
-    /** No-op — in-memory stores don't need closing. */
-    markAsClosing() { }
-    addToIndexes(id, record) {
-        for (const [indexName, indexMap] of this.indexes) {
-            const value = record[indexName];
-            if (value != null) {
-                const key = String(value);
-                if (!indexMap.has(key))
-                    indexMap.set(key, new Set());
-                indexMap.get(key).add(id);
-            }
-        }
-    }
-    removeFromIndexes(id, record) {
-        for (const [indexName, indexMap] of this.indexes) {
-            const value = record[indexName];
-            if (value != null) {
-                const key = String(value);
-                indexMap.get(key)?.delete(id);
-            }
-        }
-    }
-}

package/dist/ai-sdk/coordinatedTool.d.ts

@@ -1,120 +0,0 @@
-/**
- * Turns a write to one of your models into a Vercel AI SDK tool that handles
- * multi-agent coordination for you, so an agent can contribute to shared state
- * without silently overwriting another writer's concurrent change.
- *
- * The lower-level approach is to write your own `tool()` and call
- * `ablo.<model>.update({ id, data, claim })` inside its `execute` — the right
- * amount of control for a bespoke tool. This helper covers the common case
- * instead: the agent produced some content and you want to save it into a shared
- * row, without re-deriving optimistic concurrency each time. You declare the
- * write:
- *
- * ```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 } });
- * ```
- *
- * The {@link CoordinatedToolOptions.apply} function is the whole API: a pure
- * function from the freshest row and the tool input to a patch, in the same
- * spirit as a functional state update. Everything beneath it — reading the latest
- * row, the compare-and-swap, backing off between retries, and releasing claims —
- * is the runtime's job.
- *
- * ## Strategies
- *
- * Choose a strategy by how you want concurrent writers to relate. Each is
- * designed to converge under many agents writing at once.
- *
- * - `'merge'` (the default) delegates to the functional update
- *   `ablo.<model>.update(id, current => apply(current, input))`. The runtime
- *   re-reads and re-applies `apply` on top of every concurrent write, backing off
- *   between rounds, so many agents accumulate into one row and the model never
- *   sees a conflict. This requires the model's agent conflict policy to be
- *   `reject` (the default, or `agentsReject()`). A model that declares
- *   `agentsNotify()` holds the losing write instead of rejecting it, which
- *   defeats the reconcile loop — there, use `'claim'` or `'queue'`, or change the
- *   policy.
- *
- * - `'claim'` gives mutual exclusion. It takes a fail-fast claim; if another
- *   participant holds the row, it returns `{ status: 'claimed' }` and leaves the
- *   decision to retry up to the model. A visible signal serves the agent better
- *   than a hidden wait when it might spend its turn on something else. Works under
- *   any conflict policy.
- *
- * - `'queue'` serializes writers over stateless HTTP. The tool polls to acquire
- *   the claim until it is granted or `poll.timeoutMs` elapses, so the model calls
- *   once and the tool waits its turn. Ordering is approximate rather than strict
- *   first-in-first-out, which would require a persistent connection.
- */
-import type { z } from 'zod';
-import type { ClaimParams, ModelRetrieveParams, ModelUpdateParams } from '../client/createModelProxy.js';
-import type { ModelUpdater, ContentionOptions } from '../transaction/resources/functionalUpdate.js';
-import type { HeldClaim } from '../transaction/types/streams.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'` means the change was saved. `'claimed'` means another participant
-     * holds the row, so nothing was saved and the model should try again.
-     * `'timeout'` means 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;
-    /** The schema of what the model may send, as a standard AI SDK / Zod input schema. */
-    inputSchema: z.ZodType<TInput>;
-    /** Which row this write targets, derived from the tool input. */
-    id: (input: TInput) => string;
-    /**
-     * Produces the write patch from the freshest current row and the tool input, as
-     * a pure function of the two. Under `'merge'` it re-runs on top of every
-     * concurrent write, so it must be idempotent with respect to its own
-     * contribution — for example, skip its change when its marker is already
-     * present — to stay correct across retries.
-     */
-    apply: (current: T, input: TInput) => Partial<T>;
-    /** How concurrent writers relate. Defaults to `'merge'`. */
-    strategy?: CoordinationStrategy;
-    /** Human-readable coordination metadata attached to the claim, used by the `'claim'` and `'queue'` strategies. */
-    claim?: {
-        description?: string;
-    };
-    /** How many reconcile rounds `'merge'` may take before it gives up with `AbloContentionError`. */
-    retries?: number;
-    /** Poll interval and overall timeout for `'queue'`. Defaults to 250ms and 30s. */
-    poll?: {
-        intervalMs?: number;
-        timeoutMs?: number;
-    };
-}
-/**
- * The small model port this helper needs. Both typed transports implement this
- * exact contract; local-cache methods, wire receipts, and transport lifecycle
- * deliberately stay out of an AI tool's dependency surface.
- */
-export interface CoordinatedModel<T> {
-    retrieve(params: ModelRetrieveParams): Promise<T | undefined>;
-    update(params: ModelUpdateParams<T>): Promise<T>;
-    update(id: string, updater: ModelUpdater<T>, options?: ContentionOptions): Promise<T | undefined>;
-    claim(params: ClaimParams<T>): Promise<HeldClaim<T>>;
-}
-export declare function coordinatedTool<TInput, T = Record<string, unknown>>(model: CoordinatedModel<T>, options: CoordinatedToolOptions<TInput, T>): import("ai").Tool<TInput, CoordinatedWriteResult<T>>;

package/dist/ai-sdk/coordinatedTool.js

@@ -1,134 +0,0 @@
-/**
- * Turns a write to one of your models into a Vercel AI SDK tool that handles
- * multi-agent coordination for you, so an agent can contribute to shared state
- * without silently overwriting another writer's concurrent change.
- *
- * The lower-level approach is to write your own `tool()` and call
- * `ablo.<model>.update({ id, data, claim })` inside its `execute` — the right
- * amount of control for a bespoke tool. This helper covers the common case
- * instead: the agent produced some content and you want to save it into a shared
- * row, without re-deriving optimistic concurrency each time. You declare the
- * write:
- *
- * ```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 } });
- * ```
- *
- * The {@link CoordinatedToolOptions.apply} function is the whole API: a pure
- * function from the freshest row and the tool input to a patch, in the same
- * spirit as a functional state update. Everything beneath it — reading the latest
- * row, the compare-and-swap, backing off between retries, and releasing claims —
- * is the runtime's job.
- *
- * ## Strategies
- *
- * Choose a strategy by how you want concurrent writers to relate. Each is
- * designed to converge under many agents writing at once.
- *
- * - `'merge'` (the default) delegates to the functional update
- *   `ablo.<model>.update(id, current => apply(current, input))`. The runtime
- *   re-reads and re-applies `apply` on top of every concurrent write, backing off
- *   between rounds, so many agents accumulate into one row and the model never
- *   sees a conflict. This requires the model's agent conflict policy to be
- *   `reject` (the default, or `agentsReject()`). A model that declares
- *   `agentsNotify()` holds the losing write instead of rejecting it, which
- *   defeats the reconcile loop — there, use `'claim'` or `'queue'`, or change the
- *   policy.
- *
- * - `'claim'` gives mutual exclusion. It takes a fail-fast claim; if another
- *   participant holds the row, it returns `{ status: 'claimed' }` and leaves the
- *   decision to retry up to the model. A visible signal serves the agent better
- *   than a hidden wait when it might spend its turn on something else. Works under
- *   any conflict policy.
- *
- * - `'queue'` serializes writers over stateless HTTP. The tool polls to acquire
- *   the claim until it is granted or `poll.timeoutMs` elapses, so the model calls
- *   once and the tool waits its turn. Ordering is approximate rather than strict
- *   first-in-first-out, which would require a persistent connection.
- */
-import { tool } from 'ai';
-import { AbloClaimedError, AbloNotFoundError } from '../transaction/errors.js';
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export function coordinatedTool(model, options) {
-    const strategy = options.strategy ?? 'merge';
-    return tool({
-        description: options.description,
-        inputSchema: options.inputSchema,
-        execute: async (input) => {
-            const id = options.id(input);
-            if (strategy === 'merge') {
-                // Read the freshest row, apply the patch, and commit it with a
-                // compare-and-swap; on any concurrent write, re-read and re-apply with
-                // backoff. The model never sees a conflict.
-                const row = await model.update(id, (current) => options.apply(current, input), {
-                    retries: options.retries,
-                });
-                return { status: 'written', row: row ?? undefined };
-            }
-            // The 'claim' and 'queue' strategies both acquire a claim, write under it,
-            // and release it. They differ only in what they do when the row is already
-            // held: 'claim' returns a signal to the model, while 'queue' waits and
-            // retries by polling to acquire.
-            const acquireWriteRelease = async () => {
-                const claim = await model.claim({
-                    id,
-                    queue: false,
-                    description: options.claim?.description,
-                });
-                try {
-                    const current = await model.retrieve({ id });
-                    if (current === undefined) {
-                        throw new AbloNotFoundError(`Cannot write ${id}: it does not exist (or is outside this credential's scope).`, [id]);
-                    }
-                    const row = await model.update({ id, data: options.apply(current, input), claim, wait: 'confirmed' });
-                    return { status: 'written', row };
-                }
-                finally {
-                    await claim.release();
-                }
-            };
-            if (strategy === 'claim') {
-                try {
-                    return await acquireWriteRelease();
-                }
-                catch (e) {
-                    if (e instanceof AbloClaimedError) {
-                        return { status: 'claimed', message: 'Another participant holds this row right now — it was NOT saved. Wait briefly and try again.' };
-                    }
-                    throw e;
-                }
-            }
-            // strategy === 'queue': poll to acquire the claim over stateless HTTP.
-            const interval = options.poll?.intervalMs ?? 250;
-            const timeout = options.poll?.timeoutMs ?? 30_000;
-            const start = Date.now();
-            for (;;) {
-                try {
-                    const result = await acquireWriteRelease();
-                    return { ...result, waitedMs: Date.now() - start };
-                }
-                catch (e) {
-                    if (e instanceof AbloClaimedError) {
-                        if (Date.now() - start >= timeout) {
-                            return { status: 'timeout', message: `Could not acquire the row within ${timeout}ms.` };
-                        }
-                        await sleep(interval);
-                        continue;
-                    }
-                    throw e;
-                }
-            }
-        },
-    });
-}

package/dist/ai-sdk/coordinationContext.d.ts

@@ -1,46 +0,0 @@
-/**
- * Language-model middleware that tells the model when other participants are
- * editing the same entity. It reads peer claims on the target from the agent's
- * live presence stream and, when it finds any, injects a short coordination note
- * into the prompt before the model runs.
- *
- * This is the counterpart to the claim-broadcast middleware: that one announces
- * what this agent is about to do, while this one reads what others are doing and
- * passes it to the model. Together they let the model notice when a person or
- * another agent is mid-edit and respond — deferring, framing its work as
- * complementary, or suggesting it wait.
- *
- * It depends only on the AI SDK's provider types and a connected agent from this
- * package, and you compose it with the AI SDK's `wrapLanguageModel`. Reading
- * peers costs no extra model calls: the presence stream is already in memory from
- * the agent's subscription. It adds only a few sentences to the system prompt,
- * and only while peers are actively editing.
- */
-import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
-import type { Ablo } from '../client/Ablo.js';
-import type { SchemaRecord } from '../transaction/schema/schema.js';
-import type { ClaimTarget } from '../transaction/types/streams.js';
-export type { ClaimTarget };
-export interface CoordinationContextMiddlewareOptions<R extends SchemaRecord = SchemaRecord> {
-    readonly agent: Ablo<R> | null;
-    readonly target: ClaimTarget | null;
-    /**
-     * Claim identifiers to leave out of the read, typically this agent's own active
-     * claim so the note doesn't report that the agent is editing against itself. In
-     * the usual composition with the claim-broadcast middleware, `transformParams`
-     * runs before that middleware declares its claim, so the agent's own claim
-     * isn't in the presence stream yet and no filtering is needed. This option is
-     * here for callers that compose the middleware differently, or that coordinate a
-     * fleet and want to exclude sibling workers' claims.
-     */
-    readonly excludeClaimIds?: readonly string[];
-}
-/**
- * Builds the coordination-context middleware. If `agent` or `target` is null, the
- * middleware passes the prompt through unchanged.
- *
- * The generic over the schema record matches the claim-broadcast middleware: a
- * typed `Ablo<S>` and the widened `Ablo<SchemaRecord>` are not structurally
- * assignable, so the parameter stays generic to spare callers a cast.
- */
-export declare function coordinationContextMiddleware<R extends SchemaRecord = SchemaRecord>(options: CoordinationContextMiddlewareOptions<R>): LanguageModelV3Middleware;

package/dist/ai-sdk/coordinationContext.js

@@ -1,106 +0,0 @@
-/**
- * Language-model middleware that tells the model when other participants are
- * editing the same entity. It reads peer claims on the target from the agent's
- * live presence stream and, when it finds any, injects a short coordination note
- * into the prompt before the model runs.
- *
- * This is the counterpart to the claim-broadcast middleware: that one announces
- * what this agent is about to do, while this one reads what others are doing and
- * passes it to the model. Together they let the model notice when a person or
- * another agent is mid-edit and respond — deferring, framing its work as
- * complementary, or suggesting it wait.
- *
- * It depends only on the AI SDK's provider types and a connected agent from this
- * package, and you compose it with the AI SDK's `wrapLanguageModel`. Reading
- * peers costs no extra model calls: the presence stream is already in memory from
- * the agent's subscription. It adds only a few sentences to the system prompt,
- * and only while peers are actively editing.
- */
-/**
- * Builds the coordination-context middleware. If `agent` or `target` is null, the
- * middleware passes the prompt through unchanged.
- *
- * The generic over the schema record matches the claim-broadcast middleware: a
- * typed `Ablo<S>` and the widened `Ablo<SchemaRecord>` are not structurally
- * assignable, so the parameter stays generic to spare callers a cast.
- */
-export function coordinationContextMiddleware(options) {
-    const { agent, target } = options;
-    const excludeClaimIds = new Set(options.excludeClaimIds ?? []);
-    return {
-        specificationVersion: 'v3',
-        transformParams: async ({ params }) => {
-            if (!agent || !target)
-                return params;
-            // Look up peer claims on the same target. This reads the agent's reactive
-            // `claims.others` array in memory, with no I/O. The type is compared
-            // case-insensitively: observed claims carry a lowercased type name (such as
-            // `report`) while callers write the schema's type name (`Report`).
-            const wantedType = target.type.toLowerCase();
-            const peerClaims = agent.claims.others.filter((claim) => claim.target.type.toLowerCase() === wantedType &&
-                claim.target.id === target.id &&
-                targetsOverlap(claim.target, target) &&
-                !excludeClaimIds.has(claim.id));
-            if (peerClaims.length === 0)
-                return params;
-            const note = formatCoordinationNote(peerClaims, target);
-            return injectSystemNote(params, note);
-        },
-    };
-}
-function hasSubtarget(target) {
-    return Boolean(target.path || target.field || target.range);
-}
-function rangesOverlap(a, b) {
-    return a.startLine <= b.endLine && b.startLine <= a.endLine;
-}
-function targetsOverlap(claimTarget, target) {
-    if (!hasSubtarget(claimTarget) || !hasSubtarget(target))
-        return true;
-    if (claimTarget.path &&
-        target.path &&
-        claimTarget.path.toLowerCase() !== target.path.toLowerCase()) {
-        return false;
-    }
-    const fieldOverlaps = !claimTarget.field ||
-        !target.field ||
-        claimTarget.field.toLowerCase() === target.field.toLowerCase();
-    const rangeOverlaps = !claimTarget.range ||
-        !target.range ||
-        rangesOverlap(claimTarget.range, target.range);
-    return fieldOverlaps && rangeOverlaps;
-}
-/**
- * Formats a one-paragraph coordination note for the model. It names who is
- * editing and, when known, what they are doing. The note stays short: the goal is
- * to make the model aware, not to flood the prompt.
- */
-function formatCoordinationNote(claims, target) {
-    const entityLabel = target.type.toLowerCase();
-    const c = claims.length === 1 ? claims[0] : undefined;
-    if (c) {
-        return (`<multiplayer_context>\n` +
-            `Another participant is currently editing this ${entityLabel}. ` +
-            `Declared work: ${c.description}. ` +
-            `Defer to their concurrent changes when reasonable, or note your work as complementary to theirs. ` +
-            `Avoid stomping their in-flight edits.\n` +
-            `</multiplayer_context>`);
-    }
-    const descriptions = Array.from(new Set(claims.map((c) => c.description).filter(Boolean))).join('; ');
-    return (`<multiplayer_context>\n` +
-        `${claims.length} other participants are currently editing this ${entityLabel}. ` +
-        (descriptions ? `Declared work: ${descriptions}. ` : '') +
-        `Coordinate with their in-flight work — defer where reasonable, ` +
-        `or describe your work as complementary.\n` +
-        `</multiplayer_context>`);
-}
-/**
- * Append a system-role message to the prompt array. The AI SDK's
- * `LanguageModelV3Prompt` is an ordered list of messages.
- */
-function injectSystemNote(params, note) {
-    return {
-        ...params,
-        prompt: [...params.prompt, { role: 'system', content: note }],
-    };
-}