smoltalk 0.0.3 → 0.0.5

package/dist/classes/ToolCall.d.ts

@@ -0,0 +1,11 @@
+export type ToolCallOptions = {};
+export declare class ToolCall {
+    private _id;
+    private _name;
+    private _arguments;
+    private logger;
+    constructor(id: string, name: string, args: Record<string, any> | string, options?: ToolCallOptions);
+    get id(): string;
+    get name(): string;
+    get arguments(): Record<string, any>;
+}

package/dist/classes/ToolCall.js

@@ -0,0 +1,33 @@
+import { getLogger } from "../logger.js";
+export class ToolCall {
+    _id;
+    _name;
+    _arguments;
+    logger;
+    constructor(id, name, args, options = {}) {
+        this._id = id;
+        this._name = name;
+        this.logger = getLogger();
+        if (typeof args === "string") {
+            try {
+                this._arguments = JSON.parse(args);
+            }
+            catch (e) {
+                this.logger.error(`Failed to parse arguments for ToolCall ${name} with id ${id}:`, e, args);
+                this._arguments = {};
+            }
+        }
+        else {
+            this._arguments = args;
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    get name() {
+        return this._name;
+    }
+    get arguments() {
+        return this._arguments;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { BaseMessage, MessageClass } from "./BaseMessage.js";
+import { TextPart } from "../../types.js";
+import { ChatCompletionMessageParam } from "openai/resources";
+import { Content } from "@google/genai";
+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>;
+    _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>;
+        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 rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/AssistantMessage.js

@@ -0,0 +1,56 @@
+import { BaseMessage } from "./BaseMessage.js";
+export class AssistantMessage extends BaseMessage {
+    _role = "assistant";
+    _content;
+    _name;
+    _audio;
+    _function_call;
+    _refusal;
+    _tool_calls;
+    _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._rawData = options.rawData;
+    }
+    get content() {
+        if (this._content === null || this._content === undefined) {
+            return "";
+        }
+        return typeof this._content === "string"
+            ? this._content
+            : JSON.stringify(this._content);
+    }
+    get role() {
+        return this._role;
+    }
+    get name() {
+        return this._name;
+    }
+    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 rawData() {
+        return this._rawData;
+    }
+    toOpenAIMessage() {
+        return { role: this.role, content: this.content, name: this.name };
+    }
+    toGoogleMessage() {
+        return { role: "model", parts: [{ text: this.content }] };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Content } from "@google/genai";
+import { ChatCompletionMessageParam } from "openai/resources";
+export declare class BaseMessage {
+}
+export interface MessageClass {
+    get content(): string;
+    get role(): string;
+    get name(): string | undefined;
+    get rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/BaseMessage.js

@@ -0,0 +1,2 @@
+export class BaseMessage {
+}

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

@@ -0,0 +1,20 @@
+import { BaseMessage, MessageClass } from "./BaseMessage.js";
+import { TextPart } from "../../types.js";
+import { ChatCompletionMessageParam } from "openai/resources";
+import { Content } from "@google/genai";
+export declare class DeveloperMessage extends BaseMessage implements MessageClass {
+    _role: "developer";
+    _content: string | Array<TextPart>;
+    _name?: string;
+    _rawData?: any;
+    constructor(content: string | Array<TextPart>, options?: {
+        name?: string;
+        rawData?: any;
+    });
+    get content(): string;
+    get role(): "developer";
+    get name(): string | undefined;
+    get rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/DeveloperMessage.js

@@ -0,0 +1,33 @@
+import { BaseMessage } from "./BaseMessage.js";
+export class DeveloperMessage extends BaseMessage {
+    _role = "developer";
+    _content;
+    _name;
+    _rawData;
+    constructor(content, options = {}) {
+        super();
+        this._content = content;
+        this._name = options.name;
+        this._rawData = options.rawData;
+    }
+    get content() {
+        return typeof this._content === "string"
+            ? this._content
+            : JSON.stringify(this._content);
+    }
+    get role() {
+        return this._role;
+    }
+    get name() {
+        return this._name;
+    }
+    get rawData() {
+        return this._rawData;
+    }
+    toOpenAIMessage() {
+        return { role: this.role, content: this.content, name: this.name };
+    }
+    toGoogleMessage() {
+        return { role: this.role, parts: [{ text: this.content }] };
+    }
+}

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

@@ -0,0 +1,20 @@
+import { BaseMessage, MessageClass } from "./BaseMessage.js";
+import { TextPart } from "../../types.js";
+import { ChatCompletionMessageParam } from "openai/resources";
+import { Content } from "@google/genai";
+export declare class SystemMessage extends BaseMessage implements MessageClass {
+    _role: "system";
+    _content: string | Array<TextPart>;
+    _name?: string;
+    _rawData?: any;
+    constructor(content: string | Array<TextPart>, options?: {
+        name?: string;
+        rawData?: any;
+    });
+    get content(): string;
+    get role(): "system";
+    get name(): string | undefined;
+    get rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/SystemMessage.js

@@ -0,0 +1,33 @@
+import { BaseMessage } from "./BaseMessage.js";
+export class SystemMessage extends BaseMessage {
+    _role = "system";
+    _content;
+    _name;
+    _rawData;
+    constructor(content, options = {}) {
+        super();
+        this._content = content;
+        this._name = options.name;
+        this._rawData = options.rawData;
+    }
+    get content() {
+        return typeof this._content === "string"
+            ? this._content
+            : JSON.stringify(this._content);
+    }
+    get role() {
+        return this._role;
+    }
+    get name() {
+        return this._name;
+    }
+    get rawData() {
+        return this._rawData;
+    }
+    toOpenAIMessage() {
+        return { role: this.role, content: this.content, name: this.name };
+    }
+    toGoogleMessage() {
+        return { role: this.role, parts: [{ text: this.content }] };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { BaseMessage, MessageClass } from "./BaseMessage.js";
+import { TextPart } from "../../types.js";
+import { ChatCompletionMessageParam } from "openai/resources";
+import { Content } from "@google/genai";
+export declare class ToolMessage extends BaseMessage implements MessageClass {
+    _role: "tool";
+    _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;
+    get tool_call_id(): string;
+    get rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/ToolMessage.js

@@ -0,0 +1,51 @@
+import { BaseMessage } from "./BaseMessage.js";
+export class ToolMessage extends BaseMessage {
+    _role = "tool";
+    _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"
+            ? this._content
+            : JSON.stringify(this._content);
+    }
+    get role() {
+        return this._role;
+    }
+    get name() {
+        return this._name;
+    }
+    get tool_call_id() {
+        return this._tool_call_id;
+    }
+    get rawData() {
+        return this._rawData;
+    }
+    toOpenAIMessage() {
+        return {
+            role: this.role,
+            content: this.content,
+            tool_call_id: this.tool_call_id,
+        };
+    }
+    toGoogleMessage() {
+        return {
+            role: "user", parts: [{
+                    functionResponse: {
+                        name: this.name,
+                        response: {
+                            result: this.content
+                        }
+                    }
+                }]
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+import { BaseMessage, MessageClass } from "./BaseMessage.js";
+import { ChatCompletionMessageParam } from "openai/resources";
+import { Content } from "@google/genai";
+export declare class UserMessage extends BaseMessage implements MessageClass {
+    _role: "user";
+    _content: string;
+    _name?: string;
+    _rawData?: any;
+    constructor(content: string, options?: {
+        name?: string;
+        rawData?: any;
+    });
+    get content(): string;
+    get role(): "user";
+    get name(): string | undefined;
+    get rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/UserMessage.js

@@ -0,0 +1,31 @@
+import { BaseMessage } from "./BaseMessage.js";
+export class UserMessage extends BaseMessage {
+    _role = "user";
+    _content;
+    _name;
+    _rawData;
+    constructor(content, options = {}) {
+        super();
+        this._content = content;
+        this._name = options.name;
+        this._rawData = options.rawData;
+    }
+    get content() {
+        return this._content;
+    }
+    get role() {
+        return this._role;
+    }
+    get name() {
+        return this._name;
+    }
+    get rawData() {
+        return this._rawData;
+    }
+    toOpenAIMessage() {
+        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

@@ -0,0 +1,38 @@
+import { UserMessage } from "./UserMessage.js";
+import { AssistantMessage } from "./AssistantMessage.js";
+import { DeveloperMessage } from "./DeveloperMessage.js";
+import { SystemMessage } from "./SystemMessage.js";
+import { ToolMessage } from "./ToolMessage.js";
+import { TextPart } from "../../types.js";
+export * from "./AssistantMessage.js";
+export * from "./BaseMessage.js";
+export * from "./DeveloperMessage.js";
+export * from "./SystemMessage.js";
+export * from "./ToolMessage.js";
+export * from "./UserMessage.js";
+export declare function userMessage(content: string, options?: {
+    name?: string;
+    rawData?: any;
+}): UserMessage;
+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>;
+    rawData?: any;
+}): AssistantMessage;
+export declare function developerMessage(content: string | Array<TextPart>, options?: {
+    name?: string;
+    rawData?: any;
+}): DeveloperMessage;
+export declare function systemMessage(content: string | Array<TextPart>, options?: {
+    name?: string;
+    rawData?: any;
+}): SystemMessage;
+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/classes/message/index.js

@@ -0,0 +1,26 @@
+import { UserMessage } from "./UserMessage.js";
+import { AssistantMessage } from "./AssistantMessage.js";
+import { DeveloperMessage } from "./DeveloperMessage.js";
+import { SystemMessage } from "./SystemMessage.js";
+import { ToolMessage } from "./ToolMessage.js";
+export * from "./AssistantMessage.js";
+export * from "./BaseMessage.js";
+export * from "./DeveloperMessage.js";
+export * from "./SystemMessage.js";
+export * from "./ToolMessage.js";
+export * from "./UserMessage.js";
+export function userMessage(content, options = {}) {
+    return new UserMessage(content, options);
+}
+export function assistantMessage(content, options = {}) {
+    return new AssistantMessage(content, options);
+}
+export function developerMessage(content, options = {}) {
+    return new DeveloperMessage(content, options);
+}
+export function systemMessage(content, options = {}) {
+    return new SystemMessage(content, options);
+}
+export function toolMessage(content, options) {
+    return new ToolMessage(content, options);
+}

package/dist/client.d.ts

@@ -3,4 +3,4 @@ export * from "./clients/openai.js";
 import { SmolGoogle } from "./clients/google.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { SmolConfig } from "./types.js";
-export declare function getClient(config: SmolConfig): SmolOpenAi | SmolGoogle;
+export declare function getClient(config: SmolConfig): SmolGoogle | SmolOpenAi;

package/dist/client.js

@@ -1,18 +1,21 @@
 export * from "./clients/google.js";
 export * from "./clients/openai.js";
-import { EgonLog } from "egonlog";
 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;
-    const logger = new EgonLog({ level: config.logLevel || "info" });
+    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.`);
     }
-    const clientConfig = { ...config, logger };
+    const clientConfig = { ...config };
     switch (model.source) {
         case "openai":
             return new SmolOpenAi(clientConfig);

package/dist/clients/baseClient.d.ts

@@ -0,0 +1,5 @@
+import { PromptConfig, PromptResult, Result, SmolClient } from "../types.js";
+export declare class BaseClient implements SmolClient {
+    text(config: PromptConfig): Promise<Result<PromptResult>>;
+    prompt(text: string, config?: PromptConfig): Promise<Result<PromptResult>>;
+}

package/dist/clients/baseClient.js

@@ -0,0 +1,14 @@
+import { userMessage } from "../classes/message/index.js";
+export class BaseClient {
+    text(config) {
+        throw new Error("Method not implemented.");
+    }
+    prompt(text, config) {
+        const msg = userMessage(text);
+        const promptConfig = {
+            ...config,
+            messages: config?.messages ? [...config.messages, msg] : [msg],
+        };
+        return this.text(promptConfig);
+    }
+}

package/dist/clients/google.d.ts

@@ -1,11 +1,12 @@
 import { GoogleGenAI } from "@google/genai";
-import { BaseClientConfig, PromptConfig, PromptResult, Result } from "../types.js";
+import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient } from "../types.js";
+import { BaseClient } from "./baseClient.js";
 export type SmolGoogleConfig = BaseClientConfig;
-export declare class SmolGoogle implements SmolClient {
+export declare class SmolGoogle extends BaseClient implements SmolClient {
     private client;
     private logger;
     private model;
     constructor(config: SmolGoogleConfig);
     getClient(): GoogleGenAI;
-    text(content: string, config?: PromptConfig): Promise<Result<PromptResult>>;
+    text(config: PromptConfig): Promise<Result<PromptResult>>;
 }

package/dist/clients/google.js

@@ -1,39 +1,57 @@
-// @ts-nocheck
 import { GoogleGenAI } from "@google/genai";
+import { getLogger } from "../logger.js";
 import { success, } from "../types.js";
-export class SmolGoogle {
+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) {
-        this.client = new GoogleGenAI({ apiKey: config.apiKey });
-        this.logger = config.logger;
+        super();
+        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;
     }
     getClient() {
         return this.client;
     }
-    async text(content, config) {
-        const messages = structuredClone(config?.messages) || [];
-        messages.push({ role: "user", content });
-        /*   const contents = messages.map((message) => ({
-        role: message.role === "user" ? "user" : "model", // Use consistent roles
-        parts: [makePart(message)] as Part[],
-      }));
-    
-      role: "user",
-      parts: [{ text: sanitizedPrompt }],
-    });
-      contents.push({
-    */
-        // Send the prompt as the latest message
-        const result = await this.client.models.generateContent({
-            contents: content,
+    async text(config) {
+        const messages = config.messages.map((msg) => msg.toGoogleMessage());
+        const tools = (config.tools || []).map((tool) => convertOpenAIToolToGoogle(tool));
+        const genConfig = {};
+        if (tools.length > 0) {
+            genConfig.tools = [{ functionDeclarations: tools }];
+        }
+        const request = {
+            contents: messages,
             model: this.model,
+            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));
+                    }
+                });
+            }
         });
-        //console.log("Full response:", JSON.stringify(result, null, 2));
-        const text = result.text;
         // Return the response, updating the chat history
-        return success({ output: result.text, toolCalls: [] });
+        return success({ output: text, toolCalls });
     }
 }

package/dist/clients/openai.d.ts

@@ -1,11 +1,12 @@
 import OpenAI from "openai";
 import { BaseClientConfig, PromptConfig, PromptResult, Result, SmolClient } from "../types.js";
+import { BaseClient } from "./baseClient.js";
 export type SmolOpenAiConfig = BaseClientConfig;
-export declare class SmolOpenAi implements SmolClient {
+export declare class SmolOpenAi extends BaseClient implements SmolClient {
     private client;
     private logger;
     private model;
     constructor(config: SmolOpenAiConfig);
     getClient(): OpenAI;
-    text(content: string, config?: PromptConfig): Promise<Result<PromptResult>>;
+    text(config: PromptConfig): Promise<Result<PromptResult>>;
 }