modelpact 2.0.2

package/dist/helpers/monitor.js

@@ -0,0 +1,69 @@
+/**
+ * Download progress as the platform reports it: an `EventTarget` that fires
+ * `downloadprogress`.
+ *
+ * The Prompt API hands `create()` a `CreateMonitor` and fires a `ProgressEvent`
+ * on it. This is the same object for a provider with no browser behind it, and
+ * both satisfy `DownloadMonitor` from `../types/session.ts` —
+ * `src/types.test-d.ts` checks the ambient declaration against it.
+ *
+ * `ProgressEvent` is not a global in Node 22 — `typeof ProgressEvent` is
+ * `"undefined"` there, while `Event`, `EventTarget` and `CustomEvent` are
+ * present — and the vitest suites run in the node environment. So the event is
+ * a subclass of `Event` carrying the three `ProgressEvent` fields, which is
+ * what a listener reads. `CustomEvent` was the alternative and puts the numbers
+ * behind `detail`, where a listener written against the spec would not look.
+ */
+export const DOWNLOAD_PROGRESS = "downloadprogress";
+/**
+ * `total` is 1 and `loaded` is the ratio. MDN names the normalization on
+ * `ProgressEvent` itself ("if using 1 as a total, then loaded would be a
+ * decimal value between 0 and 1"), and it settles the one thing the Prompt API
+ * docs disagree about: `e.loaded / e.total` and a bare `e.loaded` are the same
+ * number here.
+ */
+export class DownloadProgressEvent extends Event {
+    loaded;
+    lengthComputable = true;
+    total = 1;
+    constructor(loaded) {
+        super(DOWNLOAD_PROGRESS);
+        this.loaded = loaded;
+    }
+}
+/**
+ * Our `CreateMonitor`. `report` is not part of `DownloadMonitor`, so a caller
+ * holding the contract type can listen but cannot invent progress —
+ * `src/types.test-d.ts` checks that it cannot.
+ */
+export class ProgressMonitor extends EventTarget {
+    #handler = null;
+    #loaded = null;
+    /**
+     * An `onevent` property is not free with `EventTarget`: only interfaces the
+     * platform defines have one, and it is a listener registration behind an
+     * accessor — assigning twice replaces, assigning null unsubscribes. Here it
+     * also carries the event's type, which `addEventListener` cannot: see the
+     * note on `DownloadMonitor`.
+     */
+    get ondownloadprogress() {
+        return this.#handler;
+    }
+    set ondownloadprogress(handler) {
+        if (this.#handler !== null) {
+            this.removeEventListener(DOWNLOAD_PROGRESS, this.#handler);
+        }
+        this.#handler = handler;
+        if (handler !== null) {
+            this.addEventListener(DOWNLOAD_PROGRESS, handler);
+        }
+    }
+    /** Dropped rather than dispatched when it does not move forward — the contract's non-decreasing guarantee. */
+    report(loaded) {
+        if (this.#loaded !== null && loaded <= this.#loaded)
+            return;
+        this.#loaded = loaded;
+        this.dispatchEvent(new DownloadProgressEvent(loaded));
+    }
+}
+//# sourceMappingURL=monitor.js.map

package/dist/helpers/monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor.js","sourceRoot":"","sources":["../../src/helpers/monitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,MAAM,CAAC,MAAM,iBAAiB,GAAG,kBAAkB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAIzB;IAHZ,gBAAgB,GAAG,IAAI,CAAC;IACxB,KAAK,GAAG,CAAC,CAAC;IAEnB,YAAqB,MAAgB;QACnC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QADN,WAAM,GAAN,MAAM,CAAU;IAErC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC9C,QAAQ,GAA4C,IAAI,CAAC;IACzD,OAAO,GAAoB,IAAI,CAAC;IAEhC;;;;;;OAMG;IACH,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAI,kBAAkB,CAAC,OAAgD;QACrE,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC3B,IAAI,CAAC,mBAAmB,CACtB,iBAAiB,EACjB,IAAI,CAAC,QAAyB,CAC/B,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,OAAwB,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,8GAA8G;IAC9G,MAAM,CAAC,MAAgB;QACrB,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,MAAM,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAC5D,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,aAAa,CAAC,IAAI,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;CACF"}

package/dist/helpers/ndjson.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A `TransformStream` that cuts decoded text into NDJSON lines.
+ *
+ * Network chunks and protocol lines are unrelated cuts of the same bytes. A
+ * chunk is whatever arrived in one TCP read: it can hold six frames, or the
+ * first half of one, and the boundary can fall inside a multi-byte character —
+ * which is `TextDecoderStream`'s job upstream, not this one's. Feeding chunks
+ * to `JSON.parse` therefore fails on the first delta long enough to be split.
+ *
+ * A stage rather than a `let buffer` in the reader loop, for three things a
+ * variable cannot do: `flush` runs at end-of-stream, so a body that stops
+ * without a trailing newline still yields its last line; the stage takes part
+ * in backpressure, since the readable side of a `TransformStream` has
+ * `highWaterMark` 0 and stops pulling while the consumer is behind; and
+ * cancelling anywhere in a `pipeThrough` chain tears down the whole chain,
+ * buffer included.
+ */
+export declare function ndjsonLines(): TransformStream<string, string>;
+//# sourceMappingURL=ndjson.d.ts.map

package/dist/helpers/ndjson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ndjson.d.ts","sourceRoot":"","sources":["../../src/helpers/ndjson.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,IAAI,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAkB7D"}

package/dist/helpers/ndjson.js

@@ -0,0 +1,39 @@
+/**
+ * A `TransformStream` that cuts decoded text into NDJSON lines.
+ *
+ * Network chunks and protocol lines are unrelated cuts of the same bytes. A
+ * chunk is whatever arrived in one TCP read: it can hold six frames, or the
+ * first half of one, and the boundary can fall inside a multi-byte character —
+ * which is `TextDecoderStream`'s job upstream, not this one's. Feeding chunks
+ * to `JSON.parse` therefore fails on the first delta long enough to be split.
+ *
+ * A stage rather than a `let buffer` in the reader loop, for three things a
+ * variable cannot do: `flush` runs at end-of-stream, so a body that stops
+ * without a trailing newline still yields its last line; the stage takes part
+ * in backpressure, since the readable side of a `TransformStream` has
+ * `highWaterMark` 0 and stops pulling while the consumer is behind; and
+ * cancelling anywhere in a `pipeThrough` chain tears down the whole chain,
+ * buffer included.
+ */
+export function ndjsonLines() {
+    let tail = "";
+    return new TransformStream({
+        transform(chunk, controller) {
+            const lines = (tail + chunk).split("\n");
+            // `split` always yields at least one element, and the last is what comes
+            // before the next newline — "" when the chunk ended on one.
+            tail = lines.pop() ?? "";
+            for (const line of lines) {
+                // Blank lines are legal NDJSON padding. `\r` is not stripped: it is
+                // JSON whitespace, so `JSON.parse` takes a CRLF line as it stands.
+                if (line.trim() !== "")
+                    controller.enqueue(line);
+            }
+        },
+        flush(controller) {
+            if (tail.trim() !== "")
+                controller.enqueue(tail);
+        },
+    });
+}
+//# sourceMappingURL=ndjson.js.map

package/dist/helpers/ndjson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ndjson.js","sourceRoot":"","sources":["../../src/helpers/ndjson.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,WAAW;IACzB,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,OAAO,IAAI,eAAe,CAAC;QACzB,SAAS,CAAC,KAAK,EAAE,UAAU;YACzB,MAAM,KAAK,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACzC,yEAAyE;YACzE,4DAA4D;YAC5D,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;YACzB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,oEAAoE;gBACpE,mEAAmE;gBACnE,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;oBAAE,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;QACD,KAAK,CAAC,UAAU;YACd,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;gBAAE,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/helpers/overflow.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The `contextoverflow` event, carried for every provider by one object.
+ *
+ * Shared for the reason `turn.ts` is shared: the contract suite would watch
+ * each provider fire and never notice that they fire on different arithmetic.
+ * The rule lives here — a session that has spent more of the window than the
+ * window holds — and nothing but this file decides it.
+ *
+ * A session is not an `EventTarget` by construction: a provider builds one as
+ * an object of closures. So the closures are assigned onto an instance of
+ * this class, the way `ProgressMonitor` carries `downloadprogress`.
+ */
+import type { AiSession } from "../types/session.js";
+import type { ContextUsage } from "../types/usage.js";
+export declare const CONTEXT_OVERFLOW = "contextoverflow";
+export declare class ContextEvents extends EventTarget {
+    #private;
+    /**
+     * As on `DownloadMonitor`: an `onevent` property is not free with
+     * `EventTarget`, and it is the only registration that carries the event's
+     * type — `addEventListener` on a subclass takes a bare `EventListener`.
+     */
+    get oncontextoverflow(): ((event: Event) => void) | null;
+    set oncontextoverflow(handler: ((event: Event) => void) | null);
+    /**
+     * Called with what the session now holds, after a turn has been charged.
+     *
+     * Fires at most once. The window does not un-overflow: the backend has
+     * already dropped the oldest turns to make the last one fit, and every turn
+     * after it is over the same line. A listener wants to hear that the conversation
+     * started losing its beginning, not to be told again each turn.
+     *
+     * `unbounded` and `unknown` never fire — there is no line to cross.
+     */
+    report(usage: ContextUsage): void;
+    /**
+     * For a backend that decides this itself. The browser fires its own
+     * `contextoverflow`, and forwarding that is more truthful than re-deriving it
+     * from counters it may already have trimmed — by the time a listener reads
+     * them the dropped turns are gone and `used` can be under the window again.
+     */
+    announce(): void;
+}
+/**
+ * A session's closures on top of an event target, which is the one way to build
+ * an `AiSession` — the contract extends `EventTarget`, and an object literal is
+ * not one.
+ */
+export declare function withEvents(events: ContextEvents, session: Omit<AiSession, keyof EventTarget | "oncontextoverflow">): AiSession;
+//# sourceMappingURL=overflow.d.ts.map

package/dist/helpers/overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overflow.d.ts","sourceRoot":"","sources":["../../src/helpers/overflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AAElD,qBAAa,aAAc,SAAQ,WAAW;;IAI5C;;;;OAIG;IACH,IAAI,iBAAiB,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAEvD;IAED,IAAI,iBAAiB,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,EAM7D;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAOjC;;;;;OAKG;IACH,QAAQ,IAAI,IAAI;CAKjB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,WAAW,GAAG,mBAAmB,CAAC,GAChE,SAAS,CAEX"}

package/dist/helpers/overflow.js

@@ -0,0 +1,72 @@
+/**
+ * The `contextoverflow` event, carried for every provider by one object.
+ *
+ * Shared for the reason `turn.ts` is shared: the contract suite would watch
+ * each provider fire and never notice that they fire on different arithmetic.
+ * The rule lives here — a session that has spent more of the window than the
+ * window holds — and nothing but this file decides it.
+ *
+ * A session is not an `EventTarget` by construction: a provider builds one as
+ * an object of closures. So the closures are assigned onto an instance of
+ * this class, the way `ProgressMonitor` carries `downloadprogress`.
+ */
+export const CONTEXT_OVERFLOW = "contextoverflow";
+export class ContextEvents extends EventTarget {
+    #handler = null;
+    #fired = false;
+    /**
+     * As on `DownloadMonitor`: an `onevent` property is not free with
+     * `EventTarget`, and it is the only registration that carries the event's
+     * type — `addEventListener` on a subclass takes a bare `EventListener`.
+     */
+    get oncontextoverflow() {
+        return this.#handler;
+    }
+    set oncontextoverflow(handler) {
+        if (this.#handler !== null) {
+            this.removeEventListener(CONTEXT_OVERFLOW, this.#handler);
+        }
+        this.#handler = handler;
+        if (handler !== null)
+            this.addEventListener(CONTEXT_OVERFLOW, handler);
+    }
+    /**
+     * Called with what the session now holds, after a turn has been charged.
+     *
+     * Fires at most once. The window does not un-overflow: the backend has
+     * already dropped the oldest turns to make the last one fit, and every turn
+     * after it is over the same line. A listener wants to hear that the conversation
+     * started losing its beginning, not to be told again each turn.
+     *
+     * `unbounded` and `unknown` never fire — there is no line to cross.
+     */
+    report(usage) {
+        if (this.#fired || usage.kind !== "bounded")
+            return;
+        // Strictly greater: a transcript that exactly fills the window still fits.
+        if (usage.used <= usage.total)
+            return;
+        this.announce();
+    }
+    /**
+     * For a backend that decides this itself. The browser fires its own
+     * `contextoverflow`, and forwarding that is more truthful than re-deriving it
+     * from counters it may already have trimmed — by the time a listener reads
+     * them the dropped turns are gone and `used` can be under the window again.
+     */
+    announce() {
+        if (this.#fired)
+            return;
+        this.#fired = true;
+        this.dispatchEvent(new Event(CONTEXT_OVERFLOW));
+    }
+}
+/**
+ * A session's closures on top of an event target, which is the one way to build
+ * an `AiSession` — the contract extends `EventTarget`, and an object literal is
+ * not one.
+ */
+export function withEvents(events, session) {
+    return Object.assign(events, session);
+}
+//# sourceMappingURL=overflow.js.map

package/dist/helpers/overflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overflow.js","sourceRoot":"","sources":["../../src/helpers/overflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,MAAM,CAAC,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAElD,MAAM,OAAO,aAAc,SAAQ,WAAW;IAC5C,QAAQ,GAAoC,IAAI,CAAC;IACjD,MAAM,GAAG,KAAK,CAAC;IAEf;;;;OAIG;IACH,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAI,iBAAiB,CAAC,OAAwC;QAC5D,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC3B,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,OAAO,KAAK,IAAI;YAAE,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAmB;QACxB,IAAI,IAAI,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO;QACpD,2EAA2E;QAC3E,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,KAAK;YAAE,OAAO;QACtC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACH,QAAQ;QACN,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAClD,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CACxB,MAAqB,EACrB,OAAiE;IAEjE,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACxC,CAAC"}

package/dist/helpers/transcript.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The conversation as the session has actually had it: what was handed at
+ * open, then every completed turn, in order.
+ *
+ * Completed only. An aborted, cancelled or failed turn adds nothing, and the
+ * event that appends is the one that charges usage (`04_generate.ts`), so the
+ * meter and the record cannot disagree. It also keeps the prefix a stateless
+ * backend resends stable from turn to turn, which is what a server's KV cache
+ * matches on — any edit before the end invalidates everything after it.
+ *
+ * Never trimmed. What to drop when the window overflows is a decision about
+ * the conversation, and only the app knows what it can lose; the lifecycle
+ * reports the overflow and keeps the whole record.
+ */
+import type { AiMessage } from "../types/messages.js";
+export interface Transcript {
+    /** Stable once read: a later `append` builds a new array rather than writing into this one. */
+    readonly entries: () => readonly AiMessage[];
+    readonly append: (input: string, answer: string) => void;
+}
+export declare function createTranscript(seed?: readonly AiMessage[]): Transcript;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/helpers/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../src/helpers/transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,MAAM,WAAW,UAAU;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,SAAS,EAAE,CAAC;IAC7C,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,SAAS,SAAS,EAAO,GAAG,UAAU,CAU5E"}

package/dist/helpers/transcript.js

@@ -0,0 +1,26 @@
+/**
+ * The conversation as the session has actually had it: what was handed at
+ * open, then every completed turn, in order.
+ *
+ * Completed only. An aborted, cancelled or failed turn adds nothing, and the
+ * event that appends is the one that charges usage (`04_generate.ts`), so the
+ * meter and the record cannot disagree. It also keeps the prefix a stateless
+ * backend resends stable from turn to turn, which is what a server's KV cache
+ * matches on — any edit before the end invalidates everything after it.
+ *
+ * Never trimmed. What to drop when the window overflows is a decision about
+ * the conversation, and only the app knows what it can lose; the lifecycle
+ * reports the overflow and keeps the whole record.
+ */
+export function createTranscript(seed = []) {
+    let entries = [...seed];
+    return {
+        entries: () => entries,
+        append: (input, answer) => {
+            const question = { role: "user", content: input };
+            const reply = { role: "assistant", content: answer };
+            entries = [...entries, question, reply];
+        },
+    };
+}
+//# sourceMappingURL=transcript.js.map

package/dist/helpers/transcript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.js","sourceRoot":"","sources":["../../src/helpers/transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,MAAM,UAAU,gBAAgB,CAAC,OAA6B,EAAE;IAC9D,IAAI,OAAO,GAAyB,CAAC,GAAG,IAAI,CAAC,CAAC;IAC9C,OAAO;QACL,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO;QACtB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YACxB,MAAM,QAAQ,GAAc,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YAC7D,MAAM,KAAK,GAAc,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAChE,OAAO,GAAG,CAAC,GAAG,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC1C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The package: a contract for language-model backends, the lifecycle that
+ * holds it, and one backend with nothing behind it.
+ *
+ * Three ways in. An app picks a provider and talks to a session — `AiSession`
+ * and the failure vocabulary are the whole surface for that. An app that ships
+ * several picks from its own registry. A backend author fills in `ModelBackend`
+ * and hands it to `createProvider`, then proves it with `modelpact/testing`.
+ */
+export { createProvider } from "./providers/create.js";
+export { defineProviders, findProviderName, type ProviderRegistry, } from "./providers/registry.js";
+export { makeMockProvider, type MockConfig } from "./providers/mock.js";
+export { makeOllamaProvider, type OllamaConfig } from "./providers/ollama.js";
+export { makePromptApiProvider } from "./providers/prompt-api.js";
+export type { AiProvider, ProviderName } from "./types/provider.js";
+export type { AccessKind, AiSession, DownloadMonitor, GenerateOptions, ModelAccess, SessionOptions, } from "./types/session.js";
+export type { AiMessage, AiRole, Modality, ModalityExpectation, ModelRequest, } from "./types/messages.js";
+export { AiError, failureFromError, type AiFailure, type FailureKind, } from "./types/failures.js";
+export { contextUsage, type ContextUsage, type UsageKind, } from "./types/usage.js";
+export { err, fraction, jsonSchema, ok, tokens, type Fraction, type JsonSchema, type Result, type Tokens, } from "./types/foundations.js";
+export type { Availability, ConnectOptions, GenerateRequest, ModelBackend, ModelConnection, } from "./types/backend.js";
+export { ndjsonLines } from "./helpers/ndjson.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,KAAK,gBAAgB,GACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACpE,YAAY,EACV,UAAU,EACV,SAAS,EACT,eAAe,EACf,eAAe,EACf,WAAW,EACX,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,SAAS,EACT,MAAM,EACN,QAAQ,EACR,mBAAmB,EACnB,YAAY,GACb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,GACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,GAAG,EACH,QAAQ,EACR,UAAU,EACV,EAAE,EACF,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,MAAM,GACZ,MAAM,wBAAwB,CAAC;AAIhC,YAAY,EACV,YAAY,EACZ,cAAc,EACd,eAAe,EACf,YAAY,EACZ,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+/**
+ * The package: a contract for language-model backends, the lifecycle that
+ * holds it, and one backend with nothing behind it.
+ *
+ * Three ways in. An app picks a provider and talks to a session — `AiSession`
+ * and the failure vocabulary are the whole surface for that. An app that ships
+ * several picks from its own registry. A backend author fills in `ModelBackend`
+ * and hands it to `createProvider`, then proves it with `modelpact/testing`.
+ */
+export { createProvider } from "./providers/create.js";
+export { defineProviders, findProviderName, } from "./providers/registry.js";
+export { makeMockProvider } from "./providers/mock.js";
+export { makeOllamaProvider } from "./providers/ollama.js";
+export { makePromptApiProvider } from "./providers/prompt-api.js";
+export { AiError, failureFromError, } from "./types/failures.js";
+export { contextUsage, } from "./types/usage.js";
+export { err, fraction, jsonSchema, ok, tokens, } from "./types/foundations.js";
+export { ndjsonLines } from "./helpers/ndjson.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EACL,eAAe,EACf,gBAAgB,GAEjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAmB,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAqB,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAkBlE,OAAO,EACL,OAAO,EACP,gBAAgB,GAGjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,YAAY,GAGb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,GAAG,EACH,QAAQ,EACR,UAAU,EACV,EAAE,EACF,MAAM,GAKP,MAAM,wBAAwB,CAAC;AAWhC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/lifecycle/01_access.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stage one: is there a model for this request. `open` is attached only to the
+ * branches that can, which is what makes opening an unavailable model
+ * unwritable.
+ *
+ * The backend the stages run on is `../types/backend.ts`; the entry that puts
+ * them together is `../providers/create.ts`.
+ */
+import type { ModelRequest } from "../types/messages.js";
+import type { ModelAccess } from "../types/session.js";
+import type { ModelBackend } from "../types/backend.js";
+export declare const checkAccess: (backend: ModelBackend, request?: ModelRequest) => Promise<ModelAccess>;
+//# sourceMappingURL=01_access.d.ts.map

package/dist/lifecycle/01_access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"01_access.d.ts","sourceRoot":"","sources":["../../src/lifecycle/01_access.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAY,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAkBxD,eAAO,MAAM,WAAW,GACtB,SAAS,YAAY,EACrB,UAAS,YAAiB,KACzB,OAAO,CAAC,WAAW,CA6BrB,CAAC"}

package/dist/lifecycle/01_access.js

@@ -0,0 +1,45 @@
+/**
+ * Stage one: is there a model for this request. `open` is attached only to the
+ * branches that can, which is what makes opening an unavailable model
+ * unwritable.
+ *
+ * The backend the stages run on is `../types/backend.ts`; the entry that puts
+ * them together is `../providers/create.ts`.
+ */
+import { openAfterDownload } from "./02_download.js";
+import { openSession } from "./03_open.js";
+const findUnsupportedModalities = (request, supported) => {
+    const expectations = [...(request.inputs ?? []), ...(request.outputs ?? [])];
+    const modalities = expectations.map((expectation) => expectation.type);
+    const unsupported = modalities.filter((modality) => !supported.includes(modality));
+    return unsupported;
+};
+const ignoreProgress = () => undefined;
+export const checkAccess = async (backend, request = {}) => {
+    const unsupportedModalities = findUnsupportedModalities(request, backend.modalities);
+    if (unsupportedModalities.length > 0) {
+        return {
+            kind: "unavailable",
+            reason: {
+                kind: "unsupported-config",
+                languages: [],
+                modalities: unsupportedModalities,
+            },
+        };
+    }
+    const availability = await backend.availability(request);
+    if (availability.kind === "unavailable")
+        return availability;
+    if (availability.kind === "needs-download") {
+        return {
+            kind: "needs-download",
+            started: availability.started,
+            open: (subscribe, options) => openAfterDownload(backend, request, subscribe, options),
+        };
+    }
+    return {
+        kind: "ready",
+        open: (options) => openSession(backend, request, options, ignoreProgress),
+    };
+};
+//# sourceMappingURL=01_access.js.map

package/dist/lifecycle/01_access.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"01_access.js","sourceRoot":"","sources":["../../src/lifecycle/01_access.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,yBAAyB,GAAG,CAChC,OAAqB,EACrB,SAA8B,EACT,EAAE;IACvB,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC;IAC7E,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACvE,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CACnC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAC5C,CAAC;IACF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,GAAS,EAAE,CAAC,SAAS,CAAC;AAE7C,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,EAC9B,OAAqB,EACrB,UAAwB,EAAE,EACJ,EAAE;IACxB,MAAM,qBAAqB,GAAG,yBAAyB,CACrD,OAAO,EACP,OAAO,CAAC,UAAU,CACnB,CAAC;IACF,IAAI,qBAAqB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrC,OAAO;YACL,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE;gBACN,IAAI,EAAE,oBAAoB;gBAC1B,SAAS,EAAE,EAAE;gBACb,UAAU,EAAE,qBAAqB;aAClC;SACF,CAAC;IACJ,CAAC;IACD,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACzD,IAAI,YAAY,CAAC,IAAI,KAAK,aAAa;QAAE,OAAO,YAAY,CAAC;IAC7D,IAAI,YAAY,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAC3C,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,OAAO,EAAE,YAAY,CAAC,OAAO;YAC7B,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAC3B,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC;SAC1D,CAAC;IACJ,CAAC;IACD,OAAO;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,CAAC;KAC1E,CAAC;AACJ,CAAC,CAAC"}

package/dist/lifecycle/02_download.d.ts

@@ -0,0 +1,8 @@
+/** Stage two, on the `needs-download` branch only: subscribe the monitor, then let the backend fetch and connect. */
+import type { Result } from "../types/foundations.js";
+import type { AiFailure } from "../types/failures.js";
+import type { ModelRequest } from "../types/messages.js";
+import type { AiSession, DownloadMonitor, SessionOptions } from "../types/session.js";
+import type { ModelBackend } from "../types/backend.js";
+export declare const openAfterDownload: (backend: ModelBackend, request: ModelRequest, subscribe: (monitor: DownloadMonitor) => void, options?: SessionOptions) => Promise<Result<AiSession, AiFailure>>;
+//# sourceMappingURL=02_download.d.ts.map

package/dist/lifecycle/02_download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"02_download.d.ts","sourceRoot":"","sources":["../../src/lifecycle/02_download.ts"],"names":[],"mappings":"AAAA,qHAAqH;AAGrH,OAAO,KAAK,EAAY,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,cAAc,EACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,eAAO,MAAM,iBAAiB,GAC5B,SAAS,YAAY,EACrB,SAAS,YAAY,EACrB,WAAW,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,EAC7C,UAAU,cAAc,KACvB,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,CAOtC,CAAC"}

package/dist/lifecycle/02_download.js

@@ -0,0 +1,12 @@
+/** Stage two, on the `needs-download` branch only: subscribe the monitor, then let the backend fetch and connect. */
+import { ProgressMonitor } from "../helpers/monitor.js";
+import { openSession } from "./03_open.js";
+export const openAfterDownload = (backend, request, subscribe, options) => {
+    const monitor = new ProgressMonitor();
+    // Before the first await: subscribing after the promise settles is
+    // subscribing after the download.
+    subscribe(monitor);
+    const reportProgress = (loaded) => monitor.report(loaded);
+    return openSession(backend, request, options, reportProgress);
+};
+//# sourceMappingURL=02_download.js.map

package/dist/lifecycle/02_download.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"02_download.js","sourceRoot":"","sources":["../../src/lifecycle/02_download.ts"],"names":[],"mappings":"AAAA,qHAAqH;AAErH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAUxD,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,OAAqB,EACrB,OAAqB,EACrB,SAA6C,EAC7C,OAAwB,EACe,EAAE;IACzC,MAAM,OAAO,GAAG,IAAI,eAAe,EAAE,CAAC;IACtC,mEAAmE;IACnE,kCAAkC;IAClC,SAAS,CAAC,OAAO,CAAC,CAAC;IACnB,MAAM,cAAc,GAAG,CAAC,MAAgB,EAAQ,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1E,OAAO,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;AAChE,CAAC,CAAC"}

package/dist/lifecycle/03_open.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Stage three: a connected model becomes an `AiSession` with the lifecycle's
+ * closures on it. `SessionState` is what those closures share from here on.
+ */
+import { ContextEvents } from "../helpers/overflow.js";
+import { type SessionLifetime } from "../helpers/lifetime.js";
+import { type Transcript } from "../helpers/transcript.js";
+import { type Fraction, type Result } from "../types/foundations.js";
+import type { AiFailure } from "../types/failures.js";
+import type { ModelRequest } from "../types/messages.js";
+import type { AiSession, SessionOptions } from "../types/session.js";
+import type { ModelConnection, ModelBackend } from "../types/backend.js";
+export interface SessionState {
+    readonly model: ModelConnection;
+    /** Idle, generating or closed, and the only way between the three. */
+    readonly lifetime: SessionLifetime;
+    readonly events: ContextEvents;
+    /** Seeded from `options.history`; the backend got the same seed at `connect`. */
+    readonly transcript: Transcript;
+}
+export declare const openSession: (backend: ModelBackend, request: ModelRequest, options: SessionOptions | undefined, reportProgress: (loaded: Fraction) => void) => Promise<Result<AiSession, AiFailure>>;
+//# sourceMappingURL=03_open.d.ts.map

package/dist/lifecycle/03_open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"03_open.d.ts","sourceRoot":"","sources":["../../src/lifecycle/03_open.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,aAAa,EAAc,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EAAW,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIzE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED,eAAO,MAAM,WAAW,GACtB,SAAS,YAAY,EACrB,SAAS,YAAY,EACrB,SAAS,cAAc,GAAG,SAAS,EACnC,gBAAgB,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,KACzC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,CA4BtC,CAAC"}

package/dist/lifecycle/03_open.js

@@ -0,0 +1,39 @@
+/**
+ * Stage three: a connected model becomes an `AiSession` with the lifecycle's
+ * closures on it. `SessionState` is what those closures share from here on.
+ */
+import { abortFailure } from "../helpers/abort.js";
+import { ContextEvents, withEvents } from "../helpers/overflow.js";
+import { createSessionLifetime, } from "../helpers/lifetime.js";
+import { createTranscript } from "../helpers/transcript.js";
+import { err, ok } from "../types/foundations.js";
+import { prompt, promptStream } from "./04_generate.js";
+import { closeSession } from "./05_close.js";
+export const openSession = async (backend, request, options, reportProgress) => {
+    if (options?.signal?.aborted === true)
+        return err(abortFailure(options.signal));
+    const events = new ContextEvents();
+    const modelResult = await backend.connect({
+        request,
+        session: options ?? {},
+        reportProgress,
+        reportOverflow: () => events.announce(),
+    });
+    if (!modelResult.ok)
+        return modelResult;
+    const state = {
+        model: modelResult.value,
+        lifetime: createSessionLifetime(),
+        events,
+        transcript: createTranscript(options?.history),
+    };
+    const session = withEvents(events, {
+        prompt: (input, generateOptions) => prompt(state, input, generateOptions),
+        promptStream: (input, generateOptions) => promptStream(state, input, generateOptions),
+        usage: () => state.model.usage(),
+        history: () => state.transcript.entries(),
+        close: () => closeSession(state),
+    });
+    return ok(session);
+};
+//# sourceMappingURL=03_open.js.map

package/dist/lifecycle/03_open.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"03_open.js","sourceRoot":"","sources":["../../src/lifecycle/03_open.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EACL,qBAAqB,GAEtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAmB,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,EAAE,EAA8B,MAAM,yBAAyB,CAAC;AAK9E,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAW7C,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,EAC9B,OAAqB,EACrB,OAAqB,EACrB,OAAmC,EACnC,cAA0C,EACH,EAAE;IACzC,IAAI,OAAO,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI;QACnC,OAAO,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAE3C,MAAM,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;IACnC,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC;QACxC,OAAO;QACP,OAAO,EAAE,OAAO,IAAI,EAAE;QACtB,cAAc;QACd,cAAc,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE;KACxC,CAAC,CAAC;IACH,IAAI,CAAC,WAAW,CAAC,EAAE;QAAE,OAAO,WAAW,CAAC;IAExC,MAAM,KAAK,GAAiB;QAC1B,KAAK,EAAE,WAAW,CAAC,KAAK;QACxB,QAAQ,EAAE,qBAAqB,EAAE;QACjC,MAAM;QACN,UAAU,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC;KAC/C,CAAC;IACF,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,EAAE;QACjC,MAAM,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,CAAC;QACzE,YAAY,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,EAAE,CACvC,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,CAAC;QAC7C,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE;QAChC,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,EAAE;QACzC,KAAK,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC;KACjC,CAAC,CAAC;IACH,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;AACrB,CAAC,CAAC"}

package/dist/lifecycle/04_generate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stage four, once per turn: refuse at the door, hold the session, guard the
+ * stream, record the turn, free the session.
+ *
+ * `prompt` is `promptStream` drained, unless the backend has a whole-answer
+ * call. Either way a turn cannot leave the session held: every exit from the
+ * guarded stream — done, error, abort, reader cancel — ends it.
+ */
+import { type Result } from "../types/foundations.js";
+import { type AiFailure } from "../types/failures.js";
+import type { GenerateOptions } from "../types/session.js";
+import type { SessionState } from "./03_open.js";
+export declare const prompt: (state: SessionState, input: string, options?: GenerateOptions) => Promise<Result<string, AiFailure>>;
+export declare const promptStream: (state: SessionState, input: string, options?: GenerateOptions) => Promise<Result<ReadableStream<string>, AiFailure>>;
+//# sourceMappingURL=04_generate.d.ts.map

package/dist/lifecycle/04_generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"04_generate.d.ts","sourceRoot":"","sources":["../../src/lifecycle/04_generate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAkLjD,eAAO,MAAM,MAAM,GACjB,OAAO,YAAY,EACnB,OAAO,MAAM,EACb,UAAU,eAAe,KACxB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAQnC,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,OAAO,YAAY,EACnB,OAAO,MAAM,EACb,UAAU,eAAe,KACxB,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,CACA,CAAC"}