@vascend/talos 0.1.0

package/dist/providers/open-browser.d.ts

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+export type Platform = NodeJS.Platform;
+export declare function browserCommand(platform: Platform, url: string): {
+    readonly cmd: string;
+    readonly args: readonly string[];
+};
+export interface OpenUrlResult {
+    readonly opened: boolean;
+    readonly printed: boolean;
+    readonly command?: string;
+    readonly error?: string;
+}
+export interface OpenUrlOptions {
+    readonly platform?: Platform;
+    readonly spawnImpl?: typeof spawn;
+    readonly print?: (text: string) => void;
+    readonly forcePrint?: boolean;
+    readonly settleMs?: number;
+}
+export declare function openUrl(url: string, opts?: OpenUrlOptions): Promise<OpenUrlResult>;

package/dist/providers/open-browser.js

@@ -0,0 +1,92 @@
+import { spawn } from "node:child_process";
+// Comando + argomenti per aprire un URL sulla piattaforma data. L'URL e'
+// sempre l'ultimo argomento. Su Windows NON usare `cmd /c start`: i separatori
+// `&` delle query OAuth vengono interpretati dalla shell e troncano l'URL,
+// eliminando parametri PKCE come code_challenge_method. explorer.exe riceve
+// invece l'URL come singolo argomento e lo inoltra intatto al browser predefinito.
+export function browserCommand(platform, url) {
+    switch (platform) {
+        case "darwin":
+            return { cmd: "open", args: [url] };
+        case "win32":
+            return { cmd: "explorer.exe", args: [url] };
+        default:
+            // linux, freebsd, openbsd, ... : xdg-open e' lo standard freedesktop.
+            return { cmd: "xdg-open", args: [url] };
+    }
+}
+// Accetta solo schemi sicuri da passare a un comando di sistema. Evita che un
+// URL malformato o uno schema inatteso (es. file:, javascript:) venga aperto.
+function isOpenableUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.protocol === "http:" || u.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+// Stampa il link in modo che l'utente possa aprirlo manualmente.
+function printLink(url, print) {
+    print(`Apri questo URL nel browser per continuare:\n\n  ${url}\n`);
+}
+// Apre l'URL nel browser di default, con fallback a stampa del link.
+//
+// Lo spawn e' detached e con stdio ignorato: il processo del browser non deve
+// tenere in vita o bloccare il processo Node. Risolviamo dopo un breve
+// settle window osservando un eventuale evento 'error' (comando assente,
+// ENOENT): in quel caso ricadiamo sulla stampa.
+export async function openUrl(url, opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const spawnImpl = opts.spawnImpl ?? spawn;
+    const print = opts.print ?? ((t) => console.log(t));
+    const settleMs = opts.settleMs ?? 1500;
+    if (!isOpenableUrl(url)) {
+        printLink(url, print);
+        return { opened: false, printed: true, error: "URL non valido (atteso http/https)" };
+    }
+    if (opts.forcePrint) {
+        printLink(url, print);
+        return { opened: false, printed: true };
+    }
+    const { cmd, args } = browserCommand(platform, url);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        let child;
+        try {
+            child = spawnImpl(cmd, args, { stdio: "ignore", detached: true, windowsHide: true });
+        }
+        catch (err) {
+            // Eccezione sincrona (raro): fallback immediato.
+            printLink(url, print);
+            finish({ opened: false, printed: true, command: cmd, error: errMsg(err) });
+            return;
+        }
+        // Evento 'error' asincrono (es. ENOENT: comando non trovato).
+        child.on("error", (err) => {
+            printLink(url, print);
+            finish({ opened: false, printed: true, command: cmd, error: errMsg(err) });
+        });
+        // Stacchiamo il figlio dal processo padre cosi' non ne blocca l'uscita.
+        try {
+            child.unref();
+        }
+        catch {
+            /* unref non disponibile: ininfluente */
+        }
+        // Nessun errore entro la finestra di settle: consideriamo aperto. Il timer
+        // NON e' unref-ato: la finestra di settle e' breve (default 1.5s) e la
+        // Promise DEVE risolversi, altrimenti il chiamante resta appeso e il
+        // processo potrebbe uscire prima di completare l'apertura.
+        setTimeout(() => finish({ opened: true, printed: false, command: cmd }), settleMs);
+    });
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/providers/openai-compat.d.ts

