sublera-cli 0.0.0-stage → 1.3.0

package/dist/network/proxy.js

@@ -0,0 +1,328 @@
+import { Agent as HttpAgent, request as httpRequest } from 'node:http';
+import { Agent as HttpsAgent, request as httpsRequest } from 'node:https';
+import { connect as tlsConnect } from 'node:tls';
+import { isIP } from 'node:net';
+function envValue(env, name) {
+    const value = env[name] ?? env[name.toLowerCase()];
+    return value && value.trim() ? value.trim() : null;
+}
+export function proxySettings(env = process.env) {
+    return {
+        httpsProxy: envValue(env, 'HTTPS_PROXY'),
+        httpProxy: envValue(env, 'HTTP_PROXY'),
+        noProxy: (envValue(env, 'NO_PROXY') || '').split(/[\s,]+/).map((v) => v.trim().toLowerCase()).filter(Boolean),
+    };
+}
+export function proxyConfigured(settings = proxySettings()) {
+    return Boolean(settings.httpsProxy || settings.httpProxy);
+}
+/** True when NO_PROXY (or loopback) says this host must be reached directly. */
+export function bypassProxy(target, noProxy) {
+    const host = normalizeHost(target.hostname);
+    if (host === 'localhost' || host === '::1' || (isIP(host) === 4 && host.startsWith('127.')) ||
+        /^::ffff:7f[0-9a-f]{2}:/i.test(host))
+        return true;
+    const port = target.port || (target.protocol === 'https:' || target.protocol === 'wss:' ? '443' : '80');
+    for (const raw of noProxy) {
+        let entry = raw.trim().toLowerCase();
+        if (entry === '*')
+            return true;
+        // Only bracketed IPv6 may have a port; a bare IPv6 address is never split.
+        const match = entry.match(/^(\[[^\]]+\]|[^:]+):(\d+)$/);
+        if (match) {
+            if (Number(match[2]) !== Number(port))
+                continue;
+            entry = match[1];
+        }
+        entry = normalizeHost(entry.replace(/^\*?\./, ''));
+        if (entry && (host === entry || (!isIP(host) && !isIP(entry) && host.endsWith(`.${entry}`))))
+            return true;
+    }
+    return false;
+}
+function normalizeHost(host) {
+    const bare = host.toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/, '');
+    if (isIP(bare) === 6 && !bare.includes('%'))
+        return new URL(`http://[${bare}]`).hostname.slice(1, -1);
+    return bare;
+}
+/** The proxy URL to use for a target, or null for a direct connection. */
+export function proxyFor(target, settings = proxySettings()) {
+    const url = typeof target === 'string' ? new URL(target) : target;
+    if (bypassProxy(url, settings.noProxy))
+        return null;
+    const secure = url.protocol === 'https:' || url.protocol === 'wss:';
+    const raw = secure ? settings.httpsProxy || settings.httpProxy : settings.httpProxy;
+    if (!raw)
+        return null;
+    return parseProxyUrl(raw);
+}
+export function parseProxyUrl(raw) {
+    let proxy;
+    try {
+        proxy = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `http://${raw}`);
+    }
+    catch {
+        throw new Error('Invalid proxy setting (use an http:// or https:// proxy URL)');
+    }
+    if (proxy.protocol !== 'http:' && proxy.protocol !== 'https:') {
+        throw new Error('Unsupported proxy protocol (use an http:// or https:// proxy)');
+    }
+    // Fail eagerly and without echoing credentials, including malformed escapes.
+    proxyAuthHeader(proxy);
+    return proxy;
+}
+/** Proxy URL safe for logs and doctor output: credentials are hidden. */
+export function redactProxy(raw) {
+    if (!raw)
+        return 'none';
+    try {
+        const url = parseProxyUrl(String(raw));
+        // Paths, query strings and fragments can also contain secrets.
+        return `${url.protocol}//${url.username || url.password ? '***@' : ''}${url.host}`;
+    }
+    catch {
+        return '[invalid proxy URL]';
+    }
+}
+function proxyAuthHeader(proxy) {
+    if (!proxy.username && !proxy.password)
+        return null;
+    try {
+        const user = decodeURIComponent(proxy.username);
+        const pass = decodeURIComponent(proxy.password);
+        return `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}`;
+    }
+    catch {
+        throw new Error('Invalid proxy credentials (check percent-encoding)');
+    }
+}
+/** Opens an HTTP CONNECT tunnel through the proxy and returns the raw socket to host:port. */
+export function openConnectTunnel(proxy, host, port, timeoutMs = 15_000, signal) {
+    return new Promise((resolve, reject) => {
+        let req;
+        let settled = false;
+        let timer;
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            req?.destroy();
+            reject(error);
+        };
+        const abort = () => fail(new Error('Proxy connection aborted'));
+        const refused = (status) => {
+            const hint = status === 407 ? ' (the proxy needs a login: use http://user:password@proxy:port)' : '';
+            return new Error(`Proxy ${redactProxy(proxy)} refused CONNECT: HTTP ${status}${hint}`);
+        };
+        if (signal?.aborted) {
+            abort();
+            return;
+        }
+        try {
+            proxy = parseProxyUrl(proxy.href);
+            host = normalizeHost(host);
+            if (!host || /[\s/?#@]/.test(host) || (host.includes(':') && !isIP(host)) ||
+                !Number.isInteger(port) || port < 1 || port > 65535)
+                throw new Error('Invalid CONNECT target');
+            const authority = `${isIP(host) === 6 ? `[${host}]` : host}:${port}`;
+            const headers = { host: authority };
+            const auth = proxyAuthHeader(proxy);
+            if (auth)
+                headers['proxy-authorization'] = auth;
+            const request = proxy.protocol === 'https:' ? httpsRequest : httpRequest;
+            const proxyHost = proxy.hostname.replace(/^\[|\]$/g, '');
+            req = request({
+                host: proxyHost,
+                // HTTPS otherwise derives SNI/verification from the CONNECT Host header,
+                // which names the destination rather than the TLS peer (the proxy).
+                servername: isIP(proxyHost) ? '' : proxyHost,
+                port: Number(proxy.port) || (proxy.protocol === 'https:' ? 443 : 80),
+                method: 'CONNECT',
+                path: authority,
+                headers,
+                agent: false,
+            });
+            req.once('connect', (res, socket, head) => {
+                if (settled || res.statusCode !== 200) {
+                    socket.destroy();
+                    if (!settled)
+                        fail(refused(res.statusCode));
+                    return;
+                }
+                settled = true;
+                cleanup();
+                socket.setTimeout(0);
+                // The proxy may send upstream bytes in the same packet as its headers.
+                if (head.length)
+                    socket.unshift(head);
+                resolve(socket);
+            });
+            req.once('response', (res) => { res.destroy(); fail(refused(res.statusCode)); });
+            req.once('close', () => fail(new Error(`Proxy ${redactProxy(proxy)} closed before CONNECT completed`)));
+            // Do not echo peer-controlled parser errors (which can include credentials).
+            req.once('error', (error) => {
+                const code = error.code && /^[A-Z0-9_]+$/.test(error.code) ? ` (${error.code})` : '';
+                fail(new Error(`Could not reach proxy ${redactProxy(proxy)}${code}`));
+            });
+            signal?.addEventListener('abort', abort, { once: true });
+            // A deadline, not an inactivity timeout: trickled headers must not hang forever.
+            timer = setTimeout(() => fail(new Error(`Proxy ${redactProxy(proxy)} did not answer within ${timeoutMs}ms`)), timeoutMs);
+            timer.unref();
+            req.end();
+        }
+        catch {
+            fail(new Error(`Invalid proxy connection settings for ${redactProxy(proxy)}`));
+        }
+    });
+}
+/** Opens the CONNECT tunnel, then (for https/wss) does TLS end to end with the real host. */
+function connectThroughProxy(proxy, secure, rawOptions, pending, callback) {
+    // An asynchronous connection cannot be handed off without a callback.
+    if (!callback)
+        return;
+    const controller = new AbortController();
+    pending.add(controller);
+    const options = rawOptions;
+    const host = String(options.hostname || options.host || 'localhost').replace(/^\[|\]$/g, '');
+    const port = Number(options.port) || (secure ? 443 : 80);
+    const timeout = options.timeout && options.timeout > 0 ? options.timeout : 15_000;
+    let stream;
+    let settled = false;
+    let timer;
+    const finish = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        controller.signal.removeEventListener('abort', abort);
+        pending.delete(controller);
+        stream?.removeListener('secureConnect', ready);
+        stream?.removeListener('error', fail);
+        stream?.removeListener('close', closed);
+        if (error)
+            stream?.destroy();
+        // Node accepts an error with no stream; the typings require one.
+        callback(error, error ? undefined : stream);
+    };
+    const fail = (error) => finish(error);
+    const ready = () => finish(null);
+    const closed = () => fail(new Error('Proxy tunnel closed before TLS negotiation completed'));
+    const abort = () => fail(new Error('Proxy connection aborted'));
+    controller.signal.addEventListener('abort', abort, { once: true });
+    openConnectTunnel(proxy, host, port, timeout, controller.signal).then((socket) => {
+        if (settled) {
+            socket.destroy();
+            return;
+        }
+        stream = socket;
+        if (!secure) {
+            ready();
+            return;
+        }
+        try {
+            // Always validate against the destination, not the proxy or localhost.
+            // IP literals need certificate IP validation but must not be sent as SNI.
+            stream = tlsConnect({ ...options, host, port, socket, servername: options.servername ?? (isIP(host) ? '' : host) });
+            stream.once('secureConnect', ready);
+            stream.once('error', fail);
+            stream.once('close', closed);
+            timer = setTimeout(() => fail(new Error('Proxy tunnel TLS negotiation timed out')), timeout);
+            timer.unref();
+        }
+        catch {
+            fail(new Error('Could not initialize TLS through proxy'));
+        }
+    }, fail);
+}
+/**
+ * An https.Agent that reaches the target through an HTTP CONNECT proxy. Used
+ * for the wss:// tunnel, because the `ws` package takes a Node agent and ignores proxy variables.
+ */
+export class ConnectProxyAgent extends HttpsAgent {
+    proxy;
+    pending = new Set();
+    constructor(proxy, options = {}) {
+        super({ keepAlive: false, ...options });
+        this.proxy = proxy;
+    }
+    createConnection(rawOptions, callback) {
+        connectThroughProxy(this.proxy, true, rawOptions, this.pending, callback);
+        return undefined;
+    }
+    destroy() {
+        for (const controller of this.pending)
+            controller.abort();
+        super.destroy();
+    }
+}
+/** The plain-HTTP twin of ConnectProxyAgent, for ws:// servers (local or test setups). */
+export class ConnectProxyHttpAgent extends HttpAgent {
+    proxy;
+    pending = new Set();
+    constructor(proxy) {
+        super({ keepAlive: false });
+        this.proxy = proxy;
+    }
+    createConnection(rawOptions, callback) {
+        connectThroughProxy(this.proxy, false, rawOptions, this.pending, callback);
+        return undefined;
+    }
+    destroy() {
+        for (const controller of this.pending)
+            controller.abort();
+        super.destroy();
+    }
+}
+/** A Node agent for the `ws` tunnel when a proxy applies to this URL, else undefined (direct). */
+export function websocketAgentFor(url, settings = proxySettings()) {
+    const proxy = proxyFor(url, settings);
+    if (!proxy)
+        return undefined;
+    return /^(wss|https):/i.test(url) ? new ConnectProxyAgent(proxy) : new ConnectProxyHttpAgent(proxy);
+}
+let fetchProxyInstallation;
+/**
+ * Routes the global fetch() (API calls, model and engine downloads) through the
+ * configured proxy. Loads nothing and changes nothing when no proxy is set.
+ */
+export async function installFetchProxy(env = process.env) {
+    if (fetchProxyInstallation)
+        return fetchProxyInstallation;
+    const settings = proxySettings(env);
+    if (!proxyConfigured(settings))
+        return false;
+    // A malformed value fails here with a clear message instead of on the first download.
+    if (settings.httpsProxy)
+        settings.httpsProxy = parseProxyUrl(settings.httpsProxy).href;
+    if (settings.httpProxy)
+        settings.httpProxy = parseProxyUrl(settings.httpProxy).href;
+    fetchProxyInstallation = (async () => {
+        const undici = await import('undici');
+        // Node's native fetch shares this dispatcher. Do not replace fetch, Request,
+        // Response, FormData, WebSocket, etc. with different class identities.
+        undici.setGlobalDispatcher(new undici.Agent({
+            factory(origin, options) {
+                // One routing policy for fetch and ws; no ambient environment fallback.
+                const proxy = proxyFor(String(origin), settings);
+                return proxy
+                    ? new undici.ProxyAgent({ ...options, uri: proxy.href, token: proxyAuthHeader(proxy) ?? undefined })
+                    : new undici.Pool(origin, options);
+            },
+        }));
+        return true;
+    })();
+    try {
+        return await fetchProxyInstallation;
+    }
+    catch (error) {
+        fetchProxyInstallation = undefined;
+        throw error;
+    }
+}
+//# sourceMappingURL=proxy.js.map

