@vascend/talos 0.1.0

package/dist/horizon/types.d.ts

@@ -0,0 +1,233 @@
+import type { AgentDeps } from "../core/agent.js";
+import type { Harness } from "../core/bootstrap.js";
+import type { ContextLease, ContextReceipt } from "../vascend/context-fabric.js";
+import type { AgentEvent, ContentPart, ModelTurn } from "../core/types.js";
+import type { VibeModeId, VibeModeSelection, VibeModeSpec } from "../core/vibe-modes.js";
+import type { FileCoordinationContext } from "../core/file-coordination.js";
+import type { ExecutionTarget } from "../core/execution-target.js";
+/** Lifecycle osservabile del facade headless. */
+export type HorizonEngineState = "ready" | "running" | "closing" | "closed";
+export interface HorizonEngineOptions {
+    readonly cwd?: string;
+    readonly fsRoots?: readonly string[];
+    readonly executionTarget?: ExecutionTarget;
+    /** Hub condiviso di presenza e lock file; se assente l'engine ne crea uno locale. */
+    readonly fileCoordination?: FileCoordinationContext;
+    readonly model?: string;
+    readonly sessionId?: string;
+    readonly continueLast?: boolean;
+    readonly sessionName?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    /** Evidenza host non persistente applicata ai turni, salvo override locale. */
+    readonly ephemeralContext?: string;
+    /** Permission gate dell'host. In assenza, Horizon nega ogni azione. */
+    readonly confirm?: AgentDeps["confirm"];
+    /** Canale headless per le domande del modello. In assenza, non viene esposto. */
+    readonly ask?: AgentDeps["ask"];
+    /** Orchestratore opzionale per Kingdoms Mode, implementato dal processo host. */
+    readonly spawnKingdom?: AgentDeps["spawnKingdom"];
+    /**
+     * Modelli provider/modello che l'orchestratore puo' assegnare ai collaboratori.
+     * `undefined` conserva il comportamento legacy; `[]` disabilita lo spawn.
+     */
+    readonly workerModelPool?: readonly string[];
+    readonly trustPrompt?: (resources: readonly string[]) => Promise<boolean>;
+    /**
+     * Adattatore host eseguito una volta dopo bootstrap e prima di esporre il
+     * motore. Consente a Horizon Desktop di registrare tool IDE e contesto locale
+     * senza importare Electron nel core Talos.
+     */
+    readonly configureHarness?: (harness: Harness) => void | Promise<void>;
+}
+/**
+ * Opzioni della discovery modelli senza bootstrap. L'ispezione legge soltanto
+ * configurazione/credenziali globali Talos e non crea sessioni o workspace.
+ */
+export interface HorizonModelInspectionOptions {
+    readonly model?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface HorizonTurnOptions {
+    /** Override del permission gate per il solo turno. */
+    readonly confirm?: AgentDeps["confirm"];
+    /**
+     * Cartelle aggiuntive concesse ai tool filesystem per questo turno.
+     * Il riferimento non viene copiato: l'host puo' aggiungere una root dopo
+     * una conferma inline mentre il turno e' ancora in esecuzione.
+     */
+    readonly fsRoots?: readonly string[];
+    /** Evidenza host non attendibile valida esclusivamente per questo turno. */
+    readonly ephemeralContext?: string;
+    readonly ask?: AgentDeps["ask"];
+    readonly spawnKingdom?: AgentDeps["spawnKingdom"];
+    /** Mirror opzionale: un errore del callback non interrompe il motore. */
+    readonly onEvent?: (event: AgentEvent) => void;
+}
+export type HorizonTurnInput = string | readonly ContentPart[];
+export type HorizonTurnStatus = "completed" | "failed" | "aborted";
+export interface HorizonTurnResult {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly status: HorizonTurnStatus;
+    readonly error?: string;
+    /** Ultimo blocco di prosa del giro finale, dopo l'ultima tool call. */
+    readonly finalText?: string;
+    readonly stopReason?: ModelTurn["stopReason"];
+    readonly terminalEvent?: "done" | "error";
+}
+/**
+ * Handle single-consumer di un turno gia' avviato.
+ * `events` termina sempre prima che `done` si risolva; `abort()` e' idempotente.
+ */
+export interface HorizonTurn {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly events: AsyncIterable<AgentEvent>;
+    readonly done: Promise<HorizonTurnResult>;
+    abort(): boolean;
+    /**
+     * Consegna al turno IN CORSO un messaggio scritto adesso dall'utente. Entra
+     * nel contesto al primo confine sicuro (dopo gli esiti dei tool), non a fine
+     * risposta. Ritorna l'id con cui l'evento `user_message` ne annuncera' la
+     * presa in carico, oppure null se il turno e' gia' concluso.
+     */
+    send(input: HorizonTurnInput, id?: string): string | null;
+    /**
+     * Porta un messaggio gia' in attesa in testa alla casella. Non interrompe
+     * tool atomici: verra' letto al primo confine sicuro disponibile.
+     */
+    prioritize(id: string): boolean;
+}
+export interface HorizonSessionSnapshot {
+    readonly id: string;
+    readonly name: string | null;
+    readonly headId: string | null;
+    readonly messages: number;
+    readonly model: string;
+    readonly vibeMode: VibeModeSelection;
+}
+export interface HorizonSessionListItem {
+    readonly id: string;
+    readonly name: string | null;
+    readonly updatedAt: number;
+    readonly messages: number;
+    readonly preview: string;
+}
+/**
+ * Modello effettivamente instradabile da un provider configurato nel runtime.
+ * `id` e' sempre qualificato: l'host non deve ricostruirlo da label UI.
+ */
+export interface HorizonModelDescriptor {
+    readonly id: string;
+    readonly modelId: string;
+    readonly providerId: string;
+    readonly providerLabel: string;
+}
+/** Provider attivo nel registro Talos, senza credenziali o dettagli sensibili. */
+export interface HorizonProviderDescriptor {
+    readonly id: string;
+    readonly label: string;
+    readonly models: readonly HorizonModelDescriptor[];
+}
+/** Snapshot serializzabile che alimenta il selettore modelli di Horizon. */
+export interface HorizonModelCatalog {
+    /** Valore configurato nel motore; puo' essere non risolto dopo una disconnessione. */
+    readonly currentModel: string;
+    /** Vista canonica qualificata del modello corrente, o null se non risolvibile. */
+    readonly current: HorizonModelDescriptor | null;
+    readonly providers: readonly HorizonProviderDescriptor[];
+    /** Vista piatta degli stessi modelli esposti dentro `providers`. */
+    readonly models: readonly HorizonModelDescriptor[];
+}
+/** Vista serializzabile del Context Fabric relativa alla sessione corrente. */
+export interface HorizonContextStatus {
+    readonly active: boolean;
+    readonly epoch: number | null;
+    readonly turn: number;
+    readonly mode: VibeModeId | null;
+    readonly selection: VibeModeSelection;
+    readonly mission: string;
+    readonly pins: readonly string[];
+    readonly leases: readonly ContextLease[];
+    readonly receipt: ContextReceipt | null;
+    readonly summary: string;
+}
+export interface HorizonCapabilityDescriptor {
+    readonly protocol: "vascend.horizon-engine";
+    readonly protocolVersion: 1;
+    readonly product: {
+        readonly name: "Horizon";
+        readonly core: "Talos";
+        readonly headless: true;
+        readonly electron: false;
+    };
+    readonly lifecycle: readonly ["create", "close"];
+    readonly sessions: readonly ["current", "list", "new", "resume", "rename"];
+    readonly models: {
+        readonly identifiers: "provider/model";
+        readonly operations: readonly ["catalog", "select", "reload"];
+        readonly configuredOnly: true;
+    };
+    readonly turns: {
+        readonly stream: "async-iterable";
+        readonly concurrency: "single-flight";
+        readonly abort: true;
+        readonly inputs: readonly ["text", "content-parts"];
+        readonly ephemeralContext: true;
+    };
+    readonly mainTeam: {
+        readonly agents: readonly [1, 2];
+        readonly stableRefs: readonly ["r1", "r2"];
+        readonly supervisor: true;
+        readonly contextSharing: "explicit-exchanges-only";
+    };
+    readonly context: {
+        readonly paradigm: "epoch-lease-lens";
+        readonly operations: readonly ["status", "pin", "unpin", "reset"];
+        readonly receipts: true;
+    };
+    readonly vibe: {
+        readonly routing: readonly ["auto", "explicit"];
+        readonly modes: readonly VibeModeId[];
+    };
+    readonly permissions: {
+        readonly default: "deny";
+        readonly hostGate: true;
+    };
+    readonly fileCoordination: {
+        readonly modes: readonly ["viewing", "editing", "writing"];
+        readonly writePolicy: "exclusive";
+        readonly humanPresence: true;
+        readonly nestedAgents: true;
+    };
+    readonly mcp: {
+        readonly protocolVersion: "2026-07-28";
+        readonly toolSchema: "inputSchema";
+        readonly callToolResult: true;
+        readonly apps: {
+            readonly extension: "io.modelcontextprotocol/ui";
+            readonly mimeType: "text/html;profile=mcp-app";
+        };
+    };
+}
+/**
+ * Seam avanzato per host che instrumentano il runtime Talos. Gli embedder
+ * normali non devono passarlo: Horizon usa bootstrap/runTurn ufficiali.
+ */
+export interface HorizonRuntime {
+    bootstrap(options: {
+        cwd?: string;
+        fsRoots?: readonly string[];
+        model?: string;
+        sessionId?: string;
+        continueLast?: boolean;
+        sessionName?: string;
+        env?: NodeJS.ProcessEnv;
+        trustPrompt?: (resources: readonly string[]) => Promise<boolean>;
+    }): Promise<Harness>;
+    runTurn(deps: AgentDeps, input: HorizonTurnInput, sink: (event: AgentEvent) => void, signal: AbortSignal): Promise<void>;
+}
+export interface HorizonVibeStatus {
+    readonly selected: VibeModeSelection;
+    readonly modes: readonly VibeModeSpec[];
+}

package/dist/horizon/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { installCrashMonitor, writeCrashReport } from "./core/crash-report.js";
+import { TALOS_VERSION } from "./core/version.js";
+installCrashMonitor();
+import { bootstrap } from "./core/bootstrap.js";
+import { runTurn } from "./core/agent.js";
+import { startRepl } from "./tui/repl.js";
+import { startRpc } from "./rpc/server.js";
+import { proxyUrl } from "./providers/registry.js";
+import { CliArgumentError, cliHelp, parseCliArgs } from "./core/cli-args.js";
+function readStdin() {
+    try {
+        return readFileSync(0, "utf8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+// Prompt di fiducia interattivo prima di caricare risorse locali al progetto.
+async function askTrust(resources) {
+    if (!process.stdin.isTTY)
+        return false;
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    process.stdout.write(`\n  Questo progetto contiene risorse locali Talos:\n` +
+        resources.map((r) => `    - ${r}\n`).join("") +
+        `  Verranno caricate (estensioni eseguono codice). Ti fidi di questo progetto?\n`);
+    return new Promise((resolve) => {
+        rl.question("  [y/N] ", (ans) => {
+            rl.close();
+            resolve(/^y(es)?$/i.test(ans.trim()));
+        });
+    });
+}
+async function main() {
+    let args;
+    try {
+        args = parseCliArgs(process.argv.slice(2));
+    }
+    catch (err) {
+        if (err instanceof CliArgumentError) {
+            process.stderr.write(`errore: ${err.message}\nusa 'horizon --help' per l'elenco completo\n`);
+            process.exitCode = err.exitCode;
+            return;
+        }
+        throw err;
+    }
+    if (args.help) {
+        process.stdout.write(cliHelp() + "\n");
+        return;
+    }
+    if (args.version) {
+        process.stdout.write(`Horizon ${TALOS_VERSION}\n`);
+        return;
+    }
+    const { offerStartupUpdate } = await import("./tui/update-prompt.js");
+    const updateExitCode = await offerStartupUpdate(args, process.env);
+    if (updateExitCode !== null) {
+        process.exitCode = updateExitCode;
+        return;
+    }
+    const env = { ...process.env };
+    if (args.config)
+        env.TALOS_CONFIG = args.config;
+    if (args.promptTemplates.length) {
+        env.TALOS_PROMPT_TEMPLATES = [env.TALOS_PROMPT_TEMPLATES, ...args.promptTemplates]
+            .filter(Boolean)
+            .join(",");
+    }
+    if (args.skills.length) {
+        env.TALOS_SKILLS = [env.TALOS_SKILLS, ...args.skills].filter(Boolean).join(",");
+    }
+    if (args.noSkills)
+        env.TALOS_NO_SKILLS = "1";
+    if (args.vibeMode)
+        env.TALOS_VIBE_MODE = args.vibeMode;
+    // --yolo vale anche in TUI: inizializza la modalita' permessi auto senza
+    // persisterla implicitamente nel profilo globale.
+    if (args.yolo)
+        env.TALOS_PERM_MODE = "auto";
+    if (args.excludeTools.length) {
+        env.TALOS_EXCLUDE_TOOLS = [env.TALOS_EXCLUDE_TOOLS, ...args.excludeTools].filter(Boolean).join(",");
+    }
+    // Proxy globale: propaga a HTTPS_PROXY/HTTP_PROXY cosi' fetch lo usa.
+    const proxy = proxyUrl(env);
+    if (proxy) {
+        env.HTTPS_PROXY = env.HTTPS_PROXY || proxy;
+        env.HTTP_PROXY = env.HTTP_PROXY || proxy;
+    }
+    // Trust: --approve/--no-approve forzano il default; in TUI "ask" si prompta.
+    if (args.approve)
+        env.TALOS_DEFAULT_TRUST = "trust";
+    else if (args.noApprove)
+        env.TALOS_DEFAULT_TRUST = "deny";
+    // Doctor: diagnostica locale SENZA bootstrap (niente sessioni, tool, trust).
+    if (args.mode === "doctor") {
+        const { runDoctor, renderDoctorReport, doctorExitCode } = await import("./core/doctor.js");
+        const report = runDoctor({ cwd: args.cwd, model: args.model, env });
+        process.stdout.write((args.json ? JSON.stringify(report, null, 2) : renderDoctorReport(report)) + "\n");
+        process.exitCode = doctorExitCode(report);
+        return;
+    }
+    const trustPrompt = args.mode === "tui" && !args.approve && !args.noApprove
+        ? (resources) => askTrust(resources)
+        : undefined;
+    const harness = await bootstrap({
+        cwd: args.cwd,
+        fsRoots: args.addDirs,
+        model: args.model,
+        env,
+        trustPrompt,
+        sessionId: args.sessionId,
+        continueLast: args.continueLast,
+        sessionName: args.name,
+    });
+    // Seconda fase del parsing: ora le estensioni del progetto sono note e i
+    // loro flag possono essere validati/eseguiti nel vero ExtensionContext.
+    for (const flag of args.extensionFlags) {
+        const result = await harness.host.runFlag(flag.name, flag.value);
+        if (!result.ok) {
+            process.stderr.write(`errore: ${result.reason ?? `flag non valido: ${flag.name}`}\n`);
+            process.exitCode = 2;
+            return;
+        }
+    }
+    if (args.mode === "rpc") {
+        startRpc(harness.deps(async () => args.yolo), { autoApprove: args.yolo });
+        return;
+    }
+    if (args.mode === "print") {
+        const prompt = args.prompt || readStdin();
+        if (!prompt) {
+            process.stderr.write("nessun prompt fornito\n");
+            process.exit(1);
+        }
+        const controller = new AbortController();
+        let finalText = "";
+        let failed = false;
+        const sink = (event) => {
+            if (args.json) {
+                process.stdout.write(JSON.stringify(event) + "\n");
+            }
+            else if (event.type === "text") {
+                finalText += event.delta;
+            }
+            else if (event.type === "error") {
+                process.stderr.write(`errore: ${event.message}\n`);
+            }
+            if (event.type === "error")
+                failed = true;
+        };
+        const deps = harness.deps(async () => args.yolo);
+        await runTurn(deps, prompt, sink, controller.signal);
+        if (!args.json && finalText.trim())
+            process.stdout.write(finalText.trim() + "\n");
+        if (failed)
+            process.exitCode = 1;
+        return;
+    }
+    // Lavoro autonomo: il ciclo gira FUORI da qualunque conversazione. Prende
+    // un'unita' dalla coda, la fa eseguire a un agente NUOVO, la verifica con un
+    // comando esterno, e passa alla prossima. E' l'entry di un run lungo: la si
+    // richiama a intervalli (cron, servizio) e ogni giro riprende da dove la coda
+    // era rimasta, compresi i lease scaduti da recuperare.
+    if (args.mode === "work") {
+        const { WorkQueue, formatQueue } = await import("./vascend/work-queue.js");
+        const { createFreshAgentRunner } = await import("./vascend/work-agent.js");
+        const { runWorkLoop } = await import("./vascend/work-runner.js");
+        const queue = WorkQueue.open(harness.config.sessionDir, args.workScope ?? "default");
+        if (args.workList) {
+            queue.sweep();
+            process.stdout.write(formatQueue(queue.items()) + "\n");
+            return;
+        }
+        const gate = args.workVerify;
+        const controller = new AbortController();
+        process.on("SIGINT", () => controller.abort());
+        const report = await runWorkLoop({
+            queue,
+            owner: `cli-${process.pid}`,
+            runItem: createFreshAgentRunner(harness.deps(async () => args.yolo), {
+                memoryScopeId: args.workScope ?? "default",
+            }),
+            ...(gate ? {
+                // L'arbitro e' un comando esterno: conta il suo exit code, non cio' che
+                // l'agente pensa di aver fatto.
+                verify: async () => {
+                    const { spawnSync } = await import("node:child_process");
+                    const done = spawnSync(gate, { cwd: harness.config.cwd, shell: true, encoding: "utf8" });
+                    const log = `${done.stdout ?? ""}${done.stderr ?? ""}`.trim();
+                    return { ok: done.status === 0, log: log || `exit ${done.status}` };
+                },
+            } : {}),
+            onEvent: (event) => {
+                if (args.json) {
+                    process.stdout.write(JSON.stringify(event) + "\n");
+                    return;
+                }
+                if (event.type === "claimed")
+                    process.stdout.write(`> ${event.item.id} ${event.item.title}\n`);
+                if (event.type === "gate")
+                    process.stdout.write(`  verifica: ${event.gate.ok ? "verde" : "ROSSA"}\n`);
+                if (event.type === "settled")
+                    process.stdout.write(`  ${event.item.id} -> ${event.state}\n`);
+            },
+        }, {
+            ...(args.workMax ? { maxItems: args.workMax } : {}),
+            ...(args.workMinutes ? { deadline: Date.now() + args.workMinutes * 60_000 } : {}),
+            signal: controller.signal,
+        });
+        if (!args.json) {
+            process.stdout.write(`${report.why}: ${report.done} concluse, ${report.retried} da ritentare, ${report.blocked} bloccate `
+                + `(${Math.round(report.ms / 1000)}s)\n`);
+        }
+        else {
+            process.stdout.write(JSON.stringify(report) + "\n");
+        }
+        if (report.blocked > 0)
+            process.exitCode = 1;
+        return;
+    }
+    // default: TUI interattiva
+    await startRepl({ harness, resumePicker: args.resumePicker,
+        recoverQueue: !args.sessionId && !args.continueLast && !args.resumePicker && !args.name });
+}
+main().catch((err) => {
+    const report = writeCrashReport(err, "main");
+    process.stderr.write(`fatale: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+    if (report)
+        process.stderr.write(`diagnostica: ${report}\n`);
+    process.exit(1);
+});

package/dist/mcp/protocol.d.ts

@@ -0,0 +1,81 @@
+export declare const MCP_PROTOCOL_VERSION = "2026-07-28";
+export declare const MCP_UI_EXTENSION_ID = "io.modelcontextprotocol/ui";
+export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+export type JsonSchema = Readonly<Record<string, unknown>>;
+export type McpMeta = Readonly<Record<string, unknown>>;
+export interface McpToolAnnotations {
+    readonly title?: string;
+    readonly readOnlyHint?: boolean;
+    readonly destructiveHint?: boolean;
+    readonly idempotentHint?: boolean;
+    readonly openWorldHint?: boolean;
+    readonly [key: string]: unknown;
+}
+export interface McpToolDefinition {
+    readonly name: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly inputSchema: JsonSchema;
+    readonly outputSchema?: JsonSchema;
+    readonly annotations?: McpToolAnnotations;
+    readonly _meta?: McpMeta;
+}
+export interface McpTextContent {
+    readonly type: "text";
+    readonly text: string;
+    readonly annotations?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+}
+export interface McpImageContent {
+    readonly type: "image";
+    readonly data: string;
+    readonly mimeType: string;
+    readonly annotations?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+}
+export interface McpAudioContent {
+    readonly type: "audio";
+    readonly data: string;
+    readonly mimeType: string;
+    readonly annotations?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+}
+export interface McpResourceLinkContent {
+    readonly type: "resource_link";
+    readonly name: string;
+    readonly uri: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly mimeType?: string;
+    readonly size?: number;
+    readonly annotations?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+}
+export interface McpEmbeddedResourceContent {
+    readonly type: "resource";
+    readonly resource: Readonly<Record<string, unknown>>;
+    readonly annotations?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+}
+export type McpContentBlock = McpTextContent | McpImageContent | McpAudioContent | McpResourceLinkContent | McpEmbeddedResourceContent;
+export interface McpCallToolResult {
+    readonly content: readonly McpContentBlock[];
+    readonly structuredContent?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+    readonly isError?: boolean;
+}
+export interface McpAppUiMeta {
+    readonly resourceUri?: string;
+    readonly visibility?: readonly ("model" | "app")[];
+    readonly [key: string]: unknown;
+}
+export declare function mcpAppUiMeta(meta: McpMeta | undefined): McpAppUiMeta | undefined;
+export declare function isToolVisibleToModel(meta: McpMeta | undefined): boolean;
+export declare function supportsMcpApps(capabilities: unknown): boolean;
+export declare function toolInputSchema(tool: {
+    readonly inputSchema?: JsonSchema;
+    readonly schema?: JsonSchema;
+}): JsonSchema;
+export declare function textFromMcpToolResult(result: McpCallToolResult): string;
+export declare function normalizeMcpToolResult(value: unknown, defaultIsError?: boolean): McpCallToolResult;
+export declare function toolDefinitionForCapabilities<T extends McpToolDefinition>(tool: T, capabilities: unknown): T;

package/dist/mcp/protocol.js

@@ -0,0 +1,122 @@
+// Contratto MCP condiviso dal runtime Talos e dagli host che lo incorporano.
+// Il core resta dependency-free: queste funzioni normalizzano soltanto dati.
+export const MCP_PROTOCOL_VERSION = "2026-07-28";
+export const MCP_UI_EXTENSION_ID = "io.modelcontextprotocol/ui";
+export const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function mcpAppUiMeta(meta) {
+    return record(meta?.["ui"]);
+}
+export function isToolVisibleToModel(meta) {
+    const visibility = mcpAppUiMeta(meta)?.visibility;
+    return !visibility?.length || visibility.includes("model");
+}
+export function supportsMcpApps(capabilities) {
+    const caps = record(capabilities);
+    const extensions = record(caps?.["extensions"]);
+    const ui = record(extensions?.[MCP_UI_EXTENSION_ID]);
+    const mimeTypes = ui?.["mimeTypes"];
+    return Array.isArray(mimeTypes) && mimeTypes.includes(MCP_APP_MIME_TYPE);
+}
+export function toolInputSchema(tool) {
+    return tool.inputSchema ?? tool.schema ?? { type: "object", properties: {} };
+}
+export function textFromMcpToolResult(result) {
+    const text = result.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+    if (text)
+        return text;
+    if (result.structuredContent) {
+        try {
+            return JSON.stringify(result.structuredContent);
+        }
+        catch {
+            return "Risultato strutturato prodotto dal tool.";
+        }
+    }
+    if (result.content.some((part) => part.type === "image"))
+        return "Immagine prodotta dal tool.";
+    if (result.content.some((part) => part.type === "audio"))
+        return "Audio prodotto dal tool.";
+    return "Tool completato senza output testuale.";
+}
+function normalizedContent(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        const part = record(item);
+        if (!part)
+            return [];
+        const type = String(part["type"] ?? "");
+        if (type === "text")
+            return [{ ...part, type, text: String(part["text"] ?? "") }];
+        if (type === "image" || type === "audio") {
+            const data = String(part["data"] ?? "");
+            const mimeType = String(part["mimeType"] ?? part["mime"] ?? "");
+            if (!data || !mimeType)
+                return [];
+            return [{ ...part, type, data, mimeType }];
+        }
+        if (type === "resource_link") {
+            const uri = String(part["uri"] ?? "");
+            if (!uri)
+                return [];
+            return [{ ...part, type, uri, name: String(part["name"] ?? uri) }];
+        }
+        if (type === "resource" && record(part["resource"])) {
+            return [{ ...part, type, resource: record(part["resource"]) }];
+        }
+        return [];
+    });
+}
+// Accetta sia CallToolResult MCP sia i due formati storici di Talos
+// (`string` e `{output, media}`), producendo sempre la forma standard.
+export function normalizeMcpToolResult(value, defaultIsError = false) {
+    if (typeof value === "string") {
+        return { content: [{ type: "text", text: value }], ...(defaultIsError ? { isError: true } : {}) };
+    }
+    const raw = record(value) ?? {};
+    const structuredContent = record(raw["structuredContent"]);
+    const meta = record(raw["_meta"]);
+    const explicitContent = normalizedContent(raw["content"]);
+    const output = raw["output"] === undefined ? "" : String(raw["output"]);
+    const media = Array.isArray(raw["media"])
+        ? raw["media"].flatMap((item) => {
+            const image = record(item);
+            const data = String(image?.["data"] ?? "");
+            const mimeType = String(image?.["mimeType"] ?? image?.["mime"] ?? "");
+            return data && mimeType ? [{ type: "image", data, mimeType }] : [];
+        })
+        : [];
+    const fallback = output
+        ? [{ type: "text", text: output }]
+        : structuredContent
+            ? [{ type: "text", text: JSON.stringify(structuredContent) }]
+            : [];
+    const content = explicitContent.length ? explicitContent : [...fallback, ...media];
+    return {
+        content: content.length ? content : [{ type: "text", text: "Tool completato senza output testuale." }],
+        ...(structuredContent ? { structuredContent } : {}),
+        ...(meta ? { _meta: meta } : {}),
+        ...((raw["isError"] === true || defaultIsError) ? { isError: true } : {}),
+    };
+}
+// I client senza MCP Apps ricevono comunque il tool, ma non metadata UI che
+// non sanno negoziare. Il contenuto testuale di fallback resta utilizzabile.
+export function toolDefinitionForCapabilities(tool, capabilities) {
+    if (supportsMcpApps(capabilities) || !mcpAppUiMeta(tool._meta))
+        return tool;
+    const { ui: _ui, ...restMeta } = tool._meta ?? {};
+    const { _meta: _meta, ...rest } = tool;
+    return {
+        ...rest,
+        ...(Object.keys(restMeta).length ? { _meta: restMeta } : {}),
+    };
+}

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}