xindex 1.0.0

package/apps/run.search.ts

@@ -0,0 +1,21 @@
+import {BuildComponents} from "../componets/buildComponents.js";
+import {BufferedLoggerToStdOut} from "../componets/logger.js";
+import {SearchApp} from "./searchApp.js";
+import {AppId} from "../componets/appId.js";
+import {FormatSearchResults} from "../componets/index/formatSearchResults.js";
+
+const appId = AppId();
+const log = BufferedLoggerToStdOut();
+const {searchContentIndex, config} = await BuildComponents({log});
+const search = SearchApp({searchContentIndex});
+
+const query = process.argv.slice(2).join(" ");
+if (!query) {
+    log("Usage: xindex.search <query>");
+    process.exit(1);
+}
+
+log(`[${appId}] searching: "${query}"`);
+const results = await search(query);
+const format = FormatSearchResults();
+log(await format(query, results));

package/apps/run.watch.ts

@@ -0,0 +1,44 @@
+import {BuildComponents} from "../componets/buildComponents.js";
+import {HandleFileEvent} from "../componets/index/handleFileEvent.js";
+import {BufferedLoggerToStdOut} from "../componets/logger.js";
+import {WalkFiles} from "../componets/walkFiles.js";
+import {WatchFiles} from "../componets/watchFiles.js";
+import {WatcherLock} from "../componets/index/watcherLock.js";
+import {WatchApp} from "./watchApp.js";
+import {AppId} from "../componets/appId.js";
+import {join} from "path";
+
+const cwd = process.cwd();
+const log = BufferedLoggerToStdOut();
+const {indexContent, removeContent, getIndexStats, config} = await BuildComponents({log});
+const walkFiles = WalkFiles({cwd, log, ignoreFiles: config.ignoreFiles});
+const watchFiles = WatchFiles({cwd, log, ignoreFiles: config.ignoreFiles});
+const handleFileEvent = HandleFileEvent({indexContent, removeContent, log});
+
+const appId = AppId();
+const watcherLock = WatcherLock({
+    lockPath: join(cwd, ".xindex", "lock.json"),
+    appId,
+    log,
+});
+
+const app = WatchApp({walkFiles, watchFiles, handleFileEvent, log, watcherLock});
+
+const inputs = process.argv.slice(2);
+if (!inputs.length) inputs.push(".");
+
+log(`[${appId}] started, indexing and watching: ${inputs.join(", ")}`);
+
+process.on("SIGINT", async () => {
+    log(`\n[${appId}] shutting down — stopping watcher...`);
+    app.stop();
+    log(`[${appId}] releasing lock...`);
+    await watcherLock.release();
+    log(`[${appId}] waiting 7s for another watcher to take over...`);
+    await new Promise(r => setTimeout(r, 7000));
+    log(`[${appId}] exiting`);
+    process.exit(0);
+});
+
+await app.run(inputs);
+log("done. indexed:", await getIndexStats());

package/apps/searchApp.ts

@@ -0,0 +1,9 @@
+import {ISearchIndex, IIndexRecord} from "../features/searchIndex.js";
+
+export type ISearchApp = (query: string, limit?: number) => Promise<IIndexRecord[]>;
+
+export function SearchApp({searchContentIndex}: {searchContentIndex: ISearchIndex}): ISearchApp {
+    return async function search(query, limit = 10) {
+        return await searchContentIndex(query, limit);
+    }
+}

package/apps/watchApp.ts

