smoltalk 0.0.52 → 0.0.54

package/README.md

@@ -1,6 +1,6 @@
 # Smoltalk
 
-Smoltalk is a package that exposes a common interface across different LLM providers. It exists because I think it's important to have an npm package that allows users to try out different kinds of LLMs, and prevents vendor lock-in. Using a different LLM should be as simple as switching out a model name.
+Smoltalk exposes a common API to different LLM providers. There are other packages that do this, but Smoltalk allows you to build strategies on top of it. Here is a simple example. Hello world, this is functionality that other packages allow.
 
 ## Install
 
@@ -8,7 +8,7 @@ Smoltalk is a package that exposes a common interface across different LLM provi
 pnpm install smoltalk
 ```
 
-## Quickstart
+## Hello world example
 
 ```typescript
 import { getClient } from "smoltalk";

package/dist/classes/ToolCall.d.ts

@@ -1,10 +1,12 @@
+import { z } from "zod";
 import { FunctionCall } from "@google/genai";
 import { ResponseInputItem } from "openai/resources/responses/responses.js";
-export type ToolCallJSON = {
-    id: string;
-    name: string;
-    arguments: Record<string, any>;
-};
+export declare const ToolCallJSONSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodString;
+    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export type ToolCallJSON = z.infer<typeof ToolCallJSONSchema>;
 export type ToolCallOptions = {};
 export declare class ToolCall {
     private _id;
@@ -16,7 +18,7 @@ export declare class ToolCall {
     get name(): string;
     get arguments(): Record<string, any>;
     toJSON(): ToolCallJSON;
-    static fromJSON(json: any): ToolCall;
+    static fromJSON(json: unknown): ToolCall;
     toOpenAI(): any;
     toGoogle(): {
         functionCall: FunctionCall;

package/dist/classes/ToolCall.js

@@ -1,4 +1,10 @@
+import { z } from "zod";
 import { getLogger } from "../logger.js";
+export const ToolCallJSONSchema = z.object({
+    id: z.string().default(""),
+    name: z.string(),
+    arguments: z.record(z.string(), z.any()).default({}),
+});
 export class ToolCall {
     _id;
     _name;
@@ -14,6 +20,7 @@ export class ToolCall {
             }
             catch (e) {
                 this.logger.error(`Failed to parse arguments for ToolCall ${name} with id ${id}:`, e, args);
+                this.logger.debug("Falling back to empty arguments object for ToolCall", { name, id, rawArgs: args });
                 this._arguments = {};
             }
         }
@@ -38,7 +45,8 @@ export class ToolCall {
         };
     }
     static fromJSON(json) {
-        return new ToolCall(json.id, json.name, json.arguments);
+        const parsed = ToolCallJSONSchema.parse(json);
+        return new ToolCall(parsed.id, parsed.name, parsed.arguments);
     }
     toOpenAI() {
         return {

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

@@ -1,21 +1,45 @@
+import { z } from "zod";
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
 import { CostEstimate, TextPart, ThinkingBlock, TokenUsage } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
-import { ToolCall, ToolCallJSON } from "../ToolCall.js";
+import { ToolCall } from "../ToolCall.js";
 import { Message } from "ollama";
 import type { ResponseInputItem } from "openai/resources/responses/responses.js";
-export type AssistantMessageJSON = {
-    role: "assistant";
-    content: string | Array<TextPart> | null;
-    name: string | undefined;
-    audio: any | null | undefined;
-    refusal: string | null | undefined;
-    toolCalls: ToolCallJSON[] | undefined;
-    thinkingBlocks: ThinkingBlock[] | undefined;
-    usage: TokenUsage | undefined;
-    cost: CostEstimate | undefined;
-};
+export declare const AssistantMessageJSONSchema: z.ZodObject<{
+    role: z.ZodLiteral<"assistant">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>, z.ZodNull]>;
+    name: z.ZodOptional<z.ZodString>;
+    audio: z.ZodOptional<z.ZodAny>;
+    refusal: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodString;
+        arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>>;
+    thinkingBlocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strip>>>;
+    rawData: z.ZodOptional<z.ZodAny>;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    cost: z.ZodOptional<z.ZodObject<{
+        inputCost: z.ZodNumber;
+        outputCost: z.ZodNumber;
+        cachedInputCost: z.ZodOptional<z.ZodNumber>;
+        totalCost: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AssistantMessageJSON = z.infer<typeof AssistantMessageJSONSchema>;
 export declare class AssistantMessage extends BaseMessage implements MessageClass {
     _role: "assistant";
     _content: string | Array<TextPart> | null;
@@ -49,7 +73,7 @@ export declare class AssistantMessage extends BaseMessage implements MessageClas
     get usage(): TokenUsage | undefined;
     get cost(): CostEstimate | undefined;
     toJSON(): AssistantMessageJSON;
-    static fromJSON(json: any): AssistantMessage;
+    static fromJSON(json: unknown): AssistantMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;
     toOpenAIResponseInputItem(): ResponseInputItem | ResponseInputItem[];
     toGoogleMessage(): Content;

package/dist/classes/message/AssistantMessage.js

@@ -1,5 +1,19 @@
+import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
-import { ToolCall } from "../ToolCall.js";
+import { CostEstimateSchema, TextPartSchema, ThinkingBlockSchema, TokenUsageSchema, } from "../../types.js";
+import { ToolCall, ToolCallJSONSchema } from "../ToolCall.js";
+export const AssistantMessageJSONSchema = z.object({
+    role: z.literal("assistant"),
+    content: z.union([z.string(), z.array(TextPartSchema), z.null()]),
+    name: z.string().optional(),
+    audio: z.any().optional(),
+    refusal: z.string().nullable().optional(),
+    toolCalls: z.array(ToolCallJSONSchema).optional(),
+    thinkingBlocks: z.array(ThinkingBlockSchema).optional(),
+    rawData: z.any().optional(),
+    usage: TokenUsageSchema.optional(),
+    cost: CostEstimateSchema.optional(),
+});
 export class AssistantMessage extends BaseMessage {
     _role = "assistant";
     _content;
@@ -24,12 +38,7 @@ export class AssistantMessage extends BaseMessage {
         this._cost = options.cost;
     }
     get content() {
-        if (this._content === null || this._content === undefined) {
-            return "";
-        }
-        return typeof this._content === "string"
-            ? this._content
-            : JSON.stringify(this._content);
+        return this.contentToString(this._content);
     }
     set content(value) {
         this._content = value;
@@ -75,17 +84,16 @@ export class AssistantMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        return new AssistantMessage(json.content, {
-            name: json.name,
-            audio: json.audio,
-            refusal: json.refusal,
-            toolCalls: json.toolCalls
-                ? json.toolCalls.map((tcJson) => ToolCall.fromJSON(tcJson))
-                : undefined,
-            thinkingBlocks: json.thinkingBlocks,
-            rawData: json.rawData,
-            usage: json.usage,
-            cost: json.cost,
+        const parsed = AssistantMessageJSONSchema.parse(json);
+        return new AssistantMessage(parsed.content, {
+            name: parsed.name,
+            audio: parsed.audio,
+            refusal: parsed.refusal,
+            toolCalls: parsed.toolCalls?.map((tc) => ToolCall.fromJSON(tc)),
+            thinkingBlocks: parsed.thinkingBlocks,
+            rawData: parsed.rawData,
+            usage: parsed.usage,
+            cost: parsed.cost,
         });
     }
     toOpenAIMessage() {
@@ -154,7 +162,7 @@ export class AssistantMessage extends BaseMessage {
         const blocks = [];
         // Thinking blocks must come first (Anthropic requires this ordering)
         if (hasThinking) {
-            for (const block of this._thinkingBlocks) {
+            for (const block of this._thinkingBlocks ?? []) {
                 blocks.push({ type: "thinking", thinking: block.text, signature: block.signature });
             }
         }

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

@@ -3,6 +3,7 @@ import { Message } from "ollama";
 import { ChatCompletionMessageParam } from "openai/resources";
 import type { ResponseInputItem } from "openai/resources/responses/responses.js";
 export declare class BaseMessage {
+    protected contentToString(content: string | unknown[] | null | undefined): string;
 }
 export interface MessageClass {
     get content(): string;

package/dist/classes/message/BaseMessage.js

@@ -1,2 +1,7 @@
 export class BaseMessage {
+    contentToString(content) {
+        if (content === null || content === undefined)
+            return "";
+        return typeof content === "string" ? content : JSON.stringify(content);
+    }
 }

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

@@ -1,14 +1,20 @@
+import { z } from "zod";
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
 import { TextPart } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
 import { Message } from "ollama";
 import type { ResponseInputItem } from "openai/resources/responses/responses.js";
-export type DeveloperMessageJSON = {
-    role: "developer";
-    content: string | Array<TextPart>;
-    name: string | undefined;
-};
+export declare const DeveloperMessageJSONSchema: z.ZodObject<{
+    role: z.ZodLiteral<"developer">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>]>;
+    name: z.ZodOptional<z.ZodString>;
+    rawData: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type DeveloperMessageJSON = z.infer<typeof DeveloperMessageJSONSchema>;
 export declare class DeveloperMessage extends BaseMessage implements MessageClass {
     _role: "developer";
     _content: string | Array<TextPart>;
@@ -24,7 +30,7 @@ export declare class DeveloperMessage extends BaseMessage implements MessageClas
     get name(): string | undefined;
     get rawData(): any;
     toJSON(): DeveloperMessageJSON;
-    static fromJSON(json: any): DeveloperMessage;
+    static fromJSON(json: unknown): DeveloperMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;

package/dist/classes/message/DeveloperMessage.js

@@ -1,4 +1,12 @@
+import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
+import { TextPartSchema } from "../../types.js";
+export const DeveloperMessageJSONSchema = z.object({
+    role: z.literal("developer"),
+    content: z.union([z.string(), z.array(TextPartSchema)]),
+    name: z.string().optional(),
+    rawData: z.any().optional(),
+});
 export class DeveloperMessage extends BaseMessage {
     _role = "developer";
     _content;
@@ -11,9 +19,7 @@ export class DeveloperMessage extends BaseMessage {
         this._rawData = options.rawData;
     }
     get content() {
-        return typeof this._content === "string"
-            ? this._content
-            : JSON.stringify(this._content);
+        return this.contentToString(this._content);
     }
     set content(value) {
         this._content = value;
@@ -35,9 +41,10 @@ export class DeveloperMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        return new DeveloperMessage(json.content, {
-            name: json.name,
-            rawData: json.rawData,
+        const parsed = DeveloperMessageJSONSchema.parse(json);
+        return new DeveloperMessage(parsed.content, {
+            name: parsed.name,
+            rawData: parsed.rawData,
         });
     }
     toOpenAIMessage() {

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

@@ -1,14 +1,20 @@
+import { z } from "zod";
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
 import { TextPart } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
 import { Message } from "ollama";
 import type { ResponseInputItem } from "openai/resources/responses/responses.js";
-export type SystemMessageJSON = {
-    role: "system";
-    content: string | Array<TextPart>;
-    name: string | undefined;
-};
+export declare const SystemMessageJSONSchema: z.ZodObject<{
+    role: z.ZodLiteral<"system">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>]>;
+    name: z.ZodOptional<z.ZodString>;
+    rawData: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type SystemMessageJSON = z.infer<typeof SystemMessageJSONSchema>;
 export declare class SystemMessage extends BaseMessage implements MessageClass {
     _role: "system";
     _content: string | Array<TextPart>;
@@ -24,7 +30,7 @@ export declare class SystemMessage extends BaseMessage implements MessageClass {
     get name(): string | undefined;
     get rawData(): any;
     toJSON(): SystemMessageJSON;
-    static fromJSON(json: any): SystemMessage;
+    static fromJSON(json: unknown): SystemMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;

package/dist/classes/message/SystemMessage.js

@@ -1,4 +1,12 @@
+import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
+import { TextPartSchema } from "../../types.js";
+export const SystemMessageJSONSchema = z.object({
+    role: z.literal("system"),
+    content: z.union([z.string(), z.array(TextPartSchema)]),
+    name: z.string().optional(),
+    rawData: z.any().optional(),
+});
 export class SystemMessage extends BaseMessage {
     _role = "system";
     _content;
@@ -11,9 +19,7 @@ export class SystemMessage extends BaseMessage {
         this._rawData = options.rawData;
     }
     get content() {
-        return typeof this._content === "string"
-            ? this._content
-            : JSON.stringify(this._content);
+        return this.contentToString(this._content);
     }
     set content(value) {
         this._content = value;
@@ -35,9 +41,10 @@ export class SystemMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        return new SystemMessage(json.content, {
-            name: json.name,
-            rawData: json.rawData,
+        const parsed = SystemMessageJSONSchema.parse(json);
+        return new SystemMessage(parsed.content, {
+            name: parsed.name,
+            rawData: parsed.rawData,
         });
     }
     toOpenAIMessage() {

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

@@ -1,15 +1,21 @@
+import { z } from "zod";
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
 import { TextPart } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
 import { Message } from "ollama";
 import type { ResponseInputItem } from "openai/resources/responses/responses.js";
-export type ToolMessageJSON = {
-    role: "tool";
-    content: string | Array<TextPart>;
-    name: string;
-    tool_call_id: string;
-};
+export declare const ToolMessageJSONSchema: z.ZodObject<{
+    role: z.ZodLiteral<"tool">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>]>;
+    name: z.ZodString;
+    tool_call_id: z.ZodDefault<z.ZodString>;
+    rawData: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type ToolMessageJSON = z.infer<typeof ToolMessageJSONSchema>;
 export declare class ToolMessage extends BaseMessage implements MessageClass {
     _role: "tool";
     _content: string | Array<TextPart>;
@@ -28,7 +34,7 @@ export declare class ToolMessage extends BaseMessage implements MessageClass {
     get tool_call_id(): string;
     get rawData(): any;
     toJSON(): ToolMessageJSON;
-    static fromJSON(json: any): ToolMessage;
+    static fromJSON(json: unknown): ToolMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;

package/dist/classes/message/ToolMessage.js

@@ -1,4 +1,13 @@
+import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
+import { TextPartSchema } from "../../types.js";
+export const ToolMessageJSONSchema = z.object({
+    role: z.literal("tool"),
+    content: z.union([z.string(), z.array(TextPartSchema)]),
+    name: z.string(),
+    tool_call_id: z.string().default(""),
+    rawData: z.any().optional(),
+});
 export class ToolMessage extends BaseMessage {
     _role = "tool";
     _content;
@@ -13,9 +22,7 @@ export class ToolMessage extends BaseMessage {
         this._name = options.name;
     }
     get content() {
-        return typeof this._content === "string"
-            ? this._content
-            : JSON.stringify(this._content);
+        return this.contentToString(this._content);
     }
     set content(value) {
         this._content = value;
@@ -41,10 +48,11 @@ export class ToolMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        return new ToolMessage(json.content, {
-            tool_call_id: json.tool_call_id,
-            name: json.name,
-            rawData: json.rawData,
+        const parsed = ToolMessageJSONSchema.parse(json);
+        return new ToolMessage(parsed.content, {
+            tool_call_id: parsed.tool_call_id,
+            name: parsed.name,
+            rawData: parsed.rawData,
         });
     }
     toOpenAIMessage() {

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

@@ -1,13 +1,16 @@
+import { z } from "zod";
 import { BaseMessage, MessageClass } from "./BaseMessage.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
 import { Message } from "ollama";
 import type { ResponseInputItem } from "openai/resources/responses/responses.js";
-export type UserMessageJSON = {
-    role: "user";
-    content: string;
-    name: string | undefined;
-};
+export declare const UserMessageJSONSchema: z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    rawData: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type UserMessageJSON = z.infer<typeof UserMessageJSONSchema>;
 export declare class UserMessage extends BaseMessage implements MessageClass {
     _role: "user";
     _content: string;
@@ -23,7 +26,7 @@ export declare class UserMessage extends BaseMessage implements MessageClass {
     get name(): string | undefined;
     get rawData(): any;
     toJSON(): UserMessageJSON;
-    static fromJSON(json: any): UserMessage;
+    static fromJSON(json: unknown): UserMessage;
     toOpenAIMessage(): ChatCompletionMessageParam;
     toOpenAIResponseInputItem(): ResponseInputItem;
     toGoogleMessage(): Content;

package/dist/classes/message/UserMessage.js

@@ -1,4 +1,11 @@
+import { z } from "zod";
 import { BaseMessage } from "./BaseMessage.js";
+export const UserMessageJSONSchema = z.object({
+    role: z.literal("user"),
+    content: z.string(),
+    name: z.string().optional(),
+    rawData: z.any().optional(),
+});
 export class UserMessage extends BaseMessage {
     _role = "user";
     _content;
@@ -33,9 +40,10 @@ export class UserMessage extends BaseMessage {
         };
     }
     static fromJSON(json) {
-        return new UserMessage(json.content, {
-            name: json.name,
-            rawData: json.rawData,
+        const parsed = UserMessageJSONSchema.parse(json);
+        return new UserMessage(parsed.content, {
+            name: parsed.name,
+            rawData: parsed.rawData,
         });
     }
     toOpenAIMessage() {

package/dist/classes/message/index.js

@@ -22,7 +22,7 @@ export function messageFromJSON(json) {
         case "tool":
             return ToolMessage.fromJSON(json);
         default:
-            throw new Error(`Unknown message: ${JSON.stringify(json)}`);
+            throw new Error(`Unknown message role: ${json?.role}`);
     }
 }
 export function userMessage(content, options = {}) {

package/dist/client.d.ts

@@ -2,10 +2,7 @@ export * from "./clients/anthropic.js";
 export * from "./clients/google.js";
 export * from "./clients/openai.js";
 export * from "./clients/openaiResponses.js";
-import { SmolAnthropic } from "./clients/anthropic.js";
-import { SmolGoogle } from "./clients/google.js";
-import { SmolOpenAi } from "./clients/openai.js";
-import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
-import { SmolConfig } from "./types.js";
-import { SmolOllama } from "./clients/ollama.js";
-export declare function getClient(config: SmolConfig): SmolAnthropic | SmolGoogle | SmolOpenAi | SmolOpenAiResponses | SmolOllama;
+import { BaseClient } from "./clients/baseClient.js";
+import { ResolvedSmolConfig } from "./types.js";
+export declare function registerProvider(providerName: string, clientClass: typeof BaseClient): void;
+export declare function getClient(config: ResolvedSmolConfig): BaseClient;

package/dist/client.js

@@ -4,19 +4,18 @@ export * from "./clients/openai.js";
 export * from "./clients/openaiResponses.js";
 import { SmolAnthropic } from "./clients/anthropic.js";
 import { SmolGoogle } from "./clients/google.js";
+import { SmolOllama } from "./clients/ollama.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
 import { getModel, isTextModel } from "./models.js";
 import { SmolError } from "./smolError.js";
-import { getLogger } from "./logger.js";
-import { SmolOllama } from "./clients/ollama.js";
-import { Model } from "./model.js";
+const registeredProviders = {};
+export function registerProvider(providerName, clientClass) {
+    registeredProviders[providerName] = clientClass;
+}
 export function getClient(config) {
-    // Initialize logger singleton with desired log level
-    const logger = getLogger(config.logLevel);
-    // Resolve ModelConfig to a concrete model name
-    const modelName = new Model(config.model).getResolvedModel();
     let provider = config.provider;
+    const modelName = config.model;
     if (!provider) {
         const model = getModel(modelName);
         if (model === undefined) {
@@ -27,34 +26,47 @@ export function getClient(config) {
         }
         provider = model.provider;
     }
-    const clientConfig = { ...config, model: modelName };
+    const resolvedKeys = {
+        openAiApiKey: config.openAiApiKey || process.env.OPENAI_API_KEY,
+        googleApiKey: config.googleApiKey || process.env.GEMINI_API_KEY,
+        anthropicApiKey: config.anthropicApiKey || process.env.ANTHROPIC_API_KEY,
+    };
+    const clientConfig = {
+        ...config,
+        ...resolvedKeys,
+        model: modelName,
+    };
     switch (provider) {
         case "anthropic":
-            if (!config.anthropicApiKey) {
-                throw new SmolError("No Anthropic API key provided. Please provide an Anthropic API key in the config using anthropicApiKey.");
+            if (!resolvedKeys.anthropicApiKey) {
+                throw new SmolError("No Anthropic API key provided. Please provide an Anthropic API key in the config using anthropicApiKey, or set the ANTHROPIC_API_KEY environment variable.");
             }
             return new SmolAnthropic({
                 ...clientConfig,
-                anthropicApiKey: config.anthropicApiKey,
+                anthropicApiKey: resolvedKeys.anthropicApiKey,
             });
         case "openai":
-            if (!config.openAiApiKey) {
-                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey.");
+            if (!resolvedKeys.openAiApiKey) {
+                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey, or set the OPENAI_API_KEY environment variable.");
             }
             return new SmolOpenAi(clientConfig);
         case "openai-responses":
-            if (!config.openAiApiKey) {
-                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey.");
+            if (!resolvedKeys.openAiApiKey) {
+                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey, or set the OPENAI_API_KEY environment variable.");
             }
             return new SmolOpenAiResponses(clientConfig);
         case "google":
-            if (!config.googleApiKey) {
-                throw new SmolError("No Google API key provided. Please provide a Google API key in the config using googleApiKey.");
+            if (!resolvedKeys.googleApiKey) {
+                throw new SmolError("No Google API key provided. Please provide a Google API key in the config using googleApiKey, or set the GEMINI_API_KEY environment variable.");
             }
             return new SmolGoogle(clientConfig);
         case "ollama":
             return new SmolOllama(clientConfig);
         default:
+            if (provider in registeredProviders) {
+                const ClientClass = registeredProviders[provider];
+                return new ClientClass(clientConfig);
+            }
             throw new SmolError(`Model provider ${provider} is not supported.`);
     }
 }

package/dist/clients/baseClient.d.ts

@@ -1,9 +1,9 @@
 import { StatelogClient } from "../statelogClient.js";
-import { PromptConfig, PromptResult, Result, SmolClient, SmolConfig, StreamChunk } from "../types.js";
+import { PromptConfig, PromptResult, ResolvedSmolConfig, Result, SmolClient, StreamChunk } from "../types.js";
 export declare class BaseClient implements SmolClient {
-    protected config: SmolConfig;
+    protected config: ResolvedSmolConfig;
     protected statelogClient?: StatelogClient;
-    constructor(config: SmolConfig);
+    constructor(config: ResolvedSmolConfig);
     protected getAbortSignal(promptConfig: PromptConfig): AbortSignal | undefined;
     protected isAbortError(err: unknown): boolean;
     text(promptConfig: Omit<PromptConfig, "stream">): Promise<Result<PromptResult>>;
@@ -24,10 +24,9 @@ export declare class BaseClient implements SmolClient {
         continue: boolean;
         newPromptConfig: PromptConfig;
     };
-    extractResponse(promptConfig: PromptConfig, rawValue: any, schema: any): any;
+    extractResponse(promptConfig: PromptConfig, rawValue: any, schema: any, depth?: number): any;
     textWithRetry(promptConfig: PromptConfig, retries: number): Promise<Result<PromptResult>>;
     _textSync(promptConfig: PromptConfig): Promise<Result<PromptResult>>;
-    prompt(text: string, promptConfig?: PromptConfig): Promise<Result<PromptResult>> | AsyncGenerator<StreamChunk>;
     textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
     _textStream(config: PromptConfig): AsyncGenerator<StreamChunk>;
 }