@crouter/sdk 0.3.377

package/dist/resources/canvas.js

@@ -0,0 +1,42 @@
+import { routes, } from '@crouter/api';
+import { CanvasHistory } from './canvas/history.js';
+import { withQuery } from './request.js';
+export class Canvas {
+    request;
+    history;
+    constructor(request) {
+        this.request = request;
+        this.history = new CanvasHistory(request);
+    }
+    attention(options) {
+        return this.request('GET', routes.canvasAttention(), undefined, options);
+    }
+    attentionCounts(body, options) {
+        return this.request('POST', routes.canvasAttentionCounts(), body, options);
+    }
+    snapshot(options) {
+        return this.request('GET', routes.canvasSnapshot(), undefined, options);
+    }
+    roster(options) {
+        return this.request('GET', routes.canvasRoster(), undefined, options);
+    }
+    async dashboard(query, options) {
+        const nodeQuery = query?.under === undefined ? undefined : { under: query.under };
+        const [nodes, status] = await Promise.all([
+            this.request('GET', withQuery(routes.nodes(), nodeQuery), undefined, options),
+            this.request('GET', routes.status(), undefined, options),
+        ]);
+        return { nodes, counts: status.node_counts, generated_at: new Date().toISOString() };
+    }
+    /** Watch an object; `watcher` makes a custom object the receiver instead of the caller's node. */
+    watch(ref, body = {}, options) {
+        return this.request('POST', routes.objectWatch(ref), body, options);
+    }
+    /** Remove a watch. `watcher` identifies the custom object whose watch is removed. */
+    unwatch(ref, query, options) {
+        return this.request('DELETE', withQuery(routes.objectWatch(ref), query), undefined, options);
+    }
+    prune(body, options) {
+        return this.request('POST', routes.canvasPrune(), body, options);
+    }
+}

package/dist/resources/crons.d.ts

@@ -0,0 +1,15 @@
+import { type ArmCronRequest, type CancelCronQuery, type CronDTO, type CronRunDTO, type CronScopeQuery, type CronShowDTO, type ListCronsQuery, type PokeCronsResult } from '@crouter/api';
+import type { RequestOptions } from '../types.js';
+import type { Request } from './request.js';
+export declare class Crons {
+    private readonly request;
+    constructor(request: Request);
+    create(body: ArmCronRequest, options?: RequestOptions): Promise<CronDTO>;
+    retrieve(id: string, query?: CronScopeQuery, options?: RequestOptions): Promise<CronShowDTO>;
+    list(query?: ListCronsQuery, options?: RequestOptions): Promise<CronDTO[]>;
+    pause(id: string, query?: CronScopeQuery, options?: RequestOptions): Promise<CronDTO>;
+    resume(id: string, query?: CronScopeQuery, options?: RequestOptions): Promise<CronDTO>;
+    run(id: string, query?: CronScopeQuery, options?: RequestOptions): Promise<CronRunDTO>;
+    delete(id: string, query?: CancelCronQuery, options?: RequestOptions): Promise<void>;
+    poke(options?: RequestOptions): Promise<PokeCronsResult>;
+}

package/dist/resources/crons.js

@@ -0,0 +1,33 @@
+import { routes, } from '@crouter/api';
+import { cronId } from './identifiers.js';
+import { withQuery } from './request.js';
+export class Crons {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    create(body, options) {
+        return this.request('POST', routes.crons(), body, options);
+    }
+    async retrieve(id, query, options) {
+        return this.request('GET', withQuery(routes.cron(cronId(id)), query), undefined, options);
+    }
+    list(query, options) {
+        return this.request('GET', withQuery(routes.crons(), query), undefined, options);
+    }
+    async pause(id, query, options) {
+        return this.request('POST', withQuery(routes.cronPause(cronId(id)), query), {}, options);
+    }
+    async resume(id, query, options) {
+        return this.request('POST', withQuery(routes.cronResume(cronId(id)), query), {}, options);
+    }
+    async run(id, query, options) {
+        return this.request('POST', withQuery(routes.cronRun(cronId(id)), query), {}, options);
+    }
+    async delete(id, query, options) {
+        return this.request('DELETE', withQuery(routes.cron(cronId(id)), query), undefined, options);
+    }
+    poke(options) {
+        return this.request('POST', routes.cronsPoke(), {}, options);
+    }
+}

