nebula-notebook 0.2.0 → 0.2.1

package/node_modules/nebula-autocomplete/dist/backends/codex.d.ts

@@ -0,0 +1,45 @@
+import type { CompletionBackend } from "../types.js";
+import { type Transport } from "../transport.js";
+export interface CodexBackendOptions {
+    /**
+     * Model. Default "gpt-5.6-luna" — the fast model available with
+     * ChatGPT-subscription auth (measured ~2× faster than the retired
+     * gpt-5.4-mini on warm autocomplete requests). The *-codex-mini
+     * variants are API-key-only.
+     */
+    model?: string;
+    /** Reasoning effort. Default "low" ("minimal" is rejected by codex's built-in tools). */
+    reasoningEffort?: string;
+    /**
+     * CODEX_HOME containing only auth.json. Strongly recommended: skips the
+     * global config's MCP servers/plugins/hooks (measured ~2s/request saved).
+     * Prepare with: mkdir -p <dir> && cp ~/.codex/auth.json <dir>/
+     */
+    codexHome?: string;
+    /** Per-request timeout. Default 60_000 ms. */
+    timeoutMs?: number;
+    /** Path to the codex binary. Default "codex". */
+    binary?: string;
+    /** Working directory. Default a temp dir. */
+    workspaceDir?: string;
+    /** Where codex runs: locally (default) or over ssh on the user's machine.
+     *  Over ssh, codexHome is ignored (the user's own ~/.codex/auth.json is used;
+     *  --ephemeral already keeps completions trace-free). */
+    transport?: Transport;
+}
+/**
+ * One-shot `codex exec --json` per completion (subscription auth). Codex has
+ * no incremental token stream in exec mode, so results arrive buffered.
+ */
+export declare class CodexBackend implements CompletionBackend {
+    readonly name = "codex";
+    private opts;
+    constructor(options?: CodexBackendOptions);
+    complete(prompt: string, { signal, onChunk }?: {
+        signal?: AbortSignal;
+        onChunk?: (t: string) => void;
+    }): Promise<string>;
+    dispose(): void;
+}
+/** Find the agent message in codex --json JSONL output (shape varies by version). */
+export declare function extractAgentMessage(jsonl: string): string;

package/node_modules/nebula-autocomplete/dist/backends/codex.js

