@ryukin-dev/pi-featherless-kali 1.1.0

package/src/handlers/compaction.ts

@@ -0,0 +1,66 @@
+import type { Context } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { convertToLlm } from "@earendil-works/pi-coding-agent";
+import { PROVIDER, getApiKey } from "./shared";
+
+const SUMMARY_PROMPT = `Summarize the conversation so far. Focus on:
+- Files read/modified and key findings
+- Errors encountered and resolutions
+- Decisions made and reasoning
+- Current task state and next steps
+
+Be concise but preserve essential context for continuing the work.`;
+
+export function registerCompaction(pi: ExtensionAPI) {
+    pi.on("session_before_compact", async (event, ctx) => {
+        const model = ctx.model;
+        if (!model || model.provider !== PROVIDER) return;
+
+        const apiKey = await getApiKey(ctx);
+        if (!apiKey) return;
+
+        const { preparation, signal } = event;
+        const {
+            messagesToSummarize,
+            turnPrefixMessages,
+            tokensBefore,
+            firstKeptEntryId,
+            previousSummary,
+        } = preparation;
+
+        const llmMessages = convertToLlm([...messagesToSummarize, ...turnPrefixMessages]);
+        
+        const messages: Context["messages"] = [
+            ...llmMessages,
+            {
+                role: "user" as const,
+                content: [{ type: "text" as const, text: SUMMARY_PROMPT }],
+                timestamp: Date.now(),
+            },
+        ];
+
+        try {
+            const result = await completeSimple(
+                model,
+                { messages },
+                { apiKey, maxTokens: 2048, signal },
+            );
+
+            const summaryText = result.content
+                .filter((c: any) => c.type === "text")
+                .map((c: any) => c.text)
+                .join("\n");
+
+            if (!summaryText.trim()) return;
+
+            const summary = previousSummary
+                ? `## Previous Context\n${previousSummary}\n\n## Recent Activity\n${summaryText}`
+                : summaryText;
+
+            return { compaction: { summary, firstKeptEntryId, tokensBefore } };
+        } catch {
+            return;
+        }
+    });
+}

package/src/handlers/concurrency.ts