package/dist/resources/custom-objects.d.ts

@@ -0,0 +1,20 @@
+import { type AckCustomDeliveriesResponseDTO, type PublishCustomObjectRequestDTO, type PublishCustomObjectResponseDTO, type QueueLineDTO, type RegisterCustomObjectRequestDTO, type RegisterCustomObjectResponseDTO } from '@crouter/api';
+import type { RequestOptions } from '../types.js';
+import type { Request } from './request.js';
+/** Queue streams replay every pending delivery on connect. `after` is accepted for compatibility but ignored for pending work. */
+export type ReceiveOptions = Pick<RequestOptions, 'signal' | 'headers' | 'maxRetries'> & {
+    after?: number;
+};
+/** A single queue connection. EOF (including rotate/unregister/receiver change) ends iteration; reconnect to replay unacknowledged work. */
+export interface CustomDeliveryStream extends AsyncIterableIterator<QueueLineDTO> {
+}
+export declare class CustomObjects {
+    private readonly request;
+    private readonly open;
+    constructor(request: Request, open: (path: string, options: ReceiveOptions) => Promise<Response>);
+    register(body: RegisterCustomObjectRequestDTO, options?: RequestOptions): Promise<RegisterCustomObjectResponseDTO>;
+    publish(ref: string, body: PublishCustomObjectRequestDTO, options?: RequestOptions): Promise<PublishCustomObjectResponseDTO>;
+    unregister(ref: string, options?: RequestOptions): Promise<void>;
+    ack(ref: string, deliveryIds: string[], options?: RequestOptions): Promise<AckCustomDeliveriesResponseDTO>;
+    receive(ref: string, options?: ReceiveOptions): CustomDeliveryStream;
+}

package/dist/resources/custom-objects.js

@@ -0,0 +1,84 @@
+import { routes, } from '@crouter/api';
+import { APIConnectionError, APIError, APIUserAbortError } from '../errors.js';
+import { withQuery } from './request.js';
+export class CustomObjects {
+    request;
+    open;
+    constructor(request, open) {
+        this.request = request;
+        this.open = open;
+    }
+    register(body, options) {
+        return this.request('POST', routes.customObjects(), body, options);
+    }
+    publish(ref, body, options) {
+        return this.request('POST', routes.customObjectEvents(ref), body, options);
+    }
+    unregister(ref, options) {
+        return this.request('DELETE', routes.customObject(ref), undefined, options);
+    }
+    ack(ref, deliveryIds, options) {
+        return this.request('POST', routes.customObjectAck(ref), { delivery_ids: deliveryIds }, options);
+    }
+    receive(ref, options = {}) {
+        const { after, ...requestOptions } = options;
+        if (after !== undefined && (!Number.isSafeInteger(after) || after < 0)) {
+            throw new RangeError('after must be a non-negative safe integer');
+        }
+        const path = withQuery(routes.customObjectDeliveries(ref), { after });
+        const iterate = async function* (open) {
+            const controller = new AbortController();
+            const abort = () => controller.abort(options.signal?.reason);
+            if (options.signal?.aborted)
+                abort();
+            else
+                options.signal?.addEventListener('abort', abort, { once: true });
+            let reader;
+            try {
+                const response = await open(path, { ...requestOptions, signal: controller.signal });
+                if (response.body === null)
+                    return;
+                reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    buffer += decoder.decode(value, { stream: !done });
+                    const lines = buffer.split(/\r?\n/);
+                    buffer = lines.pop() ?? '';
+                    if (done && buffer !== '')
+                        lines.push(buffer);
+                    for (const line of lines) {
+                        if (line.trim() === '')
+                            continue; // heartbeat
+                        const delivery = JSON.parse(line);
+                        yield delivery;
+                    }
+                    if (done)
+                        return; // server deliberately closes on rotate/unregister/receiver change
+                }
+            }
+            catch (error) {
+                if (controller.signal.aborted && options.signal?.aborted) {
+                    throw new APIUserAbortError(0, 'request_aborted', 'request aborted by caller signal');
+                }
+                if (error instanceof Error && !(error instanceof SyntaxError) && !(error instanceof APIError)) {
+                    throw new APIConnectionError(0, 'connection_error', error.message);
+                }
+                throw error;
+            }
+            finally {
+                options.signal?.removeEventListener('abort', abort);
+                controller.abort();
+                if (reader !== undefined) {
+                    try {
+                        await reader.cancel();
+                    }
+                    catch { /* the server may have already closed */ }
+                    reader.releaseLock();
+                }
+            }
+        };
+        return iterate(this.open);
+    }
+}

