@ryukin-dev/pi-featherless-kali 1.1.0

package/src/handlers/update-check.ts

@@ -0,0 +1,202 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const PACKAGE_JSON = new URL("../../package.json", import.meta.url);
+const CHANGELOG = new URL("../../CHANGELOG.md", import.meta.url);
+const AGENT_DIR = `${homedir()}/.pi/agent`;
+const LAST_UPDATE_FILE = `${AGENT_DIR}/.kali-ai-last-update`;
+
+function getCurrentVersion(): string {
+    const pkg = JSON.parse(readFileSync(PACKAGE_JSON, "utf8"));
+    return pkg.version as string;
+}
+
+function parseVersion(version: string): number[] {
+    return version
+        .replace(/^v/, "")
+        .split(".")
+        .map((part) => parseInt(part, 10));
+}
+
+function isNewer(a: string, b: string): boolean {
+    const av = parseVersion(a);
+    const bv = parseVersion(b);
+    const len = Math.max(av.length, bv.length);
+    for (let i = 0; i < len; i++) {
+        const ai = av[i] ?? 0;
+        const bi = bv[i] ?? 0;
+        if (ai > bi) return true;
+        if (ai < bi) return false;
+    }
+    return false;
+}
+
+async function fetchLatestVersion(): Promise<string | undefined> {
+    try {
+        const pkg = JSON.parse(readFileSync(PACKAGE_JSON, "utf8"));
+        const name = encodeURIComponent(pkg.name as string);
+        const res = await fetch(`https://registry.npmjs.org/${name}/latest`, {
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok) return undefined;
+        const data = await res.json();
+        return typeof data.version === "string" ? data.version : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+function readLatestChangelog(): string {
+    try {
+        const text = readFileSync(CHANGELOG, "utf8");
+        const lines = text.split("\n");
+        const start = lines.findIndex((l) => l.startsWith("## "));
+        if (start === -1) return "Kein Changelog vorhanden.";
+        const end = lines.findIndex((l, i) => i > start && l.startsWith("## "));
+        return lines
+            .slice(start, end === -1 ? undefined : end)
+            .join("\n")
+            .trim();
+    } catch {
+        return "Changelog nicht lesbar.";
+    }
+}
+
+function bannerLines(version: string, lines: string[]): string[] {
+    return [
+        `KaliAI v${version}`,
+        ...lines,
+    ];
+}
+
+function readLastShownVersion(): string | undefined {
+    try {
+        if (!existsSync(LAST_UPDATE_FILE)) return undefined;
+        const data = JSON.parse(readFileSync(LAST_UPDATE_FILE, "utf8"));
+        return typeof data.version === "string" ? data.version : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+function writeLastShownVersion(version: string): void {
+    try {
+        if (!existsSync(AGENT_DIR)) mkdirSync(AGENT_DIR, { recursive: true });
+        writeFileSync(
+            LAST_UPDATE_FILE,
+            JSON.stringify({ version }, null, 2),
+            "utf8",
+        );
+    } catch {
+        // ignore
+    }
+}
+
+export function registerUpdateCheck(pi: ExtensionAPI) {
+    pi.on("session_start", async (_event, ctx) => {
+        if (!ctx.ui) return;
+
+        const current = getCurrentVersion();
+        const latest = await fetchLatestVersion();
+        const outdated = latest ? isNewer(latest, current) : false;
+
+        if (outdated && latest) {
+            ctx.ui.setWidget(
+                "kali-update-banner",
+                bannerLines(current, [
+                    `Update verfügbar: v${latest}`,
+                    `Installieren mit /update`,
+                    `Neuigkeiten mit /whatsnew`,
+                ]),
+                { placement: "aboveEditor" },
+            );
+            return;
+        }
+
+        const lastShown = readLastShownVersion();
+        if (lastShown !== current) {
+            writeLastShownVersion(current);
+            ctx.ui.setWidget(
+                "kali-update-banner",
+                bannerLines(current, [
+                    "Update installiert.",
+                    ...readLatestChangelog().split("\n").slice(0, 12),
+                ]),
+                { placement: "aboveEditor" },
+            );
+            setTimeout(() => {
+                ctx.ui.setWidget("kali-update-banner", undefined);
+            }, 10000);
+        }
+    });
+
+    pi.registerCommand("update", {
+        description: "KaliAI auf die neueste npm-Version aktualisieren.",
+        handler: async (_args, ctx) => {
+            if (!ctx.ui) return;
+            const current = getCurrentVersion();
+            const latest = await fetchLatestVersion();
+            if (!latest) {
+                ctx.ui.notify("Versionsprüfung fehlgeschlagen.", "error");
+                return;
+            }
+            if (!isNewer(latest, current)) {
+                ctx.ui.notify(`KaliAI ist aktuell (v${current}).`, "info");
+                return;
+            }
+            const ok = await ctx.ui.confirm(
+                "KaliAI aktualisieren",
+                `v${current} -> v${latest} installieren?`,
+            );
+            if (!ok) return;
+
+            ctx.ui.setWorkingMessage("KaliAI wird aktualisiert...");
+            const result = await pi.exec(
+                "npm",
+                ["install", "-g", `@earendil-works/pi-featherless-kali@${latest}`],
+                { timeout: 120000 },
+            );
+            ctx.ui.setWorkingMessage();
+
+            if (result.code !== 0) {
+                ctx.ui.notify(
+                    `Update fehlgeschlagen: ${result.stderr || result.stdout}`,
+                    "error",
+                );
+                return;
+            }
+
+            writeLastShownVersion(latest);
+            ctx.ui.setWidget(
+                "kali-update-banner",
+                bannerLines(latest, [
+                    "Update installiert.",
+                    "Bitte KaliAI neu starten.",
+                    ...readLatestChangelog().split("\n").slice(0, 8),
+                ]),
+                { placement: "aboveEditor" },
+            );
+            setTimeout(() => {
+                ctx.ui.setWidget("kali-update-banner", undefined);
+            }, 10000);
+        },
+    });
+
+    pi.registerCommand("whatsnew", {
+        description: "Zeigt die neuesten KaliAI-Änderungen an.",
+        handler: async (_args, ctx) => {
+            if (!ctx.ui) return;
+            const current = getCurrentVersion();
+            const latest = await fetchLatestVersion();
+            const title = latest
+                ? `KaliAI v${current} (aktuellste npm: v${latest})`
+                : `KaliAI v${current}`;
+            ctx.ui.setWidget(
+                "kali-update-banner",
+                [title, "", ...readLatestChangelog().split("\n")],
+                { placement: "aboveEditor" },
+            );
+        },
+    });
+}

package/src/models/fetch.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const BASE_URL = "https://api.featherless.ai/v1";
+
+export async function fetchModelsJson(): Promise<string> {
+    const response = await fetch(`${BASE_URL}/models`, {
+        credentials: "include",
+        headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-US",
+            "Upgrade-Insecure-Requests": "1",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "none",
+            "Sec-Fetch-User": "?1",
+            "Priority": "u=0, i",
+            "Pragma": "no-cache",
+            "Cache-Control": "no-cache",
+        },
+        method: "GET",
+        mode: "cors",
+    });
+
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return JSON.stringify(data, null, 2) + '\n';
+}

package/src/models.ts

@@ -0,0 +1,262 @@
+
+
+interface ModelClass {
+    context_limit: number;
+    concurrency_cost: number;
+    chars_per_token?: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+}
+
+const MODEL_CLASSES: Record<string, ModelClass> = {
+    "glm4-9b": {
+        context_limit: 32768,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qwen25-7b": {
+        context_limit: 32768,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qwen25-3b": {
+        context_limit: 32768,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "glm4-32b": {
+        context_limit: 32768,
+        concurrency_cost: 2,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "glm47-flash": {
+        context_limit: 32768,
+        concurrency_cost: 2,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "glm47-357b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "glm51-754b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "glm5-754b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "slf-dstl-1.5b": {
+        context_limit: 32768,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "tiny-agent-1.5b": {
+        context_limit: 32768,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "minimax-m25": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "kimi-k2": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "kimi-k25": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "deepseek-v3.2": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "deepseek31-685b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "mistral-24b-2503": {
+        context_limit: 32768,
+        concurrency_cost: 2,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qwen3-32b": {
+        context_limit: 32768,
+        concurrency_cost: 2,
+        chars_per_token: 3.12,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qwen3-235b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qwen3-coder-480b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "nemotron3-120b": {
+        context_limit: 32768,
+        concurrency_cost: 4,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qrwkv-72b-32k": {
+        context_limit: 65536,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+    "qrwkv-32b-32k": {
+        context_limit: 32768,
+        concurrency_cost: 1,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    },
+};
+
+export interface ModelEntry {
+    id: string;
+    model_class: string;
+    reasoning?: boolean;
+    tool_use?: boolean;
+}
+
+export const MODELS: ModelEntry[] = [
+    {
+        id: "zai-org/GLM-Z1-9B-0414",
+        model_class: "glm4-9b",
+        tool_use: true,
+    },
+    {
+        id: "Qwen/Qwen2.5-Coder-7B-Instruct",
+        model_class: "qwen25-7b",
+        tool_use: true,
+    },
+    {
+        id: "Qwen/Qwen2.5-3B-Instruct",
+        model_class: "qwen25-3b",
+        tool_use: true,
+    },
+    { id: "zai-org/GLM-4.7-Flash", model_class: "glm47-flash", tool_use: true },
+    { id: "RyanYr/slf-dstl_Q2.5-1.5B-It_tooluse_SFT", model_class: "slf-dstl-1.5b", tool_use: true },
+    { id: "driaforall/Tiny-Agent-a-1.5B", model_class: "tiny-agent-1.5b", tool_use: true },
+    { id: "zai-org/GLM-4.7", model_class: "glm47-357b", tool_use: true },
+    { id: "zai-org/GLM-5", model_class: "glm51-754b", tool_use: true },
+    { id: "zai-org/GLM-5", model_class: "glm5-754b", tool_use: true },
+    {
+        id: "MiniMaxAI/MiniMax-M2.5",
+        model_class: "minimax-m25",
+        tool_use: true,
+    },
+    {
+        id: "moonshotai/Kimi-K2-Instruct",
+        model_class: "kimi-k2",
+        tool_use: true,
+    },
+    { id: "moonshotai/Kimi-K2.5", model_class: "kimi-k25", tool_use: true },
+    {
+        id: "deepseek-ai/DeepSeek-V3.2",
+        model_class: "deepseek-v3.2",
+        tool_use: true,
+    },
+    {
+        id: "deepseek-ai/DeepSeek-V3.1",
+        model_class: "deepseek31-685b",
+        tool_use: true,
+    },
+    {
+        id: "mistralai/Mistral-Small-3.2-24B-Instruct-2506",
+        model_class: "mistral-24b-2503",
+        tool_use: true,
+    },
+    {
+        id: "Qwen/Qwen3-32B",
+        model_class: "qwen3-32b",
+        reasoning: true,
+        tool_use: true,
+    },
+    {
+        id: "Qwen/Qwen3-235B-A22B",
+        model_class: "qwen3-235b",
+        reasoning: true,
+        tool_use: true,
+    },
+    {
+        id: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+        model_class: "qwen3-coder-480b",
+        reasoning: true,
+        tool_use: true,
+    },
+    {
+        id: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
+        model_class: "nemotron3-120b",
+        tool_use: true,
+    },
+    {
+        id: "recursal/RWKV6Qwen2.5-32B-QwQ-Preview",
+        model_class: "qrwkv-32b-32k",
+        tool_use: true,
+    },
+];
+
+export function getModelConfig(entry: ModelEntry) {
+    const mc = MODEL_CLASSES[entry.model_class];
+    if (!mc) throw new Error(`Unknown model_class: ${entry.model_class}`);
+
+    return {
+        id: entry.id,
+        name: entry.id,
+        reasoning: entry.reasoning ?? false,
+        contextWindow: mc.context_limit,
+        maxTokens: 131072, // Support infinite generation beyond context window
+        input: ["text"] as ("text" | "image")[],
+        cost: mc.cost,
+    };
+}
+
+export function getRealContextLimit(modelId: string): number | undefined {
+    const entry = MODELS.find((m) => m.id === modelId);
+    if (!entry) return undefined;
+    const mc = MODEL_CLASSES[entry.model_class];
+    return mc?.context_limit;
+}
+
+export function getCharsPerToken(modelClass: string): number {
+    const mc = MODEL_CLASSES[modelClass];
+    return mc?.chars_per_token ?? 3.2;
+}
+
+export function getConcurrencyCost(modelClass: string): number {
+    const mc = MODEL_CLASSES[modelClass];
+    if (!mc) throw new Error(`Unknown model_class: ${modelClass}`);
+    return mc.concurrency_cost;
+}
+
+export function getModelClass(modelId: string): string | undefined {
+    const entry = MODELS.find((m) => m.id === modelId);
+    if (entry) return entry.model_class;
+
+    const lower = modelId.toLowerCase();
+    if (lower.includes("qrwkv-72b") || lower.includes("qrwkv7b-72b")) {
+        return "qrwkv-72b-32k";
+    }
+    if (lower.includes("qrwkv-32b") || lower.includes("qrwkv7b-32b")) {
+        return "qrwkv-32b-32k";
+    }
+    if (lower.includes("qwen3-32b")) {
+        return "qwen3-32b";
+    }
+    return undefined;
+}

package/src/test-api.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+const TIMEOUT_MS = 20000;
+const BASE_URL = "https://api.featherless.ai/v1";
+const MODEL_ID = "zai-org/GLM-5";
+
+async function withTimeout<T>(promise: Promise<T>, ms: number = TIMEOUT_MS): Promise<T> {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms);
+        promise.then(
+            (result) => { clearTimeout(timer); resolve(result); },
+            (error) => { clearTimeout(timer); reject(error); }
+        );
+    });
+}
+
+async function testPing(apiKey: string) {
+    console.log("🏓 Pinging API (simple chat)...");
+    const start = Date.now();
+    const response = await withTimeout(
+        fetch(`${BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                model: MODEL_ID,
+                messages: [{ role: "user", content: "Reply with: pong" }],
+                max_tokens: 10
+            })
+        })
+    );
+    const elapsed = Date.now() - start;
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API error ${response.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const usage = data.usage || {};
+    console.log(`✅ API reachable in ${elapsed}ms`);
+    console.log(`   Model: ${MODEL_ID}`);
+    console.log(`   Usage: ${JSON.stringify(usage)}`);
+}
+
+async function testChat(apiKey: string) {
+    console.log("🤖 Testing chat completion...");
+    const start = Date.now();
+    const response = await withTimeout(
+        fetch(`${BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                model: MODEL_ID,
+                messages: [{ role: "user", content: "Say 'hello' and nothing else." }],
+                max_tokens: 50
+            })
+        })
+    );
+    const elapsed = Date.now() - start;
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Request failed ${response.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content || "(no content)";
+    const reasoning = data.choices?.[0]?.message?.reasoning || "";
+    const usage = data.usage || {};
+    console.log(`✅ Chat completion succeeded in ${elapsed}ms`);
+    console.log(`   Model: ${MODEL_ID}`);
+    console.log(`   Response: "${content}"`);
+    if (reasoning) console.log(`   Reasoning: "${reasoning.slice(0, 100)}..."`);
+    console.log(`   Usage: ${JSON.stringify(usage)}`);
+}
+
+async function testTools(apiKey: string) {
+    console.log("🔧 Testing tool calling...");
+    const start = Date.now();
+    const response = await withTimeout(
+        fetch(`${BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                model: MODEL_ID,
+                messages: [{ role: "user", content: "What is 2+2? Use the calculator tool." }],
+                max_tokens: 100,
+                tools: [{
+                    type: "function",
+                    function: {
+                        name: "calculator",
+                        description: "Perform arithmetic",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                expression: { type: "string", description: "Math expression" }
+                            },
+                            required: ["expression"]
+                        }
+                    }
+                }]
+            })
+        })
+    );
+    const elapsed = Date.now() - start;
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Request failed ${response.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    const message = choice?.message || {};
+    const toolCalls = message.tool_calls || [];
+    console.log(`✅ Tool calling test completed in ${elapsed}ms`);
+    console.log(`   Model: ${MODEL_ID}`);
+    console.log(`   Tool calls: ${toolCalls.length}`);
+    console.log(`   Content: "${message.content || "(none)"}"`);
+    if (toolCalls.length > 0) {
+        console.log(`   Tool calls: ${JSON.stringify(toolCalls, null, 2)}`);
+    }
+}
+
+async function main() {
+    const apiKey = process.env.FEATHERLESS_API_KEY;
+    if (!apiKey) {
+        console.error("❌ FEATHERLESS_API_KEY not set");
+        process.exit(1);
+    }
+    const command = process.argv[2] || "ping";
+    try {
+        switch (command) {
+            case "ping":
+                await testPing(apiKey);
+                break;
+            case "chat":
+                await testChat(apiKey);
+                break;
+            case "tools":
+                await testTools(apiKey);
+                break;
+            default:
+                console.error(`Unknown command: ${command}`);
+                console.error("Usage: npx tsx src/test-api.ts [ping|chat|tools]");
+                process.exit(1);
+        }
+    } catch (error) {
+        console.error(`❌ Test failed: ${error}`);
+        process.exit(1);
+    }
+}
+
+main();