smoltalk 0.0.4 → 0.0.6

package/dist/classes/ToolCall.d.ts

@@ -1,3 +1,4 @@
+import { FunctionCall } from "@google/genai";
 export type ToolCallOptions = {};
 export declare class ToolCall {
     private _id;
@@ -8,4 +9,8 @@ export declare class ToolCall {
     get id(): string;
     get name(): string;
     get arguments(): Record<string, any>;
+    toOpenAI(): any;
+    toGoogle(): {
+        functionCall: FunctionCall;
+    };
 }

package/dist/classes/ToolCall.js

@@ -30,4 +30,22 @@ export class ToolCall {
     get arguments() {
         return this._arguments;
     }
+    toOpenAI() {
+        return {
+            id: this._id,
+            type: "function",
+            function: {
+                name: this.name,
+                arguments: JSON.stringify(this.arguments),
+            },
+        };
+    }
+    toGoogle() {
+        return {
+            functionCall: {
+                name: this.name,
+                args: this.arguments,
+            },
+        };
+    }
 }

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

@@ -2,30 +2,28 @@ import { BaseMessage, MessageClass } from "./BaseMessage.js";
 import { TextPart } from "../../types.js";
 import { ChatCompletionMessageParam } from "openai/resources";
 import { Content } from "@google/genai";
+import { ToolCall } from "../ToolCall.js";
 export declare class AssistantMessage extends BaseMessage implements MessageClass {
     _role: "assistant";
     _content: string | Array<TextPart> | null;
     _name?: string;
     _audio?: any | null;
-    _function_call?: any | null;
     _refusal?: string | null;
-    _tool_calls?: Array<any>;
+    _toolCalls?: ToolCall[];
     _rawData?: any;
     constructor(content: string | Array<TextPart> | null, options?: {
         name?: string;
         audio?: any | null;
-        function_call?: any | null;
         refusal?: string | null;
-        tool_calls?: Array<any>;
+        toolCalls?: ToolCall[];
         rawData?: any;
     });
     get content(): string;
     get role(): "assistant";
     get name(): string | undefined;
     get audio(): any | null | undefined;
-    get function_call(): any | null | undefined;
     get refusal(): string | null | undefined;
-    get tool_calls(): Array<any> | undefined;
+    get toolCalls(): ToolCall[] | undefined;
     get rawData(): any;
     toOpenAIMessage(): ChatCompletionMessageParam;
     toGoogleMessage(): Content;

package/dist/classes/message/AssistantMessage.js

@@ -4,18 +4,16 @@ export class AssistantMessage extends BaseMessage {
     _content;
     _name;
     _audio;
-    _function_call;
     _refusal;
-    _tool_calls;
+    _toolCalls;
     _rawData;
     constructor(content, options = {}) {
         super();
         this._content = content;
         this._name = options.name;
         this._audio = options.audio;
-        this._function_call = options.function_call;
         this._refusal = options.refusal;
-        this._tool_calls = options.tool_calls;
+        this._toolCalls = options.toolCalls;
         this._rawData = options.rawData;
     }
     get content() {
@@ -35,22 +33,33 @@ export class AssistantMessage extends BaseMessage {
     get audio() {
         return this._audio;
     }
-    get function_call() {
-        return this._function_call;
-    }
     get refusal() {
         return this._refusal;
     }
-    get tool_calls() {
-        return this._tool_calls;
+    get toolCalls() {
+        return this._toolCalls;
     }
     get rawData() {
         return this._rawData;
     }
     toOpenAIMessage() {
-        return { role: this.role, content: this.content, name: this.name };
+        return {
+            role: this.role,
+            content: this.content,
+            name: this.name,
+            tool_calls: this.toolCalls?.map((tc) => tc.toOpenAI()),
+        };
     }
     toGoogleMessage() {
-        return { role: this.role, parts: [{ text: this.content }] };
+        const parts = [];
+        if (this.content) {
+            parts.push({ text: this.content });
+        }
+        if (this.toolCalls) {
+            for (const tc of this.toolCalls) {
+                parts.push(tc.toGoogle());
+            }
+        }
+        return { role: "model", parts };
     }
 }

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

@@ -7,13 +7,15 @@ export declare class ToolMessage extends BaseMessage implements MessageClass {
     _content: string | Array<TextPart>;
     _tool_call_id: string;
     _rawData?: any;
+    _name: string;
     constructor(content: string | Array<TextPart>, options: {
         tool_call_id: string;
         rawData?: any;
+        name: string;
     });
     get content(): string;
     get role(): "tool";
-    get name(): string | undefined;
+    get name(): string;
     get tool_call_id(): string;
     get rawData(): any;
     toOpenAIMessage(): ChatCompletionMessageParam;

package/dist/classes/message/ToolMessage.js

@@ -4,11 +4,13 @@ export class ToolMessage extends BaseMessage {
     _content;
     _tool_call_id;
     _rawData;
+    _name;
     constructor(content, options) {
         super();
         this._content = content;
         this._tool_call_id = options.tool_call_id;
         this._rawData = options.rawData;
+        this._name = options.name;
     }
     get content() {
         return typeof this._content === "string"
@@ -19,7 +21,7 @@ export class ToolMessage extends BaseMessage {
         return this._role;
     }
     get name() {
-        return undefined;
+        return this._name;
     }
     get tool_call_id() {
         return this._tool_call_id;
@@ -35,6 +37,15 @@ export class ToolMessage extends BaseMessage {
         };
     }
     toGoogleMessage() {
-        return { role: this.role, parts: [{ text: this.content }] };
+        return {
+            role: "user", parts: [{
+                    functionResponse: {
+                        name: this.name,
+                        response: {
+                            result: this.content
+                        }
+                    }
+                }]
+        };
     }
 }

package/dist/classes/message/UserMessage.js

@@ -23,7 +23,11 @@ export class UserMessage extends BaseMessage {
         return this._rawData;
     }
     toOpenAIMessage() {
-        return { role: this.role, content: this.content, name: this.name };
+        return {
+            role: this.role,
+            content: this.content,
+            name: this.name,
+        };
     }
     toGoogleMessage() {
         return { role: this.role, parts: [{ text: this.content }] };

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

@@ -17,9 +17,8 @@ export declare function userMessage(content: string, options?: {
 export declare function assistantMessage(content: string | Array<TextPart> | null, options?: {
     name?: string;
     audio?: any | null;
-    function_call?: any | null;
     refusal?: string | null;
-    tool_calls?: Array<any>;
+    toolCalls?: Array<any>;
     rawData?: any;
 }): AssistantMessage;
 export declare function developerMessage(content: string | Array<TextPart>, options?: {
@@ -33,5 +32,6 @@ export declare function systemMessage(content: string | Array<TextPart>, options
 export declare function toolMessage(content: string | Array<TextPart>, options: {
     tool_call_id: string;
     rawData?: any;
+    name: string;
 }): ToolMessage;
 export type Message = ToolMessage | UserMessage | AssistantMessage | DeveloperMessage | SystemMessage;

package/dist/client.js

@@ -4,8 +4,13 @@ import { SmolGoogle } from "./clients/google.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { getModel, isTextModel } from "./models.js";
 import { SmolError } from "./smolError.js";
+import { getLogger } from "./logger.js";
 export function getClient(config) {
-    const apiKey = config.apiKey;
+    if (!config.openAiApiKey && !config.googleApiKey) {
+        throw new SmolError("No API key provided. Please provide an OpenAI or Google API key in the config using openAiApiKey or googleApiKey.");
+    }
+    // Initialize logger singleton with desired log level
+    const logger = getLogger(config.logLevel);
     const model = getModel(config.model);
     if (model === undefined || !isTextModel(model)) {
         throw new SmolError(`Only text models are supported currently. ${config.model} is a ${model?.type} model.`);

package/dist/clients/google.js

@@ -2,13 +2,18 @@ import { GoogleGenAI } from "@google/genai";
 import { getLogger } from "../logger.js";
 import { success, } from "../types.js";
 import { BaseClient } from "./baseClient.js";
+import { ToolCall } from "../classes/ToolCall.js";
+import { convertOpenAIToolToGoogle } from "../util/common.js";
 export class SmolGoogle extends BaseClient {
     client;
     logger;
     model;
     constructor(config) {
         super();
-        this.client = new GoogleGenAI({ apiKey: config.apiKey });
+        if (!config.googleApiKey) {
+            throw new Error("Google API key is required for SmolGoogle client.");
+        }
+        this.client = new GoogleGenAI({ apiKey: config.googleApiKey });
         this.logger = getLogger();
         this.model = config.model;
     }
@@ -17,14 +22,40 @@ export class SmolGoogle extends BaseClient {
     }
     async text(config) {
         const messages = config.messages.map((msg) => msg.toGoogleMessage());
-        // Send the prompt as the latest message
-        const result = await this.client.models.generateContent({
+        const tools = (config.tools || []).map((tool) => convertOpenAIToolToGoogle(tool));
+        const genConfig = {};
+        if (tools.length > 0) {
+            genConfig.tools = [{ functionDeclarations: tools }];
+        }
+        if (config.responseFormat && config.responseFormat.type === "json_schema") {
+            genConfig.responseMimeType = "application/json";
+            genConfig.responseJsonSchema = config.responseFormat.json_schema.schema;
+        }
+        const request = {
             contents: messages,
             model: this.model,
-        });
-        //console.log("Full response:", JSON.stringify(result, null, 2));
+            config: genConfig,
+        };
+        if (config.rawAttributes) {
+            Object.assign(request, config.rawAttributes);
+        }
+        this.logger.debug("Sending request to Google Gemini:", JSON.stringify(request, null, 2));
+        // Send the prompt as the latest message
+        const result = await this.client.models.generateContent(request);
+        this.logger.debug("Response from Google Gemini:", JSON.stringify(result, null, 2));
         const text = result.text || null;
+        const toolCalls = [];
+        result.candidates?.forEach((candidate) => {
+            if (candidate.content && candidate.content.parts) {
+                candidate.content.parts.forEach((part) => {
+                    if (part.functionCall) {
+                        const functionCall = part.functionCall;
+                        toolCalls.push(new ToolCall("", functionCall.name, functionCall.args));
+                    }
+                });
+            }
+        });
         // Return the response, updating the chat history
-        return success({ output: text, toolCalls: [] });
+        return success({ output: text, toolCalls });
     }
 }

package/dist/clients/openai.js

@@ -10,7 +10,10 @@ export class SmolOpenAi extends BaseClient {
     model;
     constructor(config) {
         super();
-        this.client = new OpenAI({ apiKey: config.apiKey });
+        if (!config.openAiApiKey) {
+            throw new Error("OpenAI API key is required for SmolOpenAi client.");
+        }
+        this.client = new OpenAI({ apiKey: config.openAiApiKey });
         this.logger = getLogger();
         this.model = config.model;
     }
@@ -19,12 +22,14 @@ export class SmolOpenAi extends BaseClient {
     }
     async text(config) {
         const messages = config.messages.map((msg) => msg.toOpenAIMessage());
-        const completion = await this.client.chat.completions.create({
+        const request = {
             model: this.model,
             messages,
             tools: config.tools,
             response_format: config.responseFormat,
-        });
+        };
+        this.logger.debug("Sending request to OpenAI:", JSON.stringify(request, null, 2));
+        const completion = await this.client.chat.completions.create(request);
         this.logger.debug("Response from OpenAI:", JSON.stringify(completion, null, 2));
         const message = completion.choices[0].message;
         const output = message.content;
@@ -40,9 +45,6 @@ export class SmolOpenAi extends BaseClient {
                 }
             }
         }
-        if (toolCalls.length > 0) {
-            this.logger.debug("Tool calls detected:", toolCalls);
-        }
         return success({ output, toolCalls });
     }
 }

package/dist/logger.js

@@ -4,6 +4,7 @@ export function getLogger(level = "error") {
     if (loggerInstance) {
         return loggerInstance;
     }
+    console.log("Initializing new logger with level", level);
     loggerInstance = new EgonLog({ level });
     return loggerInstance;
 }

package/dist/models.d.ts

@@ -60,6 +60,16 @@ export declare const textModels: readonly [{
     readonly cachedInputTokenCost: 1.25;
     readonly outputTokenCost: 10;
     readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "o3";
+    readonly description: "o3 is a reasoning model that sets a new standard for math, science, and coding, visual reasoning tasks, and technical writing. Part of the o-series of reasoning models. The knowledge cutoff for o3 models is October, 2023.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 100000;
+    readonly inputTokenCost: 2;
+    readonly cachedInputTokenCost: 1;
+    readonly outputTokenCost: 8;
+    readonly source: "openai";
 }, {
     readonly type: "text";
     readonly modelName: "o3-mini";
@@ -70,6 +80,26 @@ export declare const textModels: readonly [{
     readonly cachedInputTokenCost: 0.55;
     readonly outputTokenCost: 4.4;
     readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "o4-mini";
+    readonly description: "o4-mini is a new o-series reasoning model that replaced o3-mini, providing excellent performance for math, science, and coding tasks. Available in ChatGPT Plus, Pro, and Team.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 100000;
+    readonly inputTokenCost: 1.1;
+    readonly cachedInputTokenCost: 0.55;
+    readonly outputTokenCost: 4.4;
+    readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "o1";
+    readonly description: "o1 is a reasoning model designed to excel at complex reasoning tasks including science, math, and coding. The knowledge cutoff for o1 models is October, 2023.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 100000;
+    readonly inputTokenCost: 15;
+    readonly cachedInputTokenCost: 7.5;
+    readonly outputTokenCost: 60;
+    readonly source: "openai";
 }, {
     readonly type: "text";
     readonly modelName: "gpt-4-turbo";
@@ -100,14 +130,69 @@ export declare const textModels: readonly [{
     readonly outputTokenCost: 1.5;
     readonly disabled: true;
     readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-4.1";
+    readonly description: "GPT-4.1 supports up to 1 million tokens of context, representing a significant increase in context window capacity. Ideal for processing large documents and extended conversations.";
+    readonly maxInputTokens: 1047576;
+    readonly maxOutputTokens: 32768;
+    readonly inputTokenCost: 2.5;
+    readonly cachedInputTokenCost: 1.25;
+    readonly outputTokenCost: 10;
+    readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-3-pro-preview";
+    readonly description: "Strongest Gemini 3 model quality with 2M context window. Standard pricing for ≤200k tokens, higher rates for >200k tokens.";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 2;
+    readonly outputTokenCost: 12;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-3-flash-preview";
+    readonly description: "Latest Gemini 3 flash model with 1M context window. Excellent performance for high-volume tasks.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.5;
+    readonly outputTokenCost: 3;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-2.5-pro";
+    readonly description: "High-performance Gemini 2.5 model with 2M context window. Standard pricing for ≤200k tokens, higher rates for >200k tokens.";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 1.25;
+    readonly outputTokenCost: 10;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-2.5-flash";
+    readonly description: "Balanced Gemini 2.5 model with excellent performance-to-cost ratio. 1M context window with free tier available.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.3;
+    readonly outputTokenCost: 2.5;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-2.5-flash-lite";
+    readonly description: "Most cost-effective Gemini 2.5 option for high-throughput applications. 1M context window.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.1;
+    readonly outputTokenCost: 0.4;
+    readonly source: "google";
 }, {
     readonly type: "text";
     readonly modelName: "gemini-2.0-flash";
-    readonly description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API";
+    readonly description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 8192;
-    readonly inputTokenCost: 0.15;
-    readonly outputTokenCost: 0.6;
+    readonly inputTokenCost: 0.1;
+    readonly outputTokenCost: 0.4;
     readonly source: "google";
 }, {
     readonly type: "text";
@@ -122,7 +207,7 @@ export declare const textModels: readonly [{
 }, {
     readonly type: "text";
     readonly modelName: "gemini-2.0-flash-lite";
-    readonly description: "Our cost effective offering to support high throughput.";
+    readonly description: "Cost effective offering to support high throughput. Note: May be deprecated in favor of 2.5-flash-lite.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 0.075;
@@ -277,6 +362,16 @@ export declare function getModel(modelName: ModelName): {
     readonly cachedInputTokenCost: 1.25;
     readonly outputTokenCost: 10;
     readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "o3";
+    readonly description: "o3 is a reasoning model that sets a new standard for math, science, and coding, visual reasoning tasks, and technical writing. Part of the o-series of reasoning models. The knowledge cutoff for o3 models is October, 2023.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 100000;
+    readonly inputTokenCost: 2;
+    readonly cachedInputTokenCost: 1;
+    readonly outputTokenCost: 8;
+    readonly source: "openai";
 } | {
     readonly type: "text";
     readonly modelName: "o3-mini";
@@ -287,6 +382,26 @@ export declare function getModel(modelName: ModelName): {
     readonly cachedInputTokenCost: 0.55;
     readonly outputTokenCost: 4.4;
     readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "o4-mini";
+    readonly description: "o4-mini is a new o-series reasoning model that replaced o3-mini, providing excellent performance for math, science, and coding tasks. Available in ChatGPT Plus, Pro, and Team.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 100000;
+    readonly inputTokenCost: 1.1;
+    readonly cachedInputTokenCost: 0.55;
+    readonly outputTokenCost: 4.4;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "o1";
+    readonly description: "o1 is a reasoning model designed to excel at complex reasoning tasks including science, math, and coding. The knowledge cutoff for o1 models is October, 2023.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 100000;
+    readonly inputTokenCost: 15;
+    readonly cachedInputTokenCost: 7.5;
+    readonly outputTokenCost: 60;
+    readonly source: "openai";
 } | {
     readonly type: "text";
     readonly modelName: "gpt-4-turbo";
@@ -317,14 +432,69 @@ export declare function getModel(modelName: ModelName): {
     readonly outputTokenCost: 1.5;
     readonly disabled: true;
     readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "gpt-4.1";
+    readonly description: "GPT-4.1 supports up to 1 million tokens of context, representing a significant increase in context window capacity. Ideal for processing large documents and extended conversations.";
+    readonly maxInputTokens: 1047576;
+    readonly maxOutputTokens: 32768;
+    readonly inputTokenCost: 2.5;
+    readonly cachedInputTokenCost: 1.25;
+    readonly outputTokenCost: 10;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-3-pro-preview";
+    readonly description: "Strongest Gemini 3 model quality with 2M context window. Standard pricing for ≤200k tokens, higher rates for >200k tokens.";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 2;
+    readonly outputTokenCost: 12;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-3-flash-preview";
+    readonly description: "Latest Gemini 3 flash model with 1M context window. Excellent performance for high-volume tasks.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.5;
+    readonly outputTokenCost: 3;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-2.5-pro";
+    readonly description: "High-performance Gemini 2.5 model with 2M context window. Standard pricing for ≤200k tokens, higher rates for >200k tokens.";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 1.25;
+    readonly outputTokenCost: 10;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-2.5-flash";
+    readonly description: "Balanced Gemini 2.5 model with excellent performance-to-cost ratio. 1M context window with free tier available.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.3;
+    readonly outputTokenCost: 2.5;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-2.5-flash-lite";
+    readonly description: "Most cost-effective Gemini 2.5 option for high-throughput applications. 1M context window.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.1;
+    readonly outputTokenCost: 0.4;
+    readonly source: "google";
 } | {
     readonly type: "text";
     readonly modelName: "gemini-2.0-flash";
-    readonly description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API";
+    readonly description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 8192;
-    readonly inputTokenCost: 0.15;
-    readonly outputTokenCost: 0.6;
+    readonly inputTokenCost: 0.1;
+    readonly outputTokenCost: 0.4;
     readonly source: "google";
 } | {
     readonly type: "text";
@@ -339,7 +509,7 @@ export declare function getModel(modelName: ModelName): {
 } | {
     readonly type: "text";
     readonly modelName: "gemini-2.0-flash-lite";
-    readonly description: "Our cost effective offering to support high throughput.";
+    readonly description: "Cost effective offering to support high throughput. Note: May be deprecated in favor of 2.5-flash-lite.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 0.075;

package/dist/models.js

@@ -40,6 +40,17 @@ export const textModels = [
         outputTokenCost: 10,
         source: "openai",
     },
+    {
+        type: "text",
+        modelName: "o3",
+        description: "o3 is a reasoning model that sets a new standard for math, science, and coding, visual reasoning tasks, and technical writing. Part of the o-series of reasoning models. The knowledge cutoff for o3 models is October, 2023.",
+        maxInputTokens: 200000,
+        maxOutputTokens: 100000,
+        inputTokenCost: 2,
+        cachedInputTokenCost: 1,
+        outputTokenCost: 8,
+        source: "openai",
+    },
     {
         type: "text",
         modelName: "o3-mini",
@@ -51,6 +62,28 @@ export const textModels = [
         outputTokenCost: 4.4,
         source: "openai",
     },
+    {
+        type: "text",
+        modelName: "o4-mini",
+        description: "o4-mini is a new o-series reasoning model that replaced o3-mini, providing excellent performance for math, science, and coding tasks. Available in ChatGPT Plus, Pro, and Team.",
+        maxInputTokens: 200000,
+        maxOutputTokens: 100000,
+        inputTokenCost: 1.1,
+        cachedInputTokenCost: 0.55,
+        outputTokenCost: 4.4,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "o1",
+        description: "o1 is a reasoning model designed to excel at complex reasoning tasks including science, math, and coding. The knowledge cutoff for o1 models is October, 2023.",
+        maxInputTokens: 200000,
+        maxOutputTokens: 100000,
+        inputTokenCost: 15,
+        cachedInputTokenCost: 7.5,
+        outputTokenCost: 60,
+        source: "openai",
+    },
     {
         type: "text",
         modelName: "gpt-4-turbo",
@@ -84,14 +117,75 @@ export const textModels = [
         disabled: true,
         source: "openai",
     },
+    {
+        type: "text",
+        modelName: "gpt-4.1",
+        description: "GPT-4.1 supports up to 1 million tokens of context, representing a significant increase in context window capacity. Ideal for processing large documents and extended conversations.",
+        maxInputTokens: 1047576,
+        maxOutputTokens: 32768,
+        inputTokenCost: 2.5,
+        cachedInputTokenCost: 1.25,
+        outputTokenCost: 10,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gemini-3-pro-preview",
+        description: "Strongest Gemini 3 model quality with 2M context window. Standard pricing for ≤200k tokens, higher rates for >200k tokens.",
+        maxInputTokens: 2_097_152,
+        maxOutputTokens: 8192,
+        inputTokenCost: 2.0,
+        outputTokenCost: 12.0,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-3-flash-preview",
+        description: "Latest Gemini 3 flash model with 1M context window. Excellent performance for high-volume tasks.",
+        maxInputTokens: 1_048_576,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.5,
+        outputTokenCost: 3.0,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-2.5-pro",
+        description: "High-performance Gemini 2.5 model with 2M context window. Standard pricing for ≤200k tokens, higher rates for >200k tokens.",
+        maxInputTokens: 2_097_152,
+        maxOutputTokens: 8192,
+        inputTokenCost: 1.25,
+        outputTokenCost: 10.0,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-2.5-flash",
+        description: "Balanced Gemini 2.5 model with excellent performance-to-cost ratio. 1M context window with free tier available.",
+        maxInputTokens: 1_048_576,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.3,
+        outputTokenCost: 2.5,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-2.5-flash-lite",
+        description: "Most cost-effective Gemini 2.5 option for high-throughput applications. 1M context window.",
+        maxInputTokens: 1_048_576,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.1,
+        outputTokenCost: 0.4,
+        source: "google",
+    },
     {
         type: "text",
         modelName: "gemini-2.0-flash",
-        description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API",
+        description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window.",
         maxInputTokens: 1_048_576,
         maxOutputTokens: 8192,
-        inputTokenCost: 0.15,
-        outputTokenCost: 0.6,
+        inputTokenCost: 0.1,
+        outputTokenCost: 0.4,
         source: "google",
     },
     {
@@ -108,7 +202,7 @@ export const textModels = [
     {
         type: "text",
         modelName: "gemini-2.0-flash-lite",
-        description: "Our cost effective offering to support high throughput.",
+        description: "Cost effective offering to support high throughput. Note: May be deprecated in favor of 2.5-flash-lite.",
         maxInputTokens: 1_048_576,
         maxOutputTokens: 8192,
         inputTokenCost: 0.075,

package/dist/types.d.ts

@@ -4,18 +4,24 @@ import { ModelName } from "./models.js";
 import { Message } from "./classes/message/index.js";
 import { Result } from "./types/result.js";
 import { ToolCall } from "./classes/ToolCall.js";
-export type PromptConfig<Tool = any> = {
+import { OpenAIToolDefinition } from "./util/common.js";
+import { ResponseFormatJSONSchema, ResponseFormatText } from "openai/resources";
+export type PromptConfig = {
     messages: Message[];
-    tools?: Tool[];
+    tools?: OpenAIToolDefinition[];
     instructions?: string;
     maxTokens?: number;
     temperature?: number;
     numSuggestions?: number;
     parallelToolCalls?: boolean;
-    responseFormat?: any;
+    responseFormat?: ResponseFormatText | ResponseFormatJSONSchema;
+    rawAttributes?: Record<string, any>;
 };
+export declare function responseFormatText(): ResponseFormatText;
+export declare function responseFormatJSONSchema(schema: ResponseFormatJSONSchema.JSONSchema): ResponseFormatJSONSchema;
 export type SmolConfig = {
-    apiKey: string;
+    openAiApiKey?: string;
+    googleApiKey?: string;
     model: ModelName;
     logLevel?: LogLevel;
 };

package/dist/types.js

@@ -1 +1,7 @@
 export * from "./types/result.js";
+export function responseFormatText() {
+    return { type: "text" };
+}
+export function responseFormatJSONSchema(schema) {
+    return { type: "json_schema", json_schema: schema };
+}

package/dist/util/common.d.ts

@@ -0,0 +1,54 @@
+import { FunctionDeclaration } from "@google/genai";
+/**
+ * OpenAI tool definition format
+ */
+export interface OpenAIToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+/**
+ * Converts an OpenAI tool definition to a Google FunctionDeclaration format
+ *
+ * @param openAITool - The tool definition in OpenAI format
+ * @returns The tool definition in Google FunctionDeclaration format
+ *
+ * @example
+ * ```ts
+ * const openAITool = {
+ *   type: "function" as const,
+ *   function: {
+ *     name: "add",
+ *     description: "Adds two numbers together",
+ *     parameters: {
+ *       type: "object",
+ *       properties: {
+ *         a: { type: "number", description: "First number" },
+ *         b: { type: "number", description: "Second number" }
+ *       },
+ *       required: ["a", "b"],
+ *       additionalProperties: false
+ *     }
+ *   }
+ * };
+ *
+ * const googleTool = convertOpenAIToolToGoogle(openAITool);
+ * // Returns:
+ * // {
+ * //   name: "add",
+ * //   description: "Adds two numbers together",
+ * //   parametersJsonSchema: {
+ * //     type: "object",
+ * //     properties: {
+ * //       a: { type: "number", description: "First number" },
+ * //       b: { type: "number", description: "Second number" }
+ * //     },
+ * //     required: ["a", "b"]
+ * //   }
+ * // }
+ * ```
+ */
+export declare function convertOpenAIToolToGoogle(openAITool: OpenAIToolDefinition): FunctionDeclaration;

package/dist/util/common.js

@@ -0,0 +1,75 @@
+/**
+ * Removes properties that Google's API doesn't support from JSON schemas
+ */
+function removeUnsupportedProperties(obj) {
+    if (typeof obj === "object" && obj !== null) {
+        const newObj = { ...obj };
+        // Remove properties that Google's API doesn't support
+        delete newObj.additionalProperties;
+        delete newObj.$schema;
+        delete newObj.strict;
+        // Recursively process nested objects and arrays
+        for (const key in newObj) {
+            if (key in newObj) {
+                if (Array.isArray(newObj[key])) {
+                    newObj[key] = newObj[key].map((item) => typeof item === "object" && item !== null
+                        ? removeUnsupportedProperties(item)
+                        : item);
+                }
+                else if (typeof newObj[key] === "object" && newObj[key] !== null) {
+                    newObj[key] = removeUnsupportedProperties(newObj[key]);
+                }
+            }
+        }
+        return newObj;
+    }
+    return obj;
+}
+/**
+ * Converts an OpenAI tool definition to a Google FunctionDeclaration format
+ *
+ * @param openAITool - The tool definition in OpenAI format
+ * @returns The tool definition in Google FunctionDeclaration format
+ *
+ * @example
+ * ```ts
+ * const openAITool = {
+ *   type: "function" as const,
+ *   function: {
+ *     name: "add",
+ *     description: "Adds two numbers together",
+ *     parameters: {
+ *       type: "object",
+ *       properties: {
+ *         a: { type: "number", description: "First number" },
+ *         b: { type: "number", description: "Second number" }
+ *       },
+ *       required: ["a", "b"],
+ *       additionalProperties: false
+ *     }
+ *   }
+ * };
+ *
+ * const googleTool = convertOpenAIToolToGoogle(openAITool);
+ * // Returns:
+ * // {
+ * //   name: "add",
+ * //   description: "Adds two numbers together",
+ * //   parametersJsonSchema: {
+ * //     type: "object",
+ * //     properties: {
+ * //       a: { type: "number", description: "First number" },
+ * //       b: { type: "number", description: "Second number" }
+ * //     },
+ * //     required: ["a", "b"]
+ * //   }
+ * // }
+ * ```
+ */
+export function convertOpenAIToolToGoogle(openAITool) {
+    return {
+        name: openAITool.function.name,
+        description: openAITool.function.description,
+        parametersJsonSchema: removeUnsupportedProperties(openAITool.function.parameters),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {
@@ -31,8 +31,10 @@
   "license": "ISC",
   "devDependencies": {
     "@types/node": "^25.0.3",
+    "termcolors": "github:egonSchiele/termcolors",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.16",
+    "zod": "^4.3.5"
   },
   "dependencies": {
     "@google/genai": "^1.34.0",