@vascend/talos 0.1.0

package/dist/horizon/engine.js

@@ -0,0 +1,603 @@
+import { existsSync, readFileSync } from "node:fs";
+import { bootstrap } from "../core/bootstrap.js";
+import { buildConfig } from "../core/config.js";
+import { prepareSessionStorage } from "../core/session-storage.js";
+import { applyStoredCredentials, credentialsPath } from "../core/credentials.js";
+import { runTurn } from "../core/agent.js";
+import { createUserInbox } from "../core/user-inbox.js";
+import { runKingdomForHost } from "../vascend/kingdom-run.js";
+import { FileCoordinationHub, fileActor } from "../core/file-coordination.js";
+import { listSessions, sessionFilePath } from "../core/session.js";
+import { defaultRegistry, resolveStartupModel } from "../providers/registry.js";
+import { listVibeModes, parseVibeMode, VIBE_MODE_IDS } from "../core/vibe-modes.js";
+import { contextProjectKey, loadContextFrame, renderContextFrame, resetContextFrame, updateContextPins, } from "../vascend/context-fabric.js";
+import { AsyncQueue } from "./async-queue.js";
+import { MCP_APP_MIME_TYPE, MCP_PROTOCOL_VERSION, MCP_UI_EXTENSION_ID } from "../mcp/protocol.js";
+const DEFAULT_RUNTIME = { bootstrap, runTurn };
+const deny = async () => false;
+export const HORIZON_CAPABILITIES = Object.freeze({
+    protocol: "vascend.horizon-engine",
+    protocolVersion: 1,
+    product: Object.freeze({ name: "Horizon", core: "Talos", headless: true, electron: false }),
+    lifecycle: Object.freeze(["create", "close"]),
+    sessions: Object.freeze(["current", "list", "new", "resume", "rename"]),
+    models: Object.freeze({
+        identifiers: "provider/model",
+        operations: Object.freeze(["catalog", "select", "reload"]),
+        configuredOnly: true,
+    }),
+    turns: Object.freeze({
+        stream: "async-iterable",
+        concurrency: "single-flight",
+        abort: true,
+        inputs: Object.freeze(["text", "content-parts"]),
+        ephemeralContext: true,
+        // L'host puo' consegnare messaggi a turno in corso: entrano al primo
+        // confine sicuro e l'evento `user_message` ne annuncia la presa in carico.
+        midTurnInput: true,
+    }),
+    mainTeam: Object.freeze({
+        agents: Object.freeze([1, 2]),
+        stableRefs: Object.freeze(["r1", "r2"]),
+        supervisor: true,
+        contextSharing: "explicit-exchanges-only",
+    }),
+    context: Object.freeze({
+        paradigm: "epoch-lease-lens",
+        operations: Object.freeze(["status", "pin", "unpin", "reset"]),
+        receipts: true,
+    }),
+    vibe: Object.freeze({ routing: Object.freeze(["auto", "explicit"]), modes: Object.freeze([...VIBE_MODE_IDS]) }),
+    permissions: Object.freeze({ default: "deny", hostGate: true }),
+    fileCoordination: Object.freeze({
+        modes: Object.freeze(["viewing", "editing", "writing"]),
+        writePolicy: "exclusive",
+        humanPresence: true,
+        nestedAgents: true,
+    }),
+    mcp: Object.freeze({
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        toolSchema: "inputSchema",
+        callToolResult: true,
+        apps: Object.freeze({ extension: MCP_UI_EXTENSION_ID, mimeType: MCP_APP_MIME_TYPE }),
+    }),
+});
+export class HorizonStateError extends Error {
+    code = "HORIZON_INVALID_STATE";
+    constructor(message) {
+        super(message);
+        this.name = "HorizonStateError";
+    }
+}
+export class HorizonSessionNotFoundError extends Error {
+    sessionId;
+    code = "HORIZON_SESSION_NOT_FOUND";
+    constructor(sessionId) {
+        super(`sessione Horizon non trovata: ${sessionId}`);
+        this.sessionId = sessionId;
+        this.name = "HorizonSessionNotFoundError";
+    }
+}
+export class HorizonContextUnavailableError extends Error {
+    code = "HORIZON_CONTEXT_UNAVAILABLE";
+    constructor() {
+        super("nessun epoch attivo: esegui almeno un turno prima di modificare i pin");
+        this.name = "HorizonContextUnavailableError";
+    }
+}
+function normalizedWorkerModelPool(value) {
+    if (value === undefined)
+        return undefined;
+    const out = [];
+    const seen = new Set();
+    for (const raw of value) {
+        const model = String(raw || "").trim();
+        if (!/^[a-z0-9][a-z0-9._+:/@-]*$/i.test(model) || seen.has(model))
+            continue;
+        seen.add(model);
+        out.push(model);
+        if (out.length >= 32)
+            break;
+    }
+    return out;
+}
+/** Applica il pool autorizzato senza permettere override arbitrari dal modello. */
+export function routeWorkerModels(castles, configuredPool) {
+    const pool = normalizedWorkerModelPool(configuredPool);
+    if (pool === undefined)
+        return castles;
+    if (!pool.length)
+        throw new Error("nessun modello collaboratore autorizzato dall'utente");
+    const allowed = new Set(pool);
+    return castles.map((castle, index) => {
+        const requested = String(castle.model || "").trim();
+        if (requested && !allowed.has(requested)) {
+            throw new Error(`modello collaboratore non autorizzato: ${requested}`);
+        }
+        return { ...castle, model: requested || pool[index % pool.length] };
+    });
+}
+/**
+ * Facade headless ufficiale di Talos per Vascend Terminal/Horizon.
+ *
+ * Invarianti del contratto:
+ * - nessuna dipendenza Electron o TUI;
+ * - un solo turno in volo per engine/sessione;
+ * - eventi ordinati su AsyncIterable, con completamento sempre osservabile;
+ * - cambio sessione, vibe e context mutation vietati durante un turno;
+ * - permission gate deny-by-default, fornito dal processo host.
+ */
+export class HorizonEngine {
+    harness;
+    options;
+    runtime;
+    stateValue = "ready";
+    active = null;
+    turnSequence = 0;
+    constructor(harness, options, runtime) {
+        this.harness = harness;
+        this.options = options;
+        this.runtime = runtime;
+    }
+    static async create(options = {}, runtime = DEFAULT_RUNTIME) {
+        // Nel contratto Horizon un sessionId significa sempre RESUME. Il bootstrap
+        // core resta tollerante per la CLI storica, ma l'host grafico deve sapere
+        // se il file e' sparito: accettarlo come sessione vuota farebbe saltare il
+        // recovery della chat e perderebbe il contesto senza alcun errore.
+        if (runtime === DEFAULT_RUNTIME && options.sessionId !== undefined) {
+            const env = applyStoredCredentials(options.env ?? process.env);
+            const config = buildConfig({
+                ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                ...(options.model !== undefined ? { model: options.model } : {}),
+                env,
+            });
+            const sessionFile = sessionFilePath(config.sessionDir, options.sessionId);
+            prepareSessionStorage(config, env);
+            if (!existsSync(sessionFile)) {
+                throw new HorizonSessionNotFoundError(options.sessionId);
+            }
+        }
+        const harness = await runtime.bootstrap({
+            ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+            ...(options.fsRoots !== undefined ? { fsRoots: options.fsRoots } : {}),
+            ...(options.executionTarget !== undefined ? { executionTarget: options.executionTarget } : {}),
+            ...(options.model !== undefined ? { model: options.model } : {}),
+            ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+            ...(options.continueLast !== undefined ? { continueLast: options.continueLast } : {}),
+            ...(options.sessionName !== undefined ? { sessionName: options.sessionName } : {}),
+            ...(options.env !== undefined ? { env: options.env } : {}),
+            ...(options.trustPrompt !== undefined ? { trustPrompt: options.trustPrompt } : {}),
+        });
+        const workerModelPool = normalizedWorkerModelPool(options.workerModelPool);
+        if (workerModelPool !== undefined) {
+            harness.config = { ...harness.config, workerModelPool };
+        }
+        await options.configureHarness?.(harness);
+        const fileCoordination = options.fileCoordination ?? {
+            hub: new FileCoordinationHub(harness.config.cwd, harness.executionTarget),
+            actor: fileActor(`horizon:${harness.session.id}`, "Horizon", "main"),
+        };
+        return new HorizonEngine(harness, { ...options, fileCoordination }, runtime);
+    }
+    /**
+     * Ispeziona i modelli realmente instradabili senza avviare Talos. Usa le
+     * stesse credenziali persistite e lo stesso ProviderRegistry del bootstrap,
+     * ma non crea Harness, sessioni, tool, estensioni o stato nel workspace.
+     */
+    static inspectModels(options = {}) {
+        const env = applyStoredCredentials(options.env ?? process.env);
+        const providers = defaultRegistry(env);
+        const requested = inspectionModelPreference(options.model, env);
+        const effective = resolveStartupModel(providers, requested).model;
+        return modelCatalog(providers, effective);
+    }
+    get state() {
+        return this.stateValue;
+    }
+    get capabilities() {
+        return HORIZON_CAPABILITIES;
+    }
+    get session() {
+        this.assertOpen();
+        return this.sessionSnapshot();
+    }
+    listSessions() {
+        this.assertOpen();
+        return listSessions(this.harness.config.sessionDir);
+    }
+    newSession(options = {}) {
+        this.assertMutable();
+        const session = this.harness.newSession();
+        if (options.name !== undefined)
+            session.setName(options.name);
+        return this.sessionSnapshot();
+    }
+    resumeSession(id) {
+        this.assertMutable();
+        if (!existsSync(sessionFilePath(this.harness.config.sessionDir, id))) {
+            throw new HorizonSessionNotFoundError(id);
+        }
+        this.harness.loadSession(id);
+        return this.sessionSnapshot();
+    }
+    renameSession(name) {
+        this.assertMutable();
+        this.harness.session.setName(name);
+        return this.sessionSnapshot();
+    }
+    setModel(model) {
+        this.assertMutable();
+        this.harness.setModel(model);
+        return this.sessionSnapshot();
+    }
+    /**
+     * Catalogo autoritativo per il selector dell'host. Non usa il catalogo
+     * statico: legge ogni volta il ProviderRegistry corrente, quindi non espone
+     * provider privi di credenziali e riflette subito setModel/reloadProviders.
+     */
+    modelCatalog() {
+        this.assertOpen();
+        return modelCatalog(this.harness.providers, this.harness.config.model);
+    }
+    /** Rilegge le credenziali Talos e restituisce nello stesso giro il catalogo aggiornato. */
+    reloadProviders() {
+        this.assertMutable();
+        this.harness.reloadProviders();
+        return this.modelCatalog();
+    }
+    vibe() {
+        this.assertOpen();
+        return { selected: this.harness.config.vibeMode, modes: listVibeModes() };
+    }
+    setVibeMode(value) {
+        this.assertMutable();
+        const selection = parseVibeMode(value);
+        if (!selection)
+            throw new TypeError(`modalita' vibe non valida: ${String(value)}`);
+        this.harness.config = { ...this.harness.config, vibeMode: selection };
+        return this.vibe();
+    }
+    contextStatus() {
+        this.assertOpen();
+        return this.contextSnapshot(this.currentFrame());
+    }
+    pinContext(values) {
+        this.assertMutable();
+        const current = this.currentFrame();
+        if (!current || current.reset)
+            throw new HorizonContextUnavailableError();
+        const frame = updateContextPins({
+            sessionDir: this.harness.config.sessionDir,
+            frameId: this.harness.session.id,
+            cwd: this.harness.config.cwd,
+            add: normalizeValues(values),
+        });
+        if (!frame)
+            throw new HorizonContextUnavailableError();
+        return this.contextSnapshot(frame);
+    }
+    unpinContext(values) {
+        this.assertMutable();
+        const current = this.currentFrame();
+        if (!current || current.reset)
+            throw new HorizonContextUnavailableError();
+        const frame = updateContextPins({
+            sessionDir: this.harness.config.sessionDir,
+            frameId: this.harness.session.id,
+            cwd: this.harness.config.cwd,
+            remove: normalizeValues(values),
+        });
+        if (!frame)
+            throw new HorizonContextUnavailableError();
+        return this.contextSnapshot(frame);
+    }
+    resetContext(options = {}) {
+        this.assertMutable();
+        const frame = resetContextFrame({
+            sessionDir: this.harness.config.sessionDir,
+            frameId: this.harness.session.id,
+            cwd: this.harness.config.cwd,
+            selection: this.harness.config.vibeMode,
+            ...(options.preservePins !== undefined ? { preservePins: options.preservePins } : {}),
+        });
+        return this.contextSnapshot(frame);
+    }
+    startTurn(input, options = {}) {
+        this.assertMutable();
+        if (!validInput(input))
+            throw new TypeError("il turno Horizon richiede testo o almeno una content part");
+        const sessionId = this.harness.session.id;
+        const id = `${sessionId}:${Date.now().toString(36)}:${(++this.turnSequence).toString(36)}`;
+        const controller = new AbortController();
+        const queue = new AsyncQueue();
+        let resolveDone;
+        const done = new Promise((resolve) => { resolveDone = resolve; });
+        // Casella per i messaggi che l'utente scrive mentre questo turno lavora.
+        const inbox = createUserInbox();
+        const active = { id, controller, done, inbox, finished: false };
+        this.active = active;
+        this.stateValue = "running";
+        let finalText = "";
+        let sawDone = false;
+        let sawError = false;
+        let lastStopReason;
+        const emit = (event) => {
+            if (event.type === "turn_start")
+                finalText = "";
+            else if (event.type === "tool_call")
+                finalText = "";
+            else if (event.type === "text")
+                finalText += event.delta;
+            else if (event.type === "turn_end")
+                lastStopReason = event.stopReason;
+            else if (event.type === "done")
+                sawDone = true;
+            else if (event.type === "error")
+                sawError = true;
+            queue.push(event);
+            try {
+                options.onEvent?.(event);
+            }
+            catch { /* il renderer host non governa il core */ }
+        };
+        void (async () => {
+            let status = "completed";
+            let error;
+            try {
+                const confirm = options.confirm ?? this.options.confirm ?? deny;
+                const base = this.harness.deps(confirm);
+                // Kingdoms Mode NON e' piu' un privilegio della TUI: se l'host non
+                // fornisce il suo orchestratore, il motore ne mette uno che emette
+                // eventi strutturati sullo stesso sink del turno. Senza, il tool
+                // rispondeva "solo TUI" e in chat il parallelismo non esisteva.
+                const spawnKingdom = options.spawnKingdom ?? this.options.spawnKingdom
+                    ?? ((castles, kopts) => runKingdomForHost({
+                        harness: this.harness,
+                        castles: routeWorkerModels(castles, this.options.workerModelPool),
+                        signal: controller.signal,
+                        sink: emit,
+                        confirm,
+                        ask: options.ask ?? this.options.ask,
+                        ...(base.fileCoordination ? { fileCoordination: base.fileCoordination } : {}),
+                        ...(kopts?.baseBranch ? { baseBranch: kopts.baseBranch } : {}),
+                        ...(kopts?.detach ? { detach: true } : {}),
+                    }));
+                const ephemeralContext = options.ephemeralContext !== undefined
+                    ? options.ephemeralContext
+                    : this.options.ephemeralContext;
+                await this.runtime.runTurn({
+                    ...base,
+                    inbox,
+                    spawnKingdom,
+                    ...(this.options.fileCoordination ? { fileCoordination: this.options.fileCoordination } : {}),
+                    ...(options.fsRoots !== undefined ? { fsRoots: options.fsRoots } : {}),
+                    ...(ephemeralContext !== undefined ? { ephemeralContext } : {}),
+                    ...(options.ask ?? this.options.ask ? { ask: options.ask ?? this.options.ask } : {}),
+                }, input, (event) => {
+                    if (event.type === "error") {
+                        status = controller.signal.aborted ? "aborted" : "failed";
+                        error = event.message;
+                    }
+                    emit(event);
+                }, controller.signal);
+                if (controller.signal.aborted)
+                    status = "aborted";
+                if (status === "completed" && !finalText.trim()) {
+                    status = "failed";
+                    error = "Il runtime Talos ha terminato senza una risposta finale; il task non e' stato dichiarato completato.";
+                    if (!sawError)
+                        emit({ type: "error", message: error });
+                }
+                else if (status === "completed" && !sawDone && this.runtime === DEFAULT_RUNTIME) {
+                    status = "failed";
+                    error = "Il runtime Talos si e' chiuso senza l'evento terminale `done`; la sessione e' conservata e puo' essere ripresa.";
+                    if (!sawError)
+                        emit({ type: "error", message: error });
+                }
+            }
+            catch (cause) {
+                status = controller.signal.aborted ? "aborted" : "failed";
+                error = errorMessage(cause);
+                emit({ type: "error", message: error });
+            }
+            finally {
+                if (this.options.fileCoordination) {
+                    this.options.fileCoordination.hub.clearActor(this.options.fileCoordination.actor.id);
+                }
+                active.finished = true;
+                queue.close();
+                if (this.active === active)
+                    this.active = null;
+                if (this.stateValue === "running")
+                    this.stateValue = "ready";
+                resolveDone({
+                    id,
+                    sessionId,
+                    status,
+                    ...(error !== undefined ? { error } : {}),
+                    ...(finalText.trim() ? { finalText: finalText.trim() } : {}),
+                    ...(lastStopReason !== undefined ? { stopReason: lastStopReason } : {}),
+                    ...(sawError ? { terminalEvent: "error" } : sawDone ? { terminalEvent: "done" } : {}),
+                });
+            }
+        })();
+        return {
+            id,
+            sessionId,
+            events: queue,
+            done,
+            abort: () => {
+                if (controller.signal.aborted || this.active !== active)
+                    return false;
+                controller.abort();
+                return true;
+            },
+            send: (message, messageId) => {
+                // A turno concluso la consegna fallisce invece di sparire in silenzio:
+                // l'host deve poterlo trasformare in un turno nuovo.
+                if (active.finished || controller.signal.aborted)
+                    return null;
+                if (!validInput(message))
+                    throw new TypeError("il messaggio Horizon richiede testo o almeno una content part");
+                return inbox.push(typeof message === "string" ? message : message, messageId);
+            },
+            prioritize: (messageId) => {
+                if (active.finished || controller.signal.aborted)
+                    return false;
+                return inbox.promote(messageId);
+            },
+        };
+    }
+    /**
+     * Consegna un messaggio al turno attualmente in corso, senza doverne
+     * conservare il riferimento. Null se in questo momento non c'e' nulla in
+     * volo: sta all'host aprire allora un turno normale.
+     */
+    sendToActiveTurn(input, id) {
+        this.assertOpen();
+        const active = this.active;
+        if (!active || active.finished || active.controller.signal.aborted)
+            return null;
+        if (!validInput(input))
+            throw new TypeError("il messaggio Horizon richiede testo o almeno una content part");
+        return active.inbox.push(typeof input === "string" ? input : input, id);
+    }
+    abortTurn(id) {
+        this.assertOpen();
+        if (!this.active || (id !== undefined && this.active.id !== id) || this.active.controller.signal.aborted) {
+            return false;
+        }
+        this.active.controller.abort();
+        return true;
+    }
+    async close() {
+        if (this.stateValue === "closed")
+            return;
+        this.stateValue = "closing";
+        const active = this.active;
+        if (active) {
+            active.controller.abort();
+            await active.done;
+        }
+        this.harness.dispose?.();
+        this.stateValue = "closed";
+    }
+    sessionSnapshot() {
+        return {
+            id: this.harness.session.id,
+            name: this.harness.session.name,
+            headId: this.harness.session.head,
+            messages: this.harness.session.history().length,
+            model: this.harness.config.model,
+            vibeMode: this.harness.config.vibeMode,
+        };
+    }
+    currentFrame() {
+        return loadContextFrame(this.harness.config.sessionDir, this.harness.session.id, contextProjectKey(this.harness.config.cwd), false);
+    }
+    contextSnapshot(frame) {
+        const active = Boolean(frame && !frame.reset);
+        return {
+            active,
+            epoch: frame?.epoch ?? null,
+            turn: frame?.turn ?? 0,
+            mode: active ? frame?.activeMode ?? null : null,
+            selection: frame?.selection ?? this.harness.config.vibeMode,
+            mission: active ? frame?.mission ?? "" : "",
+            pins: frame?.leases.filter((lease) => lease.source === "pinned").map((lease) => lease.term) ?? [],
+            leases: frame?.leases ?? [],
+            receipt: active ? frame?.receipt ?? null : null,
+            summary: renderContextFrame(frame),
+        };
+    }
+    assertOpen() {
+        if (this.stateValue === "closed" || this.stateValue === "closing") {
+            throw new HorizonStateError(`engine Horizon ${this.stateValue}`);
+        }
+    }
+    assertMutable() {
+        this.assertOpen();
+        if (this.active)
+            throw new HorizonStateError("un turno Horizon e' gia' in corso");
+    }
+}
+function normalizeValues(values) {
+    const list = typeof values === "string" ? [values] : values;
+    const normalized = list.map((value) => value.trim()).filter(Boolean);
+    if (!normalized.length)
+        throw new TypeError("specifica almeno un valore di contesto non vuoto");
+    return normalized;
+}
+function validInput(input) {
+    return typeof input === "string" ? input.trim().length > 0 : input.length > 0;
+}
+function errorMessage(value) {
+    return value instanceof Error ? value.message : String(value);
+}
+function modelDescriptor(provider, modelId) {
+    return {
+        id: `${provider.id}/${modelId}`,
+        modelId,
+        providerId: provider.id,
+        providerLabel: provider.label ?? provider.id,
+    };
+}
+const DEFAULT_MODEL = "anthropic/claude-sonnet-4-6";
+function inspectionModelPreference(explicit, env) {
+    if (explicit !== undefined)
+        return explicit.trim();
+    const fromEnv = String(env["TALOS_MODEL"] ?? "").trim();
+    if (fromEnv)
+        return fromEnv;
+    const path = credentialsPath(env);
+    if (path && existsSync(path)) {
+        try {
+            const raw = JSON.parse(readFileSync(path, "utf8"));
+            if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+                const value = raw["model"];
+                if (typeof value === "string" && value.trim())
+                    return value.trim();
+            }
+        }
+        catch {
+            // Come il bootstrap: una config globale illeggibile non blocca la discovery.
+        }
+    }
+    return DEFAULT_MODEL;
+}
+function modelCatalog(registry, configuredModel) {
+    const providers = registry.list().map((provider) => providerDescriptor(registry, provider));
+    const models = providers.flatMap((provider) => provider.models);
+    const resolved = registry.resolve(configuredModel);
+    const current = resolved ? modelDescriptor(resolved.provider, resolved.modelId) : null;
+    return {
+        // Il selector Horizon riceve sempre l'identificatore canonico quando il
+        // runtime sa risolverlo, anche se la preferenza era un model id nudo.
+        currentModel: current?.id ?? configuredModel,
+        current,
+        providers,
+        models,
+    };
+}
+function providerDescriptor(registry, provider) {
+    const seen = new Set();
+    const models = [];
+    for (const raw of provider.models) {
+        const modelId = raw.trim();
+        if (!modelId)
+            continue;
+        const descriptor = modelDescriptor(provider, modelId);
+        if (seen.has(descriptor.id))
+            continue;
+        const resolved = registry.resolve(descriptor.id);
+        if (!resolved || resolved.provider.id !== provider.id || resolved.modelId !== modelId)
+            continue;
+        seen.add(descriptor.id);
+        models.push(descriptor);
+    }
+    return {
+        id: provider.id,
+        label: provider.label ?? provider.id,
+        models,
+    };
+}