@@ -0,0 +1,53 @@
+import {from} from "../packages/streamx/src/from.js";
+import {map} from "../packages/streamx/src/map.js";
+import {tap} from "../packages/streamx/src/tap.js";
+import {run} from "../packages/streamx/src/index.js";
+import {IWalkFiles} from "../componets/walkFiles.js";
+import {FileEventType, IWatchFiles} from "../componets/watchFiles.js";
+import {IHandleFileEvent} from "../componets/index/handleFileEvent.js";
+import {ILogger} from "../componets/logger.js";
+import {IWatcherLock} from "../componets/index/watcherLock.js";
+import {WatchFileEventsApp} from "./watchFileEventsApp.js";
+
+export type IWatchApp = {
+    run: (inputs: string[]) => Promise<void>;
+    stop: () => void;
+};
+
+export function WatchApp({walkFiles, watchFiles, handleFileEvent, log, watcherLock}: {
+    walkFiles: IWalkFiles,
+    watchFiles: IWatchFiles,
+    handleFileEvent: IHandleFileEvent,
+    log: ILogger,
+    watcherLock: IWatcherLock,
+}): IWatchApp {
+    return {
+        async run(inputs) {
+            // Phase 1: initial index — walk all files
+            await run(
+                from(walkFiles(inputs))
+                    .pipe(tap(id => log(`indexing: ${id}`)))
+                    .pipe(map<string, string>(async (id) => {
+                        await handleFileEvent({type: FileEventType.index, path: id});
+                        return id;
+                    }))
+            );
+
+            log("initial index complete, acquiring watcher lock...");
+
+            // Phase 2: watch for changes — delegate to WatchFileEventsApp
+            const startWatch = WatchFileEventsApp({
+                watchFiles,
+                watchDir: inputs[0] ?? ".",
+                handleFileEvent,
+                log,
+                watcherLock,
+            });
+            startWatch();
+        },
+        stop() {
+            watcherLock.stopHeartbeat();
+            watcherLock.stopWaiting();
+        },
+    };
+}

package/apps/watchFileEventsApp.ts

@@ -0,0 +1,39 @@
+import {IWatchFiles} from "../componets/watchFiles.js";
+import {IHandleFileEvent} from "../componets/index/handleFileEvent.js";
+import {ILogger} from "../componets/logger.js";
+import {IWatcherLock} from "../componets/index/watcherLock.js";
+
+export type IWatchFileEventsApp = () => void;
+
+export function WatchFileEventsApp({watchFiles, watchDir, handleFileEvent, log, watcherLock}: {
+    watchFiles: IWatchFiles,
+    watchDir: string,
+    handleFileEvent: IHandleFileEvent,
+    log: ILogger,
+    watcherLock: IWatcherLock,
+}): IWatchFileEventsApp {
+    return function startWatchProcess() {
+        (async () => {
+            await new Promise(r => setTimeout(r, 500 + Math.random() * 500));
+            while (!watcherLock.stopped) {
+                if (await watcherLock.tryAcquire()) {
+                    log(`watching for changes: ${watchDir}`);
+                    const watcher = watchFiles([watchDir]);
+                    const events = (async () => {
+                        try {
+                            for await (const e of watcher.events) await handleFileEvent(e);
+                        } catch (e) {
+                            log(`watch error: ${(e as any)?.message ?? e}`);
+                        }
+                    })();
+                    await watcherLock.heartbeatUntilLost();
+                    watcher.stop();
+                    await events;
+                } else {
+                    log("another watcher is active, standing by...");
+                    await watcherLock.waitForRelease();
+                }
+            }
+        })();
+    };
+}

package/bin/xindex-index

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx --yes tsx
+import "../apps/run.index.js";

package/bin/xindex-mcp

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx --yes tsx
+import "../apps/run.mcp.js";

package/bin/xindex-reset

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx --yes tsx
+import "../apps/run.reset.js";

package/bin/xindex-search

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx --yes tsx
+import "../apps/run.search.js";

package/bin/xindex-watch

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx --yes tsx
+import "../apps/run.watch.js";

package/componets/IType.ts

@@ -0,0 +1 @@
+export type IType<T extends { type: string }> = Readonly<T>

package/componets/appId.ts

