smoltalk 0.0.66 → 0.2.1

package/dist/types.js

@@ -4,7 +4,7 @@ export * from "./types/costEstimate.js";
 export * from "./types/tokenUsage.js";
 export function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, }) {
     return {
-        output: output || null,
+        output: (output ?? null),
         toolCalls: toolCalls || [],
         thinkingBlocks: thinkingBlocks,
         usage,

package/dist/util/logger.d.ts

@@ -1,2 +1,18 @@
-import { EgonLog, LogLevel } from "egonlog";
+export type LogLevel = "error" | "warn" | "info" | "debug";
+export type EgonLogConfig = {
+    logLevel: LogLevel;
+};
+export declare class EgonLog {
+    private logLevel;
+    constructor(config: EgonLogConfig);
+    private shouldLog;
+    private log;
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    table(...args: unknown[]): void;
+    setLogLevel(level: LogLevel): void;
+    getLogLevel(): LogLevel;
+}
 export declare function getLogger(level?: LogLevel): EgonLog;

package/dist/util/logger.js

@@ -1,9 +1,72 @@
-import { EgonLog } from "egonlog";
+const LOG_LEVELS = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+};
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const GREEN = "\x1b[32m";
+const RESET = "\x1b[0m";
+export class EgonLog {
+    logLevel;
+    constructor(config) {
+        this.logLevel = config.logLevel;
+    }
+    shouldLog(messageLevel) {
+        return LOG_LEVELS[messageLevel] <= LOG_LEVELS[this.logLevel];
+    }
+    log(level, ...args) {
+        if (!this.shouldLog(level))
+            return;
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+        switch (level) {
+            case "error":
+                console.error(RED + prefix, ...args, RESET);
+                break;
+            case "warn":
+                console.warn(YELLOW + prefix, ...args, RESET);
+                break;
+            case "info":
+                console.info(GREEN + prefix, ...args, RESET);
+                break;
+            case "debug":
+                console.debug(prefix, ...args);
+                break;
+        }
+    }
+    error(...args) {
+        this.log("error", ...args);
+    }
+    warn(...args) {
+        this.log("warn", ...args);
+    }
+    info(...args) {
+        this.log("info", ...args);
+    }
+    debug(...args) {
+        this.log("debug", ...args);
+    }
+    table(...args) {
+        if (!this.shouldLog("debug"))
+            return;
+        console.table(...args);
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    getLogLevel() {
+        return this.logLevel;
+    }
+}
 let loggerInstance = null;
-export function getLogger(level = "error") {
-    if (loggerInstance) {
-        return loggerInstance;
+export function getLogger(level) {
+    if (!loggerInstance) {
+        loggerInstance = new EgonLog({ logLevel: level ?? "error" });
+    }
+    else if (level !== undefined) {
+        loggerInstance.setLogLevel(level);
     }
-    loggerInstance = new EgonLog({ level });
     return loggerInstance;
 }

package/package.json

@@ -1,17 +1,8 @@
 {
   "name": "smoltalk",
-  "version": "0.0.66",
+  "version": "0.2.1",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
-  "scripts": {
-    "test": "vitest",
-    "test:tsc": "tsc -p tests/tsconfig.json",
-    "build": "rm -rf dist && tsc",
-    "start": "cd dist && node index.js",
-    "doc": "typedoc --disableSources --out docs lib && prettier docs/ --write",
-    "typecheck": "tsc --noEmit",
-    "pull": "node-llama-cpp pull --dir ./models"
-  },
   "files": [
     "./dist"
   ],
@@ -20,6 +11,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js",
+      "require": "./dist/testing/index.js"
     }
   },
   "type": "module",
@@ -31,21 +27,21 @@
   ],
   "author": "Aditya Bhargava",
   "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^25.0.3",
-    "prettier": "^3.7.4",
-    "typedoc": "^0.28.15",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
-  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
     "@google/genai": "^1.34.0",
-    "egonlog": "^0.0.2",
     "nanoid": "^5.1.6",
-    "node-llama-cpp": "^3.17.1",
     "ollama": "^0.6.3",
     "openai": "^6.15.0",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "test": "vitest --exclude=**/*.live.test.ts",
+    "test:live": "vitest run lib/clients/*.live.test.ts",
+    "test:tsc": "tsc -p tests/tsconfig.json",
+    "build": "rm -rf dist && tsc",
+    "start": "cd dist && node index.js",
+    "doc": "typedoc --disableSources --out docs lib && prettier docs/ --write",
+    "typecheck": "tsc --noEmit"
   }
 }

