smoltalk 0.0.35 → 0.0.36

package/dist/clients/baseClient.d.ts

@@ -1,6 +1,8 @@
+import { StatelogClient } from "../statelogClient.js";
 import { PromptConfig, PromptResult, Result, SmolClient, SmolConfig, StreamChunk } from "../types.js";
 export declare class BaseClient implements SmolClient {
     protected config: SmolConfig;
+    protected statelogClient?: StatelogClient;
     constructor(config: SmolConfig);
     text(promptConfig: Omit<PromptConfig, "stream">): Promise<Result<PromptResult>>;
     text(promptConfig: Omit<PromptConfig, "stream"> & {

package/dist/clients/baseClient.js

@@ -1,12 +1,17 @@
 import { userMessage, assistantMessage } from "../classes/message/index.js";
 import { getLogger } from "../logger.js";
+import { getStatelogClient } from "../statelogClient.js";
 import { success, } from "../types.js";
 import { z } from "zod";
 const DEFAULT_NUM_RETRIES = 2;
 export class BaseClient {
     config;
+    statelogClient;
     constructor(config) {
         this.config = config || {};
+        if (this.config.statelog) {
+            this.statelogClient = getStatelogClient(this.config.statelog);
+        }
     }
     text(promptConfig) {
         if (promptConfig.stream) {
@@ -39,7 +44,8 @@ export class BaseClient {
                 value: { output: null, toolCalls: [], model: this.config.model },
             };
         }
-        return this.textWithRetry(newPromptConfig, newPromptConfig.responseFormatOptions?.numRetries || DEFAULT_NUM_RETRIES);
+        const result = await this.textWithRetry(newPromptConfig, newPromptConfig.responseFormatOptions?.numRetries || DEFAULT_NUM_RETRIES);
+        return result;
     }
     checkForToolLoops(promptConfig) {
         if (!this.config.toolLoopDetection?.enabled) {
@@ -57,6 +63,11 @@ export class BaseClient {
                 const intervention = this.config.toolLoopDetection.intervention || "remove-tool";
                 const logger = getLogger();
                 logger.warn(`Tool loop detected for tool "${toolName}" called ${count} times. Intervention: ${intervention}`);
+                this.statelogClient?.debug("Tool loop detected", {
+                    toolName,
+                    count,
+                    intervention,
+                });
                 switch (intervention) {
                     case "remove-tool":
                         const newTools = promptConfig.tools?.filter((t) => t.name !== toolName);
@@ -167,10 +178,15 @@ export class BaseClient {
                 catch (err) {
                     const errorMessage = err.message;
                     const logger = getLogger();
-                    logger.debug(`Response format validation failed (retries left: ${retries}): `, errorMessage, "output:", JSON.stringify(output, null, 2), "responseFormat:", JSON.stringify(promptConfig.responseFormat, null, 2));
+                    logger.warn(`Response format validation failed (retries left: ${retries}): `, errorMessage, "output:", JSON.stringify(output, null, 2), "responseFormat:", JSON.stringify(promptConfig.responseFormat, null, 2));
                     if (err instanceof z.ZodError) {
-                        logger.debug("Zod error details:", z.prettifyError(err));
+                        logger.warn("Zod error details:", z.prettifyError(err));
                     }
+                    this.statelogClient?.diff({
+                        message: "Response format validation failed",
+                        itemA: promptConfig.responseFormat,
+                        itemB: output,
+                    });
                     const retryMessages = [
                         ...promptConfig.messages,
                         assistantMessage(output),

package/dist/functions.js

@@ -1,7 +1,7 @@
 import { getClient } from "./client.js";
 import { isModelConfig, pickModel } from "./models.js";
 function splitConfig(config) {
-    const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, toolLoopDetection, ...promptConfig } = config;
+    const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, toolLoopDetection, statelog, ...promptConfig } = config;
     const model = isModelConfig(rawModel) ? pickModel(rawModel) : rawModel;
     return {
         smolConfig: {
@@ -14,6 +14,7 @@ function splitConfig(config) {
             provider,
             logLevel,
             toolLoopDetection,
+            statelog,
         },
         promptConfig,
     };

package/dist/statelogClient.d.ts

@@ -0,0 +1,113 @@
+import { JSONEdge } from "./types.js";
+import { Result } from "./types/result.js";
+import { ModelConfig, ModelName } from "./models.js";
+export type AgencyFile = {
+    name: string;
+    contents: string;
+};
+export type UploadResult = Result<{
+    endpointUrls: string[];
+}>;
+export type StatelogConfig = {
+    host: string;
+    traceId?: string;
+    apiKey: string;
+    projectId: string;
+    debugMode: boolean;
+};
+export declare function mergeUploadResults(_results: UploadResult[]): UploadResult;
+export declare class StatelogClient {
+    private host;
+    private debugMode;
+    private traceId;
+    private apiKey;
+    private projectId;
+    constructor(config: StatelogConfig);
+    toJSON(): {
+        traceId: string;
+        projectId: string;
+        host: string;
+        debugMode: boolean;
+    };
+    debug(message: string, data: any): Promise<void>;
+    graph({ nodes, edges, startNode, }: {
+        nodes: string[];
+        edges: Record<string, JSONEdge>;
+        startNode?: string;
+    }): Promise<void>;
+    enterNode({ nodeId, data, }: {
+        nodeId: string;
+        data: any;
+    }): Promise<void>;
+    exitNode({ nodeId, data, timeTaken, }: {
+        nodeId: string;
+        data: any;
+        timeTaken?: number;
+    }): Promise<void>;
+    beforeHook({ nodeId, startData, endData, timeTaken, }: {
+        nodeId: string;
+        startData: any;
+        endData: any;
+        timeTaken?: number;
+    }): Promise<void>;
+    afterHook({ nodeId, startData, endData, timeTaken, }: {
+        nodeId: string;
+        startData: any;
+        endData: any;
+        timeTaken?: number;
+    }): Promise<void>;
+    followEdge({ fromNodeId, toNodeId, isConditionalEdge, data, }: {
+        fromNodeId: string;
+        toNodeId: string;
+        isConditionalEdge: boolean;
+        data: any;
+    }): Promise<void>;
+    promptCompletion({ messages, completion, model, timeTaken, tools, responseFormat, }: {
+        messages: any[];
+        completion: any;
+        model?: ModelName | ModelConfig | string;
+        timeTaken?: number;
+        tools?: {
+            name: string;
+            description?: string;
+            schema: any;
+        }[];
+        responseFormat?: any;
+    }): Promise<void>;
+    toolCall({ toolName, args, output, model, timeTaken, }: {
+        toolName: string;
+        args: any;
+        output: any;
+        model?: ModelName | ModelConfig;
+        timeTaken?: number;
+    }): Promise<void>;
+    diff({ itemA, itemB, message, }: {
+        itemA: any;
+        itemB: any;
+        message?: string;
+    }): Promise<void>;
+    upload({ projectId, entrypoint, files, }: {
+        projectId: string;
+        entrypoint: string;
+        files: AgencyFile[];
+    }): Promise<UploadResult>;
+    remoteRun({ files, entrypoint, args, }: {
+        files: AgencyFile[];
+        entrypoint: string;
+        args?: any[];
+    }): Promise<Result<any>>;
+    hitServer({ userId, projectId, filename, nodeName, body, }: {
+        userId: string;
+        projectId: string;
+        filename: string;
+        nodeName: string;
+        body: string;
+    }): Promise<Result<any>>;
+    post(body: Record<string, any>): Promise<void>;
+}
+export declare function getStatelogClient(config: {
+    host: string;
+    traceId?: string;
+    projectId: string;
+    debugMode?: boolean;
+}): StatelogClient;

package/dist/statelogClient.js

@@ -0,0 +1,303 @@
+import { nanoid } from "nanoid";
+import { failure, mergeResults, success } from "./types/result.js";
+export function mergeUploadResults(_results) {
+    const results = mergeResults(_results);
+    if (!results.success) {
+        return failure(results.error);
+    }
+    const endpointUrls = results.value.flatMap((r) => r.endpointUrls);
+    return success({
+        endpointUrls,
+    });
+}
+export class StatelogClient {
+    host;
+    debugMode;
+    traceId;
+    apiKey;
+    projectId;
+    constructor(config) {
+        const { host, apiKey, projectId, traceId, debugMode } = config;
+        this.host = host;
+        this.apiKey = apiKey;
+        this.projectId = projectId;
+        this.debugMode = debugMode || false;
+        this.traceId = traceId || nanoid();
+        if (this.debugMode) {
+            console.log(`Statelog client initialized with host: ${host} and traceId: ${this.traceId}`, { config });
+        }
+        if (!this.apiKey) {
+            throw new Error("API key is required for StatelogClient");
+        }
+    }
+    toJSON() {
+        return {
+            traceId: this.traceId,
+            projectId: this.projectId,
+            host: this.host,
+            debugMode: this.debugMode,
+        };
+    }
+    async debug(message, data) {
+        await this.post({
+            type: "debug",
+            message: message,
+            data,
+        });
+    }
+    async graph({ nodes, edges, startNode, }) {
+        await this.post({
+            type: "graph",
+            nodes,
+            edges,
+            startNode,
+        });
+    }
+    async enterNode({ nodeId, data, }) {
+        await this.post({
+            type: "enterNode",
+            nodeId,
+            data,
+        });
+    }
+    async exitNode({ nodeId, data, timeTaken, }) {
+        await this.post({
+            type: "exitNode",
+            nodeId,
+            data,
+            timeTaken,
+        });
+    }
+    async beforeHook({ nodeId, startData, endData, timeTaken, }) {
+        await this.post({
+            type: "beforeHook",
+            nodeId,
+            startData,
+            endData,
+            timeTaken,
+        });
+    }
+    async afterHook({ nodeId, startData, endData, timeTaken, }) {
+        await this.post({
+            type: "afterHook",
+            nodeId,
+            startData,
+            endData,
+            timeTaken,
+        });
+    }
+    async followEdge({ fromNodeId, toNodeId, isConditionalEdge, data, }) {
+        await this.post({
+            type: "followEdge",
+            edgeId: `${fromNodeId}->${toNodeId}`,
+            fromNodeId,
+            toNodeId,
+            isConditionalEdge,
+            data,
+        });
+    }
+    async promptCompletion({ messages, completion, model, timeTaken, tools, responseFormat, }) {
+        await this.post({
+            type: "promptCompletion",
+            messages,
+            completion,
+            model,
+            timeTaken,
+            tools,
+            responseFormat,
+        });
+    }
+    async toolCall({ toolName, args, output, model, timeTaken, }) {
+        await this.post({
+            type: "toolCall",
+            toolName,
+            args,
+            output,
+            model,
+            timeTaken,
+        });
+    }
+    async diff({ itemA, itemB, message, }) {
+        await this.post({
+            type: "diff",
+            itemA,
+            itemB,
+            message,
+        });
+    }
+    /*   async promptResult({ result }: { result: PromptResult }): Promise<void> {
+      await this.post({
+        type: "promptResult",
+        result,
+      });
+    }
+   */
+    async upload({ projectId, entrypoint, files, }) {
+        try {
+            const fullUrl = new URL(`/api/projects/${projectId}/upload`, this.host);
+            const url = fullUrl.toString();
+            const postBody = JSON.stringify({ entrypoint, files });
+            console.log({ entrypoint, files }, postBody);
+            const result = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: postBody,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to send statelog:", err);
+            });
+            if (result) {
+                if (!result.ok) {
+                    if (this.debugMode)
+                        console.error("Failed to upload files to statelog:", {
+                            result,
+                            url,
+                            files,
+                        });
+                    return failure("Failed to upload files to statelog");
+                }
+                return (await result.json());
+            }
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error sending log in statelog client:", err, {
+                    host: this.host,
+                });
+        }
+        return failure("Error uploading files to statelog");
+    }
+    async remoteRun({ files, entrypoint, args, }) {
+        try {
+            const fullUrl = new URL(`/api/run`, this.host);
+            const url = fullUrl.toString();
+            const body = JSON.stringify({
+                files,
+                entrypoint,
+                args,
+            });
+            console.log({ entrypoint, args }, body);
+            const result = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to run on statelog:", err);
+            });
+            if (result) {
+                if (!result.ok) {
+                    if (this.debugMode) {
+                        const responseBody = await result.text();
+                        console.error("Failed to run on statelog:", {
+                            result,
+                            url,
+                            body,
+                            responseBody,
+                        });
+                    }
+                    return failure("Failed to run on statelog");
+                }
+                return (await result.json());
+            }
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error running on statelog client:", err, {
+                    host: this.host,
+                });
+        }
+        return failure("Error running on statelog");
+    }
+    async hitServer({ userId, projectId, filename, nodeName, body, }) {
+        try {
+            const fullUrl = new URL(`/run/${userId}/${projectId}/${filename}/${nodeName}`, this.host);
+            const url = fullUrl.toString();
+            const result = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: body,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to run on statelog:", err);
+            });
+            if (result) {
+                if (!result.ok) {
+                    if (this.debugMode) {
+                        const responseBody = await result.text();
+                        console.error("Failed to run on statelog:", {
+                            result,
+                            url,
+                            body,
+                            responseBody,
+                        });
+                    }
+                    return failure("Failed to run on statelog");
+                }
+                return (await result.json());
+            }
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error running on statelog client:", err, {
+                    host: this.host,
+                });
+        }
+        return failure("Error running on statelog");
+    }
+    async post(body) {
+        if (!this.host) {
+            return;
+        }
+        const postBody = JSON.stringify({
+            trace_id: this.traceId,
+            project_id: this.projectId,
+            data: { ...body, timestamp: new Date().toISOString() },
+        });
+        if (this.host.toLowerCase() === "stdout") {
+            console.log(postBody);
+            return;
+        }
+        try {
+            const fullUrl = new URL("/api/logs", this.host);
+            const url = fullUrl.toString();
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: postBody,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to send statelog:", err);
+            });
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error sending log in statelog client:", err, {
+                    host: this.host,
+                });
+        }
+    }
+}
+export function getStatelogClient(config) {
+    const statelogConfig = {
+        host: config.host,
+        traceId: config.traceId || nanoid(),
+        apiKey: process.env.STATELOG_API_KEY || "",
+        projectId: config.projectId,
+        debugMode: config.debugMode || false,
+    };
+    const client = new StatelogClient(statelogConfig);
+    return client;
+}

package/dist/types.d.ts

@@ -46,6 +46,12 @@ export type SmolConfig = {
     provider?: Provider;
     logLevel?: LogLevel;
     toolLoopDetection?: ToolLoopDetection;
+    statelog?: Partial<{
+        host: string;
+        projectId: string;
+        debugMode: boolean;
+        apiKey: string;
+    }>;
 };
 export type ToolLoopDetection = {
     enabled: boolean;
@@ -108,3 +114,10 @@ export type TextPart = {
     type: "text";
     text: string;
 };
+export type JSONEdge = {
+    type: "regular";
+    to: string;
+} | {
+    type: "conditional";
+    adjacentNodes: readonly string[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {
@@ -44,6 +44,7 @@
     "@anthropic-ai/sdk": "^0.78.0",
     "@google/genai": "^1.34.0",
     "egonlog": "^0.0.2",
+    "nanoid": "^5.1.6",
     "ollama": "^0.6.3",
     "openai": "^6.15.0"
   }