package/dist/resources/files.d.ts

@@ -0,0 +1,34 @@
+import { type FileEncoding, type FileListDTO, type FilePeekDTO, type FileWriteDTO } from '@crouter/api';
+import type { RequestOptions } from '../types.js';
+import type { Request } from './request.js';
+/** Options for `files.download`. */
+export interface FileDownloadOptions {
+    /** A single `Range` header value, e.g. `bytes=0-0` or `bytes=-500`; the answer is then 206 with `Content-Range`. */
+    range?: string;
+    /** Aborts the request and the body stream. */
+    signal?: AbortSignal;
+}
+/** Opens a raw download; the client supplies the bearer token and refresh. */
+export type FileDownloadOpener = (path: string, options: FileDownloadOptions) => Promise<Response>;
+export declare class Files {
+    private readonly request;
+    private readonly openDownload?;
+    constructor(request: Request, openDownload?: FileDownloadOpener | undefined);
+    read(path: string, options?: {
+        encoding?: FileEncoding;
+    } & RequestOptions): Promise<FilePeekDTO>;
+    write(path: string, content: string, options?: {
+        encoding?: FileEncoding;
+    } & RequestOptions): Promise<FileWriteDTO>;
+    list(path: string, options?: {
+        limit?: number;
+    } & RequestOptions): Promise<FileListDTO>;
+    /**
+     * The raw bytes of a file the caller may read (app listener only). Answers the `Response`
+     * itself (200, or 206 for `range`) with `Content-Type`, `Content-Length`, and `Content-Range`,
+     * so its body can be piped on. A non-2xx answer is thrown as `APIError` — a bad range is
+     * 416 `invalid_request` with `param: 'range'` — and never returned as bytes. A body cut
+     * short mid-stream means the file could not be read to the end.
+     */
+    download(path: string, options?: FileDownloadOptions): Promise<Response>;
+}

package/dist/resources/files.js

@@ -0,0 +1,34 @@
+import { routes, } from '@crouter/api';
+import { withQuery } from './request.js';
+export class Files {
+    request;
+    openDownload;
+    constructor(request, openDownload) {
+        this.request = request;
+        this.openDownload = openDownload;
+    }
+    read(path, options) {
+        const { encoding, ...requestOptions } = options ?? {};
+        return this.request('GET', withQuery(routes.filePeek(), { path, encoding }), undefined, requestOptions);
+    }
+    write(path, content, options) {
+        const { encoding, ...requestOptions } = options ?? {};
+        return this.request('POST', routes.fileWrite(), { path, content, encoding }, requestOptions);
+    }
+    list(path, options) {
+        const { limit, ...requestOptions } = options ?? {};
+        return this.request('GET', withQuery(routes.fileList(), { path, limit }), undefined, requestOptions);
+    }
+    /**
+     * The raw bytes of a file the caller may read (app listener only). Answers the `Response`
+     * itself (200, or 206 for `range`) with `Content-Type`, `Content-Length`, and `Content-Range`,
+     * so its body can be piped on. A non-2xx answer is thrown as `APIError` — a bad range is
+     * 416 `invalid_request` with `param: 'range'` — and never returned as bytes. A body cut
+     * short mid-stream means the file could not be read to the end.
+     */
+    async download(path, options = {}) {
+        if (!this.openDownload)
+            throw new TypeError('files.download requires a Crouter client');
+        return this.openDownload(path, options);
+    }
+}

package/dist/resources/forward.d.ts

@@ -0,0 +1,7 @@
+import type { Crouter } from '../client.js';
+/** Native EventSource sends Last-Event-ID on reconnect; it takes precedence over the URL cursor. */
+export declare function cursorFromRequest(request: Request): number;
+export declare function forwardRunEvents(crouter: Crouter, runId: string, options: {
+    after: number;
+    signal?: AbortSignal;
+}): Response;

package/dist/resources/forward.js

