@vascend/talos 0.1.0

package/dist/providers/retry.js

@@ -0,0 +1,347 @@
+import { cleanProviderText, providerResetAt } from "./provider-reset.js";
+import { quotaLimitsFromError, quotaResetAt, rejectedQuotaWindows } from "./quota-limits.js";
+export const DEFAULT_RETRY = {
+    maxRetries: 2,
+    baseDelayMs: 500,
+    timeoutMs: 0,
+    networkMaxRetries: 10,
+    networkRetryDelayMs: 2000,
+    overloadMaxAttempts: 10,
+    overloadBaseDelayMs: 3000,
+    overloadMaxDelayMs: 60000,
+};
+function intEnv(env, key) {
+    const n = Number(env[key]);
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+export function retryConfigFromEnv(env) {
+    return {
+        maxRetries: intEnv(env, "TALOS_PROVIDER_MAX_RETRIES") ?? DEFAULT_RETRY.maxRetries,
+        baseDelayMs: intEnv(env, "TALOS_PROVIDER_RETRY_BASE_MS") ?? DEFAULT_RETRY.baseDelayMs,
+        timeoutMs: intEnv(env, "TALOS_PROVIDER_TIMEOUT_MS") ?? DEFAULT_RETRY.timeoutMs,
+        networkMaxRetries: intEnv(env, "TALOS_PROVIDER_NETWORK_MAX_RETRIES") ?? DEFAULT_RETRY.networkMaxRetries,
+        networkRetryDelayMs: intEnv(env, "TALOS_PROVIDER_NETWORK_RETRY_MS") ?? DEFAULT_RETRY.networkRetryDelayMs,
+        overloadMaxAttempts: intEnv(env, "TALOS_PROVIDER_OVERLOAD_MAX_ATTEMPTS") ?? DEFAULT_RETRY.overloadMaxAttempts,
+        overloadBaseDelayMs: intEnv(env, "TALOS_PROVIDER_OVERLOAD_BASE_MS") ?? DEFAULT_RETRY.overloadBaseDelayMs,
+        overloadMaxDelayMs: intEnv(env, "TALOS_PROVIDER_OVERLOAD_MAX_DELAY_MS") ?? DEFAULT_RETRY.overloadMaxDelayMs,
+    };
+}
+// Errore di sola RETE/connessione: timeout, reset, DNS, fetch fallita. Sono i
+// casi in cui "la connessione scade" e ha senso ritentare molte volte.
+export function isNetworkError(text) {
+    return /\b(timeout|timed out|econnreset|etimedout|enotfound|econnrefused|eai_again|epipe|socket hang up|fetch failed|network error|connection (?:reset|refused|closed|timed out))\b/i.test(text);
+}
+// Fallimento del modello a valle di un router (OpenRouter e simili): lo stream
+// si chiude con finish_reason "error" e nessuno status HTTP, perche' la
+// richiesta verso il router e' andata a buon fine — a fallire e' stato il
+// modello che il router ha scelto. Senza questa riga il caso non verrebbe
+// ritentato, ed e' invece quello in cui ritentare risolve piu' spesso: su una
+// rotta che smista, il tentativo successivo finisce su un altro modello.
+export function isUpstreamRouterError(text) {
+    return /errore upstream temporaneo|upstream (?:error|failure)|provider returned error/i.test(text);
+}
+// Errore transitorio (ritentabile): status 408/409/425/429/5xx, rete, oppure
+// fallimento del modello a valle di un router.
+export function isTransientError(text) {
+    if (/(?:\(|\bhttp\s+|["']?(?:status|statuscode|code)["']?\s*[:=]\s*)(408|409|425|429|5\d\d)\b/i.test(text))
+        return true;
+    if (isUpstreamRouterError(text))
+        return true;
+    return isNetworkError(text);
+}
+// Capacita' temporaneamente esaurita. La quota personale e il credito vengono
+// esclusi prima di questa classe: non vanno mascherati con retry inutili.
+export function isOverloadError(text) {
+    const t = text.toLowerCase();
+    if (/(?:\(|\bhttp\s+|["']?(?:status|statuscode|code)["']?\s*[:=]\s*)529\b/i.test(text))
+        return true;
+    return (/overload(?:ed|ing)?|overloaded_error/.test(t) ||
+        /model (?:is )?(?:busy|at capacity|unavailable)/.test(t) ||
+        /(?:server|provider|service) (?:is )?(?:busy|overloaded|at capacity)/.test(t) ||
+        /capacity (?:is )?(?:exhausted|unavailable|temporarily unavailable)/.test(t) ||
+        /high demand|temporarily unavailable/.test(t) ||
+        /(?:502|503|504).*(?:service unavailable|upstream|capacity|overload|busy)/.test(t));
+}
+// Rispetta l'eventuale indicazione del provider, per esempio `retry after 48s`
+// o un campo JSON `retry_after_ms`.
+export function retryAfterMs(text) {
+    const ms = text.match(/(?:retry[_\s-]*after[_\s-]*ms|retryafterms)["']?\s*[:=]\s*["']?(\d+(?:\.\d+)?)/i);
+    if (ms)
+        return Math.max(0, Math.round(Number(ms[1])));
+    const seconds = text.match(/(?:retry[_\s-]*after|try again in)\s*["']?\s*(\d+(?:\.\d+)?)\s*(?:s|sec|secondi?|seconds?)\b/i);
+    if (seconds)
+        return Math.max(0, Math.round(Number(seconds[1]) * 1000));
+    return undefined;
+}
+// Limite/quota dell'abbonamento o del credito: NON e' transitorio, ritentare e'
+// inutile. Copre Claude Code (Pro/Max), ChatGPT/Codex (Plus/Pro), OpenRouter e
+// le API key a consumo (Anthropic/OpenAI). Distinto dal rate-limit per-minuto:
+// qui si tratta di quota/credito/piano esauriti, non di "rallenta".
+export function isQuotaError(text) {
+    const t = cleanProviderText(text).toLowerCase();
+    // Payment Required: credito/piano esaurito (OpenRouter, gateway).
+    if (/\(402\)/.test(text))
+        return true;
+    return (/insufficient[_\s-]*quota/.test(t) ||
+        /insufficient[_\s-]*credits?/.test(t) ||
+        /credit balance is too low/.test(t) ||
+        /not enough credits|out of credits|no credits/.test(t) ||
+        /\bquota\b.*(exceed|reach|exhaust)|(?:exceed|reach|exhaust).*\bquota\b/.test(t) ||
+        /usage[_\s-]*limit/.test(t) ||
+        /\b(monthly|daily|weekly|session)[_\s-]*limit/.test(t) ||
+        (!/rate[_\s-]*limit|per[_\s-]*minute|requests per|tokens per/.test(t)
+            && /limit reached|reached your .*limit|you(?:'ve| have)? (?:reached|hit) .*limit/.test(t)) ||
+        /upgrade your plan|upgrade to (?:a )?paid|billing (?:hard|limit)|payment required/.test(t) ||
+        /plan[_\s-]*limit|subscription.*(?:limit|expired|inactive)/.test(t));
+}
+// Messaggio chiaro e azionabile per il limite abbonamento/quota, per provider.
+export function quotaMessage(providerId, original, limits) {
+    const detail = cleanProviderText(original).replace(/\s+/g, " ").trim().slice(0, 400);
+    const head = "Limite raggiunto";
+    const resetAt = quotaResetAt(limits) ?? providerResetAt(original);
+    const reset = resetAt ? ` Reset: ${new Date(resetAt).toLocaleString("it-IT", { dateStyle: "short", timeStyle: "short" })} (${new Date(resetAt).toISOString()}).` : "";
+    const subscription = providerId === "anthropic" && limits?.windows.some(w => w.id === "5h" || w.id === "7d" || w.id === "unified");
+    const body = (() => {
+        switch (subscription ? "claude-code" : providerId) {
+            case "claude-code":
+                return "quota dell'abbonamento Claude (Pro/Max) esaurita. Attendi il reset della finestra, oppure passa a una API key con `/model anthropic/...` (ANTHROPIC_API_KEY) o a un altro modello con /models.";
+            case "anthropic":
+                return "quota o credito Anthropic esaurito. Controlla il credito su console.anthropic.com, oppure cambia provider/modello con /models.";
+            case "chatgpt":
+                return "quota dell'abbonamento ChatGPT (Plus/Pro) esaurita. Attendi il reset, oppure usa una API key con `/model openai/...` (OPENAI_API_KEY) o un altro modello con /models.";
+            case "openai":
+                return "quota OpenAI esaurita (insufficient_quota). Verifica il billing su platform.openai.com, oppure cambia provider/modello con /models.";
+            case "openrouter":
+                return "crediti OpenRouter insufficienti o limite raggiunto. Ricarica su openrouter.ai/credits, oppure scegli un altro modello con /models.";
+            default:
+                return `limite/quota del provider ${providerId} raggiunto. Attendi il reset oppure cambia modello con /models.`;
+        }
+    })();
+    return `${head}.${reset} ${body}\n(dettaglio provider: ${detail})`;
+}
+function isAbort(err) {
+    return err instanceof Error && (err.name === "AbortError" || /abort/i.test(err.message));
+}
+function isNetworkThrow(err) {
+    return err instanceof Error && isNetworkError(`${err.name} ${err.message}`);
+}
+// Combina il signal del chiamante con un timeout per tentativo. `timedOut()`
+// distingue lo scadere del timeout (ritentabile) dall'abort dell'utente.
+function withTimeout(outer, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return { signal: outer, timedOut: () => false, cleanup: () => { } };
+    const ac = new AbortController();
+    let fired = false;
+    const onAbort = () => ac.abort();
+    if (outer.aborted)
+        ac.abort();
+    else
+        outer.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+        fired = true;
+        ac.abort();
+    }, timeoutMs);
+    return {
+        signal: ac.signal,
+        timedOut: () => fired,
+        cleanup: () => {
+            clearTimeout(timer);
+            outer.removeEventListener("abort", onAbort);
+        },
+    };
+}
+function delay(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const finish = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, ms);
+        signal.addEventListener("abort", finish, { once: true });
+    });
+}
+async function delayWithCountdown(ms, signal, onTick) {
+    const deadline = Date.now() + Math.max(0, ms);
+    let previous = -1;
+    while (!signal.aborted) {
+        const remainingMs = Math.max(0, deadline - Date.now());
+        if (remainingMs <= 0)
+            return;
+        const seconds = Math.max(1, Math.ceil(remainingMs / 1000));
+        if (seconds !== previous) {
+            previous = seconds;
+            onTick(seconds);
+        }
+        await delay(Math.min(1000, remainingMs), signal);
+    }
+}
+export class RetryProvider {
+    inner;
+    cfg;
+    constructor(inner, cfg) {
+        this.inner = inner;
+        this.cfg = cfg;
+    }
+    get id() {
+        return this.inner.id;
+    }
+    get label() {
+        return this.inner.label;
+    }
+    get models() {
+        return this.inner.models;
+    }
+    get supportsFastMode() { return this.inner.supportsFastMode === true; }
+    get netMax() {
+        return this.cfg.networkMaxRetries ?? 0;
+    }
+    get netDelay() {
+        return this.cfg.networkRetryDelayMs ?? DEFAULT_RETRY.networkRetryDelayMs ?? 2000;
+    }
+    get overloadMaxAttempts() {
+        return Math.max(1, this.cfg.overloadMaxAttempts ?? DEFAULT_RETRY.overloadMaxAttempts ?? 10);
+    }
+    overloadDelay(retryNumber, providerText) {
+        const requested = retryAfterMs(providerText);
+        if (requested !== undefined)
+            return requested;
+        const base = this.cfg.overloadBaseDelayMs ?? DEFAULT_RETRY.overloadBaseDelayMs ?? 3000;
+        const cap = this.cfg.overloadMaxDelayMs ?? DEFAULT_RETRY.overloadMaxDelayMs ?? 60000;
+        return Math.min(cap, base * 2 ** Math.max(0, retryNumber - 1));
+    }
+    async waitForOverload(req, nextAttempt, providerText) {
+        const waitMs = this.overloadDelay(nextAttempt - 1, providerText);
+        await delayWithCountdown(waitMs, req.signal, (seconds) => {
+            req.onActivity?.(`Modello sovraccarico · nuovo tentativo (${nextAttempt}/${this.overloadMaxAttempts}) · ${seconds}s`);
+        });
+    }
+    async complete(req) {
+        let netAttempt = 0;
+        let genAttempt = 0;
+        let attempt = 1;
+        let recoveringFromOverload = false;
+        for (;;) {
+            if (req.signal.aborted)
+                return { text: "Richiesta interrotta", toolCalls: [], stopReason: "error" };
+            const tm = withTimeout(req.signal, this.cfg.timeoutMs);
+            // I delta sono gia' osservabili dall'host; quelli dei tool possono aver
+            // avviato esecuzioni speculative. Non riprodurre un tentativo dopo aver
+            // consegnato output. Gli errori prima dello stream restano ritentabili.
+            let delivered = false;
+            let active = true;
+            try {
+                const result = await this.inner.complete({
+                    ...req, signal: tm.signal,
+                    ...(req.onDelta ? { onDelta: (chunk) => {
+                            if (!active || tm.signal.aborted)
+                                return;
+                            if (chunk)
+                                delivered = true;
+                            req.onDelta(chunk);
+                        } } : {}),
+                    ...(req.onToolDelta ? { onToolDelta: (event) => {
+                            if (!active || tm.signal.aborted)
+                                return;
+                            delivered = true;
+                            req.onToolDelta(event);
+                        } } : {}),
+                });
+                active = false;
+                tm.cleanup();
+                if (result.stopReason === "error") {
+                    // 1. Limite/quota abbonamento: stop, messaggio chiaro (no retry).
+                    if (isQuotaError(result.text) || rejectedQuotaWindows(result.limits).length > 0) {
+                        const limits = quotaLimitsFromError(this.id, result.text, result.limits);
+                        return { ...result, toolCalls: [], text: quotaMessage(this.id, result.text, limits), ...(limits ? { limits } : {}) };
+                    }
+                    if (delivered)
+                        return result;
+                    // 2. Modello saturo: retry dedicato, con countdown comunicato alla UI.
+                    if (isOverloadError(result.text) && attempt < this.overloadMaxAttempts && !req.signal.aborted) {
+                        const nextAttempt = attempt + 1;
+                        recoveringFromOverload = true;
+                        tm.cleanup();
+                        await this.waitForOverload(req, nextAttempt, result.text);
+                        attempt = nextAttempt;
+                        continue;
+                    }
+                    // 3. Rete/connessione scaduta: retry esteso a delay fisso.
+                    if (isNetworkError(result.text) && netAttempt < this.netMax && !req.signal.aborted) {
+                        netAttempt += 1;
+                        req.onActivity?.(`connessione fallita, riprovo (${netAttempt}/${this.netMax})…`);
+                        await delay(this.netDelay, req.signal);
+                        continue;
+                    }
+                    // 4. Altro transiente (429/5xx, fallimento upstream): backoff.
+                    if (isTransientError(result.text) && genAttempt < this.cfg.maxRetries && !req.signal.aborted) {
+                        genAttempt += 1;
+                        // Dire che si sta ritentando: senza, l'attesa e' silenzio e sembra
+                        // che l'agente si sia bloccato. Il fallimento upstream ha un testo
+                        // suo perche' e' l'unico che si risolve cambiando modello, e chi usa
+                        // una rotta che smista deve sapere che sta succedendo proprio quello.
+                        req.onActivity?.(isUpstreamRouterError(result.text)
+                            ? `il modello a monte ha fallito, riprovo (${genAttempt}/${this.cfg.maxRetries})…`
+                            : `errore temporaneo, riprovo (${genAttempt}/${this.cfg.maxRetries})…`);
+                        await delay(this.backoff(genAttempt), req.signal);
+                        continue;
+                    }
+                }
+                if (recoveringFromOverload && result.stopReason !== "error") {
+                    req.onActivity?.("Modello disponibile · riprendo il lavoro");
+                }
+                return result;
+            }
+            catch (err) {
+                active = false;
+                tm.cleanup();
+                const userAbort = req.signal.aborted;
+                const thrownText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+                if (!userAbort && isQuotaError(thrownText)) {
+                    const limits = quotaLimitsFromError(this.id, thrownText);
+                    return { text: quotaMessage(this.id, thrownText, limits), toolCalls: [], stopReason: "error", ...(limits ? { limits } : {}) };
+                }
+                if (delivered)
+                    throw err;
+                if (!userAbort && !isQuotaError(thrownText) && isOverloadError(thrownText) && attempt < this.overloadMaxAttempts) {
+                    const nextAttempt = attempt + 1;
+                    recoveringFromOverload = true;
+                    tm.cleanup();
+                    await this.waitForOverload(req, nextAttempt, thrownText);
+                    attempt = nextAttempt;
+                    continue;
+                }
+                // Timeout per-tentativo o errore di rete lanciato: retry esteso.
+                if (!userAbort && (tm.timedOut() || isNetworkThrow(err)) && netAttempt < this.netMax) {
+                    netAttempt += 1;
+                    req.onActivity?.(`connessione fallita, riprovo (${netAttempt}/${this.netMax})…`);
+                    await delay(this.netDelay, req.signal);
+                    continue;
+                }
+                // Solo gli altri errori realmente transitori ricevono il backoff classico.
+                if (!userAbort && !isAbort(err) && isTransientError(thrownText) && genAttempt < this.cfg.maxRetries) {
+                    genAttempt += 1;
+                    await delay(this.backoff(genAttempt), req.signal);
+                    continue;
+                }
+                throw err;
+            }
+            finally {
+                active = false;
+                tm.cleanup();
+            }
+        }
+    }
+    // Backoff esponenziale con jitter pieno.
+    backoff(attempt) {
+        const exp = this.cfg.baseDelayMs * 2 ** (attempt - 1);
+        return Math.round(exp * (0.5 + Math.random() * 0.5));
+    }
+}
+// La classificazione degli errori resta attiva anche con i retry disabilitati.
+export function withRetry(provider, cfg) {
+    const disabled = cfg.maxRetries <= 0 && cfg.timeoutMs <= 0 && (cfg.networkMaxRetries ?? 0) <= 0;
+    return new RetryProvider(provider, disabled && cfg.overloadMaxAttempts === undefined ? { ...cfg, overloadMaxAttempts: 1 } : cfg);
+}

package/dist/rpc/server.d.ts

@@ -0,0 +1,23 @@
+import type { AgentDeps } from "../core/agent.js";
+export interface RpcProtocolInfo {
+    readonly name: "vascend.talos-rpc";
+    readonly version: 2;
+    readonly requests: readonly string[];
+    readonly singleFlight: true;
+}
+export declare const RPC_PROTOCOL: RpcProtocolInfo;
+export declare class RpcTurnQueue {
+    private readonly onQueued?;
+    private readonly queue;
+    private current;
+    private draining;
+    constructor(onQueued?: ((id: string, position: number) => void) | undefined);
+    get runningId(): string | null;
+    get depth(): number;
+    push(id: string, run: (signal: AbortSignal) => Promise<void>): void;
+    abort(target?: string): string | null;
+    private drain;
+}
+export declare function startRpc(agent: AgentDeps, opts: {
+    autoApprove: boolean;
+}): void;

package/dist/rpc/server.js

@@ -0,0 +1,222 @@
+import * as readline from "node:readline";
+import { stdin, stdout } from "node:process";
+import { runTurn } from "../core/agent.js";
+import { createUserInbox } from "../core/user-inbox.js";
+import { HORIZON_CAPABILITIES } from "../horizon/engine.js";
+import { listSessions } from "../core/session.js";
+import { normalizeMcpToolResult, textFromMcpToolResult } from "../mcp/protocol.js";
+export const RPC_PROTOCOL = Object.freeze({
+    name: "vascend.talos-rpc",
+    version: 2,
+    requests: Object.freeze(["prompt", "send", "bash", "abort", "ping", "capabilities", "sessions"]),
+    singleFlight: true,
+});
+// Coda single-flight delle richieste che toccano la sessione (prompt/bash).
+// runTurn appende alla STESSA sessione: due turni concorrenti intreccerebbero
+// cronologia ed eventi. La coda serializza; abort interrompe il corrente o
+// rimuove un job non ancora partito.
+export class RpcTurnQueue {
+    onQueued;
+    queue = [];
+    current = null;
+    draining = false;
+    constructor(onQueued) {
+        this.onQueued = onQueued;
+    }
+    get runningId() {
+        return this.current?.id ?? null;
+    }
+    get depth() {
+        return this.queue.length + (this.current ? 1 : 0);
+    }
+    push(id, run) {
+        const job = { id, run, cancelled: false };
+        this.queue.push(job);
+        if (this.current || this.queue.length > 1)
+            this.onQueued?.(id, this.depth - 1);
+        void this.drain();
+    }
+    // Interrompe: senza target il turno IN CORSO; con target il job in corso (se
+    // combacia) oppure lo rimuove dalla coda. Ritorna l'id interrotto o null.
+    abort(target) {
+        if (this.current && (target === undefined || this.current.id === target)) {
+            const id = this.current.id;
+            this.current.controller.abort();
+            return id;
+        }
+        if (target === undefined)
+            return null;
+        const job = this.queue.find((j) => j.id === target && !j.cancelled);
+        if (!job)
+            return null;
+        job.cancelled = true;
+        return job.id;
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            for (;;) {
+                const job = this.queue.shift();
+                if (!job)
+                    return;
+                if (job.cancelled)
+                    continue;
+                const controller = new AbortController();
+                this.current = { id: job.id, controller };
+                try {
+                    await job.run(controller.signal);
+                }
+                catch {
+                    // il job gestisce i propri errori; qui si garantisce solo il drain
+                }
+                finally {
+                    this.current = null;
+                }
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+}
+export function startRpc(agent, opts) {
+    const rl = readline.createInterface({ input: stdin });
+    const emit = (id, event) => {
+        stdout.write(JSON.stringify({ id, event }) + "\n");
+    };
+    const queue = new RpcTurnQueue((id, position) => emit(id, { type: "queued", position }));
+    const confirm = async () => opts.autoApprove;
+    // Casella del turno in volo: la richiesta "send" ci deposita i messaggi che
+    // l'utente scrive mentre l'agente lavora. Nulla in volo = nessuna casella.
+    let activeInbox = null;
+    rl.on("line", (raw) => {
+        if (!raw.trim())
+            return;
+        let req;
+        try {
+            req = JSON.parse(raw);
+        }
+        catch {
+            emit(null, { type: "error", message: "json non valido", code: "RPC_BAD_JSON" });
+            return;
+        }
+        const id = typeof req.id === "string" && req.id ? req.id : null;
+        if (!id) {
+            emit(null, { type: "error", message: "id richiesta mancante", code: "RPC_BAD_REQUEST" });
+            return;
+        }
+        switch (req.type) {
+            case "ping":
+                emit(id, { type: "pong" });
+                return;
+            case "capabilities":
+                emit(id, { type: "capabilities", capabilities: HORIZON_CAPABILITIES, protocol: RPC_PROTOCOL });
+                emit(id, { type: "done" });
+                return;
+            case "sessions": {
+                try {
+                    emit(id, { type: "sessions", sessions: listSessions(agent.config.sessionDir) });
+                    emit(id, { type: "done" });
+                }
+                catch (err) {
+                    emit(id, { type: "error", message: err.message, code: "RPC_SESSIONS" });
+                }
+                return;
+            }
+            case "abort": {
+                const target = queue.abort(req.target);
+                if (target)
+                    emit(id, { type: "aborted", target });
+                else
+                    emit(id, { type: "error", message: "nessun turno da interrompere", code: "RPC_NOT_RUNNING" });
+                return;
+            }
+            case "bash": {
+                const request = req;
+                queue.push(id, (signal) => runBash(agent, request, confirm, signal, (e) => emit(id, e)));
+                return;
+            }
+            case "send": {
+                const text = String(request_text(req));
+                if (!text.trim()) {
+                    emit(id, { type: "error", message: "messaggio vuoto", code: "RPC_BAD_REQUEST" });
+                    return;
+                }
+                const target = queue.runningId;
+                if (!target || !activeInbox) {
+                    // Niente turno in volo: sta al client mandarlo come prompt normale.
+                    emit(id, { type: "error", message: "nessun turno in corso", code: "RPC_NOT_RUNNING" });
+                    return;
+                }
+                const messageId = activeInbox.push(text, typeof req.messageId === "string" ? req.messageId : undefined);
+                emit(id, { type: "accepted", messageId, target });
+                emit(id, { type: "done" });
+                return;
+            }
+            case "prompt": {
+                const text = String(request_text(req));
+                if (!text.trim()) {
+                    emit(id, { type: "error", message: "prompt vuoto", code: "RPC_BAD_REQUEST" });
+                    return;
+                }
+                queue.push(id, async (signal) => {
+                    if (signal.aborted) {
+                        emit(id, { type: "error", message: "interrotto", code: "RPC_ABORTED" });
+                        return;
+                    }
+                    let finished = false;
+                    const inbox = createUserInbox();
+                    activeInbox = inbox;
+                    await runTurn({ ...agent, confirm, inbox }, text, (event) => {
+                        if (event.type === "done" || event.type === "error")
+                            finished = true;
+                        emit(id, event);
+                    }, signal).finally(() => {
+                        if (activeInbox === inbox)
+                            activeInbox = null;
+                    });
+                    // runTurn chiude sempre con done|error; questa e' una rete di
+                    // sicurezza per garantire il contratto anche su regressioni future.
+                    if (!finished)
+                        emit(id, { type: "done" });
+                });
+                return;
+            }
+            default:
+                emit(id, { type: "error", message: `richiesta sconosciuta: ${String(req.type)}`, code: "RPC_UNKNOWN_TYPE" });
+        }
+    });
+}
+function request_text(req) {
+    return typeof req.text === "string" ? req.text : "";
+}
+// Esegue un comando bash fuori dal loop dell'agente. Con excludeFromContext
+// (default true) l'esito non entra nella cronologia della sessione.
+async function runBash(agent, req, confirm, signal, emit) {
+    const tool = agent.tools.get("bash");
+    if (!tool) {
+        emit({ type: "error", message: "strumento bash non disponibile", code: "RPC_NO_TOOL" });
+        return;
+    }
+    const call = { type: "tool_call", id: `bash-${Date.now().toString(36)}`, name: "bash", input: { command: req.command } };
+    emit({ type: "tool_call", call });
+    let output;
+    let isError = false;
+    try {
+        const handled = await tool.handler({ command: req.command }, { cwd: agent.config.cwd, signal, confirm });
+        output = textFromMcpToolResult(normalizeMcpToolResult(handled));
+    }
+    catch (err) {
+        output = `eccezione: ${err.message}`;
+        isError = true;
+    }
+    const result = { type: "tool_result", callId: call.id, output, isError };
+    emit({ type: "tool_result", result });
+    if (req.excludeFromContext === false) {
+        agent.session.append({ role: "user", content: [{ type: "text", text: `$ ${req.command}` }] });
+        agent.session.append({ role: "tool", content: [result] });
+    }
+    emit({ type: "done" });
+}

package/dist/sdk.d.ts

@@ -0,0 +1,67 @@
+export { bootstrap } from "./core/bootstrap.js";
+export type { Harness } from "./core/bootstrap.js";
+export { runTurn } from "./core/agent.js";
+export type { AgentDeps } from "./core/agent.js";
+export { FileCoordinationHub, fileActor, formatFileConflicts, withFileActor } from "./core/file-coordination.js";
+export type { FileActivityMode, FileActor, FileActorKind, FileCoordinationContext, FileCoordinationEvent, FileLease, FileLeaseResult, FilePresence, } from "./core/file-coordination.js";
+export { createUserInbox, pendingText } from "./core/user-inbox.js";
+export { WorkspaceSession, workspaceSessionKey } from "./core/workspace-sessions.js";
+export type { WorkspacePeer, WorkspaceMessage } from "./core/workspace-sessions.js";
+export type { UserInbox, PendingUserMessage } from "./core/user-inbox.js";
+export { Session } from "./core/session.js";
+export type { SessionNode } from "./core/session.js";
+export { ToolRegistry } from "./tools/registry.js";
+export { registerComputerUse } from "./tools/computer-use.js";
+export type { ComputerUseModule } from "./tools/computer-use.js";
+export { executionPathKey, executionTargetKey, localExecutionTarget, normalizeExecutionTarget, workspaceUri, } from "./core/execution-target.js";
+export type { ExecutionCapabilities, ExecutionPlatform, ExecutionTarget, ExecutionTargetKind, } from "./core/execution-target.js";
+export { MCP_APP_MIME_TYPE, MCP_PROTOCOL_VERSION, MCP_UI_EXTENSION_ID, isToolVisibleToModel, mcpAppUiMeta, normalizeMcpToolResult, supportsMcpApps, textFromMcpToolResult, toolDefinitionForCapabilities, toolInputSchema, } from "./mcp/protocol.js";
+export type { JsonSchema, McpAppUiMeta, McpCallToolResult, McpContentBlock, McpMeta, McpToolAnnotations, McpToolDefinition, } from "./mcp/protocol.js";
+export { builtinTools } from "./tools/builtin.js";
+export { resolveTool } from "./tools/resolve.js";
+export { executeTool } from "./tools/execute.js";
+export { ProviderRegistry, defaultRegistry } from "./providers/registry.js";
+export { ModelRegistry, loadModelRegistry } from "./providers/model-registry.js";
+export type { ModelInfo, CostEstimate } from "./providers/model-registry.js";
+export { KnowledgeBase, knowledgeBase } from "./vascend/competitor-knowledge.js";
+export type { Competitor, BestPractice, MarketStandard, ComparisonVerdict, Category, Importance, } from "./vascend/competitor-knowledge.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { PROVIDER_CATALOG } from "./providers/catalog.js";
+export type { ProviderSpec } from "./providers/catalog.js";
+export { buildConfig, BASE_SYSTEM } from "./core/config.js";
+export type { PiConfig, TalosBanner, TalosColor, TalosUiConfig } from "./core/config.js";
+export { VIBE_MODE_IDS, listVibeModes, parseVibeMode, routeVibeMode, vibeModeSpec, } from "./core/vibe-modes.js";
+export type { VibeModeContextRecipe, VibeModeId, VibeModeRoute, VibeModeSelection, VibeModeSpec, } from "./core/vibe-modes.js";
+export { buildContextFabric, contextFramePath, contextProjectKey, loadContextFrame, renderContextFrame, resetContextFrame, updateContextPins, } from "./vascend/context-fabric.js";
+export type { ContextFabricCompileOptions, ContextFabricInput, ContextFabricResult, ContextFrame, ContextLease, ContextLeaseSource, ContextReceipt, } from "./vascend/context-fabric.js";
+export { memoryStatus } from "./vascend/memory-status.js";
+export type { MemoryFrontierNode, MemoryStatus } from "./vascend/memory-status.js";
+export { buildContextLedger } from "./core/context-ledger.js";
+export { applyMediaEviction, applyToolResultDemotion, mediaBudgetPolicy, planMediaEviction, planToolResultDemotion, slimMessageForSession, slimToolResultForSession, toolIndexPolicy, DEFAULT_MEDIA_BUDGET, DEFAULT_TOOL_INDEX, } from "./core/tool-result-index.js";
+export type { DemotedRef, MediaBudgetPolicy, MediaEvictionPlan, ToolIndexPlan, ToolIndexPolicy, } from "./core/tool-result-index.js";
+export { ToolOutputStore } from "./core/tool-result-store.js";
+export type { StoredToolOutput } from "./core/tool-result-store.js";
+export { claim, claimable, complete, counts, expire, fail, formatQueue, heartbeat, makeItem, WorkQueue, DEFAULT_LEASE_MS, DEFAULT_MAX_ATTEMPTS, } from "./vascend/work-queue.js";
+export type { NewWorkItem, QueueCounts, WorkItem, WorkItemState } from "./vascend/work-queue.js";
+export { runWorkLoop } from "./vascend/work-runner.js";
+export type { GateOutcome, ItemOutcome, LoopEvent, LoopReport, StopReason, WorkLoopDeps, WorkLoopOptions, } from "./vascend/work-runner.js";
+export { briefFor, createFreshAgentRunner, parseOutcome } from "./vascend/work-agent.js";
+export type { FreshAgentOptions } from "./vascend/work-agent.js";
+export type { ContextBlockInput, ContextHeavyItem, ContextHistoryStats, ContextLedger, ContextPackStats, ContextSlice, } from "./core/context-ledger.js";
+export { buildArchitectureMap, renderArchitectureMap, scanArchitectureMap, } from "./vascend/architecture-map.js";
+export type { ArchDependency, ArchEntryPoint, ArchExternal, ArchHotspot, ArchModuleStat, ArchSourceFile, ArchitectureMap, } from "./vascend/architecture-map.js";
+export { doctorExitCode, renderDoctorReport, runDoctor } from "./core/doctor.js";
+export type { DoctorCheck, DoctorReport, DoctorStatus } from "./core/doctor.js";
+export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonEngine, HorizonMainTeam, needsGuideArbitration, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./horizon/index.js";
+export type { HorizonCapabilityDescriptor, HorizonContextStatus, HorizonEngineOptions, HorizonEngineState, HorizonModelCatalog, HorizonModelDescriptor, HorizonModelInspectionOptions, HorizonProviderDescriptor, HorizonRuntime, HorizonSessionListItem, HorizonSessionSnapshot, HorizonTurn, HorizonTurnInput, HorizonTurnOptions, HorizonTurnResult, HorizonTurnStatus, HorizonVibeStatus, } from "./horizon/index.js";
+export type { HorizonGuideCooperation, HorizonGuideDecision, HorizonGuideDecisionRecord, HorizonGuideDecisionRequest, HorizonGuidePlan, HorizonGuideTask, HorizonGuideVerdict, HorizonMainExchange, HorizonMainRef, HorizonMainTeamConfig, HorizonMainTeamEvent, HorizonMainTeamResult, HorizonMainTeamTurn, HorizonTeamRef, HorizonAgentPurpose, } from "./horizon/index.js";
+export type { AgentEvent, EventSink, Message, ContentPart, Tool, ToolDef, ToolRegistrationDef, RegisteredTool, ToolHandler, ToolHandlerOutput, ToolContext, ImagePart, Provider, ModelTurn, CompletionRequest, } from "./core/types.js";
+export type { Extension, ExtensionApi, SlashCommand, } from "./extensions/types.js";
+export { CoworkManager, localIdentity, CoworkStore, CoworkSyncChannel, CoworkEngine, createCoworkIpc, createCoworkClient, } from "./cowork/index.js";
+export type { CoworkIdentity, CoworkWorkspace, CoworkSession, CoworkMember, CoworkMessage, CoworkSyncEvent, CoworkPresence, CoworkIpcApi, CoworkClient, } from "./cowork/index.js";
+export { kingdomLive, KingdomLive } from "./vascend/kingdom-live.js";
+export type { LiveVassal, DeliveryOutcome } from "./vascend/kingdom-live.js";
+export { loadModelsDev, cachedModelCatalog, modelCapabilities } from "./providers/models-dev.js";
+export { ModelCatalog, parseModelCatalog } from "./providers/model-catalog.js";
+export type { CatalogModel, ReasoningOption } from "./providers/model-catalog.js";
+export { modelEfforts } from "./providers/model-effort.js";