@@ -0,0 +1,108 @@
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { planSpawn } from "../transport.js";
+/**
+ * One-shot `codex exec --json` per completion (subscription auth). Codex has
+ * no incremental token stream in exec mode, so results arrive buffered.
+ */
+export class CodexBackend {
+    name = "codex";
+    opts;
+    constructor(options = {}) {
+        this.opts = {
+            model: options.model ?? "gpt-5.6-luna",
+            reasoningEffort: options.reasoningEffort ?? "low",
+            codexHome: options.codexHome,
+            timeoutMs: options.timeoutMs ?? 60_000,
+            binary: options.binary ?? "codex",
+            workspaceDir: options.workspaceDir ?? join(tmpdir(), "nebula-autocomplete-ws"),
+            transport: options.transport ?? { kind: "local" },
+        };
+        if (this.opts.transport.kind === "local")
+            mkdirSync(this.opts.workspaceDir, { recursive: true });
+    }
+    complete(prompt, { signal, onChunk } = {}) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted)
+                return reject(signal.reason ?? new Error("aborted"));
+            const argv = [
+                "exec", "--json",
+                "--skip-git-repo-check",
+                "--sandbox", "read-only",
+                "--color", "never",
+                // Completions are throwaway: don't persist rollout/session files or
+                // prompt history — at autocomplete frequency they pollute CODEX_HOME.
+                "--ephemeral",
+                "-c", 'history.persistence="none"',
+                // Also skip the curated-plugins sync, which otherwise clones tens of
+                // MB into CODEX_HOME/.tmp on every exec.
+                "-c", "features.plugins=false",
+                "-m", this.opts.model,
+                "-c", `model_reasoning_effort="${this.opts.reasoningEffort}"`,
+                prompt,
+            ];
+            // Local: honor codexHome (skips global config's MCP/plugins). Over ssh,
+            // use the user's own ~/.codex on their machine (auth lives there).
+            const envOverrides = this.opts.transport.kind === "local" && this.opts.codexHome
+                ? { CODEX_HOME: this.opts.codexHome }
+                : {};
+            const cwd = this.opts.transport.kind === "ssh" ? "/tmp/nebula-autocomplete-ws" : this.opts.workspaceDir;
+            const plan = planSpawn(this.opts.transport, this.opts.binary, argv, envOverrides, cwd);
+            const proc = spawn(plan.command, plan.args, { ...plan.options, stdio: ["ignore", "pipe", "pipe"] });
+            let out = "";
+            let err = "";
+            proc.stdout.on("data", (d) => (out += d.toString()));
+            proc.stderr.on("data", (d) => (err += d.toString()));
+            const timer = setTimeout(() => {
+                proc.kill();
+                reject(new Error("codex timed out"));
+            }, this.opts.timeoutMs);
+            const onAbort = () => {
+                proc.kill();
+                reject(signal?.reason ?? new Error("aborted"));
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            proc.on("error", (e) => {
+                clearTimeout(timer);
+                reject(e);
+            });
+            proc.on("exit", (code) => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                if (signal?.aborted)
+                    return;
+                if (code !== 0) {
+                    return reject(new Error(`codex rc=${code}: ${err.slice(-300)}`));
+                }
+                const text = extractAgentMessage(out);
+                if (text)
+                    onChunk?.(text);
+                resolve(text);
+            });
+        });
+    }
+    dispose() {
+        /* one-shot processes; nothing persistent to release */
+    }
+}
+/** Find the agent message in codex --json JSONL output (shape varies by version). */
+export function extractAgentMessage(jsonl) {
+    let text = "";
+    for (const line of jsonl.split("\n")) {
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const item = ev.item ?? ev.msg ?? ev;
+        const kind = String(item.item_type ?? item.type ?? "");
+        if (kind.includes("agent_message") && typeof item.text === "string") {
+            text = item.text;
+        }
+    }
+    return text;
+}

package/node_modules/nebula-autocomplete/dist/client/fetcher.d.ts

@@ -0,0 +1,16 @@
+import type { CompletionRequest, CompletionResult } from "../types.js";
+export interface FetchCompletionOptions {
+    signal?: AbortSignal;
+    onChunk?: (text: string) => void;
+}
+export type CompletionFetcher = (req: CompletionRequest, opts?: FetchCompletionOptions) => Promise<CompletionResult>;
+/**
+ * Browser-side client for the SSE endpoint registered by
+ * registerAutocompleteRoute. Streams chunks via onChunk and resolves with the
+ * final CompletionResult.
+ */
+export interface CompletionFetcherOptions {
+    /** Extra headers (e.g. auth) merged into every request. */
+    headers?: Record<string, string> | (() => Record<string, string>);
+}
+export declare function createCompletionFetcher(endpoint: string, options?: CompletionFetcherOptions): CompletionFetcher;

package/node_modules/nebula-autocomplete/dist/client/fetcher.js

@@ -0,0 +1,41 @@
+export function createCompletionFetcher(endpoint, options = {}) {
+    return async (req, { signal, onChunk } = {}) => {
+        const extra = typeof options.headers === "function" ? options.headers() : (options.headers ?? {});
+        const resp = await fetch(endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...extra },
+            body: JSON.stringify(req),
+            signal,
+        });
+        if (!resp.ok || !resp.body) {
+            throw new Error(`autocomplete request failed: HTTP ${resp.status}`);
+        }
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let done = null;
+        for (;;) {
+            const { done: eof, value } = await reader.read();
+            if (eof)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            let i;
+            while ((i = buf.indexOf("\n\n")) !== -1) {
+                const line = buf.slice(0, i).replace(/^data: /, "");
+                buf = buf.slice(i + 2);
+                if (!line.trim())
+                    continue;
+                const ev = JSON.parse(line);
+                if (ev.type === "chunk")
+                    onChunk?.(ev.text);
+                else if (ev.type === "done")
+                    done = ev;
+                else if (ev.type === "error")
+                    throw new Error(ev.message);
+            }
+        }
+        if (!done)
+            throw new Error("stream ended without a done event");
+        return done;
+    };
+}