@@ -0,0 +1,70 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getConcurrencyCost, getModelClass } from "../models";
+import { PROVIDER } from "./shared";
+
+interface ConcurrencyState {
+    activeRequests: Map<string, number>;
+    totalCost: number;
+    limit: number;
+}
+
+const state: ConcurrencyState = {
+    activeRequests: new Map(),
+    totalCost: 0,
+    limit: 4,
+};
+let requestIdCounter = 0;
+
+function parse429Limit(errorText: string): number | null {
+    const match = errorText.match(/plan limit:\s*(\d+)/i);
+    return match ? parseInt(match[1], 10) : null;
+}
+
+export function handleApiError(error: any): void {
+    const message = error?.message || String(error);
+    if (message.includes("429") || message.includes("Concurrency limit")) {
+        const limit = parse429Limit(message);
+        if (limit !== null) state.limit = limit;
+    }
+}
+
+function release(modelId: string): boolean {
+    const modelClass = getModelClass(modelId);
+    if (modelClass && state.totalCost > 0) {
+        const cost = getConcurrencyCost(modelClass);
+        for (const [id, c] of Array.from(state.activeRequests)) {
+            if (c === cost) {
+                state.activeRequests.delete(id);
+                state.totalCost -= c;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+export function registerConcurrencyTracking(pi: ExtensionAPI) {
+    pi.on("session_start", async () => {
+        state.activeRequests.clear();
+        state.totalCost = 0;
+    });
+
+    pi.on("before_provider_request", async (event, ctx) => {
+        const model = ctx.model;
+        if (model?.provider !== PROVIDER) return;
+
+        const modelClass = getModelClass(model.id);
+        if (!modelClass) return;
+
+        const cost = getConcurrencyCost(modelClass);
+        const requestId = `req_${++requestIdCounter}`;
+        state.activeRequests.set(requestId, cost);
+        state.totalCost += cost;
+    });
+
+    pi.on("turn_end", async (_event, ctx) => {
+        const model = ctx.model;
+        if (model?.provider !== PROVIDER) return;
+        release(model.id);
+    });
+}

package/src/handlers/context.test.ts

@@ -0,0 +1,260 @@
+
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { getModelClass } from "../models";
+
+function parseToolCallsFromText(
+    text: string,
+): Array<{ id: string; name: string; arguments: Record<string, any> }> | null {
+    const regex = /<function>\s*(\{.*?\})\s*<\/function>/gs;
+    const matches = [...text.matchAll(regex)];
+    const results = [];
+
+    for (const match of matches) {
+        try {
+            const data = JSON.parse(match[1]);
+            if (data.name && data.arguments !== undefined) {
+                results.push({
+                    id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+                    name: data.name,
+                    arguments: typeof data.arguments === 'string'
+                        ? JSON.parse(data.arguments)
+                        : data.arguments,
+                });
+            }
+        } catch {
+        }
+    }
+
+    return results.length > 0 ? results : null;
+}
+
+describe("parseToolCallsFromText", () => {
+    it("should parse a single tool call from RWKV format", () => {
+        const text = `<function>{"name": "ls", "arguments": {"path": "/tmp"}}</function>`;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(1);
+        expect(result![0].name).toBe("ls");
+        expect(result![0].arguments).toEqual({ path: "/tmp" });
+        expect(result![0].id).toMatch(/^call_\d+_/);
+    });
+
+    it("should parse multiple tool calls in sequence", () => {
+        const text = `
+            <function>{"name": "ls", "arguments": {"path": "/tmp"}}</function>
+            <function>{"name": "read", "arguments": {"path": "/etc/hosts"}}</function>
+        `;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result![0].name).toBe("ls");
+        expect(result![1].name).toBe("read");
+    });
+
+    it("should handle tool calls with complex arguments", () => {
+        const text = `<function>{"name": "grep", "arguments": {"pattern": "TODO", "files": ["*.ts", "*.js"]}}</function>`;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result![0].name).toBe("grep");
+        expect(result![0].arguments).toEqual({ pattern: "TODO", files: ["*.ts", "*.js"] });
+    });
+
+    it("should handle arguments as nested JSON strings", () => {
+        const argsJson = JSON.stringify({ path: "/tmp", recursive: true });
+        const text = `<function>{"name": "bash", "arguments": "${argsJson.replace(/"/g, '\\"')}"}</function>`;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result![0].name).toBe("bash");
+        expect(result![0].arguments).toEqual({ path: "/tmp", recursive: true });
+    });
+
+    it("should return null for text without tool calls", () => {
+        const text = "Hello, this is just a regular message without tool calls.";
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).toBeNull();
+    });
+
+    it("should skip invalid JSON and continue parsing", () => {
+        const text = `
+            <function>{"name": "ls", "arguments": {"path": "/tmp"}}</function>
+            <function>{"invalid": "json"}</function>
+            <function>{"name": "read", "arguments": {"path": "/etc"}}</function>
+        `;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+    });
+
+    it("should handle whitespace variations", () => {
+        const text = `
+            <function>  {"name": "ls", "arguments": {}}  </function>
+            <function>
+                {"name": "read", "arguments": {"path": "/etc"}}
+            </function>
+        `;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+    });
+
+    it("should handle empty arguments", () => {
+        const text = `<function>{"name": "noop", "arguments": {}}</function>`;
+        const result = parseToolCallsFromText(text);
+        
+        expect(result).not.toBeNull();
+        expect(result![0].name).toBe("noop");
+        expect(result![0].arguments).toEqual({});
+    });
+});
+
+describe("message_end handler logic simulation", () => {
+    it("should convert text blocks with tool calls to toolCall blocks", () => {
+        const event = {
+            message: {
+                role: "assistant",
+                content: [
+                    { type: "text", text: "<function>{\"name\": \"ls\", \"arguments\": {\"path\": \"/tmp\"}}</function>" },
+                ],
+                stopReason: "stop",
+            },
+        };
+
+        const MODELS_NEED_TOOL_CALL_PARSING = new Set(["qrwkv-72b-32k", "qrwkv-32b-32k"]);
+        const modelClass = "qrwkv-72b-32k";
+        
+        if (!MODELS_NEED_TOOL_CALL_PARSING.has(modelClass)) {
+        }
+
+        const hasToolCalls = event.message.content?.some(
+            (block: any) => block.type === "toolCall"
+        );
+
+        const newContent: any[] = [];
+        let foundToolCalls = false;
+
+        for (const block of event.message.content ?? []) {
+            if (block.type === "text" && block.text) {
+                const parsed = parseToolCallsFromText(block.text);
+                if (parsed && parsed.length > 0) {
+                    for (const tc of parsed) {
+                        newContent.push({
+                            type: "toolCall",
+                            id: tc.id,
+                            name: tc.name,
+                            arguments: tc.arguments,
+                        });
+                    }
+                    foundToolCalls = true;
+                    continue;
+                }
+            }
+            newContent.push(block);
+        }
+
+        if (foundToolCalls) {
+            event.message.content = newContent;
+            event.message.stopReason = "toolUse";
+        }
+
+        expect(event.message.content).toHaveLength(1);
+        const toolBlock = event.message.content[0] as any;
+        expect(toolBlock.type).toBe("toolCall");
+        expect(toolBlock.name).toBe("ls");
+        expect(toolBlock.arguments).toEqual({ path: "/tmp" });
+        expect(event.message.stopReason).toBe("toolUse");
+    });
+
+    it("should preserve text blocks that don't contain tool calls", () => {
+        const event = {
+            message: {
+                role: "assistant",
+                content: [
+                    { type: "text", text: "Hello, I can help you!" },
+                    { type: "text", text: "<function>{\"name\": \"ls\", \"arguments\": {\"path\": \"/\"}}</function>" },
+                    { type: "text", text: "Let me run that command." },
+                ],
+                stopReason: "stop",
+            },
+        };
+
+        const MODELS_NEED_TOOL_CALL_PARSING = new Set(["qrwkv-72b-32k"]);
+        const modelClass = "qrwkv-72b-32k";
+
+        const hasToolCalls = event.message.content?.some(
+            (block: any) => block.type === "toolCall"
+        );
+
+        const newContent: any[] = [];
+        let foundToolCalls = false;
+
+        for (const block of event.message.content ?? []) {
+            if (block.type === "text" && block.text) {
+                const parsed = parseToolCallsFromText(block.text);
+                if (parsed && parsed.length > 0) {
+                    for (const tc of parsed) {
+                        newContent.push({ type: "toolCall", id: tc.id, name: tc.name, arguments: tc.arguments });
+                    }
+                    foundToolCalls = true;
+                    continue;
+                }
+            }
+            newContent.push(block);
+        }
+
+        if (foundToolCalls) {
+            event.message.content = newContent;
+            event.message.stopReason = "toolUse";
+        }
+
+        expect(event.message.content).toHaveLength(3);
+        expect(event.message.content[0].type).toBe("text");
+        expect(event.message.content[0].text).toBe("Hello, I can help you!");
+        expect(event.message.content[1].type).toBe("toolCall");
+        expect(event.message.content[2].type).toBe("text");
+        expect(event.message.content[2].text).toBe("Let me run that command.");
+    });
+
+    it("should not modify messages that already have toolCall blocks", () => {
+        const event = {
+            message: {
+                role: "assistant",
+                content: [
+                    { type: "toolCall", id: "existing_1", name: "ls", arguments: {} },
+                    { type: "text", text: "<function>{\"name\": \"read\", \"arguments\": {}}</function>" },
+                ],
+                stopReason: "toolUse",
+            },
+        };
+
+        const hasToolCalls = event.message.content?.some(
+            (block: any) => block.type === "toolCall"
+        );
+
+        if (hasToolCalls) {
+        }
+
+        expect(event.message.content).toHaveLength(2);
+        expect(event.message.content[0].type).toBe("toolCall");
+        expect(event.message.content[1].type).toBe("text"); // Not converted
+    });
+});
+
+describe("getModelClass integration", () => {
+    it("should return correct model class for RWKV models", () => {
+        expect(getModelClass("featherless-ai/QRWKV-72B")).toBe("qrwkv-72b-32k");
+        expect(getModelClass("recursal/RWKV6Qwen2.5-32B-QwQ-Preview")).toBe("qrwkv-32b-32k");
+    });
+
+    it("should return undefined for non-RWKV models", () => {
+        expect(getModelClass("unknown/model")).toBeUndefined();
+        expect(getModelClass("anthropic/claude-sonnet-4-5")).toBeUndefined();
+    });
+});

