@lloyal-labs/sdk 1.0.0

package/README.md

@@ -0,0 +1,162 @@
+# @lloyal-labs/sdk
+
+Backend-agnostic TypeScript SDK for the lloyal inference platform.
+
+Composable inference primitives for forkable decode state, shared-prefix KV branching, and continuous tree batching. Branches share a KV prefix while keeping independent machinery — sampler chain, grammar, logits snapshot, perplexity tracker — for controlled divergence at decode time. `BranchStore` packs tokens from N branches (each at a different position, different seq_id, each needing independent logits captured) into a single `llama_batch` and dispatches once.
+
+```bash
+npm i @lloyal-labs/sdk
+```
+
+The SDK exports the `SessionContext` contract and the primitives that operate on it. Backend bindings ([lloyal.node](https://github.com/lloyal-ai/lloyal.node), [nitro-llama](https://github.com/lloyal-ai/nitro-llama)) provide `createContext()` — the SDK takes it from there.
+
+## The Branch API
+
+```typescript
+import { createContext } from '@lloyal-labs/lloyal.node';
+import { Branch, BranchStore } from '@lloyal-labs/sdk';
+
+const ctx = await createContext({ modelPath: './model.gguf', nSeqMax: 6 });
+const store = new BranchStore(ctx);
+
+// Shared prompt: "Explain quantum entanglement"
+const prompt = await ctx.tokenize('Explain quantum entanglement');
+
+const root = Branch.create(ctx, 0, { temperature: 0.8 });
+await root.prefill(prompt);
+
+// Fork 4 branches — each gets a different reasoning prefix
+const analogy  = await root.fork();
+const formal   = await root.fork();
+const socratic = await root.fork();
+const visual   = await root.fork();
+
+// Scatter-prefill: inject divergent prefixes in one batched dispatch
+// 4 branches × variable lengths → auto bin-packed into minimal GPU calls
+await store.prefill([
+  [analogy,  await ctx.tokenize('Think of it like two coins...')],    // 12 tokens
+  [formal,   await ctx.tokenize('In quantum mechanics, the...')],     // 8 tokens
+  [socratic, await ctx.tokenize('What happens when you measure...')], // 10 tokens
+  [visual,   await ctx.tokenize('Imagine two particles...')],         // 7 tokens
+]);
+
+// Generate — all 4 in lockstep, 1 GPU call per step
+const branches = [analogy, formal, socratic, visual];
+for (;;) {
+  const live = branches.filter(b => !b.disposed);
+  if (!live.length) break;
+
+  const entries: [Branch, number][] = [];
+  for (const b of live) {
+    const { token, text, isStop } = b.produceSync();
+    if (isStop) { b.pruneSync(); continue; }
+    entries.push([b, token]);
+  }
+  if (!entries.length) break;
+  await store.commit(entries);
+}
+
+// Winner takes all — one seq_keep pass, losers vaporized
+const winner = branches
+  .filter(b => !b.disposed)
+  .reduce((a, b) => (a.perplexity < b.perplexity ? a : b));
+await store.retainOnly(winner);
+```
+
+Or for single-branch generation, Branch is an async iterable — generate until EOG:
+
+```typescript
+for await (const { token, text } of branch) {
+  process.stdout.write(text);
+}
+```
+
+## Continuous Tree Batching
+
+Tree search with N branches means N calls to `llama_decode()` — each paying GPU dispatch overhead, memory barriers, and PCIe round-trips. `BranchStore` eliminates this: tokens from N branches are packed into a single `llama_batch` and dispatched once. N branches, 1 GPU call.
+
+Two packing strategies for different access patterns:
+
+```typescript
+// commit: 1 token per branch — one GPU dispatch for N branches
+await store.commit([[branch1, tok1], [branch2, tok2], [branch3, tok3]]);
+
+// prefill: variable tokens per branch — asymmetric injection
+await store.prefill([
+  [branchA, systemTokens],  // 200 tokens
+  [branchB, queryTokens],   //  12 tokens
+  [branchC, docTokens],     // 800 tokens
+]);
+// Greedy bin-packed into ceil(total / nBatch) dispatches
+```
+
+## Topology
+
+Parent/child edges are always-on. Simple chat to best-of-N to deep search is one continuum.
+
+```typescript
+branch.parent;       // handle or null if root
+branch.children;     // child handles
+branch.isLeaf;       // no children?
+```
+
+| Method | Behavior |
+|--------|----------|
+| `pruneSync()` | Throws if children exist |
+| `pruneSubtreeSync()` | Iterative post-order traversal |
+
+## Per-Token Metrics
+
+Every branch exposes runtime-accessible information-theoretic measures on every step:
+
+```typescript
+branch.modelEntropy();        // Shannon entropy of full vocab distribution (bits)
+branch.modelSurprisal(token); // -log2(p) for a specific token
+branch.perplexity;            // model-level PPL (exp of mean NLL from raw logits)
+branch.samplingPerplexity;    // sampling-level PPL (from filtered distribution)
+```
+
+## Session
+
+`Session` manages the conversation trunk — the single promoted branch that accumulates verified context across queries.
+
+```typescript
+const session = new Session({ ctx, store });
+
+// Prefill a user turn into the trunk
+await session.prefillUser('What is quantum entanglement?');
+
+// After generation + verification, promote a branch to become the new trunk
+await session.promote(verifiedBranch);
+
+// Next query starts from the promoted trunk's KV state
+session.trunk;  // the live branch
+```
+
+## Rerank
+
+Backend-agnostic reranker. The caller provides a `SessionContext` — how it was created (local, remote, quantized) is not the SDK's concern.
+
+```typescript
+import { Rerank } from '@lloyal-labs/sdk';
+
+const reranker = await Rerank.create(ctx, { nSeqMax: 8 });
+const scores = await reranker.rank(query, documents);
+```
+
+## Exports
+
+```typescript
+// Classes
+export { Branch, BranchStore, Session, Rerank };
+
+// Delta builders (for tool result injection)
+export { buildUserDelta, buildToolResultDelta };
+
+// Types
+export type { SessionContext, SamplingParams, Produced, ContextOptions, ... };
+```
+
+## License
+
+Apache-2.0

package/dist/Branch.d.ts

@@ -0,0 +1,463 @@
+import type { SessionContext, SamplingParams, Produced, GrammarTrigger } from './types';
+/**
+ * Forkable inference handle for covalent generation
+ *
+ * A Branch owns everything needed for independent generation: a KV cache
+ * sequence, sampler chain, logits snapshot, and perplexity tracker.
+ *
+ * Forking is cheap — the KV prefix is shared in memory (metadata-only operation under unified KV —
+ * no KV tensor buffers are copied), so sibling branches read from the same physical KV entries.
+ * Only tokens decoded after the fork point are exclusive to each branch.
+ *
+ * Branches form trees, not just flat lists. Fork from root for best-of-N,
+ * fork from children for tree search/beam search, fork from a draft for speculative
+ * decoding.
+ *
+ * The produce/commit protocol separates sampling from state advancement:
+ * produce() samples without writing to KV, letting you inspect the result
+ * before deciding to commit().
+ *
+ * @example Best-of-N with perplexity selection
+ * ```typescript
+ * const root = Branch.create(ctx, tokens.length, { temperature: 0.8 });
+ * await root.prefill(tokens);
+ *
+ * const results = [];
+ * for (let i = 0; i < 5; i++) {
+ *   const branch = await root.fork();
+ *   branch.reseedSampler(1000 + i);
+ *   const tokens = [];
+ *   for await (const { token } of branch) tokens.push(token);
+ *   results.push({ branch, tokens, ppl: branch.perplexity });
+ * }
+ *
+ * const best = results.reduce((a, b) => a.ppl < b.ppl ? a : b);
+ * for (const r of results) { if (r !== best) await r.branch.prune(); }
+ * ```
+ *
+ * @category Branching
+ */
+export declare class Branch {
+    private _ctx;
+    private _handle;
+    private _disposed;
+    constructor(ctx: SessionContext, handle: number);
+    /**
+     * Create a root branch at the given position
+     *
+     * The branch takes ownership of the sequence and creates its own sampler
+     * chain from the provided params. Call prefill() to decode prompt tokens
+     * and capture the logit distribution before forking.
+     *
+     * @param ctx - SessionContext to create branch on
+     * @param position - Starting position (typically prompt token count)
+     * @param params - Sampling parameters (temperature, topP, etc.)
+     * @param nBatch - Per-branch batch size override (defaults to context nBatch).
+     *   Controls chunk size for prefill(). Has no effect on
+     *   single-token commit() which uses a zero-allocation fast path.
+     * @param grammar - GBNF grammar string for constrained generation.
+     *   When provided, sample() returns only grammar-valid tokens. The grammar state
+     *   is cloned on fork(), so sibling branches can diverge independently.
+     * @returns New Branch instance
+     */
+    static create(ctx: SessionContext, position: number, params?: SamplingParams, nBatch?: number, grammar?: string): Branch;
+    /**
+     * Fork this branch to a new sequence (async)
+     *
+     * Async contract: local branches resolve immediately; cloud branches
+     * may perform an HTTP round-trip. Use {@link forkSync} when you know
+     * the branch is local and want zero-overhead forking.
+     *
+     * @returns New forked Branch
+     */
+    fork(): Promise<Branch>;
+    /**
+     * Fork this branch to a new sequence (sync)
+     *
+     * The child shares the parent's KV prefix in memory (metadata-only under unified KV, no KV buffer copy).
+     * Logits, sampler state, and perplexity tracker are cloned so the child
+     * can diverge independently. Fork from any branch — root or intermediate —
+     * to build arbitrarily deep trees.
+     *
+     * Call reseedSampler() on each child for stochastic diversity.
+     *
+     * @returns New forked Branch
+     */
+    forkSync(): Branch;
+    /**
+     * Get a copy of this branch's captured logits snapshot.
+     *
+     * Returns n_vocab floats — the raw logit distribution from the last
+     * prefill() or commit() call.
+     *
+     * Returns an independent copy of the branch's internal snapshot.
+     * The returned Float32Array is safe to hold across async boundaries
+     * and is not affected by subsequent decode operations.
+     *
+     * @returns Independent copy of the logits snapshot (n_vocab elements)
+     * @throws If no logits have been captured yet
+     */
+    getLogits(): Float32Array;
+    /**
+     * Bulk-decode tokens into the branch's KV cache and capture logits.
+     *
+     * `tokens.length` is the total count to process; the branch's `nBatch`
+     * (set at `Branch.create`) controls how many are sent per `llama_decode`
+     * call. E.g. 500 tokens with `nBatch=64` → 8 calls (7×64 + 1×52).
+     *
+     * Advances `position` by `tokens.length`. Stores final logits into the
+     * branch's internal snapshot — the next `produce()`/`sample()` reads
+     * from it.
+     *
+     * Does NOT accept tokens into the repeat-penalty window — for external
+     * tokens (user input between turns), not model-generated tokens.
+     * For model output, use `commit()` which does accept + decode.
+     *
+     * The primary way to feed tokens into a branch's KV cache.
+     *
+     * @param tokens - Token IDs to decode
+     */
+    prefill(tokens: number[]): Promise<void>;
+    /**
+     * Sample next token from branch's logits snapshot
+     *
+     * Applies the branch's full sampler chain (top-k, top-p, temperature,
+     * repeat/presence penalties) to the captured logits.
+     *
+     * @returns Sampled token ID
+     */
+    sample(): number;
+    /**
+     * Record token in the sampler's repeat/presence penalty window
+     *
+     * @param token - Token to accept
+     */
+    accept(token: number): void;
+    /**
+     * Discard this branch (async)
+     *
+     * Async contract: local branches resolve immediately; cloud branches
+     * may perform an HTTP round-trip. Use {@link pruneSync} when you know
+     * the branch is local.
+     *
+     * RESTRICT mode: throws if children exist. Use {@link pruneSubtree} to
+     * cascade-delete an entire subtree.
+     */
+    prune(): Promise<void>;
+    /**
+     * Discard this branch — remove its divergent KV entries and free the handle (sync)
+     *
+     * Only removes KV entries divergent from the shared prefix; sibling branches
+     * are unaffected. The disposed flag is set synchronously — any call to
+     * produce(), commit(), etc. after prune() will throw immediately.
+     *
+     * RESTRICT mode: throws if children exist. Use {@link pruneSubtreeSync} to
+     * cascade-delete an entire subtree.
+     */
+    pruneSync(): void;
+    /**
+     * Discard this branch and all its descendants (async)
+     *
+     * Async contract: local branches resolve immediately; cloud branches
+     * may perform an HTTP round-trip. Use {@link pruneSubtreeSync} when you know
+     * the branch is local.
+     */
+    pruneSubtree(): Promise<void>;
+    /**
+     * Discard this branch and all its descendants — CASCADE delete (sync)
+     *
+     * Iterative post-order traversal: prunes children first, then this branch.
+     * Use when tearing down an entire subtree (e.g. abandoned search path).
+     * Sets disposed synchronously.
+     */
+    pruneSubtreeSync(): void;
+    /**
+     * Reseed the sampler's PRNG for diversity after fork()
+     *
+     * CRITICAL for parallel generation: Without reseeding, all forked branches
+     * produce identical outputs because they share the same PRNG state.
+     *
+     * Only affects stochastic samplers (temperature > 0). Greedy samplers are unchanged.
+     *
+     * @param seed - New seed for the PRNG
+     */
+    reseedSampler(seed: number): void;
+    /**
+     * Apply dynamic logit adjustments for this branch only
+     *
+     * Unlike `logit_bias` in sampling params (which is cloned on fork), steer biases
+     * are NOT inherited by child branches. Each branch manages its own steer state
+     * independently. This makes steer ideal for path-dependent constraints.
+     *
+     * **Use cases:**
+     * - **tsampler**: Block tokens that would create repeated N-grams based on
+     *   this branch's specific generation history
+     * - **Diverse beam search**: Penalize tokens already chosen by sibling beams
+     *   to encourage output diversity across the beam
+     * - **Dynamic constraints**: Apply token restrictions that change per-step
+     *
+     * **Sampling order:** Grammar → Logit Bias → Steer → Sampler Chain
+     *
+     * @param biases - Array of token adjustments. Use `-Infinity` to completely
+     *   block a token, positive values to boost probability, negative to reduce.
+     *
+     * @example Block tokens for N-gram deduplication (tsampler pattern)
+     * ```ts
+     * // Compute which tokens would create repeated 4-grams
+     * const blocked = computeNgramBlocks(generatedTokens, n=4);
+     *
+     * // Block those tokens for this sample only
+     * branch.steer(blocked.map(t => ({ token: t, bias: -Infinity })));
+     *
+     * const { token } = await branch.produce();  // Blocked tokens won't be sampled
+     * await branch.commit(token);
+     *
+     * // Clear for next iteration (recompute based on new history)
+     * branch.clearSteer();
+     * ```
+     *
+     * @example Diverse beam search
+     * ```ts
+     * // Each beam penalizes tokens chosen by siblings this step
+     * for (const beam of beams) {
+     *   // Collect tokens chosen by other beams
+     *   const siblingTokens = beams
+     *     .filter(b => b !== beam && b.lastToken !== undefined)
+     *     .map(b => b.lastToken);
+     *
+     *   // Penalize sibling choices to encourage diversity
+     *   beam.branch.steer(siblingTokens.map(t => ({ token: t, bias: -2.0 })));
+     *
+     *   const { token } = await beam.branch.produce();
+     *   await beam.branch.commit(token);
+     *   beam.lastToken = token;
+     *   beam.branch.clearSteer();
+     * }
+     * ```
+     *
+     * @example Boost specific tokens
+     * ```ts
+     * // Boost "yes" and "no" tokens for a yes/no question
+     * branch.steer([
+     *   { token: yesTokenId, bias: 5.0 },
+     *   { token: noTokenId, bias: 5.0 }
+     * ]);
+     * ```
+     */
+    steer(biases: Array<{
+        token: number;
+        bias: number;
+    }>): void;
+    /**
+     * Clear all steer biases from this branch
+     *
+     * Removes any dynamic logit adjustments set by `steer()`. Call this after
+     * each generation step if your steer constraints are computed per-step
+     * (e.g., N-gram blocking where the blocked set changes as text grows).
+     *
+     * @example Per-step steer pattern
+     * ```ts
+     * for (let i = 0; i < maxTokens; i++) {
+     *   // Compute constraints based on current state
+     *   const blocked = computeConstraints(generatedTokens);
+     *   branch.steer(blocked.map(t => ({ token: t, bias: -Infinity })));
+     *
+     *   const { token, isStop } = await branch.produce();
+     *   if (isStop) break;
+     *
+     *   await branch.commit(token);
+     *   branch.clearSteer();  // Reset for next iteration
+     *   generatedTokens.push(token);
+     * }
+     * ```
+     */
+    clearSteer(): void;
+    /**
+     * Replace the sampler chain with new parameters (memoized)
+     *
+     * If the new params match the current chain's params, this is a no-op.
+     * Otherwise the old chain is freed and a new one is created. Use for
+     * Entropy-Driven Temperature (EDT) and other adaptive sampling strategies
+     * that adjust parameters per-step.
+     *
+     * @param params - New sampling parameters
+     *
+     * @example Entropy-Driven Temperature
+     * ```typescript
+     * const entropy = branch.modelEntropy('nats');
+     * branch.setSamplerParams({ temperature: edtTemperature(entropy) });
+     * const { token } = await branch.produce();
+     * await branch.commit(token);
+     * ```
+     */
+    setSamplerParams(params: SamplingParams): void;
+    /**
+     * Replace or remove the grammar constraint
+     *
+     * Pass a GBNF grammar string to constrain generation. Pass empty string
+     * or undefined to remove the constraint. The grammar state is cloned on
+     * fork(), so sibling branches can diverge independently after hot-swap.
+     *
+     * @param grammarStr - GBNF grammar string, or empty/undefined to remove
+     *
+     * @example Hot-swap grammar mid-generation
+     * ```typescript
+     * // Start unconstrained, then switch to JSON after detecting tool call
+     * branch.setGrammar(jsonGrammar);
+     * const { token } = await branch.produce();
+     * ```
+     */
+    setGrammar(grammarStr?: string): void;
+    /**
+     * Set lazy grammar — unconstrained until trigger, then grammar-constrained
+     *
+     * Generation runs freely until a trigger pattern or token fires, at which
+     * point the grammar activates and constrains subsequent tokens. Used for
+     * tool-call generation: model writes freely until `<tool_call>`, then
+     * grammar forces valid XML structure.
+     *
+     * The grammar state is cloned on fork(), so sibling branches can diverge
+     * independently. Call again after a tool result prefill to reset.
+     *
+     * @param grammar - GBNF grammar string
+     * @param triggers - Trigger conditions from formatChat().grammarTriggers
+     */
+    setGrammarLazy(grammar: string, triggers: GrammarTrigger[]): void;
+    /**
+     * Sample next token without advancing state (async)
+     *
+     * Async contract: local branches resolve immediately; cloud branches
+     * may perform an HTTP round-trip. Use {@link produceSync} when you know
+     * the branch is local and want zero-overhead sampling.
+     */
+    produce(): Promise<Produced>;
+    /**
+     * Sample next token without advancing state (sync)
+     *
+     * Same as {@link produce} but synchronous. Use when you know the branch
+     * is local and want to avoid the microtick overhead of a promise.
+     */
+    produceSync(): Produced;
+    /**
+     * Accept and decode — update branch state, then write token to KV
+     *
+     * Accepts the token into the sampler penalty window (for correct PPL
+     * measurement), then decodes (writing to KV cache via AsyncWorker on
+     * the libuv thread pool) and captures the resulting logits for the next
+     * produce() call. Accept-first ordering with rollback: if decode throws,
+     * sampler/grammar/metrics are restored from clones.
+     *
+     * @param token Token to commit (from produce())
+     */
+    commit(token: number): Promise<void>;
+    /**
+     * Compute entropy of the branch's logits distribution
+     *
+     * Measures model uncertainty from the branch's captured logits snapshot:
+     * - Low entropy: Model is confident (peaked distribution)
+     * - High entropy: Model is uncertain (flat distribution)
+     *
+     * Operates directly on `state->logits_snapshot` — no JS round-trip.
+     *
+     * @param base - Logarithm base: "nats" (default) or "bits"
+     * @returns Entropy value in specified base
+     *
+     * COST: O(n_vocab) - must sum over all token probabilities
+     */
+    modelEntropy(base?: 'nats' | 'bits'): number;
+    /**
+     * Compute surprisal (negative log-likelihood) for a specific token
+     *
+     * Measures how "surprising" the model finds the given token from
+     * the branch's captured logits snapshot:
+     * - Low surprisal: Model expected this token (high probability)
+     * - High surprisal: Model didn't expect this token (low probability)
+     *
+     * Operates directly on `state->logits_snapshot` — no JS round-trip.
+     *
+     * @param token - Token ID to compute surprisal for
+     * @param base - Logarithm base: "nats" (default) or "bits"
+     * @returns Surprisal value in specified base
+     *
+     * COST: O(n_vocab) - softmax normalization required
+     */
+    modelSurprisal(token: number, base?: 'nats' | 'bits'): number;
+    /**
+     * Sampling-level perplexity (from filtered distribution)
+     *
+     * Returns perplexity from the distribution actually sampled from
+     * (after top-k/p/temp/penalties). Useful for policy priors and
+     * monitoring sampler chain impact.
+     *
+     * Compare with {@link perplexity} which is model-level (raw logits).
+     */
+    get samplingPerplexity(): number;
+    /**
+     * Set static logit biases on this branch
+     *
+     * Unlike {@link steer} (which is NOT inherited on fork), logit biases
+     * ARE cloned when forking. Use for persistent constraints that should
+     * propagate to child branches.
+     *
+     * Applied during sample() in order: Grammar -> Logit Bias -> Steer -> Sampler Chain
+     *
+     * @param biases - Array of token adjustments. Use `-Infinity` to block,
+     *   positive to boost, negative to reduce.
+     */
+    setLogitBias(biases: Array<{
+        token: number;
+        bias: number;
+    }>): void;
+    /**
+     * Clear all static logit biases from this branch
+     */
+    clearLogitBias(): void;
+    /** Branch's current position (number of tokens decoded) */
+    get position(): number;
+    /** Branch's perplexity (exp of mean surprisal) */
+    get perplexity(): number;
+    /** Internal handle (for debugging) */
+    get handle(): number;
+    /** Whether this branch has been disposed */
+    get disposed(): boolean;
+    /** Parent branch handle, or null if root */
+    get parent(): number | null;
+    /** Child branch handles */
+    get children(): number[];
+    /** True if this branch has no children */
+    get isLeaf(): boolean;
+    /** True if this branch holds a KV lease */
+    get isActive(): boolean;
+    /**
+     * Async iterator — generate tokens until EOG
+     *
+     * Commit-before-yield semantics: every yielded token is already written
+     * to KV and accepted into the sampler. Breaking out of the loop is clean —
+     * no orphaned uncommitted tokens, perplexity reflects all yielded tokens.
+     *
+     * For inspect-before-commit (speculative decoding, tree search), use
+     * the {@link produce}/{@link commit} protocol directly.
+     *
+     * @example Generate to completion
+     * ```typescript
+     * for await (const { token, text } of branch) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     *
+     * @example Generate with consumer-side bound
+     * ```typescript
+     * const tokens = [];
+     * for await (const { token } of branch) {
+     *   tokens.push(token);
+     *   if (tokens.length >= limit) break;
+     * }
+     * ```
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<{
+        token: number;
+        text: string;
+    }>;
+    private _ensureNotDisposed;
+}
+//# sourceMappingURL=Branch.d.ts.map

package/dist/Branch.d.ts.map

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