package/node_modules/nebula-autocomplete/dist/codemirror/ghostText.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CodeMirror 6 inline ghost-text completion.
+ *
+ * Renders the pending LLM suggestion as dimmed inline text at the cursor;
+ * Tab accepts, Escape dismisses, any edit or cursor move invalidates. Fetching
+ * is debounced and superseded requests are aborted.
+ *
+ * This intentionally does NOT use @codemirror/autocomplete's dropdown — the
+ * kernel/static completion sources keep the dropdown; multi-line LLM
+ * suggestions render as ghost text alongside it.
+ */
+import { EditorState, type Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+export interface GhostTextContext {
+    prefix: string;
+    suffix: string;
+    state: EditorState;
+}
+export type GhostTextFetcher = (ctx: GhostTextContext, opts: {
+    signal: AbortSignal;
+    onChunk: (text: string) => void;
+}) => Promise<string>;
+export interface GhostTextOptions {
+    /** Idle time after the last edit before a fetch fires. Default 400 ms. */
+    debounceMs?: number;
+    /**
+     * Skip fetching when the prefix (trimmed) is shorter than this. Default 0:
+     * with notebook-level context (other cells) available to the fetcher, even
+     * an empty cell is completable — gate in the fetcher, which can see that
+     * context, not here. Set >0 only for context-free single-document use.
+     */
+    minPrefixLength?: number;
+    /**
+     * When this returns true at fetch time, the fetch is skipped — e.g. while a
+     * completion DROPDOWN is open, so the two UIs don't stack and ghost turns
+     * aren't burned while the user browses the list. Injected as a predicate so
+     * this package needs no dependency on @codemirror/autocomplete.
+     */
+    holdWhen?: (state: unknown) => boolean;
+}
+export declare function acceptGhostText(view: EditorView): boolean;
+export declare function dismissGhostText(view: EditorView): boolean;
+export declare function ghostText(fetcher: GhostTextFetcher, options?: GhostTextOptions): Extension;

package/node_modules/nebula-autocomplete/dist/codemirror/ghostText.js

@@ -0,0 +1,175 @@
+/**
+ * CodeMirror 6 inline ghost-text completion.
+ *
+ * Renders the pending LLM suggestion as dimmed inline text at the cursor;
+ * Tab accepts, Escape dismisses, any edit or cursor move invalidates. Fetching
+ * is debounced and superseded requests are aborted.
+ *
+ * This intentionally does NOT use @codemirror/autocomplete's dropdown — the
+ * kernel/static completion sources keep the dropdown; multi-line LLM
+ * suggestions render as ghost text alongside it.
+ */
+import { Prec, StateEffect, StateField, } from "@codemirror/state";
+import { Decoration, EditorView, keymap, ViewPlugin, WidgetType, } from "@codemirror/view";
+const setGhost = StateEffect.define();
+class GhostWidget extends WidgetType {
+    text;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    eq(other) {
+        return other.text === this.text;
+    }
+    toDOM() {
+        const span = document.createElement("span");
+        span.className = "cm-ghost-text";
+        span.style.opacity = "0.45";
+        span.style.whiteSpace = "pre-wrap";
+        span.setAttribute("aria-hidden", "true");
+        span.textContent = this.text;
+        return span;
+    }
+    get lineBreaks() {
+        return (this.text.match(/\n/g) ?? []).length;
+    }
+}
+const ghostField = StateField.define({
+    create: () => null,
+    update(value, tr) {
+        for (const e of tr.effects)
+            if (e.is(setGhost))
+                return e.value;
+        // Any document change or cursor move invalidates the suggestion.
+        if (tr.docChanged || tr.selection)
+            return null;
+        return value;
+    },
+    provide: (field) => EditorView.decorations.from(field, (value) => {
+        if (!value || !value.text)
+            return Decoration.none;
+        return Decoration.set([
+            Decoration.widget({
+                widget: new GhostWidget(value.text),
+                side: 1,
+            }).range(value.pos),
+        ]);
+    }),
+});
+export function acceptGhostText(view) {
+    const ghost = view.state.field(ghostField, false);
+    if (!ghost || !ghost.text)
+        return false;
+    view.dispatch({
+        changes: { from: ghost.pos, insert: ghost.text },
+        selection: { anchor: ghost.pos + ghost.text.length },
+        effects: setGhost.of(null),
+        userEvent: "input.complete",
+    });
+    return true;
+}
+export function dismissGhostText(view) {
+    const ghost = view.state.field(ghostField, false);
+    if (!ghost)
+        return false;
+    view.dispatch({ effects: setGhost.of(null) });
+    return true;
+}
+export function ghostText(fetcher, options = {}) {
+    const debounceMs = options.debounceMs ?? 400;
+    const minPrefixLength = options.minPrefixLength ?? 0;
+    const plugin = ViewPlugin.fromClass(class {
+        view;
+        timer = null;
+        controller = null;
+        // In-flight fetches (supersession can briefly overlap two). While > 0 the
+        // editor root carries .cm-ai-pending so themes can signal "computing"
+        // (e.g. tint the cursor) instead of leaving the wait invisible.
+        inflight = 0;
+        constructor(view) {
+            this.view = view;
+        }
+        trackFetch(delta) {
+            this.inflight += delta;
+            this.view.dom.classList.toggle("cm-ai-pending", this.inflight > 0);
+        }
+        update(update) {
+            if (!update.docChanged)
+                return;
+            // Any user-driven edit triggers a fetch — typing, paste, delete,
+            // undo/redo — EXCEPT accepting a suggestion (that would immediately
+            // re-fetch on its own output). The kind of edit doesn't matter: the
+            // model can complete from whatever state the edit produced.
+            const isUserEdit = update.transactions.some((tr) => (tr.isUserEvent("input") && !tr.isUserEvent("input.complete")) ||
+                tr.isUserEvent("delete") ||
+                tr.isUserEvent("undo") ||
+                tr.isUserEvent("redo") ||
+                tr.isUserEvent("move"));
+            if (!isUserEdit)
+                return;
+            this.schedule();
+        }
+        schedule() {
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.controller?.abort();
+            this.timer = setTimeout(() => this.fetch(), debounceMs);
+        }
+        async fetch() {
+            const { state } = this.view;
+            if (!this.view.hasFocus)
+                return;
+            if (options.holdWhen?.(state))
+                return; // e.g. kernel dropdown open
+            const pos = state.selection.main.head;
+            if (!state.selection.main.empty)
+                return;
+            const prefix = state.sliceDoc(0, pos);
+            const suffix = state.sliceDoc(pos);
+            if (prefix.trim().length < minPrefixLength)
+                return;
+            this.controller = new AbortController();
+            const { signal } = this.controller;
+            const startDoc = state.doc;
+            const stale = () => signal.aborted || this.view.state.doc !== startDoc;
+            let streamed = "";
+            this.trackFetch(1);
+            try {
+                const full = await fetcher({ prefix, suffix, state }, {
+                    signal,
+                    onChunk: (text) => {
+                        if (stale())
+                            return;
+                        streamed += text;
+                        this.view.dispatch({ effects: setGhost.of({ pos, text: streamed }) });
+                    },
+                });
+                if (stale())
+                    return;
+                if (full)
+                    this.view.dispatch({ effects: setGhost.of({ pos, text: full }) });
+            }
+            catch {
+                /* aborted or backend error — ghost text simply doesn't appear */
+            }
+            finally {
+                this.trackFetch(-1);
+            }
+        }
+        destroy() {
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.controller?.abort();
+            this.inflight = 0;
+            this.view.dom.classList.remove("cm-ai-pending");
+        }
+    });
+    return [
+        ghostField,
+        plugin,
+        Prec.highest(keymap.of([
+            { key: "Tab", run: acceptGhostText },
+            { key: "Escape", run: dismissGhostText },
+        ])),
+    ];
+}

package/node_modules/nebula-autocomplete/dist/core/engine.d.ts

@@ -0,0 +1,17 @@
+import type { CompleteOptions, CompletionRequest, CompletionResult, EngineOptions } from "../types.js";
+/**
+ * Backend-agnostic autocomplete engine: prompt assembly, LRU result cache,
+ * and per-session supersession (a new request aborts the previous one with
+ * the same sessionKey).
+ */
+export declare class AutocompleteEngine {
+    private opts;
+    private cache;
+    private inflight;
+    private turnChain;
+    private contextBudget;
+    private maxLines;
+    constructor(opts: EngineOptions);
+    complete(req: CompletionRequest, { signal, onChunk }?: CompleteOptions): Promise<CompletionResult>;
+    dispose(): void;
+}

package/node_modules/nebula-autocomplete/dist/core/engine.js

@@ -0,0 +1,135 @@
+import { LruCache } from "./lru.js";
+import { buildPrompt, cacheKey } from "./prompt.js";
+import { createPrefixTrimStreamFilter, createTagStreamFilter, extractCompletionTag, stripFences, trimPrefixOverlap, trimSuffixOverlap, } from "./text.js";
+/**
+ * Backend-agnostic autocomplete engine: prompt assembly, LRU result cache,
+ * and per-session supersession (a new request aborts the previous one with
+ * the same sessionKey).
+ */
+export class AutocompleteEngine {
+    opts;
+    cache;
+    inflight = new Map();
+    // Per-session dispatch chain (single-flight): a backend turn cannot be
+    // cancelled once dispatched — an aborted request's worker still runs its
+    // turn to completion. Without this, a typing burst fanned superseded
+    // requests out across workers: the pool exhausted, each keystroke cold-
+    // spawned another process, and contending spawns snowballed into ~30s
+    // waits. Chaining per session keeps at most ONE turn per cell in flight;
+    // superseded requests abort while queued and never touch the backend.
+    turnChain = new Map();
+    contextBudget;
+    maxLines;
+    constructor(opts) {
+        this.opts = opts;
+        this.cache = new LruCache(opts.cacheSize ?? 128);
+        this.contextBudget = opts.contextBudget ?? 6000;
+        this.maxLines = opts.maxLines ?? 10; // field-tested: longer caps don't hurt latency; short ones truncate wanted completions
+    }
+    async complete(req, { signal, onChunk } = {}) {
+        const t0 = performance.now();
+        const key = cacheKey(req);
+        const cached = this.cache.get(key);
+        if (cached !== undefined) {
+            onChunk?.(cached);
+            return {
+                text: cached,
+                backend: this.opts.backend.name,
+                fromCache: true,
+                ttfbMs: 0,
+                totalMs: Math.round(performance.now() - t0),
+            };
+        }
+        // Supersede any in-flight request for the same session (cell).
+        const session = req.sessionKey;
+        let controller;
+        if (session !== undefined) {
+            this.inflight.get(session)?.abort(new Error("superseded"));
+            controller = new AbortController();
+            this.inflight.set(session, controller);
+            if (signal) {
+                const upstream = signal;
+                upstream.addEventListener("abort", () => controller.abort(upstream.reason), {
+                    once: true,
+                });
+            }
+        }
+        const effectiveSignal = controller?.signal ?? signal;
+        let ttfb = null;
+        const rawChunkGuard = (t) => {
+            if (ttfb === null)
+                ttfb = performance.now() - t0;
+            onChunk?.(t);
+        };
+        // Streamed ghost text goes through the same shaping as the final text so
+        // the done event never visibly "snaps" it: strip <completion> tags, then
+        // hold back a possible prefix-echo until it either confirms (stripped) or
+        // is ruled out (streamed through).
+        const chunkGuard = createTagStreamFilter(createPrefixTrimStreamFilter(req.prefix, rawChunkGuard));
+        try {
+            // Per-request tuning (Advanced settings), clamped to sane bounds.
+            const clamp = (v, lo, hi, dflt) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, Math.round(v))) : dflt;
+            const prompt = buildPrompt(req, {
+                contextBudget: clamp(req.contextBudget, 0, 200_000, this.contextBudget),
+                maxLines: clamp(req.maxLines, 1, 40, this.maxLines),
+            });
+            const diag = { promptChars: prompt.length };
+            // Single-flight per session: wait for the previous turn on this cell to
+            // settle before dispatching. If we're superseded while queued (the user
+            // kept typing), bail here — no backend turn is ever wasted on us.
+            const prev = session !== undefined ? this.turnChain.get(session) : undefined;
+            const run = (async () => {
+                if (prev) {
+                    const tQueue = performance.now();
+                    await prev; // never rejects (stored pre-caught)
+                    diag.queueWaitMs = Math.round(performance.now() - tQueue);
+                    if (effectiveSignal?.aborted)
+                        throw new Error("superseded");
+                }
+                return this.opts.backend.complete(prompt, {
+                    signal: effectiveSignal,
+                    onChunk: chunkGuard,
+                    diag,
+                });
+            })();
+            if (session !== undefined) {
+                const link = run.then(() => undefined, () => undefined);
+                this.turnChain.set(session, link);
+                void link.then(() => {
+                    if (this.turnChain.get(session) === link)
+                        this.turnChain.delete(session);
+                });
+            }
+            const raw = await run;
+            diag.rawChars = raw.length;
+            // Tag-wrapped replies carry whitespace verbatim; untagged replies fall
+            // back to the fence-stripping pipeline.
+            const tagged = extractCompletionTag(raw);
+            const text = trimSuffixOverlap(req.suffix ?? "", trimPrefixOverlap(req.prefix, tagged !== null ? tagged : stripFences(raw)));
+            // Cache only non-empty results: an empty completion is a transient
+            // model shrug, and caching it pins "no suggestion" onto that exact
+            // prefix for the cache's lifetime (observed as instant empty repeats).
+            if (text)
+                this.cache.set(key, text);
+            return {
+                text,
+                backend: this.opts.backend.name,
+                fromCache: false,
+                ttfbMs: Math.round(ttfb ?? performance.now() - t0),
+                totalMs: Math.round(performance.now() - t0),
+                diag,
+            };
+        }
+        finally {
+            if (session !== undefined && this.inflight.get(session) === controller) {
+                this.inflight.delete(session);
+            }
+        }
+    }
+    dispose() {
+        for (const c of this.inflight.values())
+            c.abort(new Error("engine disposed"));
+        this.inflight.clear();
+        this.opts.backend.dispose();
+    }
+}

