@rindle/api-server 0.7.11 → 0.8.0

package/dist/streams.d.ts

@@ -0,0 +1,373 @@
+import type { StreamFrame, StreamStatus } from "@rindle/client";
+import type { Authorizer, ServerSql, SqlDialect } from "./index.ts";
+export { STREAM_STATUS_STREAMING, assembleDurableText, frameResumePoint, spliceStreamText, } from "@rindle/client";
+export type { StreamFrame, StreamStatus } from "@rindle/client";
+/** What a checkpoint hands the durable plane when the app supplies its own {@link StreamCommit}. */
+export type StreamCommitInput = 
+/** The pointer is marked live. The app's own mutator created the row (it owns `chatId`, `role`,
+ *  the model name…); this only flips it to `streaming`. */
+{
+    kind: "open";
+    streamId: string;
+    meta: unknown;
+    hostId?: string;
+    startedAt: number;
+}
+/** A prefix advance carrying ONLY its own slice. `text.length === seq - from`, and `from` is the
+ *  last append the PLANE saw confirmed — so appends are contiguous in the fault-free run, but an
+ *  append that committed while its ack was lost makes the next one RE-COVER (its `from` lags what
+ *  the app already applied). See {@link StreamCommit} for the two ways to stay idempotent. */
+ | {
+    kind: "append";
+    streamId: string;
+    from: number;
+    seq: number;
+    text: string;
+}
+/** The seal. `body` is the producer's retained text and `bodyFrom` its absolute start offset:
+ *  `bodyFrom === 0` — and `body` is the WHOLE response — unless the app opted into trimming via
+ *  `retainChars` (`commit` mode only). A compacting app requires `bodyFrom === 0` and writes
+ *  `body` wholesale; a non-compacting app appends the outstanding tail —
+ *  `body.slice(from - bodyFrom)` — as a final chunk. `seq === bodyFrom + body.length`, always. */
+ | {
+    kind: "close";
+    streamId: string;
+    from: number;
+    seq: number;
+    body: string;
+    bodyFrom: number;
+    status: StreamStatus;
+    error?: string;
+};
+/** The escape hatch: persist the checkpoint however the app likes. Retried on throw (§3.3), so it
+ *  must be idempotent under a repeated `(from, seq)` — AND under a RE-COVER: an append whose write
+ *  committed but whose ack was lost leaves the plane believing less than the store holds, so the
+ *  next append's `(from, seq)` can OVERLAP text already applied. Apply only the unseen suffix
+ *  (`text.slice(applied - from)` when `applied > from`), or better, return `{seq: applied}` — the
+ *  authoritative applied length — and the plane resynchronizes instead of re-covering at all.
+ *  Return `{cancelRequested: true}` to tell the producer the reader asked it to stop (§6). */
+export type StreamCommit = (input: StreamCommitInput) => Promise<void | {
+    cancelRequested?: boolean;
+    seq?: number;
+}>;
+/** Which columns of the app's own tables the plane reads and writes. Every entry has a default
+ *  except `cancel`, `error`, and `host`, which are opt-in BY NAMING: the plane never emits SQL
+ *  against a column the app did not ask it to use. */
+export interface StreamColumns {
+    /** The message row's primary key, matched against `streamId`. Default `id`. */
+    key?: string;
+    /** The compacted response text. Default `body`. */
+    body?: string;
+    /** {@link STREAM_STATUS_STREAMING} then a {@link StreamStatus}. Default `status`. */
+    status?: string;
+    /** Total durable length — `length(body) + Σ chunk lengths`. The CAS column (§3.2). Default `seq`. */
+    seq?: string;
+    /** Opt-in (§6): a truthy value here stops the generation at the next checkpoint. No default —
+     *  naming it is what turns cancellation on. */
+    cancel?: string;
+    /** Opt-in: where a failed generation's message is recorded. No default. */
+    error?: string;
+    /** Opt-in: where the open write records this producer's identity ({@link RindleStreamOptions.hostId}).
+     *  Naming it upgrades the row-level single-flight guard from check-then-act to a true
+     *  compare-and-swap — the open write turns conditional and a read-back names the winner (§5.1) —
+     *  and gives multi-instance subscribe routing a column to read (§4). No default. */
+    host?: string;
+    /** Chunk primary key; the plane writes the deterministic `"<streamId>:<seq>"`. Default `id`. */
+    chunkKey?: string;
+    /** Chunk → message reference. Default `streamId`. */
+    chunkStream?: string;
+    /** The chunk's END offset — the ordering key. Default `seq`. */
+    chunkSeq?: string;
+    /** The chunk's slice of the response. Default `text`. */
+    chunkText?: string;
+}
+/**
+ * The app's tables (§5). The app authors and migrates BOTH — the message row is unambiguously
+ * app-owned (it has `chatId`, `role`, token counts) and the chunk row must be reachable from the
+ * app's own query as a `related` subquery, which a Rindle system table would make awkward. The plane
+ * only needs to be told where things live. Use {@link streamChunkTableDdl} for the chunk table's
+ * migration.
+ *
+ * The message table carries WHATEVER ELSE the app wants; the plane's hard requirements are only:
+ *
+ * | mapped column | requirement | why |
+ * | --- | --- | --- |
+ * | `key`    | UNIQUE (normally the pk) | every checkpoint targets one row by it |
+ * | `seq`    | integer, **NOT NULL DEFAULT 0** | the CAS column — nothing matches NULL (§3.2) |
+ * | `body`   | text, empty at open | compaction overwrites it with the whole response |
+ * | `status` | text accepting `streaming`/`complete`/`cancelled`/`error`/`interrupted` | a CHECK
+ *              constraint that omits one of these turns a seal into an infra failure |
+ * | `cancel` | truthy-readable, if mapped | read on the checkpoint round-trip (§6) |
+ * | `error`  | nullable text, if mapped | compaction writes `NULL` when there is no error |
+ * | `host`   | text, if mapped | written at open with the producer's token; the read-back decides the open race (§5.1) |
+ *
+ * `body` is PLANE-OWNED and always a bare string. Rich content (an array of content blocks, tool
+ * calls, attachments) belongs in SIBLING columns the app's own mutators write — `flush()` orders the
+ * text before them. For genuinely multi-block streaming, point `message` at a per-BLOCK table
+ * instead: `streamId` is just an app key, so one stream per block needs nothing from this plane.
+ */
+export interface StreamTables {
+    /** The app's message table. Must already contain the row when {@link StreamPlane.open} runs. */
+    message: string;
+    /** The append-only chunk table. */
+    chunks: string;
+    columns?: StreamColumns;
+}
+export type StreamCheckpointTarget = {
+    tables: StreamTables;
+} | {
+    commit: StreamCommit;
+};
+/** When a checkpoint fires — the FIRST of these wins (§3.1). Checkpoints are serialized, so a slow
+ *  store degrades to fewer, larger checkpoints, never to a queue of them. */
+export interface StreamCheckpointPolicy {
+    /** Produced-but-uncommitted characters that force a checkpoint. Default 512. */
+    chars?: number;
+    /** Milliseconds since the last checkpoint that force one. Default 750. */
+    intervalMs?: number;
+    /** Retries for a failing commit before the slice is left for the next trigger. Default 3. */
+    retries?: number;
+}
+export interface AuthorizeStreamInput<User> {
+    user: User;
+    streamId: string;
+    /** Where the subscriber claims to be. */
+    from: number;
+    /** The `meta` this stream was opened with — `undefined` when the stream is not hosted here, which
+     *  is precisely when the app must decide from `streamId` and its own durable state. */
+    meta: unknown;
+    request?: unknown;
+}
+export interface RindleStreamOptions<User> {
+    /** Where checkpoints land: the app's tables (the default path) or a raw `commit` callback. */
+    checkpoint: StreamCheckpointTarget;
+    /** REQUIRED. Subscribing to a stream is reading someone's chat, so there is no default-allow.
+     *  Runs BEFORE existence is checked, so a denial cannot be used to probe for stream ids. */
+    authorize: Authorizer<AuthorizeStreamInput<User>>;
+    policy?: StreamCheckpointPolicy;
+    /** This process's identity — it must be UNIQUE per producer process, because the open CAS trusts
+     *  it to distinguish rivals (§5.1). In `tables` mode, map {@link StreamColumns.host} and the open
+     *  write persists it on the message row (so the app can route later subscribers to the hosting
+     *  instance, §4) and uses it as the single-flight token; setting it WITHOUT a mapped `host` column
+     *  is refused at construction. In `commit` mode it rides the `open` input. When a `host` column is
+     *  mapped and no hostId is given, a random per-plane token is used — the CAS still holds, routing
+     *  just has no stable name to read. */
+    hostId?: string;
+    /** Slack retained BELOW `durableSeq` so a client whose IVM view lags a checkpoint can still join
+     *  without a `stale` round trip. Text at or above `durableSeq` is never trimmed. Default 64 KiB.
+     *  `commit`-mode only — REFUSED (a construction-time `TypeError`) in `tables` mode, where
+     *  compaction needs the whole produced text at close (§3.4), so the buffer is retained in full. */
+    retainChars?: number;
+    /** How long a sealed stream stays joinable before eviction. Default 30s. */
+    lingerMs?: number;
+    /** Per-subscriber frame queue cap; overflow drops that subscriber with `stale` (§4). Default 1024. */
+    maxQueuedFrames?: number;
+    /** A checkpoint that exhausted its retries. The stream keeps streaming — this is a durability
+     *  stall, not a stream stall — so the error must not vanish. Absent ⇒ `console.error`. */
+    onCheckpointError?: (err: unknown, info: {
+        streamId: string;
+        from: number;
+        seq: number;
+    }) => void;
+}
+export interface OpenStreamInput<User> {
+    user: User;
+    /** The app's message-row id: the durable pointer AND the live plane's key. The row must already
+     *  exist (the app's own mutator wrote it, alongside the user's prompt) with `seq = 0`. */
+    streamId: string;
+    /** Opaque app payload, passed through to a `commit` callback. Unused in `tables` mode. */
+    meta?: unknown;
+    request?: unknown;
+}
+/** The producer's handle (§2). One writer per stream, by construction. */
+export interface StreamHandle {
+    readonly streamId: string;
+    /** Total produced code units. */
+    readonly seq: number;
+    /** Total code units the store has committed. Never exceeds {@link seq} (contract P). */
+    readonly durableSeq: number;
+    /** True once a checkpoint round-trip has seen the reader's cancel flag (§6). `pump` stops on it;
+     *  a hand-rolled generation loop should check it. */
+    readonly cancelled: boolean;
+    /** Append a delta: fanned to subscribers synchronously, checkpointed on policy. */
+    push(text: string): void;
+    /** Force a checkpoint and resolve once the store holds every character produced so far. This is
+     *  the ORDERING primitive: `await flush()` before writing a discrete row (a tool call, a stop
+     *  reason) so the text precedes it in the store (§1). Rejects if the checkpoint cannot commit. */
+    flush(): Promise<number>;
+    /** Drain a delta iterable into the stream (the shape every LLM SDK's text stream already has),
+     *  stopping early — and closing the iterator, which aborts the underlying request — once the
+     *  reader has cancelled. */
+    pump(deltas: AsyncIterable<string>): Promise<void>;
+    /** Seal the stream: `cancelled` if the reader asked it to stop, else `complete`. In `tables` mode
+     *  this is the compaction (§3.4) — it writes the whole body and drops the chunk rows in one
+     *  transaction, so it also REPAIRS any checkpoint that failed along the way. */
+    close(): Promise<void>;
+    /** Seal `error` at whatever was produced. Never throws for the reason it is sealing. */
+    fail(error: unknown): Promise<void>;
+}
+export interface SubscribeStreamInput<User> {
+    user: User;
+    streamId: string;
+    /** "I already have this many characters" — from the client's IVM view, or a `Last-Event-ID`.
+     *  A non-negative integer; default 0. */
+    from?: number;
+    request?: unknown;
+}
+export interface StreamSubscription {
+    readonly streamId: string;
+    /** Terminates after exactly one of `end` / `stale` / `absent`. */
+    readonly frames: AsyncIterable<StreamFrame>;
+    /** Detach early (a disconnected client). Idempotent. */
+    close(): void;
+}
+/** Every mapped column, defaults applied. `cancel`/`error` stay `undefined` unless named. */
+export interface ResolvedStreamColumns {
+    key: string;
+    body: string;
+    status: string;
+    seq: string;
+    cancel?: string;
+    error?: string;
+    host?: string;
+    chunkKey: string;
+    chunkStream: string;
+    chunkSeq: string;
+    chunkText: string;
+}
+export declare function resolveStreamColumns(columns: StreamColumns | undefined): ResolvedStreamColumns;
+/** The chunk row's deterministic id: a replayed checkpoint collides with itself and is absorbed by
+ *  `ON CONFLICT DO NOTHING` — idempotency without an envelope or a dedup ledger (§3.3). */
+export declare function streamChunkId(streamId: string, seq: number): string;
+/**
+ * The chunk table's DDL, for the app's migration. The app owns the message table (this only states
+ * the three columns the plane needs on it); the chunk table is entirely protocol-shaped, so it is
+ * generated rather than hand-written.
+ */
+export declare function streamChunkTableDdl(tables: StreamTables, dialect: SqlDialect): string[];
+/** What the plane needs from the api-server to write a checkpoint: the backend's OUTSIDE-transaction
+ *  SQL surface (`batch` is one transaction on every backend) and its dialect. Deliberately narrow so
+ *  `streams.ts` never imports the server (no cycle). */
+export interface StreamSqlSink {
+    readonly dialect: SqlDialect;
+    readonly sql: ServerSql;
+}
+export declare class StreamPlane<User> {
+    readonly chars: number;
+    readonly intervalMs: number;
+    readonly retries: number;
+    readonly retainChars: number;
+    readonly lingerMs: number;
+    readonly maxQueuedFrames: number;
+    private readonly live;
+    private readonly opts;
+    private readonly sink;
+    private readonly mapped;
+    private readonly tables;
+    /** The open CAS token (§5.1): `hostId`, or a random per-plane stand-in when only the CAS — not
+     *  routing — needs it. */
+    private readonly openToken;
+    constructor(opts: RindleStreamOptions<User>, sink?: StreamSqlSink);
+    /** Open a stream on an EXISTING message row (§5): the app's own mutator wrote it, alongside the
+     *  user's prompt, so the pointer is already durable and every client's query already shows the
+     *  message. This verifies it and flips it to `streaming`. */
+    open(input: OpenStreamInput<User>): Promise<StreamHandle>;
+    /**
+     * The read-only precondition on the app's message row, checked ONCE per `open` (§5.1). Read-only on
+     * purpose: it is a decision about the app's data, so re-deciding it per write attempt would let a
+     * lost ack turn a success into a refusal.
+     *
+     * The `streaming` check is the **single-flight guard**, and it lives at the ROW rather than in this
+     * process's map because the thing it defends against is distributed: the kick that starts a
+     * generation is an at-least-once effect (a retried mutation envelope re-runs its post-commit code,
+     * §10.5), so a second kick can land on another instance, where the in-memory map is empty. Two
+     * producers on one `streamId` would interleave: both CAS the same length, one stalls, and whichever
+     * closes last overwrites the body with ITS buffer. Cheap to refuse; expensive to debug.
+     *
+     * This probe alone is check-then-act — it and the open write are separate round trips, so two
+     * SIMULTANEOUS kicks can both pass it. Mapping a `host` column closes that window: the open write
+     * turns conditional and {@link verifyOpenWinner}'s read-back names the winner.
+     */
+    private assertOpenable;
+    subscribe(input: SubscribeStreamInput<User>): Promise<StreamSubscription>;
+    /** Seal every live stream `interrupted`. In mapped-table mode the seal IS the compaction, so a
+     *  graceful drain loses nothing PRODUCED; the status still says the response was cut short rather
+     *  than claiming completion (§5). Wire it to SIGTERM. */
+    drainStreams(): Promise<void>;
+    /** Teardown: drop readers and timers WITHOUT a durable write (that is `drainStreams`). */
+    closeSync(): void;
+    /** A sealed stream stays joinable for the linger window, so a subscribe that races the last token
+     *  still gets `end` (and the tail it missed) rather than a bare `absent`. */
+    retire(streamId: string): void;
+    reportCheckpointError(err: unknown, info: {
+        streamId: string;
+        from: number;
+        seq: number;
+    }): void;
+    /** Drive ONE checkpoint, retrying on failure. Every statement it emits is idempotent under replay
+     *  — the chunk insert dedups on its deterministic id, the length CAS refuses to apply twice, the
+     *  compaction is a whole-row overwrite — so "retry until it sticks" needs no dedup ledger and no
+     *  `lmid` (§3.3). */
+    commit(input: StreamCommitInput): Promise<{
+        cancelRequested?: boolean;
+        seq?: number;
+    } | void>;
+    private commitOnce;
+    /** The read-back half of the open CAS, run only when a `host` column is mapped. The probe in
+     *  `assertOpenable` and the open write are separate round trips, so bare check-then-act leaves a
+     *  window where two simultaneous kicks both pass the probe; the conditional `markStreaming`
+     *  matches nothing when a rival got there first, and whichever token the row now holds names the
+     *  winner — a true CAS with no row counts needed. A replayed open (lost ack) reads back its OWN
+     *  token and proceeds. */
+    private verifyOpenWinner;
+    /** The post-append read-back (§3.2): the row's authoritative length — which both CONFIRMS an
+     *  append (the guarded batch reports no row count) and absorbs a committed-but-ack-lost one —
+     *  plus the reader's cancel flag when mapped (§6), riding the same indexed point read. This read
+     *  is LOAD-BEARING: a failure here fails the append attempt (retried, then stalled), because
+     *  claiming durability the store did not confirm is the one dishonesty this plane refuses. */
+    private readAppendState;
+    /** The store's word on how much is durable — for resynchronizing after a FAILED append, where a
+     *  lost ack may have left the store ahead of the plane. `undefined` in `commit` mode (no readable
+     *  authority) or when the read itself fails (the next attempt retries the resync too). */
+    probeDurableSeq(streamId: string): Promise<number | undefined>;
+}
+/** The open probe's verdict: the message row is missing or already advanced. Not retried — it is a
+ *  settled statement about the app's data, and retrying re-asks a question already answered. */
+export declare class StreamOpenRefused extends Error {
+    constructor(message: string);
+}
+/** Refused by {@link RindleStreamOptions.authorize}. Distinct from the api-server's own
+ *  `RindleApiError` so this module stays importable without the server (no cycle); the server
+ *  translates it to a 403 at the handler seam. */
+export declare class StreamForbidden extends Error {
+    readonly streamId: string;
+    constructor(streamId: string);
+}
+/** Headers for the SSE response. `x-accel-buffering` is the nginx-family opt-out — without it a
+ *  buffering proxy holds the tokens and hands the user a paragraph at a time. */
+export declare const STREAM_SSE_HEADERS: Record<string, string>;
+/** Pull a subscribe request out of a fetch-style GET: `?streamId=…&from=…`, with `Last-Event-ID`
+ *  winning over an explicit `from` (a reconnecting `EventSource` knows better than its own URL —
+ *  the URL is the ORIGINAL join point, the header is where it actually got to). */
+export declare function streamRequestFromHttp(req: {
+    url: string;
+    headers: {
+        get(name: string): string | null;
+    };
+}): {
+    streamId: string;
+    from: number;
+};
+/**
+ * Encode a subscription as an SSE body. Each positional frame carries `id: <seq>`, so a browser
+ * `EventSource` that drops the connection resumes at exactly the right offset with no application
+ * code — its own `Last-Event-ID` header is the `from` of the next subscribe ({@link
+ * streamRequestFromHttp}).
+ *
+ * The reader must close the `EventSource` on the `end` frame: `EventSource` reconnects on ANY close,
+ * including a clean one.
+ */
+export declare function streamFramesToSse(sub: StreamSubscription, opts?: {
+    keepAliveMs?: number;
+}): ReadableStream<Uint8Array>;
+//# sourceMappingURL=streams.d.ts.map

package/dist/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../src/streams.ts"],"names":[],"mappings":"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"}