smoltalk 0.0.2 → 0.0.4

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: this.role, 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,21 @@
+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;
+    constructor(content: string | Array<TextPart>, options: {
+        tool_call_id: string;
+        rawData?: any;
+    });
+    get content(): string;
+    get role(): "tool";
+    get name(): string | undefined;
+    get tool_call_id(): string;
+    get rawData(): any;
+    toOpenAIMessage(): ChatCompletionMessageParam;
+    toGoogleMessage(): Content;
+}

package/dist/classes/message/ToolMessage.js

@@ -0,0 +1,40 @@
+import { BaseMessage } from "./BaseMessage.js";
+export class ToolMessage extends BaseMessage {
+    _role = "tool";
+    _content;
+    _tool_call_id;
+    _rawData;
+    constructor(content, options) {
+        super();
+        this._content = content;
+        this._tool_call_id = options.tool_call_id;
+        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 undefined;
+    }
+    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: this.role, parts: [{ text: 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,37 @@
+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;
+}): 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/{lib/client.d.ts → 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/{lib/client.js → client.js}

@@ -4,15 +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 { EgonLog } from "egonlog";
 export function getClient(config) {
     const apiKey = config.apiKey;
-    const logger = new EgonLog({ level: config.logLevel || "info" });
     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

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

package/dist/clients/google.js

@@ -0,0 +1,30 @@
+import { GoogleGenAI } from "@google/genai";
+import { getLogger } from "../logger.js";
+import { success, } from "../types.js";
+import { BaseClient } from "./baseClient.js";
+export class SmolGoogle extends BaseClient {
+    client;
+    logger;
+    model;
+    constructor(config) {
+        super();
+        this.client = new GoogleGenAI({ apiKey: config.apiKey });
+        this.logger = getLogger();
+        this.model = config.model;
+    }
+    getClient() {
+        return this.client;
+    }
+    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({
+            contents: messages,
+            model: this.model,
+        });
+        //console.log("Full response:", JSON.stringify(result, null, 2));
+        const text = result.text || null;
+        // Return the response, updating the chat history
+        return success({ output: text, toolCalls: [] });
+    }
+}

package/dist/{lib/clients → 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>>;
 }

package/dist/{lib/clients → clients}/openai.js

@@ -1,26 +1,29 @@
 import OpenAI from "openai";
 import { success, } from "../types.js";
-import { isFunctionToolCall, openAIToToolCall } from "../util.js";
-export class SmolOpenAi {
+import { ToolCall } from "../classes/ToolCall.js";
+import { isFunctionToolCall } from "../util.js";
+import { getLogger } from "../logger.js";
+import { BaseClient } from "./baseClient.js";
+export class SmolOpenAi extends BaseClient {
     client;
     logger;
     model;
     constructor(config) {
+        super();
         this.client = new OpenAI({ apiKey: config.apiKey });
-        this.logger = config.logger;
+        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 });
+    async text(config) {
+        const messages = config.messages.map((msg) => msg.toOpenAIMessage());
         const completion = await this.client.chat.completions.create({
             model: this.model,
             messages,
-            tools: config?.tools,
-            response_format: config?.responseFormat,
+            tools: config.tools,
+            response_format: config.responseFormat,
         });
         this.logger.debug("Response from OpenAI:", JSON.stringify(completion, null, 2));
         const message = completion.choices[0].message;
@@ -30,7 +33,7 @@ export class SmolOpenAi {
         if (_toolCalls) {
             for (const tc of _toolCalls) {
                 if (isFunctionToolCall(tc)) {
-                    toolCalls.push(openAIToToolCall(tc));
+                    toolCalls.push(new ToolCall(tc.id, tc.function.name, tc.function.arguments));
                 }
                 else {
                     this.logger.warn(`Unsupported tool call type: ${tc.type} for tool call ID: ${tc.id}`);
@@ -38,7 +41,7 @@ export class SmolOpenAi {
             }
         }
         if (toolCalls.length > 0) {
-            this.logger.info("Tool calls detected:", toolCalls);
+            this.logger.debug("Tool calls detected:", toolCalls);
         }
         return success({ output, toolCalls });
     }

package/dist/index.d.ts

@@ -1 +1,6 @@
-export {};
+export * from "./client.js";
+export * from "./types.js";
+export * from "./models.js";
+export * from "./smolError.js";
+export * from "./util.js";
+export * from "./classes/message/index.js";

package/dist/index.js

@@ -1,37 +1,6 @@
-import { getClient } from "./lib/client.js";
-function add({ a, b }) {
-    return a + b;
-}
-// Define the function tool for OpenAI
-const addTool = {
-    type: "function",
-    function: {
-        name: "add",
-        description: "Adds two numbers together and returns the result.",
-        parameters: {
-            type: "object",
-            properties: {
-                a: {
-                    type: "number",
-                    description: "The first number to add",
-                },
-                b: {
-                    type: "number",
-                    description: "The second number to add",
-                },
-            },
-            required: ["a", "b"],
-            additionalProperties: false,
-        },
-    },
-};
-const client = getClient({
-    apiKey: process.env.OPENAI_API_KEY || "",
-    logLevel: "debug",
-    model: "gpt-4o-mini",
-});
-async function main() {
-    const resp = await client.text("add 2 + 2", { tools: [addTool] });
-    console.log(resp);
-}
-main();
+export * from "./client.js";
+export * from "./types.js";
+export * from "./models.js";
+export * from "./smolError.js";
+export * from "./util.js";
+export * from "./classes/message/index.js";

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import { EgonLog, LogLevel } from "egonlog";
+export declare function getLogger(level?: LogLevel): EgonLog;

package/dist/logger.js

@@ -0,0 +1,9 @@
+import { EgonLog } from "egonlog";
+let loggerInstance = null;
+export function getLogger(level = "error") {
+    if (loggerInstance) {
+        return loggerInstance;
+    }
+    loggerInstance = new EgonLog({ level });
+    return loggerInstance;
+}

package/dist/{lib/types.d.ts → types.d.ts}

@@ -1,14 +1,12 @@
 export * from "./types/result.js";
-import { EgonLog, LogLevel } from "egonlog";
+import { LogLevel } from "egonlog";
 import { ModelName } from "./models.js";
-import { Result } from "./index.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> = {
+    messages: Message[];
     tools?: Tool[];
-    messages?: {
-        role: string;
-        content: string;
-        name?: string;
-    }[];
     instructions?: string;
     maxTokens?: number;
     temperature?: number;
@@ -21,18 +19,16 @@ export type SmolConfig = {
     model: ModelName;
     logLevel?: LogLevel;
 };
-export type BaseClientConfig = SmolConfig & {
-    logger: EgonLog;
-};
-export type ToolCall = {
-    id: string;
-    name: string;
-    arguments: Record<string, any>;
-};
+export type BaseClientConfig = SmolConfig & {};
 export type PromptResult = {
     output: string | null;
     toolCalls: ToolCall[];
 };
 export interface SmolClient {
-    text(content: string, config?: PromptConfig): Promise<Result<PromptResult>>;
+    text(config: PromptConfig): Promise<Result<PromptResult>>;
+    prompt(text: string, config?: PromptConfig): Promise<Result<PromptResult>>;
 }
+export type TextPart = {
+    type: "text";
+    text: string;
+};

package/dist/{lib/util → util}/openai.d.ts

@@ -1,4 +1,2 @@
 import { ChatCompletionMessageFunctionToolCall, ChatCompletionMessageToolCall } from "openai/resources";
-import { ToolCall } from "../types.js";
-export declare function openAIToToolCall(toolCall: ChatCompletionMessageFunctionToolCall): ToolCall;
 export declare function isFunctionToolCall(message: ChatCompletionMessageToolCall): message is ChatCompletionMessageFunctionToolCall;

package/dist/util/openai.js

@@ -0,0 +1,3 @@
+export function isFunctionToolCall(message) {
+    return message.type === "function";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "scripts": {

package/dist/lib/clients/google.d.ts

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

package/dist/lib/clients/google.js

@@ -1,39 +0,0 @@
-// @ts-nocheck
-import { GoogleGenAI } from "@google/genai";
-import { success, } from "../types.js";
-export class SmolGoogle {
-    client;
-    logger;
-    model;
-    constructor(config) {
-        this.client = new GoogleGenAI({ apiKey: config.apiKey });
-        this.logger = config.logger;
-        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,
-            model: this.model,
-        });
-        //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: [] });
-    }
-}

package/dist/lib/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./client.js";
-export * from "./types.js";
-export * from "./models.js";
-export * from "./smolError.js";

package/dist/lib/index.js

@@ -1,4 +0,0 @@
-export * from "./client.js";
-export * from "./types.js";
-export * from "./models.js";
-export * from "./smolError.js";

package/dist/lib/util/openai.js

@@ -1,10 +0,0 @@
-export function openAIToToolCall(toolCall) {
-    return {
-        id: toolCall.id,
-        name: toolCall.function.name,
-        arguments: JSON.parse(toolCall.function.arguments),
-    };
-}
-export function isFunctionToolCall(message) {
-    return message.type === "function";
-}