package/src/handlers/context.ts

@@ -0,0 +1,211 @@
+import {
+    buildSessionContext,
+    type ExtensionAPI,
+    type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { getRealContextLimit, getModelClass } from "../models";
+import { tokenizeBatch, extractText, clearTokenCache } from "../tokenize";
+import { PROVIDER, getApiKey } from "./shared";
+import { handleApiError } from "./concurrency";
+
+const MODELS_NEED_TOOL_CALL_PARSING = new Set([
+    "qrwkv-72b-32k",
+    "qrwkv-32b-32k",
+    "qwen3-32b",
+]);
+
+function parseToolCallsFromText(
+    text: string,
+): Array<{ id: string; name: string; arguments: Record<string, any> }> | null {
+    const results = [];
+
+    const regex1 = /<function>\s*(\{.*?\})\s*<\/function>/gs;
+    for (const match of [...text.matchAll(regex1)]) {
+        try {
+            const data = JSON.parse(match[1]);
+            if (data.name && data.arguments !== undefined) {
+                results.push({
+                    id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+                    name: data.name,
+                    arguments: typeof data.arguments === 'string'
+                        ? JSON.parse(data.arguments)
+                        : data.arguments,
+                });
+            }
+        } catch {
+        }
+    }
+
+    const regex2 = /<tool_call>\s*(\{.*?\})\s*<\/tool_call>/gs;
+    for (const match of [...text.matchAll(regex2)]) {
+        try {
+            const data = JSON.parse(match[1]);
+            if (data.name && data.arguments !== undefined) {
+                results.push({
+                    id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+                    name: data.name,
+                    arguments: typeof data.arguments === 'string'
+                        ? JSON.parse(data.arguments)
+                        : data.arguments,
+                });
+            }
+        } catch {
+        }
+    }
+
+    return results.length > 0 ? results : null;
+}
+
+const CHAR_CHECK_THRESHOLD = 10000;
+const COMPACTION_THRESHOLD_FACTOR = 0.7;
+
+const tracker = new Map<
+    string,
+    { charsSinceLastCheck: number; lastTokenCount: number }
+>();
+
+async function countTokens(
+    modelId: string,
+    messages: any[],
+    apiKey: string | undefined,
+): Promise<number> {
+    const baseModelName = modelId.split("/").pop() || modelId;
+    const texts = messages.map(extractText);
+    try {
+        const counts = await tokenizeBatch(baseModelName, texts, apiKey);
+        return counts.reduce((sum, count) => sum + count, 0);
+    } catch {
+        return texts.reduce((sum, text) => sum + Math.ceil(text.length / 4), 0);
+    }
+}
+
+async function syncAndCheckCompaction(
+    pi: ExtensionAPI,
+    ctx: ExtensionContext,
+    options?: { charsAdded?: number; messagesOverride?: any[] },
+) {
+    const model = ctx.model;
+    if (model?.provider !== PROVIDER) return;
+
+    const realContextWindow = getRealContextLimit(model.id);
+    if (!realContextWindow) return;
+
+    const sessionFile = ctx.sessionManager.getSessionFile()!;
+    let entry = tracker.get(sessionFile) || {
+        charsSinceLastCheck: 0,
+        lastTokenCount: 0,
+    };
+
+    if (options?.charsAdded) {
+        entry.charsSinceLastCheck += options.charsAdded;
+    }
+
+    const needsRecount =
+        !entry.lastTokenCount ||
+        entry.charsSinceLastCheck >= CHAR_CHECK_THRESHOLD ||
+        options?.messagesOverride !== undefined;
+
+    if (needsRecount) {
+        const apiKey = await getApiKey(ctx);
+        const msgs =
+            options?.messagesOverride ??
+            buildSessionContext(
+                ctx.sessionManager.getEntries(),
+                ctx.sessionManager.getLeafId(),
+            ).messages;
+
+        if (msgs.length > 0) {
+            try {
+                const count = await countTokens(model.id, msgs, apiKey);
+                entry = {
+                    charsSinceLastCheck: 0,
+                    lastTokenCount: count,
+                };
+            } catch (err) {
+                handleApiError(err);
+            }
+        }
+    }
+
+    tracker.set(sessionFile, entry);
+
+    if (
+        entry.lastTokenCount >
+        realContextWindow * COMPACTION_THRESHOLD_FACTOR
+    ) {
+        ctx.compact({
+            keepRecentTokens: Math.floor(realContextWindow * 0.4),
+            onComplete: () => {
+                pi.sendUserMessage("Continue", { deliverAs: "followUp" });
+            },
+        } as any);
+    }
+}
+
+export function registerContextTracking(pi: ExtensionAPI) {
+    pi.on("session_start", async () => {
+        clearTokenCache();
+        tracker.clear();
+    });
+
+    pi.on("before_provider_request", async (event, ctx) => {
+        const messagesOverride = (event.payload as any)?.messages;
+        await syncAndCheckCompaction(pi, ctx, { messagesOverride });
+    });
+
+    pi.on("tool_result", async (event, ctx) => {
+        let charsAdded = 0;
+        for (const block of event.content ?? []) {
+            if (block.type === "text" && block.text) {
+                charsAdded += block.text.length;
+            }
+        }
+        await syncAndCheckCompaction(pi, ctx, { charsAdded });
+    });
+
+    pi.on("turn_end", async (_event, ctx) => {
+        await syncAndCheckCompaction(pi, ctx);
+    });
+
+    pi.on("message_end", async (event, ctx) => {
+        const model = ctx.model;
+        if (!model || model.provider !== PROVIDER) return;
+
+        const modelClass = getModelClass(model.id);
+        if (!modelClass || !MODELS_NEED_TOOL_CALL_PARSING.has(modelClass)) return;
+
+        if (event.message?.role !== "assistant") return;
+
+        const hasToolCalls = event.message.content?.some(
+            (block: any) => block.type === "toolCall"
+        );
+        if (hasToolCalls) return;
+
+        const newContent: any[] = [];
+        let foundToolCalls = false;
+
+        for (const block of event.message.content ?? []) {
+            if (block.type === "text" && block.text) {
+                const parsed = parseToolCallsFromText(block.text);
+                if (parsed && parsed.length > 0) {
+                    for (const tc of parsed) {
+                        newContent.push({
+                            type: "toolCall",
+                            id: tc.id,
+                            name: tc.name,
+                            arguments: tc.arguments,
+                        });
+                    }
+                    foundToolCalls = true;
+                    continue;
+                }
+            }
+            newContent.push(block);
+        }
+
+        if (foundToolCalls) {
+            event.message.content = newContent;
+            event.message.stopReason = "toolUse" as any;
+        }
+    });
+}

package/src/handlers/provider.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { MODELS, getModelConfig } from "../models";
+import { BASE_URL, PROVIDER } from "./shared";
+
+export function registerProvider(pi: ExtensionAPI) {
+    pi.registerProvider(PROVIDER, {
+        name: "Featherless AI",
+        baseUrl: BASE_URL,
+        apiKey: "$FEATHERLESS_API_KEY",
+        api: "openai-completions",
+        authHeader: true,
+        models: MODELS.map(getModelConfig),
+    });
+}

package/src/handlers/shared.ts

@@ -0,0 +1,10 @@
+export const BASE_URL = "https://api.featherless.ai/v1";
+export const PROVIDER = "featherless-ai";
+
+export async function getApiKey(ctx: any): Promise<string | undefined> {
+    if (ctx.modelRegistry) {
+        const key = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER);
+        if (key) return key;
+    }
+    return process.env.FEATHERLESS_API_KEY;
+}