@@ -0,0 +1,64 @@
+import { APIError } from '../errors.js';
+/** Native EventSource sends Last-Event-ID on reconnect; it takes precedence over the URL cursor. */
+export function cursorFromRequest(request) {
+    const header = request.headers.get('Last-Event-ID');
+    const value = header !== null ? header : new URL(request.url).searchParams.get('after') ?? '0';
+    const cursor = Number(value);
+    if (!/^(0|[1-9]\d*)$/.test(value) || !Number.isSafeInteger(cursor))
+        throw new RangeError('Invalid event cursor');
+    return cursor;
+}
+export function forwardRunEvents(crouter, runId, options) {
+    const encoder = new TextEncoder();
+    const envelope = (failure) => ({
+        code: failure.code, message: failure.message,
+        ...(failure.type !== undefined ? { type: failure.type } : {}),
+        ...(failure.param !== undefined ? { param: failure.param } : {}),
+        ...(failure.details !== undefined ? { details: failure.details } : {}),
+        ...(failure.retryable !== undefined ? { retryable: failure.retryable } : {}),
+        ...(failure.retryAfterS !== undefined ? { retry_after_s: failure.retryAfterS } : {}),
+        ...(failure.resetAt !== undefined ? { reset_at: failure.resetAt } : {}),
+        ...(failure.userAction !== undefined ? { user_action: failure.userAction } : {}),
+        ...(failure.requestId !== undefined ? { request_id: failure.requestId } : {}),
+        ...(failure.runId !== undefined ? { run_id: failure.runId } : {}),
+        ...(failure.questionId !== undefined ? { question_id: failure.questionId } : {}),
+        ...(failure.scope !== undefined ? { scope: failure.scope } : {}),
+        ...(failure.origin !== undefined ? { origin: failure.origin } : {}),
+    });
+    const failureEnvelope = (error) => envelope(error instanceof APIError ? error : new APIError(0, 'transport_error', String(error), undefined, undefined, { retryable: true }));
+    let notify = () => undefined;
+    const source = crouter.runs.events(runId, { ...options, onReconnect: (state, error) => notify(state, error) });
+    let closed = false;
+    const stream = new ReadableStream({
+        start(controller) {
+            const write = (text) => { if (!closed)
+                controller.enqueue(encoder.encode(text)); };
+            notify = (state, error) => write(`data: ${JSON.stringify(state === 'reconnected' ? { type: 'stream.reconnected' } : { type: 'stream.reconnecting', error: failureEnvelope(error) })}\n\n`);
+            const keepalive = setInterval(() => write(': keepalive\n\n'), 15_000);
+            void (async () => {
+                try {
+                    for await (const event of source) {
+                        write(`id: ${event.sequence_number}\ndata: ${JSON.stringify(event)}\n\n`);
+                        if (event.type === 'node.settled')
+                            break;
+                    }
+                }
+                catch (error) {
+                    if (options.signal?.aborted)
+                        return;
+                    write(`data: ${JSON.stringify({ type: 'stream.refused', error: failureEnvelope(error) })}\n\n`);
+                }
+                finally {
+                    source.abort();
+                    clearInterval(keepalive);
+                    if (!closed) {
+                        closed = true;
+                        controller.close();
+                    }
+                }
+            })();
+        },
+        cancel() { closed = true; source.abort(); },
+    });
+    return new Response(stream, { headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no' } });
+}

package/dist/resources/human/inbox.d.ts

@@ -0,0 +1,14 @@
+import { type CancelInboxTicketRequest, type CanceledTicketResultDTO, type InboxListDTO, type InboxPageDTO, type InboxPageHistoryDTO, type InboxPageProgressDTO, type InboxPageResponseDTO, type PageTicketResultDTO, type RespondInboxPageRequest } from '@crouter/api';
+import type { RequestOptions } from '../../types.js';
+import type { Request } from '../request.js';
+export declare class HumanInbox {
+    private readonly request;
+    constructor(request: Request);
+    list(options?: RequestOptions): Promise<InboxListDTO>;
+    retrieve(ticketId: string, options?: RequestOptions): Promise<InboxPageDTO>;
+    respond(ticketId: string, body: RespondInboxPageRequest, options?: RequestOptions): Promise<PageTicketResultDTO>;
+    progress(ticketId: string, body: InboxPageProgressDTO, options?: RequestOptions): Promise<Record<string, unknown>>;
+    cancel(ticketId: string, body?: CancelInboxTicketRequest, options?: RequestOptions): Promise<CanceledTicketResultDTO>;
+    history(nodeId?: string, options?: RequestOptions): Promise<InboxPageHistoryDTO>;
+    response(ticketId: string, options?: RequestOptions): Promise<InboxPageResponseDTO>;
+}

package/dist/resources/human/inbox.js

@@ -0,0 +1,30 @@
+import { routes, } from '@crouter/api';
+import { inboxTicketId } from '../identifiers.js';
+import { withQuery } from '../request.js';
+export class HumanInbox {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    list(options) {
+        return this.request('GET', routes.humanInbox(), undefined, options);
+    }
+    async retrieve(ticketId, options) {
+        return this.request('GET', routes.humanInboxTicket(inboxTicketId(ticketId)), undefined, options);
+    }
+    async respond(ticketId, body, options) {
+        return this.request('POST', routes.humanInboxRespond(inboxTicketId(ticketId)), body, options);
+    }
+    async progress(ticketId, body, options) {
+        return this.request('POST', routes.humanInboxProgress(inboxTicketId(ticketId)), body, options);
+    }
+    async cancel(ticketId, body, options) {
+        return this.request('POST', routes.humanInboxCancel(inboxTicketId(ticketId)), body ?? {}, options);
+    }
+    history(nodeId, options) {
+        return this.request('GET', withQuery('/v1/human/inbox/history', nodeId === undefined ? undefined : { node_id: nodeId }), undefined, options);
+    }
+    async response(ticketId, options) {
+        return this.request('GET', routes.humanInboxResponse(inboxTicketId(ticketId)), undefined, options);
+    }
+}

package/dist/resources/human/requests.d.ts

@@ -0,0 +1,13 @@
+import { type CreateHumanRequestDTO, type CreateHumanRequestRequest, type HumanRequestDTO, type ReplaceHumanRequestRequest, type RespondHumanRequestRequest, type SettleHumanRequestRequest } from '@crouter/api';
+import type { RequestOptions } from '../../types.js';
+import type { Request } from '../request.js';
+export declare class HumanRequests {
+    private readonly request;
+    constructor(request: Request);
+    create(body: CreateHumanRequestRequest, options?: RequestOptions): Promise<CreateHumanRequestDTO>;
+    retrieve(id: string, options?: RequestOptions): Promise<HumanRequestDTO>;
+    replace(id: string, body: ReplaceHumanRequestRequest, options?: RequestOptions): Promise<HumanRequestDTO>;
+    respond(id: string, body: RespondHumanRequestRequest, options?: RequestOptions): Promise<HumanRequestDTO>;
+    dismiss(id: string, body?: SettleHumanRequestRequest, options?: RequestOptions): Promise<HumanRequestDTO>;
+    cancel(id: string, body?: SettleHumanRequestRequest, options?: RequestOptions): Promise<HumanRequestDTO>;
+}

package/dist/resources/human/requests.js

@@ -0,0 +1,26 @@
+import { routes, } from '@crouter/api';
+import { requestId } from '../identifiers.js';
+export class HumanRequests {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    create(body, options) {
+        return this.request('POST', routes.humanRequests(), body, options);
+    }
+    async retrieve(id, options) {
+        return this.request('GET', routes.humanRequest(requestId(id)), undefined, options);
+    }
+    async replace(id, body, options) {
+        return this.request('POST', routes.humanRequestReplace(requestId(id)), body, options);
+    }
+    async respond(id, body, options) {
+        return this.request('POST', routes.humanRequestRespond(requestId(id)), body, options);
+    }
+    async dismiss(id, body, options) {
+        return this.request('POST', routes.humanRequestDismiss(requestId(id)), body ?? {}, options);
+    }
+    async cancel(id, body, options) {
+        return this.request('POST', routes.humanRequestCancel(requestId(id)), body ?? {}, options);
+    }
+}

package/dist/resources/human.d.ts

@@ -0,0 +1,8 @@
+import { HumanInbox } from './human/inbox.js';
+import { HumanRequests } from './human/requests.js';
+import type { Request } from './request.js';
+export declare class Human {
+    readonly requests: HumanRequests;
+    readonly inbox: HumanInbox;
+    constructor(request: Request);
+}

package/dist/resources/human.js

@@ -0,0 +1,10 @@
+import { HumanInbox } from './human/inbox.js';
+import { HumanRequests } from './human/requests.js';
+export class Human {
+    requests;
+    inbox;
+    constructor(request) {
+        this.requests = new HumanRequests(request);
+        this.inbox = new HumanInbox(request);
+    }
+}

package/dist/resources/identifiers.d.ts

@@ -0,0 +1,8 @@
+export declare class ResourceIdentifierError extends TypeError {
+}
+export declare function nodeId(value: string): string;
+export declare function requestId(value: string): string;
+export declare function cronId(value: string): string;
+export declare function jobId(value: string): string;
+export declare function inboxTicketId(value: string): string;
+export declare function pathSegment(value: string, label: string): string;

package/dist/resources/identifiers.js

@@ -0,0 +1,33 @@
+import { isSafeBashJobId, isSafeCronId, isSafeNodeId } from '@crouter/api';
+export class ResourceIdentifierError extends TypeError {
+}
+function validated(value, label, validator) {
+    if (!validator(value) || !isSafePathSegment(value)) {
+        throw new ResourceIdentifierError(`invalid ${label}: ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+function isSafePathSegment(value) {
+    return typeof value === 'string'
+        && value !== '' && value !== '.' && value !== '..'
+        && !/[\\/\0\s?#%]/u.test(value)
+        && new TextEncoder().encode(value).byteLength <= 128;
+}
+export function nodeId(value) {
+    return validated(value, 'node id', isSafeNodeId);
+}
+export function requestId(value) {
+    return validated(value, 'request id', isSafeNodeId);
+}
+export function cronId(value) {
+    return validated(value, 'cron id', isSafeCronId);
+}
+export function jobId(value) {
+    return validated(value, 'job id', isSafeBashJobId);
+}
+export function inboxTicketId(value) {
+    return validated(value, 'inbox ticket id', (ticketId) => /^[a-f0-9]{64}$/u.test(ticketId));
+}
+export function pathSegment(value, label) {
+    return validated(value, label, isSafePathSegment);
+}

package/dist/resources/memory.d.ts

@@ -0,0 +1,69 @@
+import type { RequestOptions } from '../types.js';
+import { type Request } from './request.js';
+/** `memory.list` input. Only the documents the person owns (`store: 'user'`) are served in this release. */
+export interface MemoryListParams {
+    store: 'user';
+    /** A folder: documents whose name starts with `<path>/`, at any depth. */
+    path?: string;
+    kind?: 'knowledge' | 'preference';
+    /** 1 to 100; default 50. */
+    limit?: number;
+    /** The previous page's `next_cursor`, unchanged, with the same `store`, `path` and `kind`. */
+    cursor?: string;
+}
+/** `memory.get` input. */
+export interface MemoryGetParams {
+    store: 'user';
+    /** The document's full name, as `memory.list` returns it. */
+    name: string;
+}
+/** One document the person owns, as listed. */
+export interface MemoryListItem {
+    /** The full name without the `user/` owner prefix. */
+    name: string;
+    /** The name up to its last `/`; `""` for a top-level document. */
+    folder: string;
+    kind: 'knowledge' | 'preference';
+    preview: string;
+    summary: string | null;
+    /** Without a `crtr:memory:manage:user` grant an app only ever sees `public`. */
+    privacy: 'public' | 'friends' | 'private';
+    /** The current revision number. */
+    revision: number;
+    /** The time of revision 1. */
+    created_at: string;
+    /** The time of the current revision. */
+    updated_at: string;
+}
+/** A page of `memory.list`, ordered by name. */
+export interface MemoryListPage {
+    items: MemoryListItem[];
+    /** `null` on the last page. */
+    next_cursor: string | null;
+}
+/** A document with its body, from `memory.get`. */
+export interface MemoryDocument extends MemoryListItem {
+    /** The current markdown body as stored; links are not resolved. At most 1 MiB. */
+    body: string;
+    /** The full body's length in UTF-8 bytes. */
+    size: number;
+    /** `true` when `size` is over 1 MiB and `body` is its prefix. */
+    truncated: boolean;
+    /** `app:<id>` of the app whose node wrote revision 1; `null` when the person wrote it. */
+    grantee: string | null;
+}
+/**
+ * Reads the documents the person owns. The daemon filters each one by the caller's
+ * grant: an app reads `public` documents with no scope, and every privacy level with
+ * `crtr:memory:manage:user`; without it a `friends` or `private` document reads
+ * exactly as an absent one (`NotFoundError`). Reading records nothing.
+ */
+export declare class Memory {
+    private readonly request;
+    constructor(request: Request);
+    list(params: MemoryListParams, options?: RequestOptions): Promise<MemoryListPage>;
+    /** Every document across pages, ordered by name: `for await (const item of memory.listAll({store: 'user'}))`.
+     *  Fetches the next page (`limit` per page) only as you iterate; `break` stops fetching. */
+    listAll(params: Omit<MemoryListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<MemoryListItem, void, undefined>;
+    get(params: MemoryGetParams, options?: RequestOptions): Promise<MemoryDocument>;
+}

package/dist/resources/memory.js

@@ -0,0 +1,30 @@
+import { withQuery } from './request.js';
+/**
+ * Reads the documents the person owns. The daemon filters each one by the caller's
+ * grant: an app reads `public` documents with no scope, and every privacy level with
+ * `crtr:memory:manage:user`; without it a `friends` or `private` document reads
+ * exactly as an absent one (`NotFoundError`). Reading records nothing.
+ */
+export class Memory {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    list(params, options) {
+        return this.request('GET', withQuery('/v1/memory', params), undefined, options);
+    }
+    /** Every document across pages, ordered by name: `for await (const item of memory.listAll({store: 'user'}))`.
+     *  Fetches the next page (`limit` per page) only as you iterate; `break` stops fetching. */
+    async *listAll(params, options) {
+        for (let cursor;;) {
+            const page = await this.list({ ...params, ...(cursor === undefined ? {} : { cursor }) }, options);
+            yield* page.items;
+            if (!page.next_cursor)
+                return;
+            cursor = page.next_cursor;
+        }
+    }
+    get(params, options) {
+        return this.request('GET', withQuery('/v1/memory/document', params), undefined, options);
+    }
+}

package/dist/resources/models/config.d.ts

@@ -0,0 +1,8 @@
+import { type PutModelConfigRequest, type PutModelConfigResponse } from '@crouter/api';
+import type { RequestOptions } from '../../types.js';
+import type { Request } from '../request.js';
+export declare class ModelConfig {
+    private readonly request;
+    constructor(request: Request);
+    update(body: PutModelConfigRequest, options?: RequestOptions): Promise<PutModelConfigResponse>;
+}

package/dist/resources/models/config.js

@@ -0,0 +1,9 @@
+export class ModelConfig {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    update(body, options) {
+        return this.request('PUT', '/v1/model-config', body, options);
+    }
+}

package/dist/resources/models/credentials.d.ts

@@ -0,0 +1,10 @@
+import { type CredentialRemovalResultDTO, type CredentialResultDTO, type InstallCredentialRequest, type ModelAuthListDTO } from '@crouter/api';
+import type { RequestOptions } from '../../types.js';
+import type { Request } from '../request.js';
+export declare class ModelCredentials {
+    private readonly request;
+    constructor(request: Request);
+    list(options?: RequestOptions): Promise<ModelAuthListDTO>;
+    install(provider: string, body: InstallCredentialRequest, options?: RequestOptions): Promise<CredentialResultDTO>;
+    remove(provider: string, options?: RequestOptions): Promise<CredentialRemovalResultDTO>;
+}

package/dist/resources/models/credentials.js

@@ -0,0 +1,17 @@
+import { routes, } from '@crouter/api';
+import { pathSegment } from '../identifiers.js';
+export class ModelCredentials {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    list(options) {
+        return this.request('GET', routes.modelAuths(), undefined, options);
+    }
+    async install(provider, body, options) {
+        return this.request('PUT', routes.modelAuth(pathSegment(provider, 'provider')), body, options);
+    }
+    async remove(provider, options) {
+        return this.request('DELETE', routes.modelAuth(pathSegment(provider, 'provider')), undefined, options);
+    }
+}