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

package/dist/providers/mistral.d.ts

@@ -10,15 +10,25 @@ export declare const mistralProvider: {
         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/mistral.js

@@ -15,5 +15,6 @@ export const mistralProvider = {
     baseUrl: BASE,
     defaultModel: "mistral-small-latest",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/dist/providers/moonshot.d.ts

@@ -10,15 +10,25 @@ export declare const moonshotProvider: {
         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/moonshot.js

@@ -18,5 +18,6 @@ export const moonshotProvider = {
     },
     defaultModel: "kimi-k3",
     listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/dist/providers/ollama.d.ts

@@ -10,15 +10,24 @@ export declare const ollamaProvider: {
         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>;
 };

package/dist/providers/openai.d.ts

@@ -10,15 +10,25 @@ export declare const openaiProvider: {
         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: (model: any) => boolean;
 };

package/dist/providers/openai.js

@@ -21,5 +21,6 @@ export const openaiProvider = {
     baseUrl: BASE,
     defaultModel: "gpt-6-luna",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: (model) => /^(o\d|gpt-5|gpt-6)/i.test(model),
 };

package/dist/providers/openaiCompatible.d.ts

@@ -1,17 +1,48 @@
-export declare function streamChatCompletion(req: any, opts: any): AsyncGenerator<{
+import { 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 declare function toRequestSpec(opts: StreamOptions): RequestSpec;
+export declare function streamChatCompletion(req: any, opts: StreamOptions): AsyncGenerator<{
     delta: string;
     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>;
-export declare function listModelsHttp(opts: any): Promise<any>;
+export declare function listModelsHttp(opts: StreamOptions): Promise<any>;

package/dist/providers/openaiCompatible.js

@@ -1,12 +1,46 @@
 import { fetchJson, streamSSE } from "../lib/http.js";
+import { finalizeToolCalls, mergeToolCallDelta } from "../lib/native-tools.js";
+import { buildHeaders, buildRequestUrl } from "./spec.js";
+export function toRequestSpec(opts) {
+    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) {
+function buildBody(req, compat, opts, includeReasoning = true) {
     const messages = [];
     if (req.system)
         messages.push({ role: "system", content: req.system });
-    for (const m of req.messages)
+    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;
+        }
         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;
@@ -15,38 +49,56 @@ function buildBody(req, compat) {
     }
     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 send = async (compat) => {
+    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 = {
             "content-type": "application/json",
             accept: "text/event-stream",
             ...(opts.extraHeaders ?? {}),
         };
         if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
-        return await fetch(trim(opts.baseUrl) + "/chat/completions", {
+            Object.assign(headers, buildHeaders(spec, opts.apiKey));
+        if (req.clientRequestId)
+            headers["idempotency-key"] = req.clientRequestId;
+        return await fetch(buildRequestUrl(spec, opts.chatPath ?? "/chat/completions"), {
             method: "POST",
             headers,
-            body: JSON.stringify(buildBody(req, compat)),
+            body: JSON.stringify(buildBody(req, compat, opts, includeReasoning)),
             signal: req.signal,
         });
     };
     let res = await send(false);
     if (!res.ok) {
-        const detail = await res.text().catch(() => "");
+        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(() => "");
+        }
         // Newer OpenAI-style models reject max_tokens and temperature. Retry once
         // in the compatibility dialect before surfacing the real error.
-        if (res.status === 400 && /max_tokens|max_completion_tokens|temperature|unsupported|unrecognized|unknown parameter/i.test(detail)) {
-            res = await send(true);
+        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.ok) {
-            const body = await res.text().catch(() => "");
-            throw new Error(res.status + " " + res.statusText + ": " + body.slice(0, 500));
+            throw new Error(res.status + " " + res.statusText + ": " + detail.slice(0, 500));
         }
     }
     let usage;
+    const toolCalls = new Map();
     for await (const ev of streamSSE(res)) {
         if (ev.data === "[DONE]")
             break;
@@ -61,6 +113,14 @@ 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,
@@ -78,17 +138,19 @@ export async function* streamChatCompletion(req, opts) {
         else if (typeof reasoning === "string" && reasoning)
             yield { delta: "", done: false, reasoning };
     }
-    yield { delta: "", done: true, usage };
+    const calls = finalizeToolCalls(toolCalls);
+    yield calls.length > 0 ? { delta: "", done: true, usage, toolCalls: calls } : { delta: "", done: true, usage };
 }
 export async function listModelsHttp(opts) {
     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/dist/providers/openrouter.d.ts

@@ -10,15 +10,25 @@ 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,5 +22,6 @@ 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 }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, extraHeaders: EXTRA_HEADERS, reasoning: "openrouter" }),
+    supportsReasoning: () => true,
 };

package/dist/providers/qwen.d.ts

@@ -10,15 +10,25 @@ 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,5 +19,6 @@ 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 }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/dist/providers/spec.d.ts

@@ -0,0 +1,12 @@
+export interface RequestSpec {
+    baseUrl: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+}
+export declare function resolveBaseUrl(spec: RequestSpec): string;
+export declare function buildRequestUrl(spec: RequestSpec, path: string, params?: Record<string, string>): string;
+export declare function buildHeaders(spec: RequestSpec, apiKey: string, extra?: Record<string, string>): Record<string, string>;

package/dist/providers/spec.js

@@ -0,0 +1,29 @@
+const ENV_MAP = {
+    region: "AWS_REGION",
+    account_id: "CLOUDFLARE_ACCOUNT_ID",
+    project_id: "GOOGLE_CLOUD_PROJECT",
+    deployment: "AZURE_OPENAI_DEPLOYMENT",
+};
+export function resolveBaseUrl(spec) {
+    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, path, params) {
+    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, apiKey, extra) {
+    const headers = {
+        [spec.authHeaderName ?? "authorization"]: (spec.authPrefix ?? "Bearer ") + apiKey,
+        ...extra,
+    };
+    return headers;
+}

package/dist/providers/xai.d.ts

@@ -10,15 +10,25 @@ 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,5 +14,6 @@ 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 }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/dist/providers/zhipu.d.ts

@@ -10,15 +10,25 @@ 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,5 +19,6 @@ 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 }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/dist/session/log.d.ts

@@ -1,16 +1,49 @@
+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;
+}
+/** 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 declare function sessionCacheLimitBytes(): number;
 export declare function loggingEnabled(): boolean;
-export declare function createSessionLog(meta?: {}): {
-    id: any;
-    file: any;
-    append: (entry: any) => void;
-    close(): void;
+export declare function projectionPath(file: string): string;
+export declare function fsyncMode(): "on" | "off" | "auto";
+export declare function fsyncEnabled(type?: string): boolean;
+/** Summary files referenced by older compacted facts in this session. */
+export declare function staleSummaryRefs(file: string): string[];
+export declare function createSessionLog(meta?: Record<string, any>): {
+    id: string;
+    file: string;
+    append: (entry: Record<string, any>) => number;
+    count(): number;
+    close(info?: SessionCloseInfo): void;
 };
-export declare function openSessionLog(file: any): {
-    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;
+    close(info?: SessionCloseInfo): void;
 };
 export declare function listSessions(): {
     id: string;
@@ -19,11 +52,13 @@ export declare function listSessions(): {
     modified: string;
     messages: number;
 }[];
-export declare function resolveSessionFile(idOrFile: any): any;
-export declare function readSession(idOrFile: any): any[];
-export declare function loadSessionMessages(idOrFile: any): {
+export declare function resolveSessionFile(idOrFile: string): string;
+export declare function readSession(idOrFile: string): any[];
+export declare function loadSessionMessages(idOrFile: string): {
     role: any;
     content: any;
 }[];
-export declare function latestSessionFile(): string;
+export declare function latestSessionFile(): string | undefined;
+export declare function findUnclosedSessions(): SessionSummary[];
+export declare function latestUnclosedSession(): SessionSummary | undefined;
 export declare function pruneSessions(limit?: number): number;