@datename/fastcode-termux 0.1.6-beta → 0.1.8-beta.0

package/src/providers/openaiCompatible.ts

@@ -1,7 +1,42 @@
 import { fetchJson, streamSSE } from "../lib/http.js";
 import { finalizeToolCalls, mergeToolCallDelta, type ToolCallAccumulator } from "../lib/native-tools.js";
+import { buildHeaders, buildRequestUrl, type RequestSpec } from "./spec.js";
+
+export interface ModelInfo {
+    id: string;
+    label?: string;
+    [key: string]: any;
+}
+
+export interface StreamOptions {
+    baseUrl: string;
+    apiKey?: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+    staticModels?: ModelInfo[];
+    extraHeaders?: Record<string, string>;
+    /** Legacy auth prefix, e.g. "Bearer". Prefer authPrefix for new callers. */
+    authHeader?: string;
+    reasoning?: "openai" | "openrouter" | "none" | string;
+}
+
+export function toRequestSpec(opts: StreamOptions): RequestSpec {
+    return {
+        baseUrl: trim(opts.baseUrl),
+        chatPath: opts.chatPath,
+        modelsPath: opts.modelsPath,
+        query: opts.query,
+        pathParams: opts.pathParams,
+        authHeaderName: opts.authHeaderName,
+        authPrefix: opts.authPrefix ?? (opts.authHeader !== undefined ? `${opts.authHeader} ` : undefined),
+    };
+}
 /** Build a chat-completions body in the classic or the newer (compat) dialect. */
