@vascend/talos 0.1.0

package/dist/packages/packages.d.ts

@@ -0,0 +1,12 @@
+export interface PackageResources {
+    readonly skills: readonly string[];
+    readonly prompts: readonly string[];
+    readonly themeDirs: readonly string[];
+    readonly extensions: readonly string[];
+}
+export interface ResolvePackageOptions {
+    readonly cwd?: string;
+    readonly projectTrusted?: boolean;
+    readonly homeDir?: string;
+}
+export declare function resolvePackages(env: NodeJS.ProcessEnv, explicit?: readonly string[], options?: ResolvePackageOptions): PackageResources;

package/dist/packages/packages.js

@@ -0,0 +1,323 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+function emptyResources() {
+    return { skills: [], prompts: [], themeDirs: [], extensions: [] };
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined;
+}
+function manifestFrom(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const row = value;
+    return {
+        skills: stringArray(row["skills"]),
+        prompts: stringArray(row["prompts"]),
+        themes: stringArray(row["themes"]),
+        extensions: stringArray(row["extensions"]),
+    };
+}
+function readManifest(dir) {
+    const pkgJson = join(dir, "package.json");
+    if (!existsSync(pkgJson))
+        return undefined;
+    try {
+        const raw = JSON.parse(readFileSync(pkgJson, "utf8"));
+        // Un autore puo' pubblicare un unico bundle per entrambi gli agenti. Il
+        // manifest Talos, quando presente, puo' specializzare quello Pi.
+        return manifestFrom(raw["talos"]) ?? manifestFrom(raw["pi"]);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function walkFiles(root, accept, depth = 8) {
+    if (!existsSync(root))
+        return [];
+    if (isFile(root))
+        return accept(root) ? [root] : [];
+    if (!isDirectory(root) || depth < 0)
+        return [];
+    const out = [];
+    let entries = [];
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries.sort()) {
+        if (entry === "node_modules" && basename(root) !== "node_modules")
+            continue;
+        const full = join(root, entry);
+        if (isDirectory(full))
+            out.push(...walkFiles(full, accept, depth - 1));
+        else if (accept(full))
+            out.push(full);
+    }
+    return out;
+}
+function conventionSkills(root) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    if (isFile(root))
+        return root.toLowerCase().endsWith(".md") ? [root] : [];
+    if (existsSync(join(root, "SKILL.md")))
+        return [root];
+    let entries = [];
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries.sort()) {
+        const full = join(root, entry);
+        if (isDirectory(full))
+            out.push(...conventionSkills(full));
+        else if (entry.toLowerCase().endsWith(".md"))
+            out.push(full);
+    }
+    return out;
+}
+function globRegex(pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\+/, "");
+    let source = "";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index];
+        if (char === "*" && normalized[index + 1] === "*") {
+            source += ".*";
+            index += 1;
+        }
+        else if (char === "*")
+            source += "[^/]*";
+        else if (char === "?")
+            source += "[^/]";
+        else
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+    return new RegExp(`^${source}(?:/.*)?$`, "i");
+}
+function matchesFilters(root, path, filters) {
+    if (filters === undefined)
+        return true;
+    if (!filters.length)
+        return false;
+    const rel = relative(root, path).replace(/\\/g, "/");
+    const positive = filters.filter((item) => !item.startsWith("!") && !item.startsWith("-") && !item.startsWith("+"));
+    let included = positive.length === 0 || positive.some((item) => globRegex(item).test(rel));
+    for (const item of filters) {
+        if ((item.startsWith("!") || item.startsWith("-")) && globRegex(item.slice(1)).test(rel))
+            included = false;
+        if (item.startsWith("+") && globRegex(item).test(rel))
+            included = true;
+    }
+    return included;
+}
+function staticGlobRoot(root, pattern) {
+    const clean = pattern.replace(/^\+/, "").replace(/\\/g, "/");
+    const wildcard = clean.search(/[?*]/);
+    if (wildcard < 0)
+        return isAbsolute(clean) ? clean : join(root, clean);
+    const slash = clean.slice(0, wildcard).lastIndexOf("/");
+    const prefix = slash < 0 ? "." : clean.slice(0, slash);
+    return isAbsolute(prefix) ? prefix : join(root, prefix);
+}
+function rootsForManifest(root, values, fallback) {
+    const entries = values === undefined ? [fallback] : values.filter((item) => !item.startsWith("!") && !item.startsWith("-"));
+    return unique(entries.map((entry) => staticGlobRoot(root, entry)).filter(existsSync));
+}
+function resolveOne(root, filter) {
+    if (!existsSync(root))
+        return emptyResources();
+    if (isFile(root)) {
+        return /\.(?:ts|js|mjs)$/i.test(root)
+            ? { ...emptyResources(), extensions: [root] }
+            : emptyResources();
+    }
+    const manifest = readManifest(root);
+    // Le directory convenzionali valgono soltanto quando manca un manifest;
+    // dentro un manifest, una categoria omessa resta disabilitata.
+    const skillSelection = manifest ? manifest.skills ?? [] : undefined;
+    const promptSelection = manifest ? manifest.prompts ?? [] : undefined;
+    const themeSelection = manifest ? manifest.themes ?? [] : undefined;
+    const extensionSelection = manifest ? manifest.extensions ?? [] : undefined;
+    const skills = rootsForManifest(root, skillSelection, "skills")
+        .flatMap((path) => conventionSkills(path))
+        .filter((path) => matchesFilters(root, path, skillSelection))
+        .filter((path) => matchesFilters(root, path, filter?.skills));
+    const prompts = rootsForManifest(root, promptSelection, "prompts")
+        .flatMap((path) => walkFiles(path, (file) => file.toLowerCase().endsWith(".md")))
+        .filter((path) => matchesFilters(root, path, promptSelection))
+        .filter((path) => matchesFilters(root, path, filter?.prompts));
+    const themeFiles = rootsForManifest(root, themeSelection, "themes")
+        .flatMap((path) => walkFiles(path, (file) => file.toLowerCase().endsWith(".json")))
+        .filter((path) => matchesFilters(root, path, themeSelection))
+        .filter((path) => matchesFilters(root, path, filter?.themes));
+    const extensions = rootsForManifest(root, extensionSelection, "extensions")
+        .flatMap((path) => walkFiles(path, (file) => /\.(?:ts|js|mjs)$/i.test(file)))
+        .filter((path) => matchesFilters(root, path, extensionSelection))
+        .filter((path) => matchesFilters(root, path, filter?.extensions));
+    // Il nome storico del campo resta `themeDirs`, ma per i package conserviamo
+    // i file esatti: in questo modo filtri ed esclusioni Pi non riaprono per
+    // sbaglio tutti gli altri temi presenti nella stessa cartella.
+    return { skills, prompts, themeDirs: themeFiles, extensions };
+}
+function readPiSettings(file) {
+    if (!existsSync(file))
+        return [];
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        return (Array.isArray(raw["packages"]) ? raw["packages"] : []).filter((entry) => typeof entry === "string" || Boolean(entry && typeof entry === "object" && typeof entry["source"] === "string"));
+    }
+    catch {
+        return [];
+    }
+}
+function npmName(source) {
+    const spec = source.replace(/^npm:/, "");
+    if (spec.startsWith("@")) {
+        const slash = spec.indexOf("/");
+        const version = spec.indexOf("@", slash + 1);
+        return version < 0 ? spec : spec.slice(0, version);
+    }
+    const version = spec.indexOf("@");
+    return version < 0 ? spec : spec.slice(0, version);
+}
+function isNpmSource(source) {
+    return source.startsWith("npm:") || (!source.includes(":") && !source.startsWith(".") && !isAbsolute(source));
+}
+function gitRelativePath(source) {
+    let value = source.replace(/^git:/, "").replace(/^git@([^:]+):/, "$1/");
+    value = value.replace(/^(?:https?|ssh|git):\/\/(?:git@)?/, "");
+    const at = value.lastIndexOf("@");
+    if (at > value.indexOf("/"))
+        value = value.slice(0, at);
+    return value.replace(/\.git$/, "").replace(/^\/+|\/+$/g, "");
+}
+function packageIdentity(entry, settingsDir) {
+    const source = typeof entry === "string" ? entry : entry.source;
+    if (isNpmSource(source)) {
+        return "npm:" + npmName(source);
+    }
+    if (/^(?:git:|https?:|ssh:|git@)/.test(source))
+        return "git:" + gitRelativePath(source).toLowerCase();
+    return "local:" + resolve(settingsDir, source).toLowerCase();
+}
+function locatePiPackage(entry, settingsDir, piRoot) {
+    const source = typeof entry === "string" ? entry : entry.source;
+    if (isNpmSource(source)) {
+        return join(piRoot, "npm", "node_modules", ...npmName(source).split("/"));
+    }
+    if (/^(?:git:|https?:|ssh:|git@)/.test(source))
+        return join(piRoot, "git", ...gitRelativePath(source).split("/"));
+    return resolve(settingsDir, source);
+}
+function piEntries(cwd, trusted, home) {
+    const globalRoot = join(home, ".pi", "agent");
+    const projectRoot = join(cwd, ".pi");
+    const merged = new Map();
+    const add = (file, root, project = false) => {
+        const settingsDir = dirname(file);
+        for (const entry of readPiSettings(file)) {
+            const identity = packageIdentity(entry, settingsDir);
+            const previous = merged.get(identity);
+            if (project && typeof entry === "object" && entry.autoload === false) {
+                if (!previous)
+                    continue;
+                const base = typeof previous.entry === "string" ? { source: previous.entry } : previous.entry;
+                const combine = (kind) => {
+                    const before = base[kind];
+                    const delta = entry[kind];
+                    return delta === undefined ? before : [...(before ?? []), ...delta];
+                };
+                merged.set(identity, {
+                    root: previous.root,
+                    entry: {
+                        source: base.source,
+                        skills: combine("skills"), prompts: combine("prompts"),
+                        themes: combine("themes"), extensions: combine("extensions"),
+                    },
+                });
+                continue;
+            }
+            merged.set(identity, { entry, root });
+        }
+    };
+    add(join(globalRoot, "settings.json"), globalRoot);
+    if (trusted)
+        add(join(projectRoot, "settings.json"), projectRoot, true);
+    return [...merged.values()];
+}
+function unique(values) {
+    const seen = new Set();
+    return values.filter((value) => {
+        const key = resolve(value).toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function resolvePackages(env, explicit = [], options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const home = options.homeDir ?? homedir();
+    const trusted = options.projectTrusted !== false;
+    const roots = [];
+    const talosHome = join(home, ".talos", "packages");
+    if (existsSync(talosHome)) {
+        for (const entry of readdirSync(talosHome).sort()) {
+            const path = join(talosHome, entry);
+            if (isDirectory(path))
+                roots.push({ path });
+        }
+    }
+    const envEntries = (env["TALOS_PACKAGES"] ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+    for (const source of [...envEntries, ...explicit]) {
+        const fake = source;
+        const piRoot = isNpmSource(source) ? join(home, ".pi", "agent") : cwd;
+        roots.push({ path: locatePiPackage(fake, cwd, piRoot) });
+    }
+    // Directory convenzionali Pi, anche senza package installati.
+    roots.push({ path: join(home, ".pi", "agent") });
+    if (trusted)
+        roots.push({ path: join(cwd, ".pi") });
+    for (const row of piEntries(cwd, trusted, home)) {
+        const settingsDir = row.root;
+        const path = locatePiPackage(row.entry, settingsDir, row.root);
+        roots.push({ path, ...(typeof row.entry === "object" ? { filter: row.entry } : {}) });
+    }
+    const skills = [];
+    const prompts = [];
+    const themeDirs = [];
+    const extensions = [];
+    for (const row of roots) {
+        const resources = resolveOne(row.path, row.filter);
+        skills.push(...resources.skills);
+        prompts.push(...resources.prompts);
+        themeDirs.push(...resources.themeDirs);
+        extensions.push(...resources.extensions);
+    }
+    return {
+        skills: unique(skills), prompts: unique(prompts),
+        themeDirs: unique(themeDirs), extensions: unique(extensions),
+    };
+}

package/dist/prompts/templates.d.ts

@@ -0,0 +1,13 @@
+export interface PromptTemplate {
+    readonly name: string;
+    readonly description: string;
+    readonly argumentHint: string;
+    readonly body: string;
+    readonly path: string;
+}
+export declare function parseTemplateFile(path: string): PromptTemplate | null;
+export declare function splitArgs(input: string): readonly string[];
+export declare function expandTemplate(body: string, args: readonly string[]): string;
+export declare function loadTemplates(cwd: string, extraPaths?: readonly string[], projectTrusted?: boolean): readonly PromptTemplate[];
+export declare function findTemplate(templates: readonly PromptTemplate[], name: string): PromptTemplate | undefined;
+export declare function renderTemplate(tpl: PromptTemplate, rawArgs: string): string;

package/dist/prompts/templates.js

@@ -0,0 +1,139 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Frontmatter YAML minimale (solo chiavi piatte stringa): description e
+// argument-hint. Tutto il resto e' il corpo del template.
+function parseFrontmatter(raw) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+    if (!m)
+        return { body: raw };
+    const head = m[1] ?? "";
+    const body = m[2] ?? "";
+    let description;
+    let argumentHint;
+    for (const line of head.split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim());
+        if (!kv)
+            continue;
+        const key = (kv[1] ?? "").toLowerCase();
+        const value = unquote((kv[2] ?? "").trim());
+        if (key === "description")
+            description = value;
+        else if (key === "argument-hint" || key === "argumenthint")
+            argumentHint = value;
+    }
+    return { description, argumentHint, body };
+}
+function unquote(s) {
+    if (s.length >= 2 && ((s[0] === '"' && s.at(-1) === '"') || (s[0] === "'" && s.at(-1) === "'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+function firstNonEmptyLine(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t)
+            return t.length > 80 ? t.slice(0, 77) + "..." : t;
+    }
+    return "";
+}
+export function parseTemplateFile(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const fm = parseFrontmatter(raw);
+        const name = path.replace(/.*[\\/]/, "").replace(/\.md$/i, "");
+        const body = fm.body.replace(/^\s+/, "");
+        return {
+            name,
+            description: fm.description ?? firstNonEmptyLine(body),
+            argumentHint: fm.argumentHint ?? "",
+            body,
+            path,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// Suddivide la riga di argomenti rispettando le virgolette: `Button "click handler"`
+// -> ["Button", "click handler"].
+export function splitArgs(input) {
+    const out = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        out.push(m[1] ?? m[2] ?? m[3] ?? "");
+    }
+    return out;
+}
+// Espande le sostituzioni: $1..$N posizionali, $@ / $ARGUMENTS tutti gli
+// argomenti, ${1:-default} con fallback, ${@:N} e ${@:N:L} slice (1-indexed).
+export function expandTemplate(body, args) {
+    const all = args.join(" ");
+    let out = body;
+    // ${@:N:L} e ${@:N}
+    out = out.replace(/\$\{@:(\d+)(?::(\d+))?\}/g, (_full, nRaw, lRaw) => {
+        const start = Math.max(1, parseInt(nRaw, 10));
+        const slice = lRaw !== undefined
+            ? args.slice(start - 1, start - 1 + parseInt(lRaw, 10))
+            : args.slice(start - 1);
+        return slice.join(" ");
+    });
+    // ${N:-default}
+    out = out.replace(/\$\{(\d+):-([^}]*)\}/g, (_full, nRaw, def) => {
+        const v = args[parseInt(nRaw, 10) - 1];
+        return v !== undefined && v !== "" ? v : def;
+    });
+    // $@ e $ARGUMENTS
+    out = out.replace(/\$ARGUMENTS\b/g, all).replace(/\$@/g, all);
+    // $1..$N
+    out = out.replace(/\$(\d+)/g, (_full, nRaw) => args[parseInt(nRaw, 10) - 1] ?? "");
+    return out;
+}
+function templateDirs(cwd, projectTrusted) {
+    const dirs = [
+        join(homedir(), ".talos", "agent", "prompts"),
+        join(homedir(), ".talos", "prompts"),
+    ];
+    if (projectTrusted)
+        dirs.push(join(cwd, ".talos", "prompts"));
+    return dirs;
+}
+// Discovery non ricorsiva (come Pi) dei template da tutte le dir + path extra
+// (es. --prompt-template). I path extra sovrascrivono per nome. Le dir di
+// progetto richiedono project trust.
+export function loadTemplates(cwd, extraPaths = [], projectTrusted = true) {
+    const byName = new Map();
+    for (const dir of templateDirs(cwd, projectTrusted)) {
+        if (!existsSync(dir))
+            continue;
+        let files;
+        try {
+            files = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (!file.toLowerCase().endsWith(".md"))
+                continue;
+            const tpl = parseTemplateFile(join(dir, file));
+            if (tpl)
+                byName.set(tpl.name, tpl);
+        }
+    }
+    for (const path of extraPaths) {
+        const tpl = parseTemplateFile(path);
+        if (tpl)
+            byName.set(tpl.name, tpl);
+    }
+    return [...byName.values()];
+}
+export function findTemplate(templates, name) {
+    return templates.find((t) => t.name === name);
+}
+// Espande un template in input pronto per il modello dato l'argomento grezzo.
+export function renderTemplate(tpl, rawArgs) {
+    return expandTemplate(tpl.body, splitArgs(rawArgs)).trim();
+}

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

@@ -0,0 +1,13 @@
+import type { CompletionRequest, ModelTurn, Provider } from "../core/types.js";
+import { type OAuthCreds } from "./oauth-store.js";
+export declare class AnthropicOAuthProvider implements Provider {
+    private creds;
+    private readonly env;
+    private readonly now;
+    readonly id = "claude-code";
+    readonly label = "Claude Code (abbonamento)";
+    readonly models: readonly ["claude-fable-5-1", "claude-fable-5", "claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5-20251001", "claude-opus-4-8", "claude-sonnet-4-6"];
+    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number);
+    private ensureToken;
+    complete(req: CompletionRequest): Promise<ModelTurn>;
+}

package/dist/providers/anthropic-oauth.js

@@ -0,0 +1,124 @@
+import { messaggioErroreTurno } from "../core/image-limits.js";
+import { planLimitsFromHeaders } from "./plan-limits.js";
+import { toApiMessages, parseStream, applyMessageCache, wants1m, CONTEXT_1M_BETA } from "./anthropic.js";
+import { anthropicEffort } from "./effort.js";
+import { resolveMaxTokens } from "../core/model-limits.js";
+import { ANTHROPIC_MODELS } from "./catalog.js";
+import { isExpired, writeClaudeCreds, } from "./oauth-store.js";
+const API_URL = "https://api.anthropic.com/v1/messages";
+const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const VERSION = "2023-06-01";
+const OAUTH_BETA = "oauth-2025-04-20";
+// Client id pubblico del CLI Claude Code (necessario al refresh del token).
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+// L'API OAuth degli abbonamenti accetta la richiesta solo se il primo blocco
+// di system e' quello del CLI ufficiale. Le regole di Talos seguono come
+// secondo blocco.
+// HANDSHAKE OAuth: l'API dell'abbonamento Claude Code verifica che il PRIMO
+// blocco di system sia ESATTAMENTE questa stringa (misura anti-abuso). Non e'
+// un prompt di comportamento (quello, in notazione Danilov, e' il blocco
+// successivo = req.system): e' un token di protocollo, va lasciato byte-esatto
+// o le richieste vengono rifiutate.
+const CLAUDE_CODE_SYSTEM = "You are Claude Code, Anthropic's official CLI for Claude.";
+// Provider Claude Code (abbonamento Claude Pro/Max). Usa il token OAuth del
+// login gia' fatto dal CLI `claude`, NON una API key a consumo. Mantiene i tool
+// di Talos: e' una normale chiamata all'API Messages con auth Bearer.
+export class AnthropicOAuthProvider {
+    creds;
+    env;
+    now;
+    id = "claude-code";
+    label = "Claude Code (abbonamento)";
+    models = ANTHROPIC_MODELS;
+    constructor(creds, env, now = () => Date.now()) {
+        this.creds = creds;
+        this.env = env;
+        this.now = now;
+    }
+    async ensureToken(signal) {
+        if (!isExpired(this.creds, this.now()) || !this.creds.refreshToken) {
+            return this.creds.accessToken;
+        }
+        try {
+            const res = await fetch(TOKEN_URL, {
+                method: "POST",
+                signal,
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    grant_type: "refresh_token",
+                    refresh_token: this.creds.refreshToken,
+                    client_id: CLIENT_ID,
+                }),
+            });
+            if (!res.ok)
+                return null;
+            const j = (await res.json());
+            this.creds = {
+                accessToken: String(j["access_token"] ?? ""),
+                refreshToken: String(j["refresh_token"] ?? this.creds.refreshToken),
+                expiresAt: this.now() + Number(j["expires_in"] ?? 0) * 1000,
+            };
+            writeClaudeCreds(this.env, this.creds);
+            return this.creds.accessToken;
+        }
+        catch {
+            return null;
+        }
+    }
+    async complete(req) {
+        const token = await this.ensureToken(req.signal);
+        if (!token) {
+            return {
+                text: "Token Claude Code non valido o scaduto. Esegui `claude` e accedi al tuo abbonamento.",
+                toolCalls: [],
+                stopReason: "error",
+            };
+        }
+        const body = {
+            model: req.model,
+            max_tokens: resolveMaxTokens(req.maxTokens, `anthropic/${req.model}`),
+            system: [
+                { type: "text", text: CLAUDE_CODE_SYSTEM },
+                { type: "text", text: req.system, cache_control: { type: "ephemeral" } },
+                ...(req.turnContext ? [{
+                        type: "text",
+                        text: `[HORIZON_TURN_CONTEXT]\n${req.turnContext}\n[/HORIZON_TURN_CONTEXT]`,
+                    }] : []),
+            ],
+            messages: applyMessageCache(toApiMessages(req)),
+            stream: true,
+            tools: req.tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.inputSchema,
+            })),
+        };
+        const effort = anthropicEffort(req.effort, req.model);
+        if (effort)
+            Object.assign(body, effort);
+        const beta = wants1m(req.model, this.env) ? `${OAUTH_BETA},${CONTEXT_1M_BETA}` : OAUTH_BETA;
+        const res = await fetch(API_URL, {
+            method: "POST",
+            signal: req.signal,
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`,
+                "anthropic-version": VERSION,
+                "anthropic-beta": beta,
+            },
+            body: JSON.stringify(body),
+        });
+        const limits = planLimitsFromHeaders(this.id, res.headers);
+        if (!res.ok || !res.body) {
+            const detail = await res.text().catch(() => res.statusText);
+            return {
+                text: messaggioErroreTurno("Claude Code OAuth", res.status, detail),
+                toolCalls: [],
+                stopReason: "error",
+                ...(limits ? { limits } : {}),
+            };
+        }
+        const turn = await parseStream(res.body, req.onDelta, req.onActivity, req.onReasoning);
+        return limits ? { ...turn, limits } : turn;
+    }
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,27 @@
+import type { CompletionRequest, ModelTurn, Provider } from "../core/types.js";
+interface ApiBlock {
+    type: string;
+    id?: string;
+    tool_use_id?: string;
+    [k: string]: unknown;
+}
+interface ApiMessage {
+    role: string;
+    content: ApiBlock[];
+}
+export declare function toApiMessages(req: CompletionRequest): unknown[];
+export declare function normalizeToolPairing(messages: ApiMessage[]): ApiMessage[];
+export declare function withSystemCache(system: string, turnContext?: string): unknown[];
+export declare function applyMessageCache(messages: unknown[]): unknown[];
+export declare const CONTEXT_1M_BETA = "context-1m-2025-08-07";
+export declare function wants1m(model: string, env: NodeJS.ProcessEnv): boolean;
+export declare class AnthropicProvider implements Provider {
+    private readonly apiKey;
+    readonly id = "anthropic";
+    readonly label = "Anthropic";
+    readonly models: readonly ["claude-fable-5-1", "claude-fable-5", "claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5-20251001", "claude-opus-4-8", "claude-sonnet-4-6"];
+    constructor(apiKey: 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 {};