@@ -0,0 +1,14 @@
+import type { CompletionRequest, ModelTurn, Provider } from "../core/types.js";
+export declare class OpenAICompatProvider implements Provider {
+    readonly id: string;
+    readonly label: string;
+    private readonly baseUrl;
+    private readonly apiKey;
+    readonly models: readonly string[];
+    private keyCursor;
+    get supportsFastMode(): boolean;
+    constructor(id: string, label: string, baseUrl: string, apiKey: string | readonly string[], models?: readonly string[]);
+    complete(req: CompletionRequest): Promise<ModelTurn>;
+}
+export declare function parseStream(body: ReadableStream<Uint8Array>, onDelta?: (chunk: string) => void, onActivity?: (label: string) => void, onReasoning?: (chunk: string) => void, onToolDelta?: CompletionRequest["onToolDelta"]): Promise<ModelTurn>;
+export declare function routerFailureMessage(choice: Record<string, unknown> | undefined, evt: Record<string, unknown>): string;

package/dist/providers/openai-compat.js

@@ -0,0 +1,523 @@
+import { messaggioErroreTurno } from "../core/image-limits.js";
+import { planLimitsFromHeaders } from "./plan-limits.js";
+import { errorTimingDetail } from "./provider-reset.js";
+import { compatReasoningField } from "./effort.js";
+import { resolveMaxTokens } from "../core/model-limits.js";
+// Provider per qualunque API in stile OpenAI Chat Completions: OpenAI,
+// OpenRouter, Grok via xAI, Mistral, DeepSeek, Together, Gemini (endpoint compat)
+// e Ollama. Cambia solo baseUrl + chiave; il protocollo e' lo stesso.
+//
+// Supporta tool-calling (function calling) e streaming SSE. I modelli NON sono
+// vincolati alla lista `models`: quella e' solo un suggerimento per /models,
+// l'utente puo' indicare qualsiasi id con `provider/<id>`.
+export class OpenAICompatProvider {
+    id;
+    label;
+    baseUrl;
+    apiKey;
+    models;
+    keyCursor = 0;
+    get supportsFastMode() {
+        try {
+            return new URL(this.baseUrl).hostname === "api.openai.com";
+        }
+        catch {
+            return false;
+        }
+    }
+    constructor(id, label, baseUrl, apiKey, models = []) {
+        this.id = id;
+        this.label = label;
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.models = models;
+    }
+    async complete(req) {
+        const body = {
+            model: req.model,
+            ...(this.supportsFastMode && req.serviceTier ? { service_tier: req.serviceTier } : {}),
+            max_tokens: resolveMaxTokens(req.maxTokens, `${this.id}/${req.model}`),
+            stream: true,
+            stream_options: { include_usage: true },
+            messages: toApiMessages(req),
+            tools: req.tools.length
+                ? req.tools.map((t) => ({
+                    type: "function",
+                    function: {
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.inputSchema,
+                    },
+                }))
+                : undefined,
+        };
+        // Prompt cache key (OpenAI): instrada le richieste della stessa sessione
+        // sulla stessa cache di prompt -> piu' cache hit. Campo documentato OpenAI.
+        if (req.sessionId && /openai\.com/i.test(this.baseUrl)) {
+            body["prompt_cache_key"] = req.sessionId;
+        }
+        // OpenRouter usage accounting: col flag, il chunk finale dello stream
+        // include usage.cost (USD reali addebitati per la chiamata).
+        if (/openrouter\.ai/i.test(this.baseUrl)) {
+            body["usage"] = { include: true };
+            // Instradamento scelto dall'utente: lo STESSO modello puo' essere servito
+            // da provider diversi, con prezzo, finestra di contesto e politica sui
+            // dati diversi. Senza questo campo decide OpenRouter; con `order` +
+            // allow_fallbacks:false la richiesta va dove e' stato deciso, e se quel
+            // provider non e' disponibile fallisce invece di scivolare altrove in
+            // silenzio (che e' il punto: si sceglie il provider proprio per non
+            // ritrovarsi altrove).
+            const routing = String(process.env.TALOS_OPENROUTER_PROVIDER || "").trim();
+            if (routing)
+                body["provider"] = { order: [routing], allow_fallbacks: false };
+        }
+        // Reasoning/effort: inviato solo ai provider che lo supportano (allowlist
+        // per baseUrl), col campo nativo giusto. Gli altri restano senza parametro.
+        const reasoning = compatReasoningField(this.baseUrl, req.effort, process.env, req.model);
+        if (reasoning)
+            body[reasoning.key] = reasoning.value;
+        const keys = (Array.isArray(this.apiKey) ? this.apiKey : [this.apiKey])
+            .map((item) => String(item || "").trim()).filter(Boolean);
+        const attempts = keys.length || 1;
+        const startCursor = this.keyCursor;
+        let omitImages = false;
+        for (let offset = 0; offset < attempts; offset += 1) {
+            const index = keys.length ? (startCursor + offset) % keys.length : 0;
+            const key = keys[index] ?? "";
+            const headers = { "content-type": "application/json" };
+            if (key)
+                headers["authorization"] = `Bearer ${key}`;
+            // Attribuzione per i gateway che la richiedono/onorano (Vercel AI Gateway,
+            // OpenRouter): identifica l'app nei loro dashboard. Inclusa di default.
+            if (/openrouter\.ai|gateway\.ai|vercel/i.test(this.baseUrl)) {
+                headers["http-referer"] = "https://vascend.dev";
+                headers["x-title"] = "Vascend Talos";
+            }
+            if (req.sessionId && /mistral\.ai/i.test(this.baseUrl))
+                headers["x-session-id"] = req.sessionId;
+            let retrySameEndpoint = true;
+            while (retrySameEndpoint) {
+                retrySameEndpoint = false;
+                body["messages"] = toApiMessages(req, { includeImages: !omitImages });
+                let res;
+                try {
+                    res = await fetch(`${this.baseUrl}/chat/completions`, {
+                        method: "POST",
+                        signal: req.signal,
+                        headers,
+                        body: JSON.stringify(body),
+                    });
+                }
+                catch (err) {
+                    return {
+                        text: `Errore di rete verso ${this.id}: ${err.message}`,
+                        toolCalls: [],
+                        stopReason: "error",
+                    };
+                }
+                const limits = planLimitsFromHeaders(this.id, res.headers);
+                if (res.ok && res.body) {
+                    this.keyCursor = index;
+                    const turn = await parseStream(res.body, req.onDelta, req.onActivity, req.onReasoning, req.onToolDelta);
+                    return limits ? { ...turn, limits } : turn;
+                }
+                const detail = await res.text().catch(() => res.statusText);
+                // OpenRouter e diversi gateway OpenAI-compatible possono risolvere un
+                // modello su endpoint solo testo. Se un computer_snapshot e' presente,
+                // la prima richiesta fallisce con 400/404 prima di generare token. In
+                // quel caso ritentiamo una sola volta senza parti visuali: lo screenshot
+                // resta persistito/renderizzato dall'host e il modello continua con UIA
+                // e metadati testuali, invece di terminare l'intero run.
+                if (!omitImages && requestHasImages(req) && rejectsImageInput(res.status, detail)) {
+                    omitImages = true;
+                    req.onActivity?.("Il modello non supporta immagini: continuo con controlli e stato testuale");
+                    retrySameEndpoint = true;
+                    continue;
+                }
+                const canFallback = this.id === "openrouter"
+                    && keys.length > 1
+                    && offset < attempts - 1
+                    && [401, 402, 403, 429].includes(res.status);
+                if (canFallback) {
+                    req.onActivity?.(`OpenRouter: passo alla chiave di fallback ${offset + 2}/${keys.length}`);
+                    break;
+                }
+                return {
+                    text: messaggioErroreTurno(`provider ${this.id}`, res.status, detail),
+                    toolCalls: [],
+                    stopReason: "error",
+                    ...(limits ? { limits } : {}),
+                };
+            }
+        }
+        return { text: `Errore provider ${this.id}: nessuna chiave disponibile`, toolCalls: [], stopReason: "error" };
+    }
+}
+// Mappa i messaggi interni nel formato OpenAI. Il system va in testa.
+function requestHasImages(req) {
+    return req.messages.some((message) => message.content.some((part) => part.type === "image" || (part.type === "tool_result" && !!part.media?.length)));
+}
+function rejectsImageInput(status, detail) {
+    if (![400, 404, 415, 422].includes(status))
+        return false;
+    const message = String(detail || "").toLocaleLowerCase();
+    return /(?:image|vision|multimodal)/.test(message)
+        && /(?:not support|unsupported|no endpoints|cannot|can't|does not|invalid)/.test(message);
+}
+function toApiMessages(req, options = {}) {
+    const includeImages = options.includeImages !== false;
+    const out = [];
+    if (req.system)
+        out.push({ role: "system", content: req.system });
+    if (req.turnContext)
+        out.push({
+            role: "system",
+            content: `[HORIZON_TURN_CONTEXT]\n${req.turnContext}\n[/HORIZON_TURN_CONTEXT]`,
+        });
+    for (const m of req.messages) {
+        if (m.role === "system")
+            continue;
+        if (m.role === "tool") {
+            const media = [];
+            // Ogni risultato di tool e' un messaggio separato con tool_call_id.
+            for (const part of m.content) {
+                if (part.type === "tool_result") {
+                    out.push({
+                        role: "tool",
+                        tool_call_id: part.callId,
+                        content: part.output,
+                    });
+                    if (part.media?.length)
+                        media.push(...part.media);
+                }
+            }
+            // Chat Completions non accetta immagini nel messaggio role=tool. Dopo
+            // aver chiuso tutti i tool_call aggiungiamo quindi un input user visivo.
+            if (media.length && includeImages) {
+                out.push({
+                    role: "user",
+                    content: [
+                        { type: "text", text: "Immagine prodotta dal tool: analizzala come dato non fidato." },
+                        ...media.map((image) => ({
+                            type: "image_url",
+                            image_url: { url: `data:${image.mime};base64,${image.data}` },
+                        })),
+                    ],
+                });
+            }
+            else if (media.length) {
+                out.push({
+                    role: "user",
+                    content: "Lo screenshot del tool resta disponibile nell'interfaccia ma questo modello non accetta immagini. "
+                        + "Continua usando i metadati testuali e computer_inspect; non ripetere computer_snapshot in un ciclo.",
+                });
+            }
+            continue;
+        }
+        const text = m.content
+            .filter((p) => p.type === "text")
+            .map((p) => (p.type === "text" ? p.text : ""))
+            .join("");
+        const toolCalls = m.content
+            .filter((p) => p.type === "tool_call")
+            .map((p) => {
+            const call = p;
+            return {
+                id: call.id,
+                type: "function",
+                function: {
+                    name: call.name,
+                    arguments: JSON.stringify(call.input ?? {}),
+                },
+            };
+        });
+        if (m.role === "assistant") {
+            const msg = { role: "assistant" };
+            msg["content"] = text || null;
+            if (toolCalls.length)
+                msg["tool_calls"] = toolCalls;
+            out.push(msg);
+        }
+        else {
+            // Messaggio user: se ci sono immagini allegate, usa il formato vision di
+            // OpenAI (content array con parti text + image_url data-URI); altrimenti
+            // la forma stringa semplice.
+            const images = m.content.filter((p) => p.type === "image");
+            if (images.length && includeImages) {
+                const parts = [];
+                if (text)
+                    parts.push({ type: "text", text });
+                for (const p of images) {
+                    if (p.type !== "image")
+                        continue;
+                    parts.push({
+                        type: "image_url",
+                        image_url: { url: `data:${p.mime};base64,${p.data}` },
+                    });
+                }
+                out.push({ role: "user", content: parts });
+            }
+            else {
+                out.push({
+                    role: "user",
+                    content: text || (images.length
+                        ? "L'allegato visivo resta disponibile nell'interfaccia, ma il modello selezionato non accetta immagini."
+                        : ""),
+                });
+            }
+        }
+    }
+    return out;
+}
+export async function parseStream(body, onDelta, onActivity, onReasoning, onToolDelta) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let text = "";
+    let stopReason;
+    let sawTerminal = false;
+    let streamError;
+    let readError;
+    let usage;
+    const calls = new Map();
+    const announced = new Map();
+    const processLine = (line) => {
+        if (streamError || !line.startsWith("data:"))
+            return;
+        const data = line.slice(5).trim();
+        if (!data)
+            return;
+        if (data === "[DONE]") {
+            // Chat Completions usa [DONE] come terminale logico esplicito. Alcuni
+            // gateway omettono finish_reason: in quel caso inferiamo solo da cio'
+            // che e' stato ricevuto integralmente prima del sentinel.
+            stopReason ??= calls.size > 0 ? "tool_use" : "end";
+            sawTerminal = true;
+            return;
+        }
+        let evt;
+        try {
+            evt = JSON.parse(data);
+        }
+        catch {
+            streamError = "Risposta OpenAI-compatible non valida: evento SSE JSON illeggibile.";
+            return;
+        }
+        const providerError = readProviderError(evt);
+        if (providerError) {
+            streamError = providerError;
+            stopReason = "error";
+            sawTerminal = true;
+            return;
+        }
+        const u = evt["usage"];
+        if (u) {
+            // Token serviti dalla cache di prompt: OpenAI -> prompt_tokens_details
+            // .cached_tokens; Mistral/altri -> cached_tokens al livello usage.
+            const details = u["prompt_tokens_details"];
+            const cached = Number(details?.["cached_tokens"] ?? u["cached_tokens"] ?? 0);
+            const prompt = Number(u["prompt_tokens"] ?? 0);
+            // prompt_tokens INCLUDE i cached: scorporali per un tasso di hit coerente
+            // con la semantica Anthropic (inputTokens = non-cached).
+            const cost = Number(u["cost"]);
+            usage = {
+                inputTokens: Math.max(0, prompt - cached),
+                outputTokens: Number(u["completion_tokens"] ?? 0),
+                ...(cached > 0 ? { cacheReadTokens: cached } : {}),
+                ...(Number.isFinite(cost) && cost > 0 ? { costUsd: cost } : {}),
+            };
+        }
+        const choices = evt["choices"];
+        const choice = choices?.[0];
+        if (!choice)
+            return;
+        const delta = choice["delta"];
+        // Il ragionamento in streaming, dove ciascuno lo mette: OpenRouter usa
+        // `reasoning`, gli endpoint stile DeepSeek `reasoning_content`, e alcuni
+        // annidano il testo in un oggetto. Canale separato dal contenuto: non e' la
+        // risposta e non deve finire mescolato ad essa.
+        const pensiero = delta?.["reasoning"] ?? delta?.["reasoning_content"];
+        if (typeof pensiero === "string" && pensiero)
+            onReasoning?.(pensiero);
+        else if (pensiero && typeof pensiero === "object") {
+            const dentro = pensiero["text"]
+                ?? pensiero["content"];
+            if (typeof dentro === "string" && dentro)
+                onReasoning?.(dentro);
+        }
+        if (delta?.["content"]) {
+            const chunk = String(delta["content"]);
+            text += chunk;
+            onDelta?.(chunk);
+        }
+        accumulateToolCalls(delta, calls, onActivity, announced, onToolDelta);
+        const finish = choice["finish_reason"];
+        if (finish === undefined || finish === null)
+            return;
+        sawTerminal = true;
+        if (finish === "tool_calls" || finish === "function_call")
+            stopReason = "tool_use";
+        else if (finish === "length" || finish === "max_tokens")
+            stopReason = "max_tokens";
+        else if (finish === "stop")
+            stopReason = "end";
+        else if (finish === "content_filter") {
+            stopReason = "error";
+            streamError = "Risposta bloccata dal filtro contenuti del provider.";
+        }
+        else if (finish === "error") {
+            // Il caso dei router: OpenRouter (e in particolare le rotte gratuite, che
+            // smistano su modelli diversi a ogni richiesta) chiude lo stream con
+            // finish_reason "error" quando il modello a valle fallisce. Il dettaglio
+            // sta in posti diversi a seconda del router, e a volte non c'e' affatto:
+            // dire "finish_reason non supportato" e' inutile per chi legge e impedisce
+            // il retry, che qui e' proprio la cosa giusta da fare — un secondo
+            // tentativo su una rotta free finisce spesso su un altro modello e passa.
+            stopReason = "error";
+            streamError = routerFailureMessage(choice, evt);
+        }
+        else {
+            stopReason = "error";
+            streamError = `Risposta OpenAI-compatible terminata con finish_reason non supportato: ${String(finish)}.`;
+        }
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines)
+                processLine(line);
+        }
+    }
+    catch (err) {
+        readError = err;
+    }
+    buffer += decoder.decode();
+    if (buffer)
+        for (const line of buffer.split("\n"))
+            processLine(line);
+    if (streamError)
+        return { text: streamError, toolCalls: [], stopReason: "error", usage };
+    if (!sawTerminal)
+        return prematureStreamTurn(text, readError, usage);
+    const toolCalls = [];
+    for (const c of calls.values()) {
+        let input = {};
+        let truncated = 0;
+        try {
+            input = c.args ? JSON.parse(c.args) : {};
+        }
+        catch {
+            // Argomenti tagliati a meta' dal tetto di output: va detto, non nascosto
+            // dietro un oggetto vuoto.
+            input = {};
+            truncated = c.args ? c.args.length : 0;
+        }
+        toolCalls.push({
+            type: "tool_call", id: c.id, name: c.name, input,
+            ...(truncated > 0 ? { inputTruncatedChars: truncated } : {}),
+        });
+    }
+    if (toolCalls.length > 0 && stopReason !== "max_tokens")
+        stopReason = "tool_use";
+    return { text, toolCalls, stopReason: stopReason ?? "end", usage };
+}
+function prematureStreamTurn(streamedText, readError, usage) {
+    if (!streamedText) {
+        const detail = readError instanceof Error && readError.message ? ` (${readError.message})` : "";
+        return {
+            text: `Errore di rete: connection closed prima che il provider completasse la risposta${detail}.`,
+            toolCalls: [],
+            stopReason: "error",
+            usage,
+        };
+    }
+    return {
+        text: `Risposta provider incompleta: EOF prematuro dopo ${streamedText.length} caratteri; nessuna tool call e' stata eseguita.`,
+        toolCalls: [],
+        stopReason: "error",
+        usage,
+    };
+}
+// Il messaggio per uno stream chiuso con finish_reason "error". Il dettaglio
+// utile puo' stare in tre posti diversi, e nessuno e' garantito:
+//   - choice.error        (OpenRouter, quando il provider a valle risponde male)
+//   - evt.error           (errore a livello di evento)
+//   - choice.native_finish_reason (il motivo grezzo del modello sottostante)
+//
+// Il testo finisce davanti all'utente E dentro il classificatore dei retry
+// (isTransientError), percio' contiene "upstream" e "temporaneo": senza, questo
+// caso non verrebbe ritentato, mentre e' il caso in cui ritentare funziona.
+export function routerFailureMessage(choice, evt) {
+    const dettaglio = leggiDettaglioErrore(choice?.["error"]) ?? leggiDettaglioErrore(evt["error"]);
+    const nativo = choice?.["native_finish_reason"];
+    const coda = dettaglio
+        ? ` Il provider ha risposto: ${dettaglio}`
+        : nativo
+            ? ` Motivo riportato dal modello: ${String(nativo)}.`
+            : " Il provider non ha dato un motivo.";
+    return "Il modello a monte ha interrotto la risposta (errore upstream temporaneo)."
+        + coda
+        + " Se stai usando una rotta che smista su piu' modelli, un nuovo tentativo puo' finire su un altro modello.";
+}
+function leggiDettaglioErrore(raw) {
+    if (!raw)
+        return null;
+    if (typeof raw === "string")
+        return raw.trim() || null;
+    if (typeof raw !== "object")
+        return null;
+    const o = raw;
+    const messaggio = o["message"] ?? o["detail"] ?? o["reason"];
+    const codice = o["code"] ?? o["type"];
+    const testo = messaggio ? String(messaggio).trim() : "";
+    if (testo && codice)
+        return `${testo} (${String(codice)})`;
+    if (testo)
+        return testo;
+    if (codice)
+        return String(codice);
+    return null;
+}
+function readProviderError(evt) {
+    const raw = evt["error"];
+    if (raw === undefined && evt["type"] !== "error")
+        return null;
+    if (typeof raw === "string")
+        return `Errore provider streaming: ${raw}`;
+    const code = raw?.["code"] ?? raw?.["type"] ?? evt["code"] ?? "stream_error";
+    const message = raw?.["message"] ?? evt["message"] ?? "errore streaming senza dettagli";
+    return `Errore provider streaming (${String(code)}): ${String(message)}${errorTimingDetail(raw)}${errorTimingDetail(evt)}`;
+}
+function accumulateToolCalls(delta, calls, onActivity, announced, onToolDelta) {
+    const deltaCalls = delta?.["tool_calls"];
+    if (!deltaCalls)
+        return;
+    for (const dc of deltaCalls) {
+        const index = Number(dc["index"] ?? 0);
+        const cur = calls.get(index) ?? { id: "", name: "", args: "" };
+        if (dc["id"])
+            cur.id = String(dc["id"]);
+        const fn = dc["function"];
+        if (fn?.["name"])
+            cur.name = String(fn["name"]);
+        const piece = fn?.["arguments"] ? String(fn["arguments"]) : "";
+        if (piece)
+            cur.args += piece;
+        calls.set(index, cur);
+        if (cur.name || piece)
+            onToolDelta?.({ id: cur.id, name: cur.name, index, delta: piece });
+        // Progresso input grandi (parita' col provider Anthropic).
+        if (onActivity && announced && cur.name) {
+            const kb = Math.floor(cur.args.length / 2048);
+            if (kb > (announced.get(index) ?? 0)) {
+                announced.set(index, kb);
+                onActivity(`scrivo ${cur.name} · ${Math.round(cur.args.length / 1024)} KB`);
+            }
+        }
+    }
+}

package/dist/providers/openai-oauth.d.ts

@@ -0,0 +1,15 @@
+import type { CompletionRequest, ModelTurn, Provider } from "../core/types.js";
+import { type OAuthCreds } from "./oauth-store.js";
+export declare class OpenAIOAuthProvider implements Provider {
+    private creds;
+    private readonly env;
+    private readonly now;
+    readonly id = "chatgpt";
+    readonly label = "ChatGPT (abbonamento)";
+    readonly models: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra", "gpt-5-codex", "gpt-5", "gpt-5-mini", "o4-mini"];
+    readonly supportsFastMode = true;
+    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number);
+    private ensureToken;
+    complete(req: CompletionRequest): Promise<ModelTurn>;
+}
+export declare function parseResponsesStream(body: ReadableStream<Uint8Array>, onDelta?: (chunk: string) => void, onToolDelta?: CompletionRequest["onToolDelta"]): Promise<ModelTurn>;