smoltalk 0.0.52 → 0.0.53

package/dist/clients/baseClient.js

@@ -11,6 +11,9 @@ export class BaseClient {
     statelogClient;
     constructor(config) {
         this.config = config || {};
+        if (this.config.logLevel) {
+            getLogger(this.config.logLevel);
+        }
         if (this.config.statelog) {
             this.statelogClient = getStatelogClient(this.config.statelog);
         }
@@ -165,7 +168,7 @@ export class BaseClient {
         }
     }
     checkForToolLoops(promptConfig) {
-        if (!this.config.toolLoopDetection?.enabled) {
+        if (!promptConfig.toolLoopDetection?.enabled) {
             return { continue: true, newPromptConfig: promptConfig };
         }
         const toolCallCounts = {};
@@ -175,9 +178,9 @@ export class BaseClient {
             toolCallCounts[msg.name] += 1;
         }
         for (const [toolName, count] of Object.entries(toolCallCounts)) {
-            if (count >= this.config.toolLoopDetection.maxConsecutive &&
-                !(this.config.toolLoopDetection.excludeTools ?? []).includes(toolName)) {
-                const intervention = this.config.toolLoopDetection.intervention || "remove-tool";
+            if (count >= promptConfig.toolLoopDetection.maxCalls &&
+                !(promptConfig.toolLoopDetection.excludeTools ?? []).includes(toolName)) {
+                const intervention = promptConfig.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", {
@@ -207,7 +210,11 @@ export class BaseClient {
         }
         return { continue: true, newPromptConfig: promptConfig };
     }
-    extractResponse(promptConfig, rawValue, schema) {
+    extractResponse(promptConfig, rawValue, schema, depth = 0) {
+        const MAX_DEPTH = 5;
+        if (depth > MAX_DEPTH) {
+            throw new Error("extractResponse exceeded maximum depth");
+        }
         // 1. Direct match — try parsing as-is
         const direct = schema.safeParse(rawValue);
         if (direct.success) {
@@ -227,9 +234,16 @@ export class BaseClient {
                 .replace(/^```json\s*/, "")
                 .replace(/```\s*$/, "");
             try {
-                return this.extractResponse(promptConfig, JSON.parse(stripped), schema);
+                return this.extractResponse(promptConfig, JSON.parse(stripped), schema, depth + 1);
+            }
+            catch (err) {
+                const logger = getLogger();
+                logger.debug("extractResponse: failed to parse JSON from string", {
+                    error: err.message,
+                    rawValue: stripped,
+                });
+                this.statelogClient?.debug("extractResponse: failed to parse JSON from string", { error: err.message });
             }
-            catch { }
             return rawValue;
         }
         // 3. Null/undefined/primitive — nothing to unwrap
@@ -250,10 +264,10 @@ export class BaseClient {
             if (key in rawValue) {
                 const inner = schema.safeParse(rawValue[key]);
                 if (inner.success)
-                    return inner.data[key];
+                    return inner.data;
             }
         }
-        // 6. Shallow search — check every value of the object
+        // 6. Shallow search — check every value of the object (own keys only)
         for (const key of Object.keys(rawValue)) {
             const inner = schema.safeParse(rawValue[key]);
             if (inner.success)
@@ -304,7 +318,7 @@ export class BaseClient {
                 catch (err) {
                     const errorMessage = err.message;
                     const logger = getLogger();
-                    logger.warn(`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);
                     if (err instanceof z.ZodError) {
                         logger.warn("Zod error details:", z.prettifyError(err));
                     }
@@ -312,11 +326,6 @@ export class BaseClient {
                         retriesLeft: retries,
                         error: errorMessage,
                     });
-                    this.statelogClient?.diff({
-                        message: "Response format validation failed",
-                        itemA: promptConfig.responseFormat,
-                        itemB: output,
-                    });
                     const retryMessages = [
                         ...promptConfig.messages,
                         assistantMessage(output),
@@ -326,21 +335,12 @@ export class BaseClient {
                 }
             }
         }
-        throw new SmolStructuredOutputError(`Failed to get valid response after ${DEFAULT_NUM_RETRIES} attempts: ${result.success ? "Output did not match expected format" : result.error}`);
+        const numRetries = promptConfig.responseFormatOptions?.numRetries || DEFAULT_NUM_RETRIES;
+        throw new SmolStructuredOutputError(`Failed to get valid response after ${numRetries} attempts: ${result.success ? "Output did not match expected format" : result.error}`);
     }
     async _textSync(promptConfig) {
         throw new Error("Method not implemented.");
     }
-    prompt(text, promptConfig) {
-        const msg = userMessage(text);
-        const newPromptConfig = {
-            ...promptConfig,
-            messages: promptConfig?.messages
-                ? [...promptConfig.messages, msg]
-                : [msg],
-        };
-        return this.text(newPromptConfig);
-    }
     async *textStream(config) {
         const messageLimitResult = this.checkMessageLimit(config);
         if (messageLimitResult) {

package/dist/clients/google.js

@@ -3,6 +3,7 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../logger.js";
 import { addCosts, addTokenUsage, success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
+import { sanitizeAttributes } from "../util.js";
 import { BaseClient } from "./baseClient.js";
 import { Model } from "../model.js";
 import { userMessage } from "../classes/message/index.js";
@@ -80,7 +81,7 @@ export class SmolGoogle extends BaseClient {
             contents: messages,
             model: this.getModel(),
             config: genConfig,
-            ...(config.rawAttributes || {}),
+            ...sanitizeAttributes(config.rawAttributes),
         };
     }
     async _textSync(config) {

package/dist/clients/ollama.js

@@ -3,6 +3,7 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../logger.js";
 import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
+import { sanitizeAttributes } from "../util.js";
 import { BaseClient } from "./baseClient.js";
 import { Model } from "../model.js";
 export const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
@@ -66,9 +67,7 @@ export class SmolOllama extends BaseClient {
         if (config.responseFormat) {
             request.format = config.responseFormat.toJSONSchema();
         }
-        if (config.rawAttributes) {
-            Object.assign(request, config.rawAttributes);
-        }
+        Object.assign(request, sanitizeAttributes(config.rawAttributes));
         this.logger.debug("Sending request to Ollama:", JSON.stringify(request, null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
@@ -76,10 +75,15 @@ export class SmolOllama extends BaseClient {
         if (signal && abortHandler) {
             signal.addEventListener("abort", abortHandler, { once: true });
         }
-        // @ts-ignore
-        const result = await this.client.chat(request);
-        if (signal && abortHandler) {
-            signal.removeEventListener("abort", abortHandler);
+        let result;
+        try {
+            // @ts-ignore
+            result = await this.client.chat(request);
+        }
+        finally {
+            if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+            }
         }
         this.logger.debug("Response from Ollama:", JSON.stringify(result, null, 2));
         this.statelogClient?.promptResponse(result);
@@ -114,9 +118,7 @@ export class SmolOllama extends BaseClient {
         if (config.responseFormat) {
             request.format = config.responseFormat.toJSONSchema();
         }
-        if (config.rawAttributes) {
-            Object.assign(request, config.rawAttributes);
-        }
+        Object.assign(request, sanitizeAttributes(config.rawAttributes));
         this.logger.debug("Sending streaming request to Ollama:", JSON.stringify(request, null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
@@ -124,73 +126,77 @@ export class SmolOllama extends BaseClient {
         if (signal && abortHandler) {
             signal.addEventListener("abort", abortHandler, { once: true });
         }
-        // @ts-ignore
-        const stream = await this.client.chat(request);
-        let content = "";
-        const toolCallsMap = new Map();
-        let usage;
-        let cost;
-        let lastChunk;
-        for await (const chunk of stream) {
-            lastChunk = chunk;
-            // Handle text content
-            if (chunk.message?.content) {
-                content += chunk.message.content;
-                yield { type: "text", text: chunk.message.content };
-            }
-            // Handle tool calls
-            if (chunk.message?.tool_calls) {
-                for (const tc of chunk.message.tool_calls) {
-                    const tool_call = tc;
-                    const id = tool_call.id || tool_call.function.name || "";
-                    const name = tool_call.function.name || "";
-                    if (!toolCallsMap.has(id)) {
-                        toolCallsMap.set(id, {
-                            id: id,
-                            name: name,
-                            arguments: tool_call.function.arguments || {},
-                        });
-                    }
-                    else {
-                        // Merge arguments if tool call is split across chunks
-                        const existing = toolCallsMap.get(id);
-                        if (tool_call.function.arguments) {
-                            existing.arguments = {
-                                ...existing.arguments,
-                                ...tool_call.function.arguments,
-                            };
+        try {
+            // @ts-ignore
+            const stream = await this.client.chat(request);
+            let content = "";
+            const toolCallsMap = new Map();
+            let usage;
+            let cost;
+            let lastChunk;
+            for await (const chunk of stream) {
+                lastChunk = chunk;
+                // Handle text content
+                if (chunk.message?.content) {
+                    content += chunk.message.content;
+                    yield { type: "text", text: chunk.message.content };
+                }
+                // Handle tool calls
+                if (chunk.message?.tool_calls) {
+                    for (const tc of chunk.message.tool_calls) {
+                        const tool_call = tc;
+                        const id = tool_call.id || tool_call.function.name || "";
+                        const name = tool_call.function.name || "";
+                        if (!toolCallsMap.has(id)) {
+                            toolCallsMap.set(id, {
+                                id: id,
+                                name: name,
+                                arguments: tool_call.function.arguments || {},
+                            });
+                        }
+                        else {
+                            // Merge arguments if tool call is split across chunks
+                            const existing = toolCallsMap.get(id);
+                            if (tool_call.function.arguments) {
+                                existing.arguments = {
+                                    ...existing.arguments,
+                                    ...tool_call.function.arguments,
+                                };
+                            }
                         }
                     }
                 }
             }
+            this.logger.debug("Streaming response completed from Ollama");
+            // Extract usage from the last chunk
+            if (lastChunk) {
+                const usageAndCost = this.calculateUsageAndCost(lastChunk);
+                usage = usageAndCost.usage;
+                cost = usageAndCost.cost;
+            }
+            this.statelogClient?.promptResponse({ content, usage, cost });
+            // Yield tool calls
+            const toolCalls = [];
+            for (const tc of toolCallsMap.values()) {
+                const toolCall = new ToolCall(tc.id, tc.name, tc.arguments);
+                toolCalls.push(toolCall);
+                yield { type: "tool_call", toolCall };
+            }
+            yield {
+                type: "done",
+                result: {
+                    output: content || null,
+                    toolCalls,
+                    usage,
+                    cost,
+                    model: this.getModel(),
+                },
+            };
         }
-        if (signal && abortHandler) {
-            signal.removeEventListener("abort", abortHandler);
-        }
-        this.logger.debug("Streaming response completed from Ollama");
-        // Extract usage from the last chunk
-        if (lastChunk) {
-            const usageAndCost = this.calculateUsageAndCost(lastChunk);
-            usage = usageAndCost.usage;
-            cost = usageAndCost.cost;
-        }
-        this.statelogClient?.promptResponse({ content, usage, cost });
-        // Yield tool calls
-        const toolCalls = [];
-        for (const tc of toolCallsMap.values()) {
-            const toolCall = new ToolCall(tc.id, tc.name, tc.arguments);
-            toolCalls.push(toolCall);
-            yield { type: "tool_call", toolCall };
+        finally {
+            if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+            }
         }
-        yield {
-            type: "done",
-            result: {
-                output: content || null,
-                toolCalls,
-                usage,
-                cost,
-                model: this.getModel(),
-            },
-        };
     }
 }

package/dist/clients/openai.js

@@ -1,7 +1,7 @@
 import OpenAI from "openai";
 import { success, } from "../types.js";
 import { ToolCall } from "../classes/ToolCall.js";
-import { isFunctionToolCall } from "../util.js";
+import { isFunctionToolCall, sanitizeAttributes } from "../util.js";
 import { getLogger } from "../logger.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAITool } from "../util/tool.js";
@@ -55,7 +55,7 @@ export class SmolOpenAi extends BaseClient {
             ...(config.reasoningEffort && {
                 reasoning_effort: config.reasoningEffort,
             }),
-            ...(config.rawAttributes || {}),
+            ...sanitizeAttributes(config.rawAttributes),
         };
         if (config.responseFormat) {
             request.response_format = {
@@ -119,13 +119,15 @@ export class SmolOpenAi extends BaseClient {
         let usage;
         let cost;
         for await (const chunk of completion) {
-            const delta = chunk.choices[0]?.delta;
             // Extract usage from the final chunk
             if (chunk.usage) {
                 const usageAndCost = this.calculateUsageAndCost(chunk.usage);
                 usage = usageAndCost.usage;
                 cost = usageAndCost.cost;
             }
+            if (!chunk.choices || chunk.choices.length === 0)
+                continue;
+            const delta = chunk.choices[0]?.delta;
             if (!delta)
                 continue;
             if (delta.content) {

package/dist/clients/openaiResponses.js

@@ -4,6 +4,7 @@ import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../logger.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAIResponsesTool } from "../util/tool.js";
+import { sanitizeAttributes } from "../util.js";
 import { Model } from "../model.js";
 export class SmolOpenAiResponses extends BaseClient {
     client;
@@ -80,9 +81,7 @@ export class SmolOpenAiResponses extends BaseClient {
         if (config.reasoningEffort) {
             request.reasoning = { effort: config.reasoningEffort };
         }
-        if (config.rawAttributes) {
-            Object.assign(request, config.rawAttributes);
-        }
+        Object.assign(request, sanitizeAttributes(config.rawAttributes));
         return request;
     }
     calculateUsageAndCost(usageData) {

package/dist/functions.d.ts

@@ -1,5 +1,10 @@
-import { SmolPromptConfig, PromptResult, StreamChunk } from "./types.js";
+import { getClient } from "./client.js";
+import { PromptConfig, PromptResult, SmolPromptConfig, StreamChunk } from "./types.js";
 import { Result } from "./types/result.js";
+export declare function splitConfig(config: SmolPromptConfig): {
+    smolConfig: Parameters<typeof getClient>[0];
+    promptConfig: PromptConfig;
+};
 export declare function text(config: SmolPromptConfig & {
     stream: true;
 }): AsyncGenerator<StreamChunk>;
@@ -8,4 +13,3 @@ export declare function text(config: SmolPromptConfig & {
 }): Promise<Result<PromptResult>>;
 export declare function textSync(config: SmolPromptConfig): Promise<Result<PromptResult>>;
 export declare function textStream(config: SmolPromptConfig): AsyncGenerator<StreamChunk>;
-export declare function prompt(promptText: string, config: SmolPromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;

package/dist/functions.js

@@ -2,14 +2,13 @@ import { getClient } from "./client.js";
 import { Model } from "./model.js";
 import { BaseStrategy } from "./strategies/baseStrategy.js";
 import { fromJSON } from "./strategies/index.js";
-function hydrateStrategy(config) {
-    if (config.strategy && !(config.strategy instanceof BaseStrategy)) {
-        return { ...config, strategy: fromJSON(config.strategy) };
-    }
-    return config;
+function getStrategy(model) {
+    if (model instanceof BaseStrategy)
+        return model;
+    return fromJSON(model);
 }
-function splitConfig(config) {
-    const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, toolLoopDetection, statelog, ...promptConfig } = config;
+export function splitConfig(config) {
+    const { openAiApiKey, googleApiKey, ollamaApiKey, anthropicApiKey, ollamaHost, model: rawModel, provider, logLevel, statelog, ...promptConfig } = config;
     const _model = new Model(rawModel);
     const model = _model.getResolvedModel();
     return {
@@ -22,41 +21,21 @@ function splitConfig(config) {
             model,
             provider,
             logLevel,
-            toolLoopDetection,
             statelog,
         },
         promptConfig,
     };
 }
 export function text(config) {
-    config = hydrateStrategy(config);
-    if (config.strategy) {
-        return config.strategy.text(config);
-    }
-    const { smolConfig, promptConfig } = splitConfig(config);
-    const client = getClient(smolConfig);
-    return client.text(promptConfig);
+    const strategy = getStrategy(config.model);
+    return strategy.text(config);
 }
 export function textSync(config) {
-    config = hydrateStrategy(config);
-    if (config.strategy) {
-        return config.strategy.textSync(config);
-    }
-    const { smolConfig, promptConfig } = splitConfig(config);
-    const client = getClient(smolConfig);
-    return client.textSync(promptConfig);
+    const strategy = getStrategy(config.model);
+    return strategy.textSync(config);
 }
 export function textStream(config) {
-    config = hydrateStrategy(config);
-    /*   if (config.strategy) {
-      return (config.strategy as import("./strategies/types.js").Strategy).textStream(config);
-    }
-   */ const { smolConfig, promptConfig } = splitConfig(config);
-    const client = getClient(smolConfig);
-    return client.textStream(promptConfig);
-}
-export function prompt(promptText, config) {
     const { smolConfig, promptConfig } = splitConfig(config);
     const client = getClient(smolConfig);
-    return client.prompt(promptText, promptConfig);
+    return client.textStream(promptConfig);
 }

package/dist/model.d.ts

@@ -1,20 +1,21 @@
 import { ModelName, Provider, TextModel } from "./models.js";
+import { ModelConfig, ModelNameAndProvider } from "./strategies/types.js";
 import { ModelLike } from "./types.js";
-export type Optimization = "speed" | "reasoning" | "cost" | "large-context";
-export type ModelConfig = {
-    optimizeFor: Optimization[];
-    providers: Provider[];
-    limit?: {
-        cost?: number;
-    };
-};
 export declare class Model {
     private model;
     private resolvedModel;
-    constructor(model: ModelName | ModelConfig);
-    getModel(): ModelName | ModelConfig;
+    private provider?;
+    constructor(model: ModelName | ModelConfig | ModelNameAndProvider, provider?: Provider);
+    getModel(): ModelName | ModelNameAndProvider | {
+        optimizeFor: ("reasoning" | "speed" | "cost" | "large-context")[];
+        providers: ("local" | "ollama" | "openai" | "openai-responses" | "anthropic" | "google" | "replicate" | "modal")[];
+        limit?: {
+            cost?: number | undefined;
+        } | undefined;
+    };
     getResolvedModel(): ModelName;
-    isModelConfig(model: ModelName | ModelConfig): model is ModelConfig;
+    getProvider(): Provider | undefined;
+    setProvider(): Provider | undefined;
     resolveModel(models?: readonly TextModel[]): ModelName;
     private getRawMetric;
     private isLowerBetter;
@@ -29,5 +30,6 @@ export declare class Model {
         totalCost: number;
         currency: string;
     } | null;
-    static create(model: ModelLike): Model;
+    toString(): string;
+    static create(model: ModelLike, provider?: Provider): Model;
 }

package/dist/model.js

@@ -1,5 +1,6 @@
 import { getModel, isTextModel, textModels, } from "./models.js";
 import { SmolError } from "./smolError.js";
+import { ModelConfigSchema, ModelNameAndProviderSchema, ModelNameSchema, } from "./strategies/types.js";
 import { round } from "./util.js";
 const WEIGHTS = {
     1: [1],
@@ -10,9 +11,11 @@ const WEIGHTS = {
 export class Model {
     model;
     resolvedModel;
-    constructor(model) {
+    provider;
+    constructor(model, provider) {
         this.model = model;
         this.resolvedModel = this.resolveModel();
+        this.provider = provider || this.setProvider();
     }
     getModel() {
         return this.model;
@@ -20,17 +23,35 @@ export class Model {
     getResolvedModel() {
         return this.resolvedModel;
     }
-    isModelConfig(model) {
-        return typeof model === "object" && "optimizeFor" in model;
+    getProvider() {
+        if (this.provider) {
+            return this.provider;
+        }
+        return undefined;
+    }
+    setProvider() {
+        if (ModelNameAndProviderSchema.safeParse(this.model).success) {
+            const { model, provider } = this.model;
+            return provider;
+        }
+        const resolved = this.getResolvedModel();
+        const modelInfo = getModel(resolved);
+        if (modelInfo) {
+            return modelInfo.provider;
+        }
+        return undefined;
     }
     resolveModel(models = textModels) {
-        if (!this.isModelConfig(this.model)) {
-            const modelName = this.model;
-            const model = getModel(modelName);
-            if (!model) {
-                throw new SmolError(`Model ${modelName} is not recognized. Please specify a known model or a valid ModelConfig.`);
-            }
-            return modelName;
+        if (ModelNameSchema.safeParse(this.model).success) {
+            return this.model;
+        }
+        if (ModelNameAndProviderSchema.safeParse(this.model).success) {
+            const { model, provider } = this.model;
+            return model;
+        }
+        const isModelConfig = ModelConfigSchema.safeParse(this.model).success;
+        if (!isModelConfig) {
+            throw new SmolError(`Model ${JSON.stringify(this.model)} is not recognized. Please specify a known model or a valid ModelConfig.`);
         }
         const model = this.model;
         let candidates = models.filter((m) => model.providers.includes(m.provider) &&
@@ -123,10 +144,13 @@ export class Model {
             currency: "USD",
         };
     }
-    static create(model) {
+    toString() {
+        return `Model(${JSON.stringify(this.model)})`;
+    }
+    static create(model, provider) {
         if (model instanceof Model) {
             return model;
         }
-        return new Model(model);
+        return new Model(model, provider);
     }
 }

package/dist/models.d.ts

@@ -1,4 +1,16 @@
-export type Provider = "local" | "ollama" | "openai" | "openai-responses" | "anthropic" | "google" | "replicate" | "modal";
+import { z } from "zod";
+export declare const providers: readonly ["local", "ollama", "openai", "openai-responses", "anthropic", "google", "replicate", "modal"];
+export declare const ProviderSchema: z.ZodEnum<{
+    local: "local";
+    ollama: "ollama";
+    openai: "openai";
+    "openai-responses": "openai-responses";
+    anthropic: "anthropic";
+    google: "google";
+    replicate: "replicate";
+    modal: "modal";
+}>;
+export type Provider = z.infer<typeof ProviderSchema>;
 export type BaseModel = {
     modelName: string;
     provider: Provider;

package/dist/models.js

@@ -1,3 +1,15 @@
+import { z } from "zod";
+export const providers = [
+    "local",
+    "ollama",
+    "openai",
+    "openai-responses",
+    "anthropic",
+    "google",
+    "replicate",
+    "modal",
+];
+export const ProviderSchema = z.enum(providers);
 export const speechToTextModels = [
     { type: "speech-to-text", modelName: "whisper-local", provider: "local" },
     {

package/dist/statelogClient.d.ts

@@ -1,6 +1,5 @@
+import { ModelLike } from "./types.js";
 import { Result } from "./types/result.js";
-import { ModelName } from "./models.js";
-import { ModelConfig } from "./model.js";
 export type AgencyFile = {
     name: string;
     contents: string;
@@ -62,7 +61,7 @@ export declare class StatelogClient {
     promptCompletion({ messages, completion, model, timeTaken, tools, responseFormat, }: {
         messages: any[];
         completion: any;
-        model?: ModelName | ModelConfig | string;
+        model?: ModelLike;
         timeTaken?: number;
         tools?: {
             name: string;
@@ -75,7 +74,7 @@ export declare class StatelogClient {
         toolName: string;
         args: any;
         output: any;
-        model?: ModelName | ModelConfig;
+        model?: ModelLike;
         timeTaken?: number;
     }): Promise<void>;
     diff({ itemA, itemB, message, }: {