package/dist/network/streamProxy.d.ts

@@ -0,0 +1,51 @@
+import type { ChatMessage, TokenPosition } from '../types.js';
+/**
+ * Token probabilities go out with the first positions of every job, so the server can check the model behind any job
+ * (its model checks look exactly like normal work). Later tokens are sent without them to keep frames small.
+ */
+export declare const PROBED_POSITIONS = 32;
+export type ProxyJob = {
+    jobId: string;
+    messages: ChatMessage[];
+    maxTokens: number;
+    temperature: number;
+    model?: string;
+    seed?: number;
+};
+export type StreamResult = {
+    text: string;
+    finishReason: string;
+    promptTokens: number;
+    completionTokens: number;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    } | null;
+    ttftMs: number | null;
+    tokPerSec: number | null;
+};
+/** `positions` holds the probabilities of the tokens in this chunk, for the first PROBED_POSITIONS tokens only. */
+export type ChunkHandler = (text: string, positions: TokenPosition[]) => void;
+export type StreamOptions = {
+    signal?: AbortSignal;
+    onChunk?: ChunkHandler;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+};
+export declare class SseParser {
+    private buffer;
+    private dataLines;
+    private eventSize;
+    push(text: string): string[];
+    flush(): string[];
+}
+export declare function streamChat(llamaUrl: string, job: ProxyJob, options?: StreamOptions): Promise<StreamResult>;
+export declare function simulateReply(prompt: string, model: string): string;
+/** Stand-in probabilities for test nodes: the same shape as llama-server's, so the server's checks run end to end. */
+export declare function simulatedPosition(token: string): TokenPosition;
+export declare function simulateChat(job: ProxyJob, options?: {
+    signal?: AbortSignal;
+    tokPerSec?: number;
+    onChunk?: ChunkHandler;
+}): Promise<StreamResult>;