package/dist/horizon/index.d.ts

@@ -0,0 +1,4 @@
+export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonEngine, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./engine.js";
+export { HorizonMainTeam, needsGuideArbitration } from "./main-team.js";
+export type { HorizonCapabilityDescriptor, HorizonContextStatus, HorizonEngineOptions, HorizonEngineState, HorizonModelCatalog, HorizonModelDescriptor, HorizonModelInspectionOptions, HorizonProviderDescriptor, HorizonRuntime, HorizonSessionListItem, HorizonSessionSnapshot, HorizonTurn, HorizonTurnInput, HorizonTurnOptions, HorizonTurnResult, HorizonTurnStatus, HorizonVibeStatus, } from "./types.js";
+export type { HorizonGuideCooperation, HorizonGuideDecision, HorizonGuideDecisionRecord, HorizonGuideDecisionRequest, HorizonGuidePlan, HorizonGuideTask, HorizonGuideVerdict, HorizonMainExchange, HorizonMainRef, HorizonMainTeamConfig, HorizonMainTeamEvent, HorizonMainTeamResult, HorizonMainTeamTurn, HorizonTeamRef, HorizonAgentPurpose, } from "./main-team.js";

package/dist/horizon/index.js

@@ -0,0 +1,2 @@
+export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonEngine, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./engine.js";
+export { HorizonMainTeam, needsGuideArbitration } from "./main-team.js";