@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/src/agent/tools/replace_in_file.ts

@@ -1,32 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { resolvePath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
-
-export const replaceInFileTool: Tool = {
-    name: "replace_in_file",
-    requiresTrust: true,
-    stateScope: "turn",
-    revalidate: ["trust", "sandboxRoots"],
-    prepare(call, ctx) {
-        try {
-            requiredString(call, "path");
-            requiredString(call, "find");
-            requiredString(call, "replace");
-        }
-        catch (err: any) {
-            return invalid(err.message);
-        }
-        return preparePath(ctx.cwd, requiredString(call, "path"));
-    },
-    async execute(call, ctx) {
-        const file = resolvePath(ctx.cwd, call);
-        const find = requiredString(call, "find");
-        const replacement = requiredString(call, "replace");
-        const source = await readFile(file, "utf8");
-        if (!source.includes(find))
-            return { ok: false, output: `text not found in ${file}` };
-        await writeFile(file, source.split(find).join(replacement), "utf8");
-        return { ok: true, output: `replaced text in ${file}`, sideEffects: { touched: [file] } };
-    },
-};

package/src/agent/tools/shell.ts

@@ -1,53 +0,0 @@
-import type { ShellExecResult } from "../shell-session.js";
-import { executeShellCommand, pollShellSession } from "../shell-session.js";
-import type { Tool } from "./types.js";
-import { invalid, numberOption } from "./validate.js";
-
-export const shellTool: Tool = {
-    name: "shell",
-    requiresTrust: true,
-    stateScope: "turn",
-    revalidate: ["trust", "sandboxRoots"],
-    approvalHints: { mayRequireApproval: true },
-    prepare(call) {
-        if (typeof call.session_id === "string" && call.session_id.trim())
-            return { ok: true };
-        if (typeof call.command !== "string" || call.command.trim() === "")
-            return invalid("command must be a non-empty string");
-        return { ok: true };
-    },
-    async execute(call, ctx) {
-        if (typeof call.session_id === "string" && call.session_id.trim()) {
-            const polled = await pollShellSession(call.session_id, numberOption(call.waitMs, 0));
-            if (!polled)
-                return { ok: false, output: `unknown shell session: ${call.session_id}` };
-            return formatPoll(call.session_id, polled);
-        }
-        const result = await executeShellCommand(call.command, ctx.cwd, {
-            signal: ctx.signal,
-            turn: ctx.turn,
-            timeoutMs: numberOption(call.timeoutMs, 120000),
-        });
-        return formatExec(result);
-    },
-};
-
-function formatExec(result: ShellExecResult): { ok: boolean; output: string } {
-    if (result.status !== "running")
-        return { ok: result.ok, output: result.output || `[command ${result.status}]` };
-    const header = `[session ${result.sessionId}] running`;
-    const body = result.output ? "\n" + result.output : "";
-    return {
-        ok: true,
-        output: `${header}${body}\n\nPoll with: {"tool":"shell","session_id":"${result.sessionId}"}`,
-    };
-}
-
-function formatPoll(id: string, result: ShellExecResult): { ok: boolean; output: string } {
-    const status = result.status === "running"
-        ? `running (next poll ~${Math.round((result.nextPollMs ?? 1000) / 1000)}s)`
-        : `${result.status}${result.exitCode !== undefined && result.exitCode !== null ? ` (exit ${result.exitCode})` : ""}`;
-    const header = `[session ${id}] ${status}`;
-    const body = result.output ? "\n" + result.output : result.status === "running" ? "\n(no new output)" : "";
-    return { ok: result.ok, output: header + body };
-}

package/src/agent/tools/stat_path.ts

@@ -1,33 +0,0 @@
-import { stat } from "node:fs/promises";
-import { resolvePath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
-
-export const statPathTool: Tool = {
-    name: "stat_path",
-    stateScope: "call",
-    revalidate: ["sandboxRoots"],
-    prepare(call, ctx) {
-        let path: string;
-        try {
-            path = requiredString(call, "path");
-        }
-        catch (err: any) {
-            return invalid(err.message);
-        }
-        return preparePath(ctx.cwd, path);
-    },
-    async execute(call, ctx) {
-        const file = resolvePath(ctx.cwd, call);
-        const info = await stat(file);
-        return {
-            ok: true,
-            output: JSON.stringify({
-                path: file,
-                type: info.isDirectory() ? "dir" : info.isFile() ? "file" : "other",
-                size: info.size,
-                modified: info.mtime.toISOString(),
-            }, null, 2),
-        };
-    },
-};

package/src/agent/tools/types.ts

@@ -1,42 +0,0 @@
-export type StateScope = "call" | "turn" | "session";
-
-export type RevalidateKey = "trust" | "sandboxRoots" | "schema" | "modelCaps";
-
-export interface SideEffects {
-  touched?: string[];
-  created?: string[];
-  removed?: string[];
-}
-
-export interface ToolCall {
-  tool: string;
-  [key: string]: any;
-}
-
-export interface ToolResult {
-  ok: boolean;
-  output: string;
-  sideEffects?: SideEffects;
-}
-
-export interface ToolCtx {
-    cwd: string;
-    signal?: AbortSignal;
-    turn?: number;
-}
-
-export type Prepared = { ok: true } | { ok: false; output: string };
-
-export interface ApprovalHints {
-  mayRequireApproval: boolean;
-}
-
-export interface Tool {
-  name: string;
-  requiresTrust?: boolean;
-  stateScope: StateScope;
-  revalidate?: RevalidateKey[];
-  approvalHints?: ApprovalHints;
-  prepare(call: ToolCall, ctx: ToolCtx): Prepared;
-  execute(call: ToolCall, ctx: ToolCtx): Promise<ToolResult>;
-}

package/src/agent/tools/validate.ts

@@ -1,35 +0,0 @@
-import { sandboxPath } from "./paths.js";
-import type { Prepared, ToolCall } from "./types.js";
-
-export function invalid(output: string): Prepared {
-    return { ok: false, output };
-}
-
-export function requiredString(call: ToolCall, key: string): string {
-    const value = call[key];
-    if (typeof value !== "string")
-        throw new Error(`${key} must be a string`);
-    return value;
-}
-
-export function stringArray(call: ToolCall, key: string): string[] {
-    const value = call[key];
-    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
-        throw new Error(`${key} must be an array of strings`);
-    }
-    return value;
-}
-
-export function numberOption(value: any, fallback: number): number {
-    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-
-export function preparePath(cwd: string, raw: string): Prepared {
-    try {
-        sandboxPath(cwd, raw);
-        return { ok: true };
-    }
-    catch (err: any) {
-        return invalid(err?.message ?? String(err));
-    }
-}

package/src/agent/tools/write_file.ts

@@ -1,28 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { resolvePath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
-
-export const writeFileTool: Tool = {
-    name: "write_file",
-    requiresTrust: true,
-    stateScope: "turn",
-    revalidate: ["trust", "sandboxRoots"],
-    prepare(call, ctx) {
-        try {
-            requiredString(call, "path");
-            requiredString(call, "content");
-        }
-        catch (err: any) {
-            return invalid(err.message);
-        }
-        return preparePath(ctx.cwd, requiredString(call, "path"));
-    },
-    async execute(call, ctx) {
-        const file = resolvePath(ctx.cwd, call);
-        await mkdir(dirname(file), { recursive: true });
-        await writeFile(file, requiredString(call, "content"), "utf8");
-        return { ok: true, output: `wrote ${file}`, sideEffects: { touched: [file] } };
-    },
-};

package/src/commands/attach.ts

@@ -1,16 +0,0 @@
-import { pollShellSession } from "../agent/shell-session.js";
-
-export const attachCommand = {
-    name: "attach",
-    description: "Show new output from a background shell session (/attach <id>)",
-    async run({ args }) {
-        const id = args[0];
-        if (!id)
-            return { message: "Usage: /attach <session-id>  (see /jobs)" };
-        const result = await pollShellSession(id, 0);
-        if (!result)
-            return { message: `Unknown session: ${id}` };
-        const status = result.status === "running" ? "running" : `${result.status} (exit ${result.exitCode ?? "?"})`;
-        return { message: `[session ${id}] ${status}\n${result.output || "(no new output)"}` };
-    },
-};

package/src/commands/bg.ts

@@ -1,9 +0,0 @@
-export const bgCommand = {
-    name: "bg",
-    description: "Explain backgrounding (long shell commands auto-background after ~2s)",
-    run() {
-        return {
-            message: "Long shell commands already return a session id after ~2s; use /jobs to list them, /attach <id> for new output, /kill <id> to stop.",
-        };
-    },
-};

package/src/commands/cancel.ts

@@ -1,10 +0,0 @@
-export const cancelCommand = {
-    name: "cancel",
-    description: "Cancel the active agent run (soft keyboard alternative to Esc)",
-    run({ state, actions }) {
-        if (!state.busy)
-            return { message: "Nothing is running." };
-        actions.cancelRun();
-        return { message: "Cancelling the active run…" };
-    },
-};

package/src/commands/compact.ts

@@ -1,23 +0,0 @@
-import { compactMessages, DEFAULT_COMPACTION_CONFIG } from "../agent/compaction.js";
-import { getModelMeta } from "../lib/model-meta.js";
-
-export const compactCommand = {
-    name: "compact",
-    description: "Force local context compaction now",
-    run({ state, actions }) {
-        const meta = getModelMeta(state.providerId, state.model);
-        const result = compactMessages(state.history, { ...DEFAULT_COMPACTION_CONFIG, localThresholdRatio: 0 }, {
-            contextWindow: meta.contextWindow,
-            providerId: state.providerId,
-            model: state.model,
-            force: true,
-        });
-        if (!result.compacted)
-            return { message: "Nothing to compact (history is already small)." };
-        actions.replaceHistory(result.messages);
-        return {
-            message: `[context compacted] ${result.beforeTokens} → ${result.afterTokens} tokens (${result.droppedMessages} messages summarized).` +
-                (result.summaryFile ? `\nSummary: ${result.summaryFile}` : ""),
-        };
-    },
-};

package/src/commands/context.ts

@@ -1,25 +0,0 @@
-import { DEFAULT_COMPACTION_CONFIG, heapExceeded, localThresholdTokens } from "../agent/compaction.js";
-import { estMessagesTokens, getModelMeta } from "../lib/model-meta.js";
-
-export const contextCommand = {
-    name: "context",
-    description: "Show estimated context tokens, compaction threshold, and heap usage",
-    run(ctx) {
-        const meta = getModelMeta(ctx.state.providerId, ctx.state.model);
-        const tokens = estMessagesTokens(ctx.state.history, {
-            providerId: ctx.state.providerId,
-            model: ctx.state.model,
-        });
-        const threshold = localThresholdTokens(DEFAULT_COMPACTION_CONFIG, meta.contextWindow);
-        const percent = meta.contextWindow > 0 ? (tokens / meta.contextWindow) * 100 : 0;
-        const heapMb = process.memoryUsage().heapUsed / 1024 / 1024;
-        return {
-            message: [
-                `Context: ~${tokens.toLocaleString()} / ${meta.contextWindow.toLocaleString()} tokens (${percent.toFixed(1)}%)`,
-                `Compaction threshold: ${threshold.toLocaleString()} tokens (${Math.round(DEFAULT_COMPACTION_CONFIG.localThresholdRatio * 100)}%)`,
-                `Heap: ${heapMb.toFixed(1)} MB / ${DEFAULT_COMPACTION_CONFIG.heapLimitMb} MB${heapExceeded(DEFAULT_COMPACTION_CONFIG) ? "  [forced compaction]" : ""}`,
-                `Messages: ${ctx.state.history.length}  ·  chars/token: ~${meta.charsPerToken}`,
-            ].join("\n"),
-        };
-    },
-};

package/src/commands/edit.ts

@@ -1,37 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export const editCommand = {
-    name: "edit",
-    description: "Edit the prompt in $EDITOR (works around Ink IME issues on Termux)",
-    run({ state, actions }) {
-        const file = join(tmpdir(), `fastcode-edit-${Date.now()}.md`);
-        writeFileSync(file, state.draft ?? "", "utf8");
-        const editor = process.env["EDITOR"] || process.env["VISUAL"] || "nano";
-        const wasRaw = Boolean(process.stdin.isTTY && process.stdin.isRaw);
-        try {
-            if (wasRaw)
-                process.stdin.setRawMode(false);
-            const result = spawnSync(editor, [file], { stdio: "inherit" });
-            if (result.error)
-                return { message: `Could not launch ${editor}: ${result.error.message}` };
-            const text = readFileSync(file, "utf8").trim();
-            if (!text)
-                return { message: "Editor closed with no text." };
-            actions.setInput(text);
-            return { message: "Draft loaded into the prompt; press Enter to send." };
-        }
-        finally {
-            if (wasRaw)
-                process.stdin.setRawMode(true);
-            try {
-                unlinkSync(file);
-            }
-            catch {
-                // temp file may already be gone
-            }
-        }
-    },
-};

package/src/commands/effort.ts

@@ -1,49 +0,0 @@
-import { getProvider } from "../providers/index.js";
-import type { ReasoningEffort } from "../types.js";
-const EFFORTS: ReasoningEffort[] = ["auto", "low", "medium", "high", "max"];
-const HINTS: Record<ReasoningEffort, string> = {
-    auto: "provider default (send nothing)",
-    low: "fast, minimal thinking",
-    medium: "balanced",
-    high: "deeper reasoning, slower",
-    max: "maximum budget where supported",
-};
-export const effortCommand = {
-    name: "effort",
-    description: "Set thinking effort (auto/low/medium/high/max). Usage: /effort [level]",
-    run({ args, state, actions }) {
-        const provider = getProvider(state.providerId);
-        const supported = provider?.supportsReasoning?.(state.model) ?? false;
-        const current = (state.reasoningEffort ?? "auto");
-        const apply = (value: ReasoningEffort) => {
-            actions.setReasoningEffort(value);
-            return describe(value, provider, supported);
-        };
-        if (args.length > 0) {
-            const value = args[0].toLowerCase();
-            if (!EFFORTS.includes(value as ReasoningEffort)) {
-                return { message: `Unknown effort "${args[0]}". Choose: ${EFFORTS.join(", ")}.` };
-            }
-            return { message: apply(value as ReasoningEffort) };
-        }
-        return {
-            message: `Thinking effort: ${current}${supported ? "" : " (this provider has no thinking parameter)"}`,
-            picker: {
-                title: `Thinking effort · ${provider?.label ?? state.providerId}`,
-                current,
-                items: EFFORTS.map((value) => ({ value, label: value, hint: HINTS[value] })),
-                onSelect: (value) => actions.pushSystemMessage(apply(value as ReasoningEffort)),
-            },
-        };
-    },
-};
-function describe(value, provider, supported) {
-    if (value === "auto") {
-        return "Thinking effort: auto — the provider's default is used (no thinking parameter is sent).";
-    }
-    if (!supported) {
-        return `Thinking effort saved as ${value}, but ${provider?.label ?? "this provider"} does not expose a thinking parameter; ` +
-            "requests will omit it. Switch to a reasoning-capable model/provider to use it.";
-    }
-    return `Thinking effort: ${value}. The next request will carry the provider-specific thinking parameter.`;
-}

package/src/commands/expand.ts

@@ -1,8 +0,0 @@
-export const expandCommand = {
-    name: "expand",
-    description: "Toggle full tool output in the transcript (stable UI defaults to collapsed)",
-    run({ state, actions }) {
-        actions.setExpanded(!state.expanded);
-        return { message: state.expanded ? "Tool output: collapsed." : "Tool output: expanded (new output only)." };
-    },
-};

package/src/commands/jobs.ts

@@ -1,17 +0,0 @@
-import { listShellSessions } from "../agent/shell-session.js";
-
-export const jobsCommand = {
-    name: "jobs",
-    description: "List background shell sessions",
-    run() {
-        const jobs = listShellSessions();
-        if (jobs.length === 0)
-            return { message: "No shell sessions. Long commands return a session id automatically." };
-        const lines = jobs.map((job) => {
-            const exit = job.exitCode === undefined || job.exitCode === null ? "" : ` exit=${job.exitCode}`;
-            const command = job.command.length > 80 ? job.command.slice(0, 77) + "…" : job.command;
-            return `${job.id}  ${job.status}${exit}  ${(job.bytes / 1024).toFixed(1)}KB  ${command}`;
-        });
-        return { message: ["Shell sessions:", ...lines, "", "Kill one with: /kill <id>"].join("\n") };
-    },
-};

package/src/commands/kill.ts

@@ -1,12 +0,0 @@
-import { killShellSession } from "../agent/shell-session.js";
-
-export const killCommand = {
-    name: "kill",
-    description: "Kill a background shell session (/kill <id>)",
-    run(ctx) {
-        const id = ctx.args[0];
-        if (!id)
-            return { message: "Usage: /kill <session-id>  (see /jobs)" };
-        return { message: killShellSession(id) ? `Killed ${id} (process tree).` : `No running session named ${id}.` };
-    },
-};

package/src/commands/steer.ts

@@ -1,13 +0,0 @@
-export const steerCommand = {
-    name: "steer",
-    description: "Add guidance to the next request of an active run (/steer <text>)",
-    run({ args, state, actions }) {
-        const text = args.join(" ").trim();
-        if (!text)
-            return { message: "Usage: /steer <guidance>" };
-        if (!state.busy)
-            return { message: "No active run. Just send the guidance as the next message." };
-        actions.steer(text);
-        return { message: "Steering queued for the next request." };
-    },
-};

package/src/lib/model-meta.ts

@@ -1,138 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export interface ModelMeta {
-  contextWindow: number;
-  supportsTools: boolean;
-  charsPerToken: number;
-  maxOutputTokens?: number;
-}
-
-export interface EstTokenOptions {
-  providerId?: string;
-  model?: string;
-  charsPerToken?: number;
-}
-
-export const UNKNOWN_MODEL_META: ModelMeta = {
-  contextWindow: 32_768,
-  supportsTools: false,
-  charsPerToken: 2.5,
-};
-
-const PROVIDER_META: Record<string, ModelMeta> = {
-  anthropic: { contextWindow: 1_000_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 64_000 },
-  openai: { contextWindow: 400_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 32_000 },
-  google: { contextWindow: 1_048_576, supportsTools: true, charsPerToken: 3.6, maxOutputTokens: 65_536 },
-  deepseek: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
-  openrouter: { contextWindow: 128_000, supportsTools: true, charsPerToken: 2.5, maxOutputTokens: 16_384 },
-  groq: { contextWindow: 128_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 8_192 },
-  mistral: { contextWindow: 128_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 8_192 },
-  xai: { contextWindow: 256_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 16_384 },
-  moonshot: { contextWindow: 256_000, supportsTools: true, charsPerToken: 2.0, maxOutputTokens: 16_384 },
-  zhipu: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
-  qwen: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
-  ollama: { contextWindow: 32_768, supportsTools: true, charsPerToken: 2.5, maxOutputTokens: 4_096 },
-  custom: { contextWindow: 32_768, supportsTools: false, charsPerToken: 2.5 },
-};
-
-const MODEL_OVERRIDES: Record<string, Partial<ModelMeta>> = {
-  "claude-haiku-5.5": { contextWindow: 200_000 },
-  "claude-haiku-4.5": { contextWindow: 200_000 },
-  "claude-sonnet-5": { contextWindow: 1_000_000 },
-  "claude-opus-5": { contextWindow: 1_000_000 },
-  "claude-sonnet-4.6": { contextWindow: 1_000_000 },
-  "claude-opus-4.6": { contextWindow: 1_000_000 },
-  "gpt-4o": { contextWindow: 128_000 },
-  "gpt-4o-mini": { contextWindow: 128_000 },
-  "gpt-4.1": { contextWindow: 1_000_000 },
-  o3: { contextWindow: 200_000 },
-  "o4-mini": { contextWindow: 200_000 },
-  "gemini-3.5-flash-lite": { contextWindow: 1_048_576 },
-  "gemini-3.1-flash-lite": { contextWindow: 1_048_576 },
-  "deepseek-v4-pro": { contextWindow: 128_000, charsPerToken: 1.7 },
-  "deepseek-flash": { contextWindow: 128_000, charsPerToken: 1.7 },
-  "glm-5.3": { contextWindow: 128_000, charsPerToken: 1.7 },
-  "glm-5.2": { contextWindow: 128_000, charsPerToken: 1.7 },
-  "qwen3.8-max": { contextWindow: 128_000, charsPerToken: 1.7 },
-  "qwen3.8-flash": { contextWindow: 128_000, charsPerToken: 1.7 },
-  "kimi-k3": { contextWindow: 256_000, charsPerToken: 2.0 },
-  "grok-4.7": { contextWindow: 256_000, charsPerToken: 3.8 },
-  "mistral-large-latest": { contextWindow: 128_000, charsPerToken: 3.8 },
-};
-
-let overrideCache: Record<string, Partial<ModelMeta>> | undefined;
-
-export function modelMetaOverridePath(): string {
-  const root = process.env["FASTCODE_HOME"] ?? join(homedir(), ".fastcode");
-  return join(root, "model-meta.json");
-}
-
-export function clearModelMetaCache(): void {
-  overrideCache = undefined;
-}
-
-function loadOverrides(): Record<string, Partial<ModelMeta>> {
-  if (overrideCache)
-    return overrideCache;
-  const file = modelMetaOverridePath();
-  if (!existsSync(file)) {
-    overrideCache = {};
-    return overrideCache;
-  }
-  try {
-    const raw = JSON.parse(readFileSync(file, "utf8"));
-    overrideCache = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
-  }
-  catch {
-    overrideCache = {};
-  }
-  return overrideCache;
-}
-
-function usable(meta: Partial<ModelMeta> | undefined): meta is Partial<ModelMeta> {
-  return Boolean(meta) && typeof meta === "object";
-}
-
-function apply(base: ModelMeta, ...layers: Array<Partial<ModelMeta> | undefined>): ModelMeta {
-  const next = { ...base };
-  for (const layer of layers) {
-    if (!usable(layer))
-      continue;
-    if (typeof layer.contextWindow === "number" && layer.contextWindow > 0)
-      next.contextWindow = Math.floor(layer.contextWindow);
-    if (typeof layer.charsPerToken === "number" && layer.charsPerToken > 0)
-      next.charsPerToken = layer.charsPerToken;
-    if (typeof layer.supportsTools === "boolean")
-      next.supportsTools = layer.supportsTools;
-    if (typeof layer.maxOutputTokens === "number" && layer.maxOutputTokens > 0)
-      next.maxOutputTokens = Math.floor(layer.maxOutputTokens);
-  }
-  return next;
-}
-
-export function getModelMeta(providerId?: string, model?: string): ModelMeta {
-  const provider = providerId && PROVIDER_META[providerId] ? PROVIDER_META[providerId] : UNKNOWN_MODEL_META;
-  const overrides = loadOverrides();
-  const keys = [
-    providerId && model ? `${providerId}/${model}` : undefined,
-    providerId && model ? `${providerId}::${model}` : undefined,
-    model,
-  ].filter((key): key is string => Boolean(key));
-  const layers = keys.map((key) => overrides[key]);
-  return apply(provider, model ? MODEL_OVERRIDES[model] : undefined, ...layers);
-}
-
-export function estTokens(text: string, options: number | EstTokenOptions = {}): number {
-  if (!text)
-    return 0;
-  const ratio = typeof options === "number"
-    ? options
-    : options.charsPerToken ?? getModelMeta(options.providerId, options.model).charsPerToken;
-  return Math.ceil(text.length / Math.max(0.1, ratio));
-}
-
-export function estMessagesTokens(messages: Array<{ content: string }>, options: EstTokenOptions = {}): number {
-  return messages.reduce((sum, message) => sum + estTokens(message.content ?? "", options), 0);
-}

package/src/lib/native-tools.ts

@@ -1,32 +0,0 @@
-import type { NativeToolCall } from "../types.js";
-
-export type ToolCallAccumulator = Map<number, NativeToolCall>;
-
-export interface ToolCallDelta {
-    index?: number;
-    id?: string;
-    function?: { name?: string; arguments?: string };
-}
-
-export function mergeToolCallDelta(accumulator: ToolCallAccumulator, delta: ToolCallDelta): void {
-    const index = typeof delta.index === "number" && Number.isFinite(delta.index) ? delta.index : accumulator.size;
-    const entry = accumulator.get(index) ?? { id: "", name: "", arguments: "" };
-    if (typeof delta.id === "string" && delta.id)
-        entry.id = delta.id;
-    if (typeof delta.function?.name === "string" && delta.function.name)
-        entry.name = delta.function.name;
-    if (typeof delta.function?.arguments === "string")
-        entry.arguments += delta.function.arguments;
-    accumulator.set(index, entry);
-}
-
-export function finalizeToolCalls(accumulator: ToolCallAccumulator): NativeToolCall[] {
-    return Array.from(accumulator.entries())
-        .sort((a, b) => a[0] - b[0])
-        .filter(([, call]) => Boolean(call.name))
-        .map(([index, call]) => ({
-            id: call.id || `call_${index}`,
-            name: call.name,
-            arguments: call.arguments || "{}",
-        }));
-}