package/dist/network/streamProxy.js

@@ -0,0 +1,286 @@
+/**
+ * Token probabilities go out with the first positions of every job, so the server can check the model behind any job
+ * (its model checks look exactly like normal work). Later tokens are sent without them to keep frames small.
+ */
+export const PROBED_POSITIONS = 32;
+const TOP_ALTERNATIVES = 5;
+export class SseParser {
+    buffer = '';
+    dataLines = [];
+    eventSize = 0;
+    push(text) {
+        this.buffer += text;
+        if (this.buffer.length > 2 * 1024 * 1024)
+            throw new Error('llama-server SSE buffer exceeds limit');
+        const events = [];
+        while (true) {
+            const match = this.buffer.match(/\r?\n/);
+            if (!match || match.index == null)
+                break;
+            const line = this.buffer.slice(0, match.index);
+            this.buffer = this.buffer.slice(match.index + match[0].length);
+            if (line === '') {
+                if (this.dataLines.length) {
+                    events.push(this.dataLines.join('\n'));
+                    this.dataLines = [];
+                    this.eventSize = 0;
+                }
+                continue;
+            }
+            if (line.startsWith(':'))
+                continue;
+            if (line.startsWith('data:')) {
+                this.eventSize += line.length;
+                if (this.eventSize > 1024 * 1024)
+                    throw new Error('llama-server SSE event exceeds limit');
+                this.dataLines.push(line.slice(5).trimStart());
+            }
+        }
+        return events;
+    }
+    flush() {
+        const events = [];
+        if (this.buffer.startsWith('data:'))
+            this.dataLines.push(this.buffer.slice(5).trimStart());
+        this.buffer = '';
+        if (this.dataLines.length) {
+            events.push(this.dataLines.join('\n'));
+            this.dataLines = [];
+            this.eventSize = 0;
+        }
+        return events;
+    }
+}
+function deltaContent(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value.map((part) => {
+        if (typeof part === 'string')
+            return part;
+        if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string')
+            return part.text;
+        return '';
+    }).join('');
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value <= 0 && value > -9999 ? value : null;
+}
+function toPosition(entry) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const l = asNumber(entry.logprob);
+    if (typeof entry.token !== 'string' || l == null)
+        return null;
+    const top = [];
+    for (const alt of Array.isArray(entry.top_logprobs) ? entry.top_logprobs.slice(0, TOP_ALTERNATIVES) : []) {
+        if (!alt || typeof alt !== 'object')
+            continue;
+        const value = asNumber(alt.logprob);
+        if (typeof alt.token === 'string' && value != null)
+            top.push([alt.token, value]);
+    }
+    return { t: entry.token, l, top };
+}
+export async function streamChat(llamaUrl, job, options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new Error('Generation timed out')), options.timeoutMs ?? 10 * 60_000);
+    const onAbort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', onAbort);
+    if (options.signal?.aborted)
+        onAbort();
+    const started = Date.now();
+    let firstTokenAt = null;
+    let text = '';
+    let finishReason = 'stop';
+    let usage = null;
+    let chunkCount = 0;
+    let probed = 0;
+    let pending = [];
+    let completed = false;
+    let reader;
+    try {
+        controller.signal.throwIfAborted();
+        const response = await fetchImpl(`${llamaUrl.replace(/\/+$/, '')}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', accept: 'text/event-stream' },
+            body: JSON.stringify({
+                model: job.model || 'local',
+                messages: job.messages,
+                stream: true,
+                stream_options: { include_usage: true },
+                temperature: job.temperature,
+                max_tokens: job.maxTokens,
+                logprobs: true,
+                top_logprobs: TOP_ALTERNATIVES,
+                ...(job.seed != null ? { seed: job.seed } : {}),
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok || !response.body) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`llama-server returned ${response.status}${body ? `: ${body.slice(0, 300)}` : ''}`);
+        }
+        const parser = new SseParser();
+        reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        const consume = (event) => {
+            if (completed)
+                return;
+            if (event === '[DONE]') {
+                completed = true;
+                return;
+            }
+            let json;
+            try {
+                json = JSON.parse(event);
+            }
+            catch {
+                throw new Error('Malformed JSON in llama-server stream');
+            }
+            if (!json || typeof json !== 'object' || Array.isArray(json))
+                throw new Error('Invalid llama-server stream event');
+            if (json.error) {
+                const error = json.error;
+                throw new Error(typeof error === 'string' ? error : error.message || 'llama-server stream error');
+            }
+            const eventUsage = json.usage;
+            if (eventUsage) {
+                const counts = [eventUsage.prompt_tokens, eventUsage.completion_tokens, eventUsage.total_tokens];
+                if (!counts.every((n) => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0))
+                    throw new Error('Invalid llama-server token usage');
+                usage = {
+                    prompt_tokens: Number(eventUsage.prompt_tokens || 0),
+                    completion_tokens: Number(eventUsage.completion_tokens || 0),
+                    total_tokens: Number(eventUsage.total_tokens || 0),
+                };
+            }
+            const choices = Array.isArray(json.choices) ? json.choices : [];
+            for (const choice of choices) {
+                if (!choice || typeof choice !== 'object')
+                    throw new Error('Invalid llama-server choice');
+                const delta = choice.delta && typeof choice.delta === 'object' ? choice.delta : {};
+                const lp = choice.logprobs && typeof choice.logprobs === 'object' ? choice.logprobs : null;
+                for (const entry of Array.isArray(lp?.content) ? lp.content : []) {
+                    if (probed >= PROBED_POSITIONS)
+                        break;
+                    const position = toPosition(entry);
+                    if (!position)
+                        continue;
+                    pending.push(position);
+                    probed++;
+                }
+                const piece = deltaContent(delta.content);
+                if (piece) {
+                    if (text.length + piece.length > 16 * 1024 * 1024)
+                        throw new Error('llama-server output exceeds limit');
+                    if (firstTokenAt == null)
+                        firstTokenAt = Date.now();
+                    text += piece;
+                    chunkCount++;
+                    options.onChunk?.(piece, pending);
+                    pending = [];
+                }
+                if (typeof choice.finish_reason === 'string' && choice.finish_reason)
+                    finishReason = choice.finish_reason;
+            }
+        };
+        while (!completed) {
+            controller.signal.throwIfAborted();
+            const { done, value } = await reader.read();
+            if (done) {
+                for (const event of parser.push(decoder.decode()))
+                    consume(event);
+                for (const event of parser.flush())
+                    consume(event);
+                break;
+            }
+            for (const event of parser.push(decoder.decode(value, { stream: true })))
+                consume(event);
+        }
+        controller.signal.throwIfAborted();
+        if (!completed)
+            throw new Error('llama-server stream ended before [DONE]');
+        const elapsed = Math.max(1, Date.now() - started);
+        // Events update usage inside consume(), which TypeScript cannot track here.
+        const finalUsage = usage;
+        const completion = finalUsage?.completion_tokens ?? chunkCount;
+        return {
+            text,
+            finishReason,
+            promptTokens: finalUsage?.prompt_tokens ?? 0,
+            completionTokens: completion,
+            usage: finalUsage,
+            ttftMs: firstTokenAt ? firstTokenAt - started : null,
+            tokPerSec: completion / (elapsed / 1000),
+        };
+    }
+    finally {
+        if (reader) {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', onAbort);
+    }
+}
+export function simulateReply(prompt, model) {
+    const q = prompt.replace(/\s+/g, ' ').trim();
+    const short = q.length > 180 ? `${q.slice(0, 180)}.` : q;
+    if (!q)
+        return 'Sublera simulator is ready. Send a prompt and every streamed token is metered by the central server.';
+    if (/```|function|def |class |sql|python|typescript|javascript|regex/i.test(q)) {
+        return [
+            'Here is a small, explicit sketch you can replace:',
+            '',
+            '```ts',
+            'export function solve(input: string): string {',
+            `  // ${short}`,
+            '  return input.trim();',
+            '}',
+            '```',
+            '',
+            `Simulated by Sublera on ${model}. A live GPU would run the real GGUF weights.`,
+        ].join('\n');
+    }
+    return [
+        `On ${model}, the useful reading of that prompt is: ${short || 'a short request'}.`,
+        'This node is in simulation mode: the stream, the meter, and the wallet are real, while the words are a stand-in.',
+        'Run sublera doctor, install llama-server, and drop --simulation for real GGUF output.',
+    ].join(' ');
+}
+/** Stand-in probabilities for test nodes: the same shape as llama-server's, so the server's checks run end to end. */
+export function simulatedPosition(token) {
+    return { t: token, l: -0.05, top: [[token, -0.05], [' the', -3.2], [' a', -3.9], ['.', -4.4], [',', -4.8]] };
+}
+export async function simulateChat(job, options = {}) {
+    const prompt = job.messages.filter((m) => m.role === 'user').map((m) => m.content).join('\n');
+    const text = simulateReply(prompt, job.model || 'sublera-simulator');
+    const pieces = text.split(/(\s+)/).filter((piece) => piece.length > 0);
+    const started = Date.now();
+    let sent = '';
+    let first = null;
+    const delay = Math.max(5, Math.round(1000 / Math.max(5, options.tokPerSec ?? 24)));
+    for (const [index, piece] of pieces.entries()) {
+        if (options.signal?.aborted)
+            break;
+        if (first == null)
+            first = Date.now();
+        await new Promise((r) => setTimeout(r, delay));
+        sent += piece;
+        options.onChunk?.(piece, index < PROBED_POSITIONS ? [simulatedPosition(piece)] : []);
+    }
+    const elapsed = Math.max(1, Date.now() - started);
+    return {
+        text: sent,
+        finishReason: 'stop',
+        promptTokens: Math.max(1, Math.ceil(prompt.length / 4)),
+        completionTokens: pieces.length,
+        usage: { prompt_tokens: Math.max(1, Math.ceil(prompt.length / 4)), completion_tokens: pieces.length, total_tokens: pieces.length + Math.ceil(prompt.length / 4) },
+        ttftMs: first ? first - started : null,
+        tokPerSec: pieces.length / (elapsed / 1000),
+    };
+}
+//# sourceMappingURL=streamProxy.js.map