package/dist/clients/llamaCpp.d.ts

@@ -1,28 +0,0 @@
-import { BaseClient } from "./baseClient.js";
-import { BaseClientConfig, PromptConfig, PromptResult, Result, StreamChunk } from "../types.js";
-export declare class LlamaCPP extends BaseClient {
-    private llama;
-    private llamaModel;
-    private modelDir;
-    private model;
-    private logger;
-    constructor(config: BaseClientConfig);
-    setup(): Promise<void>;
-    private getModelName;
-    /**
-     * Converts smoltalk messages to node-llama-cpp's ChatHistoryItem format.
-     * Builds the full history including the last user message (LlamaChat.generateResponse
-     * expects the complete history, unlike LlamaChatSession which takes the last message separately).
-     */
-    private convertMessages;
-    /**
-     * Builds node-llama-cpp function definitions from smoltalk tool configs.
-     * Uses ChatModelFunctions (no handler) — LlamaChat.generateResponse() returns
-     * function calls without executing them, which matches smoltalk's tool loop model.
-     */
-    private buildFunctions;
-    private calculateUsageAndCost;
-    private extractToolCalls;
-    _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
-    _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
-}

package/dist/clients/llamaCpp.js

@@ -1,316 +0,0 @@
-import { getLlama, LlamaChat, LlamaLogLevel } from "node-llama-cpp";
-import { BaseClient } from "./baseClient.js";
-import { ToolCall } from "../classes/ToolCall.js";
-import { getLogger } from "../util/logger.js";
-import { Model } from "../model.js";
-import { sanitizeAttributes } from "../util/util.js";
-import { success, } from "../types.js";
-import path from "path";
-export class LlamaCPP extends BaseClient {
-    llama = null;
-    llamaModel = null;
-    modelDir;
-    model;
-    logger;
-    constructor(config) {
-        super(config);
-        if (!config.llamaCppModelDir) {
-            throw new Error("llamaCppModelDir is required in the config when using the LlamaCPP client.");
-        }
-        this.model = new Model(config.model);
-        this.modelDir = config.llamaCppModelDir;
-        this.logger = getLogger();
-    }
-    async setup() {
-        this.llama = await getLlama({ logLevel: LlamaLogLevel.error });
-        this.llamaModel = await this.llama.loadModel({
-            modelPath: path.join(this.modelDir, this.config.model),
-        });
-    }
-    getModelName() {
-        return this.model.getResolvedModel();
-    }
-    /**
-     * Converts smoltalk messages to node-llama-cpp's ChatHistoryItem format.
-     * Builds the full history including the last user message (LlamaChat.generateResponse
-     * expects the complete history, unlike LlamaChatSession which takes the last message separately).
-     */
-    convertMessages(messages) {
-        let systemPrompt;
-        const chatHistory = [];
-        for (let i = 0; i < messages.length; i++) {
-            const msg = messages[i];
-            if (msg.role === "system" || msg.role === "developer") {
-                if (!systemPrompt) {
-                    systemPrompt = msg.content;
-                }
-                else {
-                    systemPrompt += "\n" + msg.content;
-                }
-            }
-            else if (msg.role === "user") {
-                chatHistory.push({ type: "user", text: msg.content });
-            }
-            else if (msg.role === "assistant") {
-                const assistantMsg = msg;
-                const response = [];
-                if (assistantMsg.content) {
-                    response.push(assistantMsg.content);
-                }
-                // Handle tool calls: pair them with their results from subsequent tool messages
-                if (assistantMsg.toolCalls?.length) {
-                    for (const tc of assistantMsg.toolCalls) {
-                        // Find the corresponding tool result message
-                        const toolResultMsg = messages
-                            .slice(i + 1)
-                            .find((m) => m.role === "tool" &&
-                            m.tool_call_id === tc.id);
-                        response.push({
-                            type: "functionCall",
-                            name: tc.name,
-                            params: tc.arguments,
-                            result: toolResultMsg ? toolResultMsg.content : undefined,
-                        });
-                    }
-                }
-                chatHistory.push({ type: "model", response });
-            }
-            // Tool messages are handled as part of assistant messages above
-        }
-        // Prepend system message if present
-        if (systemPrompt) {
-            chatHistory.unshift({ type: "system", text: systemPrompt });
-        }
-        return { systemPrompt, chatHistory };
-    }
-    /**
-     * Builds node-llama-cpp function definitions from smoltalk tool configs.
-     * Uses ChatModelFunctions (no handler) — LlamaChat.generateResponse() returns
-     * function calls without executing them, which matches smoltalk's tool loop model.
-     */
-    buildFunctions(tools) {
-        if (!tools)
-            return undefined;
-        const functions = {};
-        for (const tool of tools) {
-            const jsonSchema = tool.schema.toJSONSchema();
-            functions[tool.name] = {
-                description: tool.description,
-                params: jsonSchema,
-            };
-        }
-        return functions;
-    }
-    calculateUsageAndCost(meterBefore, meterAfter) {
-        const inputTokens = meterAfter.usedInputTokens - meterBefore.usedInputTokens;
-        const outputTokens = meterAfter.usedOutputTokens - meterBefore.usedOutputTokens;
-        const usage = {
-            inputTokens,
-            outputTokens,
-            totalTokens: inputTokens + outputTokens,
-        };
-        const cost = this.model.calculateCost(usage) ?? undefined;
-        return { usage, cost };
-    }
-    extractToolCalls(functionCalls) {
-        if (!functionCalls?.length)
-            return [];
-        return functionCalls.map((fc) => new ToolCall(fc.functionName, fc.functionName, (fc.params ?? {})));
-    }
-    async _textSync(config) {
-        if (!this.llama || !this.llamaModel) {
-            await this.setup();
-        }
-        const setupLlama = this.llama;
-        const setupModel = this.llamaModel;
-        const { chatHistory } = this.convertMessages(config.messages);
-        if (chatHistory.length === 0) {
-            return success({
-                output: "",
-                toolCalls: [],
-                model: this.getModelName(),
-            });
-        }
-        // Create grammar for response format
-        let grammar;
-        if (config.responseFormat) {
-            grammar = await setupLlama.createGrammarForJsonSchema(config.responseFormat.toJSONSchema());
-        }
-        // Create context and LlamaChat
-        const context = await setupModel.createContext();
-        const sequence = context.getSequence();
-        const chat = new LlamaChat({
-            contextSequence: sequence,
-        });
-        // Build tools if provided
-        const functions = this.buildFunctions(config.tools);
-        // Track token usage
-        const meterBefore = sequence.tokenMeter.getState();
-        // Build options
-        const options = {};
-        if (config.maxTokens !== undefined) {
-            options.maxTokens = config.maxTokens;
-        }
-        if (config.temperature !== undefined) {
-            options.temperature = config.temperature;
-        }
-        if (config.abortSignal) {
-            options.signal = config.abortSignal;
-            options.stopOnAbortSignal = true;
-        }
-        if (grammar && !functions) {
-            options.grammar = grammar;
-        }
-        if (functions) {
-            options.functions = functions;
-        }
-        // Apply raw attributes
-        Object.assign(options, sanitizeAttributes(config.rawAttributes));
-        this.logger.debug("Sending request to llama.cpp");
-        this.statelogClient?.promptRequest({
-            model: this.getModelName(),
-            messageCount: config.messages.length,
-        });
-        let result;
-        let meterAfter;
-        try {
-            result = await chat.generateResponse(chatHistory, options);
-            meterAfter = sequence.tokenMeter.getState();
-        }
-        finally {
-            chat.dispose();
-            await context.dispose();
-        }
-        // Extract text output
-        const output = result.response || null;
-        // Extract tool calls — generateResponse returns them without executing handlers
-        const toolCalls = this.extractToolCalls(result.functionCalls);
-        // Calculate usage and cost
-        const { usage, cost } = this.calculateUsageAndCost(meterBefore, meterAfter);
-        this.logger.debug("Response from llama.cpp:", output);
-        this.statelogClient?.promptResponse({ output, usage, cost });
-        return success({
-            output,
-            toolCalls,
-            usage,
-            cost,
-            model: this.getModelName(),
-        });
-    }
-    async *_textStream(config) {
-        if (!this.llama || !this.llamaModel) {
-            await this.setup();
-        }
-        const setupLlama = this.llama;
-        const setupModel = this.llamaModel;
-        const { chatHistory } = this.convertMessages(config.messages);
-        if (chatHistory.length === 0) {
-            yield {
-                type: "done",
-                result: { output: null, toolCalls: [], model: this.getModelName() },
-            };
-            return;
-        }
-        // Create grammar for response format
-        let grammar;
-        if (config.responseFormat) {
-            grammar = await setupLlama.createGrammarForJsonSchema(config.responseFormat.toJSONSchema());
-        }
-        // Create context and LlamaChat
-        const context = await setupModel.createContext();
-        const sequence = context.getSequence();
-        const chat = new LlamaChat({
-            contextSequence: sequence,
-        });
-        const functions = this.buildFunctions(config.tools);
-        const meterBefore = sequence.tokenMeter.getState();
-        // Bridge callback-based streaming to async generator using a queue
-        const chunks = [];
-        let resolveWaiter = null;
-        let done = false;
-        const pushChunk = (chunk) => {
-            chunks.push(chunk);
-            if (resolveWaiter) {
-                resolveWaiter();
-                resolveWaiter = null;
-            }
-        };
-        // Build options
-        const options = {
-            onTextChunk: (text) => {
-                pushChunk({ type: "text", text });
-            },
-        };
-        if (config.maxTokens !== undefined) {
-            options.maxTokens = config.maxTokens;
-        }
-        if (config.temperature !== undefined) {
-            options.temperature = config.temperature;
-        }
-        if (config.abortSignal) {
-            options.signal = config.abortSignal;
-            options.stopOnAbortSignal = true;
-        }
-        if (grammar && !functions) {
-            options.grammar = grammar;
-        }
-        if (functions) {
-            options.functions = functions;
-        }
-        Object.assign(options, sanitizeAttributes(config.rawAttributes));
-        this.logger.debug("Sending streaming request to llama.cpp");
-        this.statelogClient?.promptRequest({
-            model: this.getModelName(),
-            messageCount: config.messages.length,
-        });
-        // Run generateResponse in background, push chunks as they arrive
-        const promptPromise = chat
-            .generateResponse(chatHistory, options)
-            .then((result) => {
-            const meterAfter = sequence.tokenMeter.getState();
-            const toolCalls = this.extractToolCalls(result.functionCalls);
-            for (const tc of toolCalls) {
-                pushChunk({ type: "tool_call", toolCall: tc });
-            }
-            const { usage, cost } = this.calculateUsageAndCost(meterBefore, meterAfter);
-            const output = result.response || null;
-            this.logger.debug("Streaming response completed from llama.cpp");
-            this.statelogClient?.promptResponse({ output, usage, cost });
-            pushChunk({
-                type: "done",
-                result: {
-                    output,
-                    toolCalls,
-                    usage,
-                    cost,
-                    model: this.getModelName(),
-                },
-            });
-        })
-            .catch((error) => {
-            pushChunk({ type: "error", error: error.message });
-        })
-            .finally(() => {
-            done = true;
-            chat.dispose();
-            context.dispose();
-            // Wake up the generator if it's waiting
-            if (resolveWaiter) {
-                resolveWaiter();
-                resolveWaiter = null;
-            }
-        });
-        // Yield chunks as they arrive
-        while (!done || chunks.length > 0) {
-            if (chunks.length > 0) {
-                yield chunks.shift();
-            }
-            else if (!done) {
-                await new Promise((resolve) => {
-                    resolveWaiter = resolve;
-                });
-            }
-        }
-        await promptPromise;
-    }
-}

