smoltalk 0.0.52 → 0.0.53

package/dist/types.d.ts

@@ -1,16 +1,24 @@
 export * from "./types/result.js";
 import { LogLevel } from "egonlog";
-import { ZodType } from "zod";
+import z, { ZodType } from "zod";
 import { Message } from "./classes/message/index.js";
 import { ToolCall } from "./classes/ToolCall.js";
+import { Model } from "./model.js";
 import { ModelName, Provider } from "./models.js";
+import { ModelConfig, ModelNameAndProvider, Strategy, StrategyJSON } from "./strategies/types.js";
 import { Result } from "./types/result.js";
-import { Model, ModelConfig } from "./model.js";
-import { Strategy, StrategyJSON } from "./strategies/types.js";
 export type ThinkingBlock = {
     text: string;
     signature: string;
 };
+export declare const TextPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.z.core.$strip>;
+export declare const ThinkingBlockSchema: z.ZodObject<{
+    text: z.ZodString;
+    signature: z.ZodString;
+}, z.z.core.$strip>;
 export type Budget = {
     timeBudgetMs?: number;
     tokenBudget?: number;
@@ -49,6 +57,7 @@ export type PromptConfig = {
     maxMessages?: number;
     budget?: Budget;
     abortSignal?: AbortSignal;
+    toolLoopDetection?: ToolLoopDetection;
     hooks?: Partial<{
         onStart: (config: PromptConfig) => void;
         onToolCall: (toolCall: ToolCall) => void;
@@ -56,7 +65,6 @@ export type PromptConfig = {
         onError: (error: Error) => void;
         onStrategyStart: (strategy: Strategy, config: SmolPromptConfig) => void;
     }>;
-    strategy?: Strategy | StrategyJSON;
 };
 export type SmolConfig = {
     openAiApiKey?: string;
@@ -64,10 +72,9 @@ export type SmolConfig = {
     anthropicApiKey?: string;
     ollamaApiKey?: string;
     ollamaHost?: string;
-    model: ModelName | ModelConfig;
+    model: ModelParam;
     provider?: Provider;
     logLevel?: LogLevel;
-    toolLoopDetection?: ToolLoopDetection;
     statelog?: Partial<{
         host: string;
         projectId: string;
@@ -78,20 +85,26 @@ export type SmolConfig = {
 };
 export type ToolLoopDetection = {
     enabled: boolean;
-    maxConsecutive: number;
+    maxCalls: number;
     intervention?: "remove-tool" | "remove-all-tools" | "throw-error" | "halt-execution";
     excludeTools?: string[];
 };
 export type ResolvedSmolConfig = Omit<SmolConfig, "model"> & {
     model: ModelName;
 };
-export type BaseClientConfig = ResolvedSmolConfig & {};
+export type BaseClientConfig = ResolvedSmolConfig;
 export type TokenUsage = {
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens?: number;
     totalTokens?: number;
 };
+export declare const TokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+}, z.z.core.$strip>;
 export type CostEstimate = {
     inputCost: number;
     outputCost: number;
@@ -99,6 +112,13 @@ export type CostEstimate = {
     totalCost: number;
     currency: string;
 };
+export declare const CostEstimateSchema: z.ZodObject<{
+    inputCost: z.ZodNumber;
+    outputCost: z.ZodNumber;
+    cachedInputCost: z.ZodOptional<z.ZodNumber>;
+    totalCost: z.ZodNumber;
+    currency: z.ZodString;
+}, z.z.core.$strip>;
 export declare function addTokenUsage(_a?: TokenUsage, _b?: TokenUsage): TokenUsage;
 export declare function addCosts(_a?: CostEstimate, _b?: CostEstimate): CostEstimate;
 export type PromptResult = {
@@ -109,6 +129,7 @@ export type PromptResult = {
     cost?: CostEstimate;
     model?: ModelName | ModelConfig;
 };
+export declare function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, }: Partial<PromptResult>): PromptResult;
 export type StreamChunk = {
     type: "text";
     text: string;
@@ -135,11 +156,11 @@ export interface SmolClient {
     _textSync(config: PromptConfig): Promise<Result<PromptResult>>;
     textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
     _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
-    prompt(text: string, config?: PromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
 }
-export type SmolPromptConfig = SmolConfig & PromptConfig;
+export type SmolPromptConfig = PromptConfig & SmolConfig;
 export type TextPart = {
     type: "text";
     text: string;
 };
-export type ModelLike = ModelName | ModelConfig | Model;
+export type ModelLike = ModelName | ModelConfig | Model | ModelNameAndProvider;
+export type ModelParam = ModelName | ModelConfig | ModelNameAndProvider | Strategy | StrategyJSON;

package/dist/types.js

@@ -1,4 +1,26 @@
 export * from "./types/result.js";
+import z from "zod";
+export const TextPartSchema = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+export const ThinkingBlockSchema = z.object({
+    text: z.string(),
+    signature: z.string(),
+});
+export const TokenUsageSchema = z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cachedInputTokens: z.number().optional(),
+    totalTokens: z.number().optional(),
+});
+export const CostEstimateSchema = z.object({
+    inputCost: z.number(),
+    outputCost: z.number(),
+    cachedInputCost: z.number().optional(),
+    totalCost: z.number(),
+    currency: z.string(),
+});
 export function addTokenUsage(_a, _b) {
     let a = _a;
     let b = _b;
@@ -39,3 +61,13 @@ export function addCosts(_a, _b) {
         currency: a.currency,
     };
 }
+export function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, }) {
+    return {
+        output: output || null,
+        toolCalls: toolCalls || [],
+        thinkingBlocks: thinkingBlocks,
+        usage,
+        cost,
+        model,
+    };
+}

package/dist/util/tool.js

@@ -1,4 +1,6 @@
+import { validateToolName } from "../util.js";
 export function zodToOpenAITool(name, schema, options = {}) {
+    validateToolName(name);
     // Convert Zod schema to JSON Schema
     const jsonSchema = schema.toJSONSchema();
     let description = "";
@@ -34,6 +36,7 @@ export function zodToOpenAITool(name, schema, options = {}) {
     };
 }
 export function zodToOpenAIResponsesTool(name, schema, options = {}) {
+    validateToolName(name);
     const jsonSchema = schema.toJSONSchema();
     const strict = options?.strict ?? false;
     const parameters = {
@@ -63,6 +66,7 @@ export function zodToOpenAIResponsesTool(name, schema, options = {}) {
     return tool;
 }
 export function zodToAnthropicTool(name, schema, options = {}) {
+    validateToolName(name);
     const jsonSchema = schema.toJSONSchema();
     let description;
     if (options?.description) {

package/dist/util.d.ts

@@ -1,2 +1,12 @@
 export * from "./util/openai.js";
 export declare function round(num: number, places: number): number;
+/**
+ * Sanitizes an object by removing keys that could cause prototype pollution.
+ * Returns a shallow copy with dangerous keys filtered out.
+ */
+export declare function sanitizeAttributes(attrs: Record<string, any> | undefined): Record<string, any>;
+/**
+ * Validates that a tool name contains only safe characters.
+ * Throws if the name contains characters outside [a-zA-Z0-9_-].
+ */
+export declare function validateToolName(name: string): void;

package/dist/util.js

@@ -3,3 +3,37 @@ export function round(num, places) {
     const factor = Math.pow(10, places);
     return Math.round(num * factor) / factor;
 }
+const DANGEROUS_KEYS = new Set([
+    "__proto__",
+    "constructor",
+    "prototype",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__",
+]);
+/**
+ * Sanitizes an object by removing keys that could cause prototype pollution.
+ * Returns a shallow copy with dangerous keys filtered out.
+ */
+export function sanitizeAttributes(attrs) {
+    if (!attrs)
+        return {};
+    const result = {};
+    for (const key of Object.keys(attrs)) {
+        if (!DANGEROUS_KEYS.has(key)) {
+            result[key] = attrs[key];
+        }
+    }
+    return result;
+}
+const VALID_TOOL_NAME = /^[a-zA-Z0-9_-]+$/;
+/**
+ * Validates that a tool name contains only safe characters.
+ * Throws if the name contains characters outside [a-zA-Z0-9_-].
+ */
+export function validateToolName(name) {
+    if (!VALID_TOOL_NAME.test(name)) {
+        throw new Error(`Invalid tool name "${name}": must match /^[a-zA-Z0-9_-]+$/`);
+    }
+}

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "smoltalk",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {
     "test": "vitest",
     "test:tsc": "tsc -p tests/tsconfig.json",
-    "coverage": "vitest --coverage",
     "build": "rm -rf dist && tsc",
     "start": "cd dist && node index.js",
     "doc": "typedoc --disableSources --out docs lib && prettier docs/ --write",
@@ -37,8 +36,7 @@
     "termcolors": "github:egonSchiele/termcolors",
     "typedoc": "^0.28.15",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16",
-    "zod": "^4.3.5"
+    "vitest": "^4.0.16"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
@@ -46,6 +44,7 @@
     "egonlog": "^0.0.2",
     "nanoid": "^5.1.6",
     "ollama": "^0.6.3",
-    "openai": "^6.15.0"
+    "openai": "^6.15.0",
+    "zod": "^4.3.6"
   }
 }