@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/dist/providers/openaiCompatible.js

@@ -1,34 +1,12 @@
 import { fetchJson, streamSSE } from "../lib/http.js";
-import { finalizeToolCalls, mergeToolCallDelta } from "../lib/native-tools.js";
 /** Build a chat-completions body in the classic or the newer (compat) dialect. */
-function buildBody(req, compat, opts, includeReasoning = true) {
+function buildBody(req, compat) {
     const messages = [];
     if (req.system)
         messages.push({ role: "system", content: req.system });
-    for (const m of req.messages) {
-        if (m.role === "tool") {
-            messages.push({ role: "tool", tool_call_id: m.toolCallId, content: m.content });
-            continue;
-        }
-        if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
-            messages.push({
-                role: "assistant",
-                content: m.content || null,
-                tool_calls: m.toolCalls.map((call) => ({
-                    id: call.id,
-                    type: "function",
-                    function: { name: call.name, arguments: call.arguments },
-                })),
-            });
-            continue;
-        }
+    for (const m of req.messages)
         messages.push({ role: m.role, content: m.content });
-    }
     const body = { model: req.model, messages, stream: true };
-    if (req.tools && req.tools.length > 0) {
-        body.tools = req.tools;
-        body.tool_choice = "auto";
-    }
     if (req.maxOutputTokens !== undefined) {
         if (compat)
             body.max_completion_tokens = req.maxOutputTokens;
@@ -37,18 +15,10 @@ function buildBody(req, compat, opts, includeReasoning = true) {
     }
     if (req.temperature !== undefined && !compat)
         body.temperature = req.temperature;
-    if (includeReasoning && req.reasoningEffort && req.reasoningEffort !== "auto") {
-        const effort = req.reasoningEffort === "max" ? "high" : req.reasoningEffort;
-        if (opts.reasoning === "openai")
-            body.reasoning_effort = effort;
-        else if (opts.reasoning === "openrouter")
-            body.reasoning = { effort };
-    }
     return body;
 }
 export async function* streamChatCompletion(req, opts) {
-    const hasReasoning = Boolean(req.reasoningEffort && req.reasoningEffort !== "auto" && opts.reasoning && opts.reasoning !== "none");
-    const send = async (compat, includeReasoning = hasReasoning) => {
+    const send = async (compat) => {
         const headers = {
             "content-type": "application/json",
             accept: "text/event-stream",
@@ -56,36 +26,27 @@ export async function* streamChatCompletion(req, opts) {
         };
         if (opts.apiKey)
             headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
-        if (req.clientRequestId)
-            headers["idempotency-key"] = req.clientRequestId;
         return await fetch(trim(opts.baseUrl) + "/chat/completions", {
             method: "POST",
             headers,
-            body: JSON.stringify(buildBody(req, compat, opts, includeReasoning)),
+            body: JSON.stringify(buildBody(req, compat)),
             signal: req.signal,
         });
     };
     let res = await send(false);
     if (!res.ok) {
-        let detail = await res.text().catch(() => "");
-        // Some models reject the thinking parameter even though the provider
-        // as a whole accepts it. Drop it once, then keep the request alive.
-        if (res.status === 400 && hasReasoning && /reasoning|thinking|effort|unsupported|unrecognized|unknown parameter/i.test(detail)) {
-            res = await send(false, false);
-            detail = res.ok ? detail : await res.text().catch(() => "");
-        }
+        const detail = await res.text().catch(() => "");
         // Newer OpenAI-style models reject max_tokens and temperature. Retry once
         // in the compatibility dialect before surfacing the real error.
-        if (!res.ok && res.status === 400 && /max_tokens|max_completion_tokens|temperature|unsupported|unrecognized|unknown parameter/i.test(detail)) {
-            res = await send(true, false);
-            detail = res.ok ? detail : await res.text().catch(() => "");
+        if (res.status === 400 && /max_tokens|max_completion_tokens|temperature|unsupported|unrecognized|unknown parameter/i.test(detail)) {
+            res = await send(true);
         }
         if (!res.ok) {
-            throw new Error(res.status + " " + res.statusText + ": " + detail.slice(0, 500));
+            const body = await res.text().catch(() => "");
+            throw new Error(res.status + " " + res.statusText + ": " + body.slice(0, 500));
         }
     }
     let usage;
-    const toolCalls = new Map();
     for await (const ev of streamSSE(res)) {
         if (ev.data === "[DONE]")
             break;
@@ -100,14 +61,6 @@ export async function* streamChatCompletion(req, opts) {
         const choice = obj.choices?.[0];
         const raw = choice?.delta?.content ?? choice?.text;
         const reasoning = choice?.delta?.reasoning_content ?? choice?.delta?.reasoning;
-        if (Array.isArray(choice?.delta?.tool_calls)) {
-            for (const delta of choice.delta.tool_calls)
-                mergeToolCallDelta(toolCalls, delta);
-        }
-        if (Array.isArray(choice?.message?.tool_calls)) {
-            for (const delta of choice.message.tool_calls)
-                mergeToolCallDelta(toolCalls, delta);
-        }
         if (obj.usage) {
             usage = {
                 inputTokens: obj.usage.prompt_tokens,
@@ -125,8 +78,7 @@ export async function* streamChatCompletion(req, opts) {
         else if (typeof reasoning === "string" && reasoning)
             yield { delta: "", done: false, reasoning };
     }
-    const calls = finalizeToolCalls(toolCalls);
-    yield calls.length > 0 ? { delta: "", done: true, usage, toolCalls: calls } : { delta: "", done: true, usage };
+    yield { delta: "", done: true, usage };
 }
 export async function listModelsHttp(opts) {
     const staticModels = opts.staticModels ?? [];

package/dist/providers/openrouter.d.ts

@@ -10,25 +10,15 @@ export declare const openrouterProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/openrouter.js

@@ -22,6 +22,5 @@ export const openrouterProvider = {
     baseUrl: BASE,
     defaultModel: "anthropic/claude-sonnet-5.5",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS, reasoning: "openrouter" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS }),
 };

package/dist/providers/qwen.d.ts

@@ -10,25 +10,15 @@ export declare const qwenProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/qwen.js

@@ -19,6 +19,5 @@ export const qwenProvider = {
     },
     defaultModel: "qwen3.8-max",
     listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
 };

package/dist/providers/xai.d.ts

@@ -10,25 +10,15 @@ export declare const xaiProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/xai.js

@@ -14,6 +14,5 @@ export const xaiProvider = {
     baseUrl: BASE,
     defaultModel: "grok-4.7",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
 };

package/dist/providers/zhipu.d.ts

@@ -10,25 +10,15 @@ export declare const zhipuProvider: {
         done: boolean;
         reasoning?: undefined;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         reasoning: string;
         usage?: undefined;
-        toolCalls?: undefined;
     } | {
         delta: string;
         done: boolean;
         usage: any;
-        toolCalls: import("../types.js").NativeToolCall[];
         reasoning?: undefined;
-    } | {
-        delta: string;
-        done: boolean;
-        usage: any;
-        reasoning?: undefined;
-        toolCalls?: undefined;
     }, void, unknown>;
-    supportsReasoning: () => boolean;
 };

package/dist/providers/zhipu.js

@@ -19,6 +19,5 @@ export const zhipuProvider = {
     },
     defaultModel: "glm-5.3",
     listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
-    supportsReasoning: () => true,
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
 };

package/dist/session/log.d.ts

@@ -1,36 +1,15 @@
-export interface ActiveFile {
-    path: string;
-    sha1_8: string;
-    mtime: string;
-}
-export interface SessionSummary {
-    id: string;
-    file: string;
-    cwd: string;
-    providerId: string;
-    model: string;
-    turns: number;
-    activeFiles: ActiveFile[];
-    messages: number;
-    lastTs: number;
-}
 export declare function sessionCacheLimitBytes(): number;
 export declare function loggingEnabled(): boolean;
-export declare function projectionPath(file: string): string;
-export declare function fsyncMode(): "on" | "off" | "auto";
-export declare function fsyncEnabled(type?: string): boolean;
-export declare function createSessionLog(meta?: Record<string, any>): {
-    id: string;
-    file: string;
-    append: (entry: Record<string, any>) => number;
-    count(): number;
+export declare function createSessionLog(meta?: {}): {
+    id: any;
+    file: any;
+    append: (entry: any) => void;
     close(): void;
 };
-export declare function openSessionLog(file: string, meta?: Record<string, any>): {
-    id: string;
-    file: string;
-    append: (entry: Record<string, any>) => number;
-    count(): number;
+export declare function openSessionLog(file: any): {
+    id: any;
+    file: any;
+    append: (entry: any) => void;
     close(): void;
 };
 export declare function listSessions(): {
@@ -40,13 +19,11 @@ export declare function listSessions(): {
     modified: string;
     messages: number;
 }[];
-export declare function resolveSessionFile(idOrFile: string): string;
-export declare function readSession(idOrFile: string): any[];
-export declare function loadSessionMessages(idOrFile: string): {
+export declare function resolveSessionFile(idOrFile: any): any;
+export declare function readSession(idOrFile: any): any[];
+export declare function loadSessionMessages(idOrFile: any): {
     role: any;
     content: any;
 }[];
-export declare function latestSessionFile(): string | undefined;
-export declare function findUnclosedSessions(): SessionSummary[];
-export declare function latestUnclosedSession(): SessionSummary | undefined;
+export declare function latestSessionFile(): string;
 export declare function pruneSessions(limit?: number): number;

package/dist/session/log.js

@@ -8,10 +8,9 @@
  *
  *   FASTCODE_SESSION_LOG=0        disable logging
  *   FASTCODE_SESSION_CACHE_MB=N   sessions cache cap in MB (default 256)
- *   FASTCODE_FSYNC=0|1            force checkpoint fsync off/on
  */
-import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
-import { basename, join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
 import { getPaths } from "../config/paths.js";
 const NL = String.fromCharCode(10);
 export function sessionCacheLimitBytes() {
@@ -21,76 +20,19 @@ export function sessionCacheLimitBytes() {
 export function loggingEnabled() {
     return process.env["FASTCODE_SESSION_LOG"] !== "0";
 }
-export function projectionPath(file) {
-    return file.replace(/[.]jsonl$/, ".projection.json");
-}
-export function fsyncMode() {
-    const raw = (process.env["FASTCODE_FSYNC"] ?? "").trim().toLowerCase();
-    if (["1", "true", "yes", "on"].includes(raw))
-        return "on";
-    if (["0", "false", "no", "off"].includes(raw))
-        return "off";
-    return "auto";
-}
-function onSharedStorage(root) {
-    const normalized = root.replace(/\\/g, "/");
-    return normalized === "/sdcard"
-        || normalized.startsWith("/sdcard/")
-        || normalized === "/storage/emulated"
-        || normalized.startsWith("/storage/emulated/");
-}
-export function fsyncEnabled(type = "checkpoint") {
-    if (type !== "checkpoint")
-        return false;
-    const mode = fsyncMode();
-    if (mode === "on")
-        return true;
-    if (mode === "off")
-        return false;
-    return onSharedStorage(getPaths().root);
-}
-function writeLine(file, line, type) {
-    if (!fsyncEnabled(type)) {
-        appendFileSync(file, line, "utf8");
-        return;
-    }
-    const fd = openSync(file, "a");
-    try {
-        writeSync(fd, line);
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function countLines(file) {
-    if (!existsSync(file))
-        return 0;
-    try {
-        return readFileSync(file, "utf8").split(NL).filter(Boolean).length;
-    }
-    catch {
-        return 0;
-    }
-}
 function newId() {
     return new Date().toISOString().replace(/[:.]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
 }
 function openLog(id, file, meta) {
     let closed = false;
-    let seq = countLines(file);
     const append = (entry) => {
         if (closed || !loggingEnabled())
-            return 0;
-        const next = seq + 1;
-        const line = JSON.stringify({ ts: Date.now(), seq: next, ...entry }) + NL;
+            return;
         try {
-            writeLine(file, line, String(entry.type ?? ""));
-            seq = next;
-            return next;
+            appendFileSync(file, JSON.stringify({ ts: Date.now(), ...entry }) + NL, "utf8");
         }
         catch {
-            return 0;
+            // A read-only or full filesystem must not break the TUI.
         }
     };
     append({ type: "session_start", id, cwd: process.cwd(), ...meta });
@@ -98,9 +40,6 @@ function openLog(id, file, meta) {
         id,
         file,
         append,
-        count() {
-            return seq;
-        },
         close() {
             append({ type: "session_end" });
             closed = true;
@@ -120,10 +59,10 @@ export function createSessionLog(meta = {}) {
     const file = join(sessions, id + ".jsonl");
     return openLog(id, file, meta);
 }
-export function openSessionLog(file, meta = {}) {
+export function openSessionLog(file) {
     const { sessions } = getPaths();
     mkdirSync(sessions, { recursive: true });
-    return openLog(undefined, existsSync(file) ? file : join(sessions, file), meta);
+    return openLog(undefined, existsSync(file) ? file : join(sessions, file), {});
 }
 export function listSessions() {
     const { sessions } = getPaths();
@@ -140,8 +79,7 @@ export function listSessions() {
             const info = statSync(file);
             bytes = info.size;
             modified = info.mtime.toISOString();
-            messages = readFileSync(file, "utf8").split(NL).filter((line) => line.includes('"type":"user"') ||
-                (line.includes('"type":"message"') && line.includes('"role":"user"'))).length;
+            messages = readFileSync(file, "utf8").split(NL).filter((line) => line.includes('"type":"message"')).length;
         }
         catch {
             // unreadable: report what we have
@@ -174,152 +112,18 @@ export function readSession(idOrFile) {
 }
 export function loadSessionMessages(idOrFile) {
     return readSession(idOrFile)
-        .filter((entry) => (entry.type === "message" || entry.type === "user" || entry.type === "assistant_raw") && typeof entry.content === "string")
-        .map((entry) => ({
-        role: entry.type === "assistant_raw" ? "assistant" : entry.role ?? "user",
-        content: entry.content,
-    }));
+        .filter((entry) => entry.type === "message" && typeof entry.content === "string")
+        .map((entry) => ({ role: entry.role, content: entry.content }));
 }
 export function latestSessionFile() {
     const all = listSessions();
     return all.length > 0 ? all[0].file : undefined;
 }
-function summarize(id, file, entries) {
-    let cwd = "";
-    let providerId = "";
-    let model = "";
-    let turns = 0;
-    let activeFiles = [];
-    let messages = 0;
-    let lastTs = 0;
-    for (const entry of entries) {
-        if (typeof entry.ts === "number")
-            lastTs = entry.ts;
-        if (entry.type === "session_start") {
-            cwd = typeof entry.cwd === "string" ? entry.cwd : cwd;
-            providerId = typeof entry.providerId === "string" ? entry.providerId : providerId;
-            model = typeof entry.model === "string" ? entry.model : model;
-        }
-        else if (entry.type === "message") {
-            messages += 1;
-        }
-        else if (entry.type === "checkpoint") {
-            cwd = typeof entry.cwd === "string" ? entry.cwd : cwd;
-            providerId = typeof entry.providerId === "string" ? entry.providerId : providerId;
-            model = typeof entry.model === "string" ? entry.model : model;
-            if (typeof entry.turn === "number")
-                turns = entry.turn;
-            if (Array.isArray(entry.activeFiles))
-                activeFiles = entry.activeFiles;
-        }
-    }
-    return { id, file, cwd, providerId, model, turns, activeFiles, messages, lastTs };
-}
-function readLastEntry(file) {
-    let size = 0;
-    try {
-        size = statSync(file).size;
-    }
-    catch {
-        return undefined;
-    }
-    if (size === 0)
-        return undefined;
-    const length = Math.min(size, 64 * 1024);
-    const fd = openSync(file, "r");
-    try {
-        const buffer = Buffer.alloc(length);
-        readSync(fd, buffer, 0, length, size - length);
-        const lines = buffer.toString("utf8").trimEnd().split(NL);
-        for (let i = lines.length - 1; i >= 0; i -= 1) {
-            if (!lines[i])
-                continue;
-            try {
-                return JSON.parse(lines[i]);
-            }
-            catch {
-                return { type: "unparsable_tail" };
-            }
-        }
-        return undefined;
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function findUnclosedSessions() {
-    const { sessions } = getPaths();
-    if (!existsSync(sessions))
-        return [];
-    const files = readdirSync(sessions)
-        .filter((name) => name.endsWith(".jsonl"))
-        .map((name) => {
-        const file = join(sessions, name);
-        let modified = 0;
-        try {
-            modified = statSync(file).mtimeMs;
-        }
-        catch {
-            // unreadable
-        }
-        return { name, file, modified };
-    })
-        .sort((a, b) => b.modified - a.modified);
-    const out = [];
-    for (const entry of files) {
-        const last = readLastEntry(entry.file);
-        if (!last || last.type === "session_end")
-            continue;
-        let entries;
-        try {
-            entries = readSession(entry.file);
-        }
-        catch {
-            continue;
-        }
-        if (entries.length === 0 || !entries.some((item) => item.type === "session_start"))
-            continue;
-        out.push(summarize(entry.name.replace(/[.]jsonl$/, ""), entry.file, entries));
-    }
-    return out;
-}
-export function latestUnclosedSession() {
-    return findUnclosedSessions()[0];
-}
-function ensureProjection(file) {
-    const target = projectionPath(file);
-    if (existsSync(target))
-        return;
-    const entries = readSession(file);
-    if (entries.length === 0)
-        return;
-    const summary = summarize(basename(file).replace(/[.]jsonl$/, ""), file, entries);
-    const lastUser = [...entries].reverse().find((entry) => entry.type === "message" && entry.role === "user");
-    const lastAssistant = [...entries].reverse().find((entry) => entry.type === "message" && entry.role === "assistant");
-    const payload = {
-        version: 1,
-        kind: "pruned_session",
-        source: basename(file),
-        createdAt: new Date().toISOString(),
-        summary: {
-            cwd: summary.cwd,
-            providerId: summary.providerId,
-            model: summary.model,
-            turns: summary.turns,
-            messages: summary.messages,
-            activeFiles: summary.activeFiles.slice(0, 200),
-            lastUser: typeof lastUser?.content === "string" ? lastUser.content.slice(0, 2000) : "",
-            lastAssistant: typeof lastAssistant?.content === "string" ? lastAssistant.content.slice(0, 2000) : "",
-        },
-    };
-    writeFileSync(target, JSON.stringify(payload, null, 2), "utf8");
-}
 export function pruneSessions(limit = sessionCacheLimitBytes()) {
     const all = listSessions();
     let total = all.reduce((sum, entry) => sum + entry.bytes, 0);
     for (let i = all.length - 1; i >= 0 && total > limit; i -= 1) {
         try {
-            ensureProjection(all[i].file);
             rmSync(all[i].file, { force: true });
             total -= all[i].bytes;
         }