@nathapp/nax-ai 0.1.0

package/dist/protocols/registry.js

@@ -0,0 +1,85 @@
+/**
+ * Protocol backend registration and selection.
+ *
+ * A protocol may have more than one backend — `pi` today, `native` when a wire
+ * format is hand-written later. Both can be registered at once so a native
+ * implementation can be run against the pi-backed one on real traffic before
+ * becoming the default. That comparison is the reason selection happens at
+ * runtime rather than by swapping a module at build time.
+ */
+export class UnknownProtocolError extends Error {
+    protocolName;
+    constructor(protocolName) {
+        super(`Unknown protocol "${protocolName}".`);
+        this.protocolName = protocolName;
+        this.name = "UnknownProtocolError";
+    }
+}
+export class UnregisteredBackendError extends Error {
+    protocolName;
+    backendId;
+    constructor(protocolName, backendId, available) {
+        super(`Backend "${backendId}" is not registered for protocol "${protocolName}". ` +
+            `Available: ${available.length > 0 ? available.join(", ") : "none"}. ` +
+            `This is not falling back — a silent fallback would misreport which implementation ran.`);
+        this.protocolName = protocolName;
+        this.backendId = backendId;
+        this.name = "UnregisteredBackendError";
+    }
+}
+export function createRegistry(entries, selection = {}) {
+    const resolved = new Map();
+    const backendsFor = (protocolName) => {
+        const backends = entries[protocolName];
+        if (backends === undefined)
+            throw new UnknownProtocolError(protocolName);
+        return backends;
+    };
+    const idsFor = (backends) => Object.keys(backends).filter((id) => backends[id] !== undefined);
+    const selectedFor = (protocolName) => selection.byProtocol?.[protocolName] ?? selection.default ?? "pi";
+    return {
+        available() {
+            const map = new Map();
+            for (const [name, backends] of Object.entries(entries)) {
+                map.set(name, idsFor(backends));
+            }
+            return map;
+        },
+        async resolve(protocolName) {
+            const cached = resolved.get(protocolName);
+            if (cached !== undefined)
+                return cached;
+            const backends = backendsFor(protocolName);
+            const backendId = selectedFor(protocolName);
+            const factory = backends[backendId];
+            if (factory === undefined) {
+                throw new UnregisteredBackendError(protocolName, backendId, idsFor(backends));
+            }
+            const promise = factory();
+            resolved.set(protocolName, promise);
+            return promise;
+        },
+        validate() {
+            // Per-protocol overrides first: they take precedence over the default,
+            // and names a protocol outside `entries` must surface as unknown before
+            // any default-derived check runs. Throwing exits immediately, so the
+            // same defect is never reported twice.
+            for (const [protocolName, backendId] of Object.entries(selection.byProtocol ?? {})) {
+                const backends = backendsFor(protocolName);
+                if (backends[backendId] === undefined) {
+                    throw new UnregisteredBackendError(protocolName, backendId, idsFor(backends));
+                }
+            }
+            // The default applies to every protocol not named in byProtocol. A
+            // `{ default: "native" }` selection must fail at startup, not on the
+            // first resolve().
+            for (const [protocolName, backends] of Object.entries(entries)) {
+                const backendId = selectedFor(protocolName);
+                if (backends[backendId] === undefined) {
+                    throw new UnregisteredBackendError(protocolName, backendId, idsFor(backends));
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=registry.js.map

package/dist/protocols/registry.js.map

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

package/dist/protocols/retry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bounded transport-fault retry, ahead of the first event.
+ *
+ * Lives in its own module rather than inline in client.ts so it is
+ * unit-testable with an injected clock, and so it survives a future
+ * migration that deletes the pi-ai backend entirely: this file imports
+ * nothing pi-ai-shaped, only the wire-protocol vocabulary in ./types.ts.
+ *
+ * Spec: docs/superpowers/specs/2026-08-31-nax-ai-protocol-architecture-design.md §10.1.
+ * nax-ai retries transport faults only, and only before the first event of an
+ * attempt is emitted. Rate limits and overload capacity are consumer policy
+ * (concurrency, cost budget, failover) and must never be retried internally.
+ * 4xx and auth failures are terminal — retrying cannot help either.
+ */
+import type { ProtocolEvent } from "./types.ts";
+export interface RetryOptions {
+    /** Retries beyond the first attempt. 0 makes exactly one attempt. */
+    readonly retries: number;
+    /** Injected so tests never actually wait; client.ts passes the real clock. */
+    readonly sleep: (ms: number) => Promise<void>;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Wraps a protocol stream factory with bounded transport-fault retry.
+ *
+ * `makeStream` is called once per attempt so each retry is a fresh request.
+ * The moment any event is yielded — including "usage" — everything from then
+ * on passes straight through with no further retry for this call. "usage"
+ * counts deliberately: pi-client.ts yields a usage event before an error
+ * event when a failed request still consumed tokens ("A failed request that
+ * consumed tokens still bills for them"). If usage did not gate the retry, a
+ * retry would emit a second usage event, and collectStream's "last usage
+ * wins" rule would silently discard the failed attempt's billed tokens. So
+ * retry only ever covers attempts that produced literally nothing.
+ */
+export declare function retryTransportFaults(makeStream: () => AsyncIterable<ProtocolEvent>, { retries, sleep, signal }: RetryOptions): AsyncIterable<ProtocolEvent>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/protocols/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/protocols/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AA2CD;;;;;;;;;;;;GAYG;AACH,wBAAuB,oBAAoB,CACzC,UAAU,EAAE,MAAM,aAAa,CAAC,aAAa,CAAC,EAC9C,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,GACvC,aAAa,CAAC,aAAa,CAAC,CAoC9B"}

package/dist/protocols/retry.js

@@ -0,0 +1,96 @@
+/**
+ * Bounded transport-fault retry, ahead of the first event.
+ *
+ * Lives in its own module rather than inline in client.ts so it is
+ * unit-testable with an injected clock, and so it survives a future
+ * migration that deletes the pi-ai backend entirely: this file imports
+ * nothing pi-ai-shaped, only the wire-protocol vocabulary in ./types.ts.
+ *
+ * Spec: docs/superpowers/specs/2026-08-31-nax-ai-protocol-architecture-design.md §10.1.
+ * nax-ai retries transport faults only, and only before the first event of an
+ * attempt is emitted. Rate limits and overload capacity are consumer policy
+ * (concurrency, cost budget, failover) and must never be retried internally.
+ * 4xx and auth failures are terminal — retrying cannot help either.
+ */
+/** 250ms then 500ms. No jitter: §10.1 hands concurrency policy to the
+ * consumer, so de-synchronising a herd is their call, not ours — and a fixed
+ * schedule keeps tests deterministic. */
+const INITIAL_BACKOFF_MS = 250;
+function backoffMs(retryIndex) {
+    return INITIAL_BACKOFF_MS * 2 ** retryIndex;
+}
+function isRetryableErrorEvent(event) {
+    // 503/529 classify as "overloaded", not "transport" (see errors.ts and
+    // its test) — deliberately excluded here, along with rate-limit, auth and
+    // bad-request. Only a fault with no policy content is ours to retry.
+    return event.type === "error" && event.error.kind === "transport";
+}
+function abortError(signal) {
+    return signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+/** A sleep that resolves early, and rejects, when `signal` fires — so a
+ * pending backoff cannot outlive the caller's own cancellation and go on to
+ * start a request nobody wants. */
+function abortableSleep(ms, sleep, signal) {
+    if (signal === undefined)
+        return sleep(ms);
+    if (signal.aborted)
+        return Promise.reject(abortError(signal));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError(signal));
+        signal.addEventListener("abort", onAbort, { once: true });
+        sleep(ms).then(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, reject);
+    });
+}
+/**
+ * Wraps a protocol stream factory with bounded transport-fault retry.
+ *
+ * `makeStream` is called once per attempt so each retry is a fresh request.
+ * The moment any event is yielded — including "usage" — everything from then
+ * on passes straight through with no further retry for this call. "usage"
+ * counts deliberately: pi-client.ts yields a usage event before an error
+ * event when a failed request still consumed tokens ("A failed request that
+ * consumed tokens still bills for them"). If usage did not gate the retry, a
+ * retry would emit a second usage event, and collectStream's "last usage
+ * wins" rule would silently discard the failed attempt's billed tokens. So
+ * retry only ever covers attempts that produced literally nothing.
+ */
+export async function* retryTransportFaults(makeStream, { retries, sleep, signal }) {
+    let retryIndex = 0;
+    for (;;) {
+        let emitted = false;
+        let fault;
+        try {
+            for await (const event of makeStream()) {
+                if (!emitted && isRetryableErrorEvent(event)) {
+                    fault = event;
+                    break;
+                }
+                emitted = true;
+                yield event;
+            }
+        }
+        catch (cause) {
+            // A throw is retryable whenever it precedes any emitted event and
+            // attempts remain — unlike an error event, a throw carries no `kind`
+            // to gate on, so any pre-first-event throw is presumed transport-shaped.
+            if (emitted || retryIndex >= retries)
+                throw cause;
+            await abortableSleep(backoffMs(retryIndex), sleep, signal);
+            retryIndex += 1;
+            continue;
+        }
+        if (fault === undefined)
+            return; // this attempt completed cleanly
+        if (retryIndex >= retries) {
+            yield fault;
+            return;
+        }
+        await abortableSleep(backoffMs(retryIndex), sleep, signal);
+        retryIndex += 1;
+    }
+}
+//# sourceMappingURL=retry.js.map

package/dist/protocols/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/protocols/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAYH;;yCAEyC;AACzC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAE/B,SAAS,SAAS,CAAC,UAAkB;IACnC,OAAO,kBAAkB,GAAG,CAAC,IAAI,UAAU,CAAC;AAC9C,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAoB;IACjD,uEAAuE;IACvE,0EAA0E;IAC1E,qEAAqE;IACrE,OAAO,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC;AACpE,CAAC;AAED,SAAS,UAAU,CAAC,MAAmB;IACrC,OAAO,MAAM,CAAC,MAAM,IAAI,IAAI,YAAY,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AACpE,CAAC;AAED;;mCAEmC;AACnC,SAAS,cAAc,CACrB,EAAU,EACV,KAAoC,EACpC,MAA+B;IAE/B,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC,EAAE,CAAC,CAAC;IAC3C,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;IAE9D,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QACjD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1D,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAClB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7C,OAAO,EAAE,CAAC;QACZ,CAAC,EAAE,MAAM,CAAC,CAAC;IACb,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,oBAAoB,CACzC,UAA8C,EAC9C,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAgB;IAExC,IAAI,UAAU,GAAG,CAAC,CAAC;IAEnB,SAAS,CAAC;QACR,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,KAAgC,CAAC;QAErC,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,UAAU,EAAE,EAAE,CAAC;gBACvC,IAAI,CAAC,OAAO,IAAI,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC7C,KAAK,GAAG,KAAK,CAAC;oBACd,MAAM;gBACR,CAAC;gBACD,OAAO,GAAG,IAAI,CAAC;gBACf,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,kEAAkE;YAClE,qEAAqE;YACrE,yEAAyE;YACzE,IAAI,OAAO,IAAI,UAAU,IAAI,OAAO;gBAAE,MAAM,KAAK,CAAC;YAClD,MAAM,cAAc,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;YAC3D,UAAU,IAAI,CAAC,CAAC;YAChB,SAAS;QACX,CAAC;QAED,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,CAAC,iCAAiC;QAElE,IAAI,UAAU,IAAI,OAAO,EAAE,CAAC;YAC1B,MAAM,KAAK,CAAC;YACZ,OAAO;QACT,CAAC;QAED,MAAM,cAAc,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAC3D,UAAU,IAAI,CAAC,CAAC;IAClB,CAAC;AACH,CAAC"}

package/dist/protocols/thinking.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Clamping a requested thinking level onto what a model actually supports.
+ *
+ * Clamping rather than throwing is deliberate: models expose different
+ * granularities, and a profile that says "high" should not fail outright
+ * because one model only offers off/low/medium. The caller's intent — think
+ * harder than default — is still expressible.
+ */
+import { type ThinkingLevel } from "./types.ts";
+export declare function clampThinkingLevel(requested: ThinkingLevel, supported: readonly ThinkingLevel[]): ThinkingLevel;
+//# sourceMappingURL=thinking.d.ts.map

package/dist/protocols/thinking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.d.ts","sourceRoot":"","sources":["../../src/protocols/thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAIjE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,aAAa,EAAE,GAAG,aAAa,CAyB/G"}

package/dist/protocols/thinking.js

@@ -0,0 +1,35 @@
+/**
+ * Clamping a requested thinking level onto what a model actually supports.
+ *
+ * Clamping rather than throwing is deliberate: models expose different
+ * granularities, and a profile that says "high" should not fail outright
+ * because one model only offers off/low/medium. The caller's intent — think
+ * harder than default — is still expressible.
+ */
+import { THINKING_LEVELS } from "./types.js";
+const rank = (level) => THINKING_LEVELS.indexOf(level);
+export function clampThinkingLevel(requested, supported) {
+    if (supported.length === 0)
+        return "off";
+    if (supported.includes(requested))
+        return requested;
+    // Sorted ascending so that "first seen wins on a tie" means "lower level
+    // wins" — callers are not required to pass an ordered list.
+    const ordered = [...supported].sort((a, b) => rank(a) - rank(b));
+    const target = rank(requested);
+    // Safe: `ordered` is non-empty, guarded above. noUncheckedIndexedAccess
+    // still widens the type, hence the assertion.
+    let best = ordered[0];
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const level of ordered) {
+        const distance = Math.abs(rank(level) - target);
+        // Strict `<` keeps the first-seen (lower) candidate on a tie: spending
+        // fewer thinking tokens than asked is the safer surprise.
+        if (distance < bestDistance) {
+            best = level;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=thinking.js.map

package/dist/protocols/thinking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.js","sourceRoot":"","sources":["../../src/protocols/thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAsB,MAAM,YAAY,CAAC;AAEjE,MAAM,IAAI,GAAG,CAAC,KAAoB,EAAU,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAE9E,MAAM,UAAU,kBAAkB,CAAC,SAAwB,EAAE,SAAmC;IAC9F,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACzC,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IAEpD,yEAAyE;IACzE,4DAA4D;IAC5D,MAAM,OAAO,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAE/B,wEAAwE;IACxE,8CAA8C;IAC9C,IAAI,IAAI,GAAG,OAAO,CAAC,CAAC,CAAkB,CAAC;IACvC,IAAI,YAAY,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAE5C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC;QAChD,uEAAuE;QACvE,0DAA0D;QAC1D,IAAI,QAAQ,GAAG,YAAY,EAAE,CAAC;YAC5B,IAAI,GAAG,KAAK,CAAC;YACb,YAAY,GAAG,QAAQ,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/protocols/tool-args.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Streamed tool-call argument accumulation.
+ *
+ * A pure helper rather than a method on a backend: every protocol receives
+ * arguments as JSON fragments and must accumulate before parsing, so a
+ * hand-written backend needs this same logic and should not re-derive it.
+ */
+interface PendingToolArgs {
+    readonly name: string;
+    readonly raw: string;
+}
+export interface ToolArgAccumulator {
+    /** Appends a fragment and returns everything accumulated for `id` so far. */
+    append(id: string, name: string, fragment: string): string;
+    /** Removes and returns the accumulation, or undefined if `id` is unknown. */
+    take(id: string): PendingToolArgs | undefined;
+}
+export declare function createToolArgAccumulator(): ToolArgAccumulator;
+/**
+ * Parses an accumulated argument string.
+ *
+ * An empty accumulation means the provider sent a tool call with no arguments,
+ * which is an empty object rather than an error.
+ */
+export declare function parseToolArgs(raw: string): unknown;
+export {};
+//# sourceMappingURL=tool-args.d.ts.map

package/dist/protocols/tool-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-args.d.ts","sourceRoot":"","sources":["../../src/protocols/tool-args.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,UAAU,eAAe;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3D,6EAA6E;IAC7E,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;CAC/C;AAED,wBAAgB,wBAAwB,IAAI,kBAAkB,CAsB7D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAElD"}

package/dist/protocols/tool-args.js

@@ -0,0 +1,38 @@
+/**
+ * Streamed tool-call argument accumulation.
+ *
+ * A pure helper rather than a method on a backend: every protocol receives
+ * arguments as JSON fragments and must accumulate before parsing, so a
+ * hand-written backend needs this same logic and should not re-derive it.
+ */
+export function createToolArgAccumulator() {
+    const pending = new Map();
+    return {
+        append(id, name, fragment) {
+            const current = pending.get(id);
+            // The name arrives with the first fragment and is authoritative; later
+            // fragments may not carry it.
+            const next = {
+                name: current?.name ?? name,
+                raw: (current?.raw ?? "") + fragment,
+            };
+            pending.set(id, next);
+            return next.raw;
+        },
+        take(id) {
+            const current = pending.get(id);
+            pending.delete(id);
+            return current;
+        },
+    };
+}
+/**
+ * Parses an accumulated argument string.
+ *
+ * An empty accumulation means the provider sent a tool call with no arguments,
+ * which is an empty object rather than an error.
+ */
+export function parseToolArgs(raw) {
+    return raw === "" ? {} : JSON.parse(raw);
+}
+//# sourceMappingURL=tool-args.js.map

package/dist/protocols/tool-args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-args.js","sourceRoot":"","sources":["../../src/protocols/tool-args.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAcH,MAAM,UAAU,wBAAwB;IACtC,MAAM,OAAO,GAAG,IAAI,GAAG,EAA2B,CAAC;IAEnD,OAAO;QACL,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ;YACvB,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAChC,uEAAuE;YACvE,8BAA8B;YAC9B,MAAM,IAAI,GAAoB;gBAC5B,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,IAAI;gBAC3B,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,EAAE,CAAC,GAAG,QAAQ;aACrC,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YACtB,OAAO,IAAI,CAAC,GAAG,CAAC;QAClB,CAAC;QAED,IAAI,CAAC,EAAE;YACL,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAChC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACnB,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,OAAO,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC3C,CAAC"}

package/dist/protocols/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Wire-protocol vocabulary.
+ *
+ * Every concept here appears in more than one provider's wire format, or is a
+ * deliberate normalisation. No field is named after one provider's API: the
+ * point of this file is that a backend for any provider can be written against
+ * it without the interface having already picked a side.
+ */
+import type { StopReason, TokenUsage } from "../types.ts";
+/** JSON Schema draft 2020-12 object. Structural — nax-ai does not validate it. */
+export type JsonSchema = Readonly<Record<string, unknown>>;
+/**
+ * Ascending order is load-bearing: clamping an unsupported level picks the
+ * nearest supported one by index, so reordering this array changes behaviour.
+ */
+export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+export declare const CACHE_RETENTIONS: readonly ["none", "short", "long"];
+export type CacheRetention = (typeof CACHE_RETENTIONS)[number];
+export declare const PROTOCOL_EVENT_TYPES: readonly ["text-delta", "thinking-delta", "thinking", "tool-call-partial", "tool-call", "usage", "error", "done"];
+export type ProtocolEventType = (typeof PROTOCOL_EVENT_TYPES)[number];
+export declare const PROTOCOL_ERROR_KINDS: readonly ["rate-limit", "auth", "overloaded", "bad-request", "transport", "unknown"];
+export type ProtocolErrorKind = (typeof PROTOCOL_ERROR_KINDS)[number];
+export interface ProtocolError {
+    readonly kind: ProtocolErrorKind;
+    readonly message: string;
+    readonly status?: number;
+    /** Seconds, when the provider signals one. The consumer owns the retry loop. */
+    readonly retryAfter?: number;
+    readonly cause?: unknown;
+}
+export interface ToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonSchema;
+}
+export interface ToolCall {
+    readonly id: string;
+    readonly name: string;
+    /** Parsed. A protocol accumulates streamed JSON fragments and parses before emitting. */
+    readonly input: unknown;
+}
+/**
+ * A complete extended-thinking block, durable enough to replay on the next
+ * turn. Anthropic requires the exact thinking block (text plus signature) that
+ * preceded a tool call to be sent back verbatim on the following request, or
+ * the call cannot be verified server-side.
+ */
+export interface ThinkingBlock {
+    readonly text: string;
+    /**
+     * Opaque, like `StoredCredential`'s `key` (see src/types.ts): some
+     * providers put a cryptographic signature here, a redacted block puts its
+     * entire encrypted payload here instead. Never inspect, compare or log it.
+     * Absent means the provider did not send one — never synthesise "" for
+     * that, since an empty string is itself a value a provider could send.
+     */
+    readonly signature?: string;
+    readonly redacted?: boolean;
+}
+export type ConversationMessage = {
+    readonly role: "user";
+    readonly content: string;
+} | {
+    readonly role: "assistant";
+    readonly content: string;
+    readonly toolCalls?: readonly ToolCall[];
+    readonly thinking?: readonly ThinkingBlock[];
+} | {
+    readonly role: "tool-result";
+    readonly toolCallId: string;
+    readonly content: string;
+    readonly isError?: boolean;
+};
+export interface ProtocolRequest {
+    readonly model: string;
+    /**
+     * The model's owning provider, supplied by the client so a protocol can
+     * scope model resolution when ids are ambiguous across providers.
+     */
+    readonly provider?: string;
+    /**
+     * Kept out of `messages` deliberately: Anthropic takes a top-level `system`
+     * parameter while OpenAI takes a system message in the array. Each backend
+     * places it correctly, so callers never encode a provider's shape.
+     */
+    readonly system?: string;
+    readonly messages: readonly ConversationMessage[];
+    readonly tools?: readonly ToolDefinition[];
+    readonly toolChoice?: "auto" | "none";
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly thinking?: ThinkingLevel;
+    readonly cacheRetention?: CacheRetention;
+    readonly signal?: AbortSignal;
+}
+export type ProtocolEvent = {
+    readonly type: "text-delta";
+    readonly text: string;
+} | {
+    readonly type: "thinking-delta";
+    readonly text: string;
+}
+/**
+ * Mirrors the "tool-call-partial" -> "tool-call" pair: "thinking-delta"
+ * stays display-only progress, this is the durable complete block a
+ * consumer can carry into the next request's `ConversationMessage`.
+ */
+ | {
+    readonly type: "thinking";
+    readonly block: ThinkingBlock;
+} | {
+    readonly type: "tool-call-partial";
+    readonly id: string;
+    readonly name: string;
+    /** Raw accumulated JSON fragment — for progress display only. */
+    readonly rawInput: string;
+} | {
+    readonly type: "tool-call";
+    readonly call: ToolCall;
+} | {
+    readonly type: "usage";
+    readonly usage: TokenUsage;
+} | {
+    readonly type: "error";
+    readonly error: ProtocolError;
+} | {
+    readonly type: "done";
+    readonly stopReason: StopReason;
+};
+/**
+ * A wire protocol.
+ *
+ * `complete` is deliberately absent. It is derived once, at the client layer,
+ * by collecting a stream — so a backend has no way to implement it as a second
+ * request path that drifts from this one.
+ */
+export interface Protocol {
+    readonly name: string;
+    stream(req: ProtocolRequest): AsyncIterable<ProtocolEvent>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/protocols/types.d.ts.map

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

package/dist/protocols/types.js

@@ -0,0 +1,33 @@
+/**
+ * Wire-protocol vocabulary.
+ *
+ * Every concept here appears in more than one provider's wire format, or is a
+ * deliberate normalisation. No field is named after one provider's API: the
+ * point of this file is that a backend for any provider can be written against
+ * it without the interface having already picked a side.
+ */
+/**
+ * Ascending order is load-bearing: clamping an unsupported level picks the
+ * nearest supported one by index, so reordering this array changes behaviour.
+ */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export const CACHE_RETENTIONS = ["none", "short", "long"];
+export const PROTOCOL_EVENT_TYPES = [
+    "text-delta",
+    "thinking-delta",
+    "thinking",
+    "tool-call-partial",
+    "tool-call",
+    "usage",
+    "error",
+    "done",
+];
+export const PROTOCOL_ERROR_KINDS = [
+    "rate-limit",
+    "auth",
+    "overloaded",
+    "bad-request",
+    "transport",
+    "unknown",
+];
+//# sourceMappingURL=types.js.map

package/dist/protocols/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/protocols/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAU,CAAC;AAGpG,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAU,CAAC;AAGnE,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,YAAY;IACZ,gBAAgB;IAChB,UAAU;IACV,mBAAmB;IACnB,WAAW;IACX,OAAO;IACP,OAAO;IACP,MAAM;CACE,CAAC;AAGX,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,YAAY;IACZ,MAAM;IACN,YAAY;IACZ,aAAa;IACb,WAAW;IACX,SAAS;CACD,CAAC"}

package/dist/providers/catalog.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Normalises a raw provider catalog into nax-ai types.
+ *
+ * STAYS pi-ai-BACKED. Hand-rolling the model catalog is explicitly out of
+ * scope: its pricing and model data are maintained upstream, and taking that
+ * maintenance back is the burden the dependency was chosen to avoid. Unlike
+ * `protocols/`, this layer is not a migration surface.
+ *
+ * This is also where the OAuth allowlist meets a real code path: a provider
+ * declaring a prohibited flow fails to resolve here.
+ */
+import type { ThinkingLevel } from "../protocols/types.ts";
+import type { Pricing, ProviderAuth, ProviderOverride, ResolvedModel, ResolvedProvider } from "./types.ts";
+export interface RawModel {
+    readonly id: string;
+    /** Falls back to the provider's `defaultProtocol` when absent. */
+    readonly protocol?: string;
+    readonly pricing: Pricing;
+    readonly contextWindow: number;
+    readonly supportsTools: boolean;
+    readonly thinkingLevels: readonly ThinkingLevel[];
+}
+export interface RawProvider {
+    readonly id: string;
+    readonly baseUrl: string;
+    readonly auth: ProviderAuth;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly defaultProtocol: string;
+    readonly models: readonly RawModel[];
+}
+export interface Catalog {
+    provider(id: string): ResolvedProvider | undefined;
+    model(provider: string, model: string): ResolvedModel | undefined;
+    listModels(provider?: string): readonly ResolvedModel[];
+}
+export declare function normaliseCatalog(raw: readonly RawProvider[], overrides?: readonly ProviderOverride[]): Catalog;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/providers/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/providers/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE3G,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;CACnD;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACnD,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;IAClE,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,aAAa,EAAE,CAAC;CACzD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,WAAW,EAAE,EAAE,SAAS,GAAE,SAAS,gBAAgB,EAAO,GAAG,OAAO,CAgElH"}