@@ -0,0 +1,3 @@
+export function AppId() {
+    return `xindex-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/componets/buildComponents.ts

@@ -0,0 +1,27 @@
+import {Embed} from "./llm/embed.js";
+import {ExtractKeywords} from "./keywords/extractKeywords.js";
+import {CleanUpKeywords} from "./keywords/cleanUpKeywords.js";
+import {ContentIndexDriver} from "./index/contentIndexDriver.js";
+import {LoadConfig} from "./config/loadConfig.js";
+import {ILogger} from "./logger.js";
+
+export async function BuildComponents({log}: {log: ILogger}) {
+    const loadConfig = LoadConfig({configPath: ".xindex.json", log});
+    const config = await loadConfig();
+
+    const embed = Embed({pooling: "mean", normalize: true});
+    const extractKeywords = ExtractKeywords();
+    const cleanUpKeywords = CleanUpKeywords({maxNgrams: 2, minLength: 2, ignoreKeywords: config.ignoreKeywords});
+
+    const DEFAULT_INDEX_PATH = ".xindex";
+
+    const {indexContent, removeContent, getIndexStats, searchContentIndex, resetIndex}
+        = await ContentIndexDriver({
+            path: DEFAULT_INDEX_PATH,
+            embed,
+            extractKeywords,
+            cleanUpKeywords,
+        });
+    return {extractKeywords, cleanUpKeywords, indexContent, removeContent, getIndexStats,
+            searchContentIndex, resetIndex, config};
+}

package/componets/config/loadConfig.ts

@@ -0,0 +1,43 @@
+import {readFile} from "fs/promises";
+import {IXindexConfig} from "./xindexConfig.js";
+import {ILogger} from "../logger.js";
+
+const DEFAULTS: IXindexConfig = {
+    ignoreKeywords: [],
+    ignoreFiles: [],
+};
+
+export type ILoadConfig = () => Promise<IXindexConfig>;
+
+export function LoadConfig({configPath, log}: {configPath: string, log: ILogger}): ILoadConfig {
+    return async function loadConfig() {
+        let raw: string;
+        try {
+            raw = await readFile(configPath, "utf8");
+        } catch (e: any) {
+            if (e?.code === "ENOENT") return {...DEFAULTS};
+            throw new Error(`Cannot read ${configPath}: ${e?.message ?? e}`);
+        }
+
+        if (!raw.trim()) return {...DEFAULTS};
+
+        let parsed: Record<string, unknown>;
+        try {
+            parsed = JSON.parse(raw);
+        } catch (e) {
+            throw new Error(`Failed to parse ${configPath}: ${e instanceof Error ? e.message : e}`);
+        }
+
+        const toStrings = (v: unknown) => Array.isArray(v) ? v.filter((e): e is string => typeof e === "string") : [];
+        const config: IXindexConfig = {
+            ignoreKeywords: toStrings(parsed.ignoreKeywords),
+            ignoreFiles: toStrings(parsed.ignoreFiles),
+        };
+
+        for (const kw of config.ignoreKeywords) {
+            if (kw.length <= 1) log(`warning: ignoreKeywords entry "${kw}" is <=1 char`);
+        }
+
+        return config;
+    };
+}

package/componets/config/xindexConfig.ts

@@ -0,0 +1,4 @@
+export type IXindexConfig = {
+    ignoreKeywords: string[];
+    ignoreFiles: string[];
+};

package/componets/index/contentIndexDriver.ts

@@ -0,0 +1,39 @@
+import {IEmbed} from "../llm/embed.js";
+import {IExtractKeywords} from "../keywords/extractKeywords.js";
+import {ICleanUpKeywords} from "../keywords/cleanUpKeywords.js";
+import {GetIndexStats, IGetIndexStats} from "./getIndexStats.js";
+import {IndexContent, IIndexContent} from "../../features/indexContent.js";
+import {SearchIndex, ISearchIndex} from "../../features/searchIndex.js";
+import {RemoveContent, IRemoveContent} from "../../features/removeContent.js";
+import {ResetIndex, IResetIndex} from "../../features/resetIndex.js";
+import {VectraIndex} from "./vectraIndex.js";
+import {IndexApi} from "./indexApi.js";
+
+export type IContentIndexDriver = Readonly<{
+    getIndexStats: IGetIndexStats,
+    indexContent: IIndexContent,
+    removeContent: IRemoveContent,
+    searchContentIndex: ISearchIndex,
+    resetIndex: IResetIndex,
+    flush: () => Promise<void>,
+}>;
+
+export async function ContentIndexDriver({path, embed, extractKeywords, cleanUpKeywords, scoreThreshold}: {
+    path: string,
+    embed: IEmbed,
+    extractKeywords: IExtractKeywords,
+    cleanUpKeywords: ICleanUpKeywords,
+    scoreThreshold?: number,
+}): Promise<IContentIndexDriver> {
+    const index = await VectraIndex(path + "/semantic");
+    const indexApi = IndexApi({index, embed});
+
+    return {
+        getIndexStats: GetIndexStats({index}),
+        indexContent: IndexContent({extractKeywords, cleanUpKeywords, indexApi}),
+        removeContent: RemoveContent({indexApi}),
+        searchContentIndex: SearchIndex({extractKeywords, cleanUpKeywords, embed, index, scoreThreshold}),
+        resetIndex: ResetIndex({indexApi}),
+        flush: () => indexApi.flush(),
+    };
+}

package/componets/index/formatSearchResults.ts

@@ -0,0 +1,18 @@
+import {IIndexRecord} from "../../features/searchIndex.js";
+
+export type IFormatSearchResults = (query: string, results: IIndexRecord[]) => Promise<string>;
+
+export function FormatSearchResults(): IFormatSearchResults {
+    return async function formatSearchResults(query, results) {
+        if (results.length === 0) return `No results for: "${query}"`;
+
+        const lines: string[] = [];
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            const kw = r.keywords ? ` — ${r.keywords}` : "";
+            lines.push("", `${i + 1}. ${r.id}${kw}`);
+        }
+
+        return `Search: "${query}" — ${results.length} result(s)\n\n${lines.join("\n")}`;
+    };
+}

package/componets/index/getIndexStats.ts

@@ -0,0 +1,11 @@
+import {LocalIndex} from "vectra";
+
+export type IIndexStats = { indexedAmount: number };
+export type IGetIndexStats = () => Promise<IIndexStats>;
+
+export function GetIndexStats({index}: { index: LocalIndex }): IGetIndexStats {
+    return async function getIndexStats() {
+        const {items} = await index.getIndexStats();
+        return {indexedAmount: items} satisfies IIndexStats;
+    }
+}

package/componets/index/handleFileEvent.ts

@@ -0,0 +1,25 @@
+import {readFile} from "fs/promises";
+import {IIndexContent} from "../../features/indexContent.js";
+import {IRemoveContent} from "../../features/removeContent.js";
+import {ILogger} from "../logger.js";
+import {FileEventType, IFileEvent} from "../watchFiles.js";
+
+export type IHandleFileEvent = (event: IFileEvent) => Promise<void>;
+
+export function HandleFileEvent({indexContent, removeContent, log}: {
+    indexContent: IIndexContent,
+    removeContent: IRemoveContent,
+    log: ILogger,
+}): IHandleFileEvent {
+    return async function handleFileEvent(event) {
+        if (event.type === FileEventType.index) {
+            try { await removeContent(event.path); } catch (e) { log(`remove failed: ${event.path} — ${(e as any)?.message ?? e}`); }
+            const text = await readFile(event.path, "utf8");
+            await indexContent(event.path, `${text}. ${event.path}`);
+            log(`index: ${event.path}`);
+        } else {
+            try { await removeContent(event.path); } catch (e) { log(`remove failed: ${event.path} — ${(e as any)?.message ?? e}`); }
+            log(`remove: ${event.path}`);
+        }
+    };
+}

package/componets/index/indexApi.ts

@@ -0,0 +1,45 @@
+import {LocalIndex} from "vectra";
+import {IType} from "../IType.js";
+import {ISerial, Serial} from "../../packages/fun/src/serial.js";
+import {caseNever} from "../../packages/fun/src/case-never.js";
+import {IEmbed} from "../llm/embed.js";
+
+export enum IndexCommandType {
+    index = 'index',
+    delete = 'delete',
+    reset = 'reset',
+}
+
+export type IIndexCommand =
+    | IType<{ type: IndexCommandType.index, id: string, content: string, keywords: string }>
+    | IType<{ type: IndexCommandType.delete, id: string }>
+    | IType<{ type: IndexCommandType.reset }>;
+
+export type IIndexApi = ISerial<IIndexCommand, void>;
+
+export function IndexApi({index, embed}: { index: LocalIndex, embed: IEmbed }): IIndexApi {
+    return Serial<IIndexCommand, void>(async msg => {
+        switch (msg.type) {
+            case IndexCommandType.delete: {
+                await index.deleteItem(msg.id);
+                break;
+            }
+            case IndexCommandType.index: {
+                const vector = await embed(msg.content);
+                await index.upsertItem({
+                    id: msg.id,
+                    vector,
+                    metadata: {id: msg.id, keywords: msg.keywords},
+                });
+                break;
+            }
+            case IndexCommandType.reset: {
+                await index.deleteIndex();
+                await index.createIndex();
+                break;
+            }
+            default:
+                return caseNever(msg);
+        }
+    });
+}

package/componets/index/vectraIndex.ts

@@ -0,0 +1,11 @@
+import {LocalIndex} from "vectra";
+
+export async function VectraIndex(path: string): Promise<LocalIndex> {
+    const index = new LocalIndex(path);
+
+    if (!(await index.isIndexCreated())) {
+        await index.createIndex();
+    }
+
+    return index;
+}

package/componets/index/watcherLock.ts

@@ -0,0 +1,107 @@
+import {access, readFile, rm, writeFile} from "fs/promises";
+import {ILogger} from "../logger.js";
+
+export type LockData = { appId: string; lockedAt: number };
+
+export type IWatcherLock = {
+    tryAcquire: () => Promise<boolean>;
+    release: () => Promise<void>;
+    heartbeatUntilLost: () => Promise<void>;
+    stopHeartbeat: () => void;
+    waitForRelease: () => Promise<void>;
+    stopWaiting: () => void;
+    readonly stopped: boolean;
+};
+
+export function WatcherLock({lockPath, appId, log, heartbeatMs = 5000, staleMs = 20000}: {
+    lockPath: string,
+    appId: string,
+    log: ILogger,
+    heartbeatMs?: number,
+    staleMs?: number,
+}): IWatcherLock {
+    let heartbeat: { stop: () => void } | null = null;
+    let wait: { stop: () => void } | null = null;
+    let stopped = false;
+
+    async function readLock(): Promise<LockData | null> {
+        try {
+            await access(lockPath);
+            return JSON.parse(await readFile(lockPath, "utf8")) as LockData;
+        } catch {
+            return null;
+        }
+    }
+
+    async function writeLock(): Promise<void> {
+        await writeFile(lockPath, JSON.stringify({appId, lockedAt: Date.now()} satisfies LockData));
+    }
+
+    function isLockMine(current: LockData | null): boolean {
+        return current?.appId === appId;
+    }
+
+    return {
+        async tryAcquire() {
+            if (stopped) return false;
+            const lock = await readLock();
+            if (lock && (Date.now() - lock.lockedAt) < staleMs) return false;
+            try {
+                if (!lock) {
+                    await writeFile(lockPath, JSON.stringify({appId, lockedAt: Date.now()}), {flag: "wx"});
+                } else {
+                    await writeLock();
+                }
+                return true;
+            } catch {
+                const current = await readLock();
+                const isMine = isLockMine(current);
+                if (isMine) await writeLock();
+                return isMine;
+            }
+        },
+
+        async release() {
+            const lock = await readLock();
+            if (isLockMine(lock)) await rm(lockPath, {force: true});
+        },
+
+        heartbeatUntilLost() {
+            if (stopped) return Promise.resolve();
+            return new Promise<void>(resolve => {
+                const timer = setInterval(async () => {
+                    if (stopped) return;
+                    try {
+                        const current = await readLock();
+                        if (stopped) return;
+                        if (current && !isLockMine(current)) {
+                            log("watcher lock lost to another process");
+                            heartbeat?.stop();
+                            return;
+                        }
+                        await writeLock();
+                    } catch {}
+                }, heartbeatMs);
+                heartbeat = {stop: () => { clearInterval(timer); heartbeat = null; resolve(); }};
+            });
+        },
+
+        stopHeartbeat() { stopped = true; heartbeat?.stop(); wait?.stop(); },
+
+        waitForRelease() {
+            if (stopped) return Promise.resolve();
+            return new Promise<void>(resolve => {
+                const timer = setInterval(async () => {
+                    if (stopped) { wait?.stop(); return; }
+                    const lock = await readLock();
+                    if (!lock || (Date.now() - lock.lockedAt) >= staleMs) wait?.stop();
+                }, heartbeatMs);
+                wait = {stop: () => { clearInterval(timer); wait = null; resolve(); }};
+            });
+        },
+
+        stopWaiting() { stopped = true; wait?.stop(); heartbeat?.stop(); },
+
+        get stopped() { return stopped; },
+    };
+}

package/componets/keywords/cleanUpKeywords.ts

@@ -0,0 +1,38 @@
+import {createRequire} from "module";
+
+const require = createRequire(import.meta.url);
+const keyword_extractor = require("keyword-extractor");
+
+export type ICleanUpKeywords = (keywords: string[]) => string[];
+
+export function CleanUpKeywords({maxNgrams, minLength, ignoreKeywords = []}: {
+    maxNgrams: number, minLength: number, ignoreKeywords?: string[]
+}): ICleanUpKeywords {
+
+    const normalize = (kw: string) => kw.toLowerCase().trim();
+    const ignoreSet = new Set(ignoreKeywords.map(normalize));
+
+    return function cleanUpKeywords(keywords) {
+        const cleaned = keywords.join(" ").replace(/\W+/gm, " ").trim();
+
+        const extracted: string[] = keyword_extractor.extract(cleaned, {
+            language: "english",
+            remove_digits: false,
+            return_changed_case: true,
+            remove_duplicates: true,
+            return_max_ngrams: maxNgrams,
+        });
+
+        const seen = new Set<string>();
+
+        return extracted
+            .map(normalize)
+            .filter((kw: string) => {
+                if (kw.length <= minLength || !/[a-z]/i.test(kw)) return false;
+                if (ignoreSet.has(kw)) return false;
+                if (seen.has(kw)) return false;
+                seen.add(kw);
+                return true;
+            });
+    }
+}

package/componets/keywords/extractKeywords.ts

@@ -0,0 +1,14 @@
+import nlp from "compromise";
+
+export type IExtractKeywords = (text: string) => string[];
+
+export function ExtractKeywords(): IExtractKeywords {
+    return function extractKeywords(text) {
+        const doc = nlp(text);
+        return [
+            ...doc.topics().out("array"),
+            ...doc.nouns().out("array"),
+            ...doc.verbs().out("array"),
+        ] as string[];
+    }
+}

package/componets/keywords/refineKeywords.ts

@@ -0,0 +1,16 @@
+import {IQueryLLM} from "../llm/queryLLM.js";
+import {ICleanUpKeywords} from "./cleanUpKeywords.js";
+
+export type IRefineKeywords = (keywords: string[]) => Promise<string[]>;
+
+export function RefineKeywords({queryLLM, cleanUpKeywords, prompt}: {
+    queryLLM: IQueryLLM,
+    cleanUpKeywords: ICleanUpKeywords,
+    prompt: string,
+}): IRefineKeywords {
+    return async function refineKeywords(keywords) {
+        const input = keywords.join(", ");
+        const result = await queryLLM(prompt, input);
+        return cleanUpKeywords(result.split(",").map(s => s.trim()));
+    }
+}

package/componets/llm/embed.ts

@@ -0,0 +1,18 @@
+import {pipeline} from "@huggingface/transformers";
+
+const embedder = await pipeline(
+    "feature-extraction",
+    "sentence-transformers/all-MiniLM-L6-v2"
+);
+
+export type IEmbed = (text: string) => Promise<number[]>;
+
+type Pooling = "none" | "mean" | "cls" | "first_token" | "eos" | "last_token";
+
+export function Embed({pooling, normalize}: {pooling: Pooling, normalize: boolean}): IEmbed {
+    return async function embed(text) {
+        const result = await embedder(text, {pooling, normalize});
+        return Array.from(result.data as Float32Array);
+    }
+}
+

package/componets/llm/queryLLM.ts

@@ -0,0 +1,20 @@
+import {pipeline} from "@huggingface/transformers";
+
+const generator = await pipeline(
+    "text-generation",
+    "HuggingFaceTB/SmolLM2-135M-Instruct"
+);
+
+export type IQueryLLM = (prompt: string, input: string, maxTokens?: number) => Promise<string>;
+
+export function QueryLLM({maxTokens}: { maxTokens: number }): IQueryLLM {
+    return async function queryLLM(prompt, input, overrideMaxTokens?) {
+        const messages = [
+            {role: "system", content: prompt},
+            {role: "user", content: input},
+        ];
+        const output = await generator(messages, {max_new_tokens: overrideMaxTokens ?? maxTokens});
+        return (output[0].generated_text.at(-1)?.content as string) ?? "";
+    }
+}
+