-function buildBody(req, compat, opts, includeReasoning = true) {
+function buildBody(req: any, compat: boolean, opts: StreamOptions, includeReasoning = true) {
     const messages = [];
     if (req.system)
         messages.push({ role: "system", content: req.system });
@@ -46,19 +81,20 @@ function buildBody(req, compat, opts, includeReasoning = true) {
     }
     return body;
 }
-export async function* streamChatCompletion(req, opts) {
+export async function* streamChatCompletion(req: any, opts: StreamOptions) {
     const hasReasoning = Boolean(req.reasoningEffort && req.reasoningEffort !== "auto" && opts.reasoning && opts.reasoning !== "none");
+    const spec = toRequestSpec(opts);
     const send = async (compat, includeReasoning = hasReasoning) => {
-        const headers = {
+        const headers: Record<string, string> = {
             "content-type": "application/json",
             accept: "text/event-stream",
             ...(opts.extraHeaders ?? {}),
         };
         if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
+            Object.assign(headers, buildHeaders(spec, opts.apiKey));
         if (req.clientRequestId)
             headers["idempotency-key"] = req.clientRequestId;
-        return await fetch(trim(opts.baseUrl) + "/chat/completions", {
+        return await fetch(buildRequestUrl(spec, opts.chatPath ?? "/chat/completions"), {
             method: "POST",
             headers,
             body: JSON.stringify(buildBody(req, compat, opts, includeReasoning)),
@@ -128,15 +164,16 @@ export async function* streamChatCompletion(req, opts) {
     const calls = finalizeToolCalls(toolCalls);
     yield calls.length > 0 ? { delta: "", done: true, usage, toolCalls: calls } : { delta: "", done: true, usage };
 }
-export async function listModelsHttp(opts) {
+export async function listModelsHttp(opts: StreamOptions) {
     const staticModels = opts.staticModels ?? [];
+    if (opts.modelsPath === null)
+        return staticModels;
     if (!opts.apiKey && staticModels.length)
         return staticModels;
     try {
-        const headers = {};
-        if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
-        const json = await fetchJson(trim(opts.baseUrl) + "/models", { headers });
+        const spec = toRequestSpec(opts);
+        const headers = opts.apiKey ? buildHeaders(spec, opts.apiKey) : {};
+        const json = await fetchJson(buildRequestUrl(spec, opts.modelsPath ?? "/models"), { headers });
         const ids = (json.data ?? [])
             .map((m) => m.id)
             .filter((id) => typeof id === "string" && id.length > 0);

package/src/providers/spec.ts

@@ -0,0 +1,42 @@
+export interface RequestSpec {
+    baseUrl: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+}
+
+const ENV_MAP: Record<string, string> = {
+    region: "AWS_REGION",
+    account_id: "CLOUDFLARE_ACCOUNT_ID",
+    project_id: "GOOGLE_CLOUD_PROJECT",
+    deployment: "AZURE_OPENAI_DEPLOYMENT",
+};
+
+export function resolveBaseUrl(spec: RequestSpec): string {
+    return spec.baseUrl.replace(/\{(\w+)\}/g, (_, key) => {
+        const envName = ENV_MAP[key];
+        const value = envName ? process.env[envName] : undefined;
+        if (!value)
+            throw new Error(`Missing ${envName ?? key} for placeholder {${key}}`);
+        return value;
+    });
+}
+
+export function buildRequestUrl(spec: RequestSpec, path: string, params?: Record<string, string>): string {
+    const base = resolveBaseUrl(spec);
+    const merged = { ...spec.pathParams, ...params };
+    const resolvedPath = path.replace(/\{(\w+)\}/g, (_, key) => merged[key] ?? `{${key}}`);
+    const query = spec.query ? "?" + new URLSearchParams(spec.query).toString() : "";
+    return base + resolvedPath + query;
+}
+
+export function buildHeaders(spec: RequestSpec, apiKey: string, extra?: Record<string, string>): Record<string, string> {
+    const headers: Record<string, string> = {
+        [spec.authHeaderName ?? "authorization"]: (spec.authPrefix ?? "Bearer ") + apiKey,
+        ...extra,
+    };
+    return headers;
+}

package/src/session/log.ts

@@ -10,9 +10,10 @@
  *   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, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeSync } from "node:fs";
+import { join } from "node:path";
 import { getPaths } from "../config/paths.js";
+import { buildProjection, writeProjection } from "./projection.js";
 
 const NL = String.fromCharCode(10);
 
@@ -34,6 +35,18 @@ export interface SessionSummary {
     lastTs: number;
 }
 
+/** Reserved slot for conversation compaction at the exit save point. */
+export interface SessionCompactionSlot {
+    source?: "local" | "server" | "none";
+    summaryRef?: string | null;
+    pending?: boolean;
+}
+
+export interface SessionCloseInfo {
+    reason?: "exit" | "signal" | "fatal" | "close";
+    compaction?: SessionCompactionSlot;
+}
+
 export function sessionCacheLimitBytes(): number {
     const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
     return (Number.isFinite(mb) && mb > 0 ? mb : 256) * 1024 * 1024;
@@ -90,6 +103,24 @@ function writeLine(file: string, line: string, type: string): void {
     }
 }
 
+function fsyncPath(file: string): void {
+    if (!existsSync(file))
+        return;
+    try {
+        const fd = openSync(file, "r");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        // FUSE / read-only filesystems may reject fsync; the append is still
+        // best effort and the caller already caught close-level failures.
+    }
+}
+
 function countLines(file: string): number {
     if (!existsSync(file))
         return 0;
@@ -130,10 +161,25 @@ function openLog(id: string | undefined, file: string, meta: Record<string, any>
         count() {
             return seq;
         },
-        close() {
-            append({ type: "session_end" });
+        close(info: SessionCloseInfo = {}) {
+            append({
+                type: "session_end",
+                reason: info.reason ?? "close",
+                // Reserved extension point: future compaction can fill this
+                // slot without changing the session_end event shape.
+                compaction: {
+                    source: info.compaction?.source ?? "none",
+                    summaryRef: info.compaction?.summaryRef ?? null,
+                    pending: info.compaction?.pending ?? false,
+                },
+            });
             closed = true;
             try {
+                // Snapshot + manifest are written while the facts still exist;
+                // pruning later keeps this verified copy.
+                ensureProjection(file);
+                fsyncPath(file);
+                fsyncPath(projectionPath(file));
                 pruneSessions();
             }
             catch {
@@ -143,6 +189,22 @@ function openLog(id: string | undefined, file: string, meta: Record<string, any>
     };
 }
 
+/** Summary files referenced by older compacted facts in this session. */
+export function staleSummaryRefs(file: string): string[] {
+    let facts: any[];
+    try {
+        facts = readSession(file);
+    }
+    catch {
+        return [];
+    }
+    const compacted = facts.filter((fact) => fact?.type === "compacted");
+    const latest = compacted.at(-1)?.summaryRef;
+    return Array.from(new Set(compacted
+        .map((fact) => fact.summaryRef)
+        .filter((ref): ref is string => typeof ref === "string" && ref.length > 0 && ref !== latest)));
+}
+
 export function createSessionLog(meta: Record<string, any> = {}) {
     const { sessions } = getPaths();
     mkdirSync(sessions, { recursive: true });
@@ -329,32 +391,13 @@ export function latestUnclosedSession(): SessionSummary | undefined {
 }
 
 function ensureProjection(file: string): void {
-    const target = projectionPath(file);
-    if (existsSync(target))
-        return;
+    // Always refresh from the facts that still exist: a projection written at
+    // an earlier checkpoint may be stale by the time we close or prune. If the
+    // JSONL is already gone, leave the verified projection untouched.
     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");
+    writeProjection(file, buildProjection(entries), entries);
 }
 
 export function pruneSessions(limit = sessionCacheLimitBytes()): number {