package/node_modules/nebula-autocomplete/dist/core/lru.d.ts

@@ -0,0 +1,7 @@
+export declare class LruCache<V> {
+    private capacity;
+    private map;
+    constructor(capacity: number);
+    get(key: string): V | undefined;
+    set(key: string, value: V): void;
+}

package/node_modules/nebula-autocomplete/dist/core/lru.js

@@ -0,0 +1,26 @@
+export class LruCache {
+    capacity;
+    map = new Map();
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    get(key) {
+        const v = this.map.get(key);
+        if (v !== undefined) {
+            this.map.delete(key);
+            this.map.set(key, v);
+        }
+        return v;
+    }
+    set(key, value) {
+        if (this.capacity <= 0)
+            return;
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, value);
+        if (this.map.size > this.capacity) {
+            const oldest = this.map.keys().next().value;
+            this.map.delete(oldest);
+        }
+    }
+}

package/node_modules/nebula-autocomplete/dist/core/prompt.d.ts

@@ -0,0 +1,12 @@
+import type { CompletionRequest } from "../types.js";
+export interface PromptOptions {
+    contextBudget: number;
+    maxLines: number;
+}
+/**
+ * Build the completion prompt: instruction, cross-cell context (nearest cells
+ * kept when over budget), then the active cell with a <CURSOR> marker.
+ */
+export declare function buildPrompt(req: CompletionRequest, opts: PromptOptions): string;
+/** Cache key: exact near-cursor text + a cheap digest of the wider context. */
+export declare function cacheKey(req: CompletionRequest): string;