smoltalk 0.0.34 → 0.0.36

package/dist/classes/message/AssistantMessage.d.ts

@@ -1,5 +1,5 @@
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
-import { TextPart } from "../../types.js";
+import { TextPart, ThinkingBlock } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
 import { ToolCall, ToolCallJSON } from "../ToolCall.js";
@@ -12,6 +12,7 @@ export type AssistantMessageJSON = {
     audio: any | null | undefined;
     refusal: string | null | undefined;
     toolCalls: ToolCallJSON[] | undefined;
+    thinkingBlocks: ThinkingBlock[] | undefined;
 };
 export declare class AssistantMessage extends BaseMessage implements MessageClass {
     _role: "assistant";
@@ -20,12 +21,14 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     _audio?: any | null;
     _refusal?: string | null;
     _toolCalls?: ToolCall[];
+    _thinkingBlocks?: ThinkingBlock[];
     _rawData?: any;
     constructor(content: string | Array<TextPart> | null, options?: {
         name?: string;
         audio?: any | null;
         refusal?: string | null;
         toolCalls?: ToolCall[];
+        thinkingBlocks?: ThinkingBlock[];
         rawData?: any;
     });
     get content(): string;
@@ -36,6 +39,7 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     get refusal(): string | null | undefined;
     get toolCalls(): ToolCall[] | undefined;
     get rawData(): any;
+    get thinkingBlocks(): ThinkingBlock[] | undefined;
     toJSON(): AssistantMessageJSON;
     static fromJSON(json: any): AssistantMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;
@@ -45,6 +49,10 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     toAnthropicMessage(): {
         role: "assistant";
         content: string | Array<{
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        } | {
             type: "text";
             text: string;
         } | {

package/dist/classes/message/AssistantMessage.js

@@ -7,6 +7,7 @@ export class AssistantMessage extends BaseMessage {
     _audio;
     _refusal;
     _toolCalls;
+    _thinkingBlocks;
     _rawData;
     constructor(content, options = {}) {
         super();
@@ -15,6 +16,7 @@ export class AssistantMessage extends BaseMessage {
         this._audio = options.audio;
         this._refusal = options.refusal;
         this._toolCalls = options.toolCalls;
+        this._thinkingBlocks = options.thinkingBlocks;
         this._rawData = options.rawData;
     }
     get content() {
@@ -46,6 +48,9 @@ export class AssistantMessage extends BaseMessage {
     get rawData() {
         return this._rawData;
     }
+    get thinkingBlocks() {
+        return this._thinkingBlocks;
+    }
     toJSON() {
         return {
             role: this.role,
@@ -54,6 +59,7 @@ export class AssistantMessage extends BaseMessage {
             audio: this.audio,
             refusal: this.refusal,
             toolCalls: this.toolCalls?.map((tc) => tc.toJSON()),
+            thinkingBlocks: this._thinkingBlocks,
         };
     }
     static fromJSON(json) {
@@ -64,6 +70,7 @@ export class AssistantMessage extends BaseMessage {
             toolCalls: json.toolCalls
                 ? json.toolCalls.map((tcJson) => ToolCall.fromJSON(tcJson))
                 : undefined,
+            thinkingBlocks: json.thinkingBlocks,
             rawData: json.rawData,
         });
     }
@@ -95,6 +102,12 @@ export class AssistantMessage extends BaseMessage {
     }
     toGoogleMessage() {
         const parts = [];
+        // Prepend thought parts with their signatures so Gemini can resume reasoning
+        if (this._thinkingBlocks) {
+            for (const block of this._thinkingBlocks) {
+                parts.push({ thought: true, text: block.text, thoughtSignature: block.signature });
+            }
+        }
         if (this.content) {
             parts.push({ text: this.content });
         }
@@ -119,10 +132,18 @@ export class AssistantMessage extends BaseMessage {
                 ? this._content.length > 0
                 : this._content.length > 0);
         const hasToolCalls = this._toolCalls && this._toolCalls.length > 0;
-        if (!hasToolCalls) {
+        const hasThinking = this._thinkingBlocks && this._thinkingBlocks.length > 0;
+        // If only text and no thinking/tool calls, use string shorthand
+        if (!hasToolCalls && !hasThinking) {
             return { role: "assistant", content: this.content };
         }
         const blocks = [];
+        // Thinking blocks must come first (Anthropic requires this ordering)
+        if (hasThinking) {
+            for (const block of this._thinkingBlocks) {
+                blocks.push({ type: "thinking", thinking: block.text, signature: block.signature });
+            }
+        }
         if (hasText) {
             const text = typeof this._content === "string"
                 ? this._content
@@ -131,7 +152,7 @@ export class AssistantMessage extends BaseMessage {
                 blocks.push({ type: "text", text });
             }
         }
-        for (const tc of this._toolCalls) {
+        for (const tc of this._toolCalls ?? []) {
             blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
         }
         return { role: "assistant", content: blocks };

package/dist/classes/message/index.d.ts

@@ -25,6 +25,10 @@ export declare function assistantMessage(content: string | Array<TextPart> | nul
     audio?: any | null;
     refusal?: string | null;
     toolCalls?: Array<any>;
+    thinkingBlocks?: Array<{
+        text: string;
+        signature: string;
+    }>;
     rawData?: any;
 }): AssistantMessage;
 export declare function developerMessage(content: string | Array<TextPart>, options?: {

package/dist/clients/anthropic.js

@@ -64,16 +64,20 @@ export class SmolAnthropic extends BaseClient {
                 description: tool.description,
             }))
             : undefined;
-        return { system, messages: anthropicMessages, tools };
+        const thinking = config.thinking?.enabled
+            ? { type: "enabled", budget_tokens: config.thinking.budgetTokens ?? 5000 }
+            : undefined;
+        return { system, messages: anthropicMessages, tools, thinking };
     }
     async _textSync(config) {
-        const { system, messages, tools } = this.buildRequest(config);
+        const { system, messages, tools, thinking } = this.buildRequest(config);
         this.logger.debug("Sending request to Anthropic:", {
             model: this.model,
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
             messages,
             system,
             tools,
+            thinking,
         });
         const response = await this.client.messages.create({
             model: this.model,
@@ -81,6 +85,7 @@ export class SmolAnthropic extends BaseClient {
             messages,
             ...(system && { system }),
             ...(tools && { tools }),
+            ...(thinking && { thinking }),
             ...(config.temperature !== undefined && {
                 temperature: config.temperature,
             }),
@@ -90,6 +95,7 @@ export class SmolAnthropic extends BaseClient {
         this.logger.debug("Response from Anthropic:", response);
         let output = null;
         const toolCalls = [];
+        const thinkingBlocks = [];
         for (const block of response.content) {
             if (block.type === "text") {
                 output = (output ?? "") + block.text;
@@ -97,24 +103,30 @@ export class SmolAnthropic extends BaseClient {
             else if (block.type === "tool_use") {
                 toolCalls.push(new ToolCall(block.id, block.name, block.input));
             }
+            else if (block.type === "thinking") {
+                const b = block;
+                thinkingBlocks.push({ text: b.thinking, signature: b.signature });
+            }
         }
         const { usage, cost } = this.calculateUsageAndCost(response.usage);
         return success({
             output,
             toolCalls,
+            ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
             usage,
             cost,
             model: this.model,
         });
     }
     async *_textStream(config) {
-        const { system, messages, tools } = this.buildRequest(config);
+        const { system, messages, tools, thinking } = this.buildRequest(config);
         this.logger.debug("Sending streaming request to Anthropic:", {
             model: this.model,
             max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
             messages,
             system,
             tools,
+            thinking,
         });
         const stream = await this.client.messages.create({
             model: this.model,
@@ -122,6 +134,7 @@ export class SmolAnthropic extends BaseClient {
             messages,
             ...(system && { system }),
             ...(tools && { tools }),
+            ...(thinking && { thinking }),
             ...(config.temperature !== undefined && {
                 temperature: config.temperature,
             }),
@@ -131,19 +144,25 @@ export class SmolAnthropic extends BaseClient {
         let content = "";
         // Track tool blocks by index: index -> { id, name, arguments (partial JSON) }
         const toolBlocks = new Map();
+        // Track thinking blocks by index: index -> { text, signature }
+        const thinkingBlockMap = new Map();
         let inputTokens = 0;
         let outputTokens = 0;
         for await (const event of stream) {
             if (event.type === "message_start") {
                 inputTokens = event.message.usage.input_tokens;
             }
-            else if (event.type === "content_block_start" &&
-                event.content_block.type === "tool_use") {
-                toolBlocks.set(event.index, {
-                    id: event.content_block.id,
-                    name: event.content_block.name,
-                    arguments: "",
-                });
+            else if (event.type === "content_block_start") {
+                if (event.content_block.type === "tool_use") {
+                    toolBlocks.set(event.index, {
+                        id: event.content_block.id,
+                        name: event.content_block.name,
+                        arguments: "",
+                    });
+                }
+                else if (event.content_block.type === "thinking") {
+                    thinkingBlockMap.set(event.index, { text: "", signature: "" });
+                }
             }
             else if (event.type === "content_block_delta") {
                 if (event.delta.type === "text_delta") {
@@ -156,6 +175,25 @@ export class SmolAnthropic extends BaseClient {
                         block.arguments += event.delta.partial_json;
                     }
                 }
+                else if (event.delta.type === "thinking_delta") {
+                    const block = thinkingBlockMap.get(event.index);
+                    if (block) {
+                        block.text += event.delta.thinking;
+                    }
+                }
+                else if (event.delta.type === "signature_delta") {
+                    const block = thinkingBlockMap.get(event.index);
+                    if (block) {
+                        block.signature = event.delta.signature;
+                    }
+                }
+            }
+            else if (event.type === "content_block_stop") {
+                // Emit thinking chunk once the block is fully assembled
+                const thinkingBlock = thinkingBlockMap.get(event.index);
+                if (thinkingBlock) {
+                    yield { type: "thinking", text: thinkingBlock.text, signature: thinkingBlock.signature };
+                }
             }
             else if (event.type === "message_delta") {
                 outputTokens = event.usage.output_tokens;
@@ -168,6 +206,7 @@ export class SmolAnthropic extends BaseClient {
             toolCalls.push(toolCall);
             yield { type: "tool_call", toolCall };
         }
+        const thinkingBlocks = Array.from(thinkingBlockMap.values());
         const usage = {
             inputTokens,
             outputTokens,
@@ -179,6 +218,7 @@ export class SmolAnthropic extends BaseClient {
             result: {
                 output: content || null,
                 toolCalls,
+                ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
                 usage,
                 cost,
                 model: this.model,

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/clients/google.js

@@ -91,6 +91,7 @@ export class SmolGoogle extends BaseClient {
         this.logger.debug("Response from Google Gemini:", JSON.stringify(result, null, 2));
         const output = result.text || null;
         const toolCalls = [];
+        const thinkingBlocks = [];
         result.candidates?.forEach((candidate) => {
             if (candidate.content && candidate.content.parts) {
                 candidate.content.parts.forEach((part) => {
@@ -98,6 +99,13 @@ export class SmolGoogle extends BaseClient {
                         const functionCall = part.functionCall;
                         toolCalls.push(new ToolCall("", functionCall.name, functionCall.args));
                     }
+                    // Capture thought parts (thought: true indicates a thinking part)
+                    if (part.thoughtSignature) {
+                        thinkingBlocks.push({
+                            text: part.text || "",
+                            signature: part.thoughtSignature,
+                        });
+                    }
                 });
             }
         });
@@ -107,6 +115,7 @@ export class SmolGoogle extends BaseClient {
         return success({
             output,
             toolCalls,
+            ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
             usage,
             cost,
             model: request.model,
@@ -118,6 +127,7 @@ export class SmolGoogle extends BaseClient {
         const stream = await this.client.models.generateContentStream(request);
         let content = "";
         const toolCallsMap = new Map();
+        const thinkingBlocks = [];
         let usage;
         let cost;
         for await (const chunk of stream) {
@@ -127,22 +137,28 @@ export class SmolGoogle extends BaseClient {
                 usage = usageAndCost.usage;
                 cost = usageAndCost.cost;
             }
-            // Handle text content
-            if (chunk.text) {
-                content += chunk.text;
-                yield { type: "text", text: chunk.text };
-            }
-            // Handle function calls
-            if (chunk.functionCalls) {
-                for (const functionCall of chunk.functionCalls) {
-                    const id = functionCall.id || functionCall.name || "";
-                    const name = functionCall.name || "";
-                    if (!toolCallsMap.has(id)) {
-                        toolCallsMap.set(id, {
-                            id: id,
-                            name: name,
-                            arguments: functionCall.args,
-                        });
+            // Iterate raw parts to capture thought signatures and regular content
+            for (const candidate of chunk.candidates || []) {
+                for (const part of candidate?.content?.parts || []) {
+                    const p = part;
+                    if (p.thoughtSignature) {
+                        const block = {
+                            text: p.text || "",
+                            signature: p.thoughtSignature,
+                        };
+                        thinkingBlocks.push(block);
+                        yield { type: "thinking", text: block.text, signature: block.signature };
+                    }
+                    else if (p.text) {
+                        content += p.text;
+                        yield { type: "text", text: p.text };
+                    }
+                    else if (p.functionCall) {
+                        const id = p.functionCall.id || p.functionCall.name || "";
+                        const name = p.functionCall.name || "";
+                        if (!toolCallsMap.has(id)) {
+                            toolCallsMap.set(id, { id, name, arguments: p.functionCall.args });
+                        }
                     }
                 }
             }
@@ -160,6 +176,7 @@ export class SmolGoogle extends BaseClient {
             result: {
                 output: content || null,
                 toolCalls,
+                ...(thinkingBlocks.length > 0 && { thinkingBlocks }),
                 usage,
                 cost,
                 model: request.model,

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

@@ -5,6 +5,10 @@ import { Message } from "./classes/message/index.js";
 import { ToolCall } from "./classes/ToolCall.js";
 import { ModelConfig, ModelName, Provider } from "./models.js";
 import { Result } from "./types/result.js";
+export type ThinkingBlock = {
+    text: string;
+    signature: string;
+};
 export type PromptConfig = {
     messages: Message[];
     tools?: {
@@ -19,6 +23,10 @@ export type PromptConfig = {
     parallelToolCalls?: boolean;
     responseFormat?: ZodType;
     stream?: boolean;
+    thinking?: {
+        enabled: boolean;
+        budgetTokens?: number;
+    };
     responseFormatOptions?: Partial<{
         name: string;
         strict: boolean;
@@ -38,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;
@@ -65,6 +79,7 @@ export type CostEstimate = {
 export type PromptResult = {
     output: string | null;
     toolCalls: ToolCall[];
+    thinkingBlocks?: ThinkingBlock[];
     usage?: TokenUsage;
     cost?: CostEstimate;
     model?: ModelName | ModelConfig;
@@ -72,6 +87,10 @@ export type PromptResult = {
 export type StreamChunk = {
     type: "text";
     text: string;
+} | {
+    type: "thinking";
+    text: string;
+    signature?: string;
 } | {
     type: "tool_call";
     toolCall: ToolCall;
@@ -95,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.34",
+  "version": "0.0.36",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {
@@ -44,7 +44,8 @@
     "@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"
   }
-}
+}