package/dist/latencyTracker.d.ts

@@ -1,32 +0,0 @@
-export type LatencySample = {
-    /** Milliseconds per output token */
-    msPerToken: number;
-    /** Timestamp when sample was recorded */
-    timestamp: number;
-};
-declare class LatencyTracker {
-    private samples;
-    private windowSize;
-    constructor(windowSize?: number);
-    /** Record a latency sample for a model. */
-    record(model: string, elapsedMs: number, outputTokens: number): void;
-    /** Get the windowed mean ms-per-token for a model, or null if no samples. */
-    getMeanMsPerToken(model: string): number | null;
-    /**
-     * Get estimated output tokens per second for a model based on tracked latency.
-     * Returns null if no samples exist or if the number of samples is below the minimum required.
-     */
-    getTokensPerSecond(model: string, minSamples?: number): number | null;
-    /** Get the number of samples recorded for a model. */
-    getSampleCount(model: string): number;
-    /** Get all samples for a model (defensive copy). */
-    getSamples(model: string): LatencySample[];
-    /** Clear all samples for a model. */
-    clear(model?: string): void;
-    /** Update the window size. Existing samples beyond the new size are trimmed. */
-    setWindowSize(size: number): void;
-    getWindowSize(): number;
-}
-/** Global singleton latency tracker. */
-export declare const latencyTracker: LatencyTracker;
-export {};

package/dist/latencyTracker.js

@@ -1,73 +0,0 @@
-const DEFAULT_WINDOW_SIZE = 10;
-class LatencyTracker {
-    samples = new Map();
-    windowSize;
-    constructor(windowSize = DEFAULT_WINDOW_SIZE) {
-        this.windowSize = windowSize;
-    }
-    /** Record a latency sample for a model. */
-    record(model, elapsedMs, outputTokens) {
-        if (outputTokens <= 0 || elapsedMs <= 0)
-            return;
-        const msPerToken = elapsedMs / outputTokens;
-        const samples = this.samples.get(model) ?? [];
-        samples.push({ msPerToken, timestamp: Date.now() });
-        // Keep only the last windowSize samples
-        if (samples.length > this.windowSize) {
-            samples.splice(0, samples.length - this.windowSize);
-        }
-        this.samples.set(model, samples);
-    }
-    /** Get the windowed mean ms-per-token for a model, or null if no samples. */
-    getMeanMsPerToken(model) {
-        const samples = this.samples.get(model);
-        if (!samples || samples.length === 0)
-            return null;
-        const sum = samples.reduce((acc, s) => acc + s.msPerToken, 0);
-        return sum / samples.length;
-    }
-    /**
-     * Get estimated output tokens per second for a model based on tracked latency.
-     * Returns null if no samples exist or if the number of samples is below the minimum required.
-     */
-    getTokensPerSecond(model, minSamples = 1) {
-        const sampleCount = this.getSampleCount(model);
-        if (sampleCount < minSamples)
-            return null;
-        const msPerToken = this.getMeanMsPerToken(model);
-        if (msPerToken === null || msPerToken === 0)
-            return null;
-        return 1000 / msPerToken;
-    }
-    /** Get the number of samples recorded for a model. */
-    getSampleCount(model) {
-        return this.samples.get(model)?.length ?? 0;
-    }
-    /** Get all samples for a model (defensive copy). */
-    getSamples(model) {
-        return [...(this.samples.get(model) ?? [])];
-    }
-    /** Clear all samples for a model. */
-    clear(model) {
-        if (model) {
-            this.samples.delete(model);
-        }
-        else {
-            this.samples.clear();
-        }
-    }
-    /** Update the window size. Existing samples beyond the new size are trimmed. */
-    setWindowSize(size) {
-        this.windowSize = size;
-        for (const [model, samples] of this.samples) {
-            if (samples.length > size) {
-                samples.splice(0, samples.length - size);
-            }
-        }
-    }
-    getWindowSize() {
-        return this.windowSize;
-    }
-}
-/** Global singleton latency tracker. */
-export const latencyTracker = new LatencyTracker();

package/dist/middleware.d.ts

@@ -1,54 +0,0 @@
-import { ZodType } from "zod";
-import { Message } from "./classes/message/index.js";
-import { PromptConfig, PromptResult, SmolPromptConfig, StreamChunk } from "./types.js";
-import { Result } from "./types/result.js";
-import { TokenUsage } from "./types/tokenUsage.js";
-import { CostEstimate } from "./types/costEstimate.js";
-export type MiddlewareCheck = {
-    /** Messages for the middleware LLM call (original prompt messages are appended automatically). */
-    messages: Message[];
-    /** Optional Zod schema for structured output from the middleware. */
-    responseFormat?: ZodType;
-    responseFormatOptions?: PromptConfig["responseFormatOptions"];
-    /**
-     * Given the middleware's result, decide whether to block.
-     * Return a replacement output string to block, or null/undefined to pass.
-     */
-    decide: (result: PromptResult) => string | null;
-};
-export type MiddlewareConfig = {
-    /** Run all checks before the main prompt, or in parallel with it. */
-    timing: "before" | "parallel";
-    /** Run checks in parallel or sequentially (short-circuit on first block). */
-    mode: "parallel" | "sequential";
-    /** The middleware checks to run. */
-    checks: MiddlewareCheck[];
-};
-export type MiddlewareResult = {
-    blocked: boolean;
-    result: Result<PromptResult>;
-    usage?: TokenUsage;
-    cost?: CostEstimate;
-};
-/**
- * Run a single middleware check. Returns a MiddlewareResult indicating
- * whether the check blocked and what output to use.
- */
-export declare function runMiddlewareCheck(check: MiddlewareCheck, parentConfig: SmolPromptConfig, textSyncFn: (config: SmolPromptConfig) => Promise<Result<PromptResult>>): Promise<MiddlewareResult>;
-/**
- * Run multiple middleware checks in sequential or parallel mode.
- * Returns a combined MiddlewareResult.
- */
-export declare function runMiddlewareChecks(checks: MiddlewareCheck[], mode: "sequential" | "parallel", parentConfig: SmolPromptConfig, textSyncFn: (config: SmolPromptConfig) => Promise<Result<PromptResult>>): Promise<MiddlewareResult>;
-/**
- * High-level middleware orchestration for sync calls.
- * Returns the blocked result if middleware blocks, the main prompt result for parallel timing,
- * or null to indicate "proceed normally" (no middleware or middleware passed with "before" timing).
- */
-export declare function executeMiddlewareSync(config: SmolPromptConfig, runMainPrompt: (config: SmolPromptConfig) => Promise<Result<PromptResult>>, textSyncFn: (config: SmolPromptConfig) => Promise<Result<PromptResult>>): Promise<Result<PromptResult> | null>;
-/**
- * High-level middleware orchestration for streaming calls.
- * Yields stream chunks, handling middleware checks according to timing config.
- * Only call this when middleware is configured — the caller should check first.
- */
-export declare function executeMiddlewareStream(config: SmolPromptConfig, getStream: (config: SmolPromptConfig) => AsyncGenerator<StreamChunk>, textSyncFn: (config: SmolPromptConfig) => Promise<Result<PromptResult>>): AsyncGenerator<StreamChunk>;