smoltalk 0.0.1

package/README.md

@@ -0,0 +1,222 @@
+# Typestache: static typing for mustache
+
+> Get your templates to "if it compiles, it probably works!"
+
+Typestache is still a work in progress. Use with caution.
+
+## Quickstart
+Install Typestache:
+
+```bash
+npm install typestache
+```
+
+Typestache consists of a CLI tool and a library. To use it, point the CLI tool towards your template directory:
+
+```bash
+typestache src/templates
+```
+
+Typestache will find your mustache files, and create a corresponding TypeScript file:
+
+```bash
+src/templates
+  - myTemplate.mustache
+  - myTemplate.ts
+```
+
+Now simply import this TypeScript file and render it.
+
+```typescript
+import myTemplate from './myTemplate';
+
+const data = {
+  name: 'Adit',
+  value: 10000,
+  in_ca: true
+};
+
+const result = myTemplate(data);
+```
+
+Easy as that! Behind the scenes, Typestache has converted your mustache template into a typed template for you, so if you have a type error, TypeScript will tell you. Example:
+
+```typescript
+const data = {
+  name: 'Adit',
+  value: 10000,
+  in_ca: "true" // Oops, this should be a boolean
+};
+
+const result = myTemplate(data); // Error: Type 'string' is not assignable to type 'boolean'.
+```
+
+[See examples here](https://github.com/egonSchiele/typestache/tree/main/examples).
+
+Typestache also extends mustache syntax to add type hints. Here's a short example:
+
+```mustache
+I am {{age:number}} years old.
+```
+
+Now `age` will be a `number` in the generated TypeScript file.
+
+**Heads up, typestache is *not* a drop-in replacement for mustache.** Read more below.
+
+## Deriving types
+
+Typestache will automatically derive types for you. For example, given this template
+
+```mustache
+{{#person}}
+  Hello, {{name}}!
+{{/person}}
+```
+
+Typestache will derive this type:
+
+```typescript
+type TemplateType = {
+  person: boolean;
+  name: string | boolean | number;
+};
+```
+
+## Specifying types
+If you know what type something will be, you can tell typestache. For example, in the above example, we know `name` is a `string`. Here's how we can tell typestache:
+
+```mustache
+{{#person}}
+  Hello, {{name:string}}!
+{{/person}}
+```
+
+and here's the derived type:
+
+```typescript
+type TemplateType = {
+  person: boolean;
+  name: string;
+};
+```
+
+Here is another example. `amount` can be a `string` or a `number`, so we have used a union here.
+
+```mustache
+{{#person}}
+  Hello, {{name:string}}! You have {{amount:string|number}} in your account.
+{{/person}}
+```
+
+and here's the derived type:
+
+```typescript
+type TemplateType = {
+  person: boolean;
+  name: string;
+  amount: string | number; 
+};
+```
+
+### Sections and scoping
+
+In all these examples, you'll notice `name` is never a key. `person` is always a `boolean`, it's never an object with a key `name`. Mustache has very loose scoping rules. Deriving a type for this template 
+
+```mustache
+{{#person}}
+  Hello, {{name}}!
+{{/person}}
+```
+
+in mustache might look something like this:
+
+```typescript
+type TemplateType = {
+  person: boolean;
+  name: string | boolean | number;
+} | {
+  person: {
+    name: string | boolean | number;
+  }
+} | {
+  person: {
+    name: string | boolean | number;
+  }
+}[]
+```
+
+Even that's not enough, since technically, `person` could be any truthy value, and `person` and `name` could both be `undefined`.
+
+A type like this is harder to read, and reduces type safety. Things look even worse as you have more sections, and more variables. So typestache chooses to interpret every variable as if it's in the global context. If you want `name` to be a key on `person`, use the new `this` keyword:
+
+```mustache
+{{#person}}
+  Hello, {{this.name}}!
+{{/person}}
+```
+
+Generates this type:
+
+```typescript
+type TemplateType = {
+  person: {
+    name: string | boolean | number;
+  }
+}
+```
+
+You'll also notice `person` is an object. If you want it to be an array of objects, use `[]` after the name in the opening tag:
+
+```mustache
+{{#person[]}}
+  Hello, {{this.name}}!
+{{/person}}
+```
+
+
+Generates this type:
+
+```typescript
+type TemplateType = {
+  person: {
+    name: string | boolean | number;
+  }[];
+}
+```
+
+### Optionals
+
+Finally, typestache makes all variables required by default. You can make something optional by adding a question mark at the end of the name, like this:
+
+```mustache
+  Hello, {{name?:string}}!
+```
+
+Generates this type:
+
+```typescript
+type TemplateType = {
+  name?: string;
+}
+```
+
+## Typestache doesn't implement the entire mustache spec.
+
+There are several parts of the mustache spec that Typestache does not implement. The most important one to know about is that Typestache handles scope differently. Mustache is very loose with its scoping, which makes it hard to write a useful type for it.
+
+Here are some other things not currently supported:
+
+Eventual support:
+
+- Nested sections
+- Lambdas (no support for dynamic templates)
+- partials
+
+No support planned:
+
+- Dynamic names
+- blocks
+- parents
+- custom delimiter tags.
+
+For the ones where there is no support planned, mostly it's because the feature would be very hard or impossible to type correctly. The nature of dynamic partials, for example, means we don't know what will be generated until runtime, which makes it impossible to type.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,11 @@
+import { getClient } from "./lib/client.js";
+const client = getClient({
+    apiKey: process.env.GEMINI_API_KEY || "",
+    logLevel: "debug",
+    model: "gemini-2.0-flash-lite",
+});
+async function main() {
+    const resp = await client.text("Hello, how are you?");
+    console.log(resp);
+}
+main();

package/dist/lib/client.d.ts

@@ -0,0 +1,6 @@
+export * from "./clients/google.js";
+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;

package/dist/lib/client.js

@@ -0,0 +1,26 @@
+export * from "./clients/google.js";
+export * from "./clients/openai.js";
+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 };
+    switch (model.source) {
+        case "openai":
+            return new SmolOpenAi(clientConfig);
+            break;
+        case "google":
+            return new SmolGoogle(clientConfig);
+            break;
+        default:
+            throw new SmolError(`Model source ${model.source} is not supported.`);
+    }
+}

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,39 @@
+// @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 });
+    }
+}

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

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

package/dist/lib/clients/openai.js

@@ -0,0 +1,28 @@
+import OpenAI from "openai";
+import { success, } from "../types.js";
+export class SmolOpenAi {
+    client;
+    logger;
+    model;
+    constructor(config) {
+        this.client = new OpenAI({ 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 response = await this.client.responses.create({
+            model: this.model,
+            instructions: config?.instructions,
+            input: content,
+            max_output_tokens: config?.maxTokens,
+            temperature: config?.temperature,
+            parallel_tool_calls: config?.parallelToolCalls,
+        });
+        return success({ output: response.output_text });
+    }
+}

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

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

package/dist/lib/models.d.ts

@@ -0,0 +1,460 @@
+export type ModelSource = "local" | "debug" | "local-ollama" | "openai" | "anthropic" | "google" | "replicate" | "modal";
+export type BaseModel = {
+    modelName: string;
+    source: ModelSource;
+    description?: string;
+    inputTokenCost?: number;
+    cachedInputTokenCost?: number;
+    outputTokenCost?: number;
+    disabled?: boolean;
+    costUnit?: "tokens" | "characters" | "minutes";
+};
+export type SpeechToTextModel = BaseModel & {
+    type: "speech-to-text";
+    perMinuteCost?: number;
+};
+export type ImageModel = BaseModel & {
+    type: "image";
+    costPerImage?: number;
+    outputType?: "FileOutput" | "Array";
+};
+export type TextModel = BaseModel & {
+    type: "text";
+    modelName: string;
+    maxInputTokens: number;
+    maxOutputTokens: number;
+};
+export type EmbeddingsModel = {
+    type: "embeddings";
+    modelName: string;
+    tokenCost?: number;
+};
+export type Model = SpeechToTextModel | TextModel | EmbeddingsModel | ImageModel;
+export declare const speechToTextModels: readonly [{
+    readonly type: "speech-to-text";
+    readonly modelName: "whisper-local";
+    readonly source: "local";
+}, {
+    readonly type: "speech-to-text";
+    readonly modelName: "whisper-web";
+    readonly perMinuteCost: 0.006;
+    readonly source: "openai";
+}];
+export declare const textModels: readonly [{
+    readonly type: "text";
+    readonly modelName: "gpt-4o-mini";
+    readonly description: "GPT-4o mini (“o” for “omni”) is a fast, affordable small model for focused tasks. It accepts both text and image inputs, and produces text outputs (including Structured Outputs). It is ideal for fine-tuning, and model outputs from a larger model like GPT-4o can be distilled to GPT-4o-mini to produce similar results at lower cost and latency. The knowledge cutoff for GPT-4o-mini models is October, 2023.";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 16384;
+    readonly inputTokenCost: 0.15;
+    readonly cachedInputTokenCost: 0.075;
+    readonly outputTokenCost: 0.6;
+    readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-4o";
+    readonly description: "GPT-4o (“o” for “omni”) is our versatile, high-intelligence flagship model. It accepts both text and image inputs, and produces text outputs (including Structured Outputs). The knowledge cutoff for GPT-4o-mini models is October, 2023.";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 16384;
+    readonly inputTokenCost: 2.5;
+    readonly cachedInputTokenCost: 1.25;
+    readonly outputTokenCost: 10;
+    readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "o3-mini";
+    readonly description: "o3-mini is our most recent small reasoning model, providing high intelligence at the same cost and latency targets of o1-mini. o3-mini also supports key developer features, like Structured Outputs, function calling, Batch API, and more. Like other models in the o-series, it is designed to excel at science, math, and coding tasks.The knowledge cutoff for o3-mini models is October, 2023.";
+    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: "gpt-4-turbo";
+    readonly description: "GPT-4 is an older version of a high-intelligence GPT model, usable in Chat Completions. Learn more in the text generation guide. The knowledge cutoff for the latest GPT-4 Turbo version is December, 2023.";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 4096;
+    readonly inputTokenCost: 10;
+    readonly outputTokenCost: 30;
+    readonly disabled: true;
+    readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-4";
+    readonly description: "GPT-4 is an older version of a high-intelligence GPT model, usable in Chat Completions. Learn more in the text generation guide. The knowledge cutoff for the latest GPT-4 Turbo version is December, 2023.";
+    readonly maxInputTokens: 8192;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 30;
+    readonly outputTokenCost: 60;
+    readonly disabled: true;
+    readonly source: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-3.5-turbo";
+    readonly description: "GPT-3.5 Turbo models can understand and generate natural language or code and have been optimized for chat using the Chat Completions API but work well for non-chat tasks as well. gpt-4o-mini should be used in place of gpt-3.5-turbo, as it is cheaper, more capable, multimodal, and just as fast.";
+    readonly maxInputTokens: 16385;
+    readonly maxOutputTokens: 4096;
+    readonly inputTokenCost: 0.5;
+    readonly outputTokenCost: 1.5;
+    readonly disabled: true;
+    readonly source: "openai";
+}, {
+    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 maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.15;
+    readonly outputTokenCost: 0.6;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-2.0-pro-exp-02-05";
+    readonly description: "Strongest model quality, especially for code & world knowledge; 2M long context. In private beta.";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.5;
+    readonly outputTokenCost: 1.5;
+    readonly disabled: true;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-2.0-flash-lite";
+    readonly description: "Our cost effective offering to support high throughput.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.075;
+    readonly outputTokenCost: 0.3;
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-1.5-flash";
+    readonly description: "Provides speed and efficiency for high-volume, quality, cost-effective apps. Note: prices ~double after the first 128k tokens.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.01875;
+    readonly outputTokenCost: 0.075;
+    readonly costUnit: "characters";
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-1.5-pro";
+    readonly description: "Supports text or chat prompts for a text or code response. Supports long-context understanding up to the maximum input token limit. Also does video?";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.3125;
+    readonly outputTokenCost: 1.25;
+    readonly costUnit: "characters";
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-1.0-pro";
+    readonly description: "The best performing model for a wide range of text-only tasks.";
+    readonly maxInputTokens: 32760;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.125;
+    readonly outputTokenCost: 0.375;
+    readonly costUnit: "characters";
+    readonly source: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "claude-3-7-sonnet-latest";
+    readonly description: "Our most intelligent model to date and the first hybrid reasoning model on the market. Claude 3.7 Sonnet shows particularly strong improvements in coding and front-end web development.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 3;
+    readonly outputTokenCost: 15;
+    readonly source: "anthropic";
+}, {
+    readonly type: "text";
+    readonly modelName: "claude-3-5-haiku-latest";
+    readonly description: "Our fastest model";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.8;
+    readonly outputTokenCost: 4;
+    readonly source: "anthropic";
+}, {
+    readonly type: "text";
+    readonly modelName: "deepseek-r1:8b";
+    readonly description: "Runs via ollama";
+    readonly source: "local-ollama";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 128000;
+}, {
+    readonly type: "text";
+    readonly modelName: "mistral-adapters-chunk50-iters100";
+    readonly description: "Fine tuned Mistral 7B model fed on my stories, chunked into parts of 50 chars each, 100 iterations.";
+    readonly source: "local";
+    readonly maxInputTokens: 8192;
+    readonly maxOutputTokens: 8192;
+}, {
+    readonly type: "text";
+    readonly modelName: "llama-7b";
+    readonly source: "replicate";
+    readonly maxInputTokens: 256;
+    readonly maxOutputTokens: 256;
+}, {
+    readonly type: "text";
+    readonly modelName: "console.log text";
+    readonly source: "debug";
+    readonly description: "Fake model that just echoes the prompt to the console for debugging";
+    readonly maxInputTokens: 8192;
+    readonly maxOutputTokens: 8192;
+}];
+export declare const imageModels: readonly [{
+    readonly type: "image";
+    readonly modelName: "google/imagen-3";
+    readonly source: "replicate";
+    readonly costPerImage: 0.05;
+}, {
+    readonly type: "image";
+    readonly modelName: "minimax/image-01";
+    readonly source: "replicate";
+    readonly costPerImage: 0.01;
+    readonly outputType: "Array";
+}, {
+    readonly type: "image";
+    readonly modelName: "flux-modal";
+    readonly source: "modal";
+    readonly costPerImage: 0.03;
+}, {
+    readonly type: "image";
+    readonly modelName: "gpt-image-1";
+    readonly source: "openai";
+    readonly costPerImage: 0.25;
+}, {
+    readonly type: "image";
+    readonly modelName: "gemini-2.5-flash-image-preview";
+    readonly source: "google";
+    readonly description: "aka nano-banana";
+    readonly costPerImage: 0.04;
+}, {
+    readonly type: "image";
+    readonly modelName: "console.log image";
+    readonly source: "debug";
+    readonly description: "Fake model that just echoes the prompt to the console for debugging";
+    readonly costPerImage: 0;
+}];
+export declare const embeddingsModels: {
+    type: string;
+    modelName: string;
+    tokenCost: number;
+}[];
+export type TextModelName = (typeof textModels)[number]["modelName"];
+export type ImageModelName = (typeof imageModels)[number]["modelName"];
+export type SpeechToTextModelName = (typeof speechToTextModels)[number]["modelName"];
+export type EmbeddingsModelName = (typeof embeddingsModels)[number]["modelName"];
+export type ModelName = TextModelName | ImageModelName | SpeechToTextModelName | EmbeddingsModelName;
+export declare function getModel(modelName: ModelName): {
+    readonly type: "speech-to-text";
+    readonly modelName: "whisper-local";
+    readonly source: "local";
+} | {
+    readonly type: "speech-to-text";
+    readonly modelName: "whisper-web";
+    readonly perMinuteCost: 0.006;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "gpt-4o-mini";
+    readonly description: "GPT-4o mini (“o” for “omni”) is a fast, affordable small model for focused tasks. It accepts both text and image inputs, and produces text outputs (including Structured Outputs). It is ideal for fine-tuning, and model outputs from a larger model like GPT-4o can be distilled to GPT-4o-mini to produce similar results at lower cost and latency. The knowledge cutoff for GPT-4o-mini models is October, 2023.";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 16384;
+    readonly inputTokenCost: 0.15;
+    readonly cachedInputTokenCost: 0.075;
+    readonly outputTokenCost: 0.6;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "gpt-4o";
+    readonly description: "GPT-4o (“o” for “omni”) is our versatile, high-intelligence flagship model. It accepts both text and image inputs, and produces text outputs (including Structured Outputs). The knowledge cutoff for GPT-4o-mini models is October, 2023.";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 16384;
+    readonly inputTokenCost: 2.5;
+    readonly cachedInputTokenCost: 1.25;
+    readonly outputTokenCost: 10;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "o3-mini";
+    readonly description: "o3-mini is our most recent small reasoning model, providing high intelligence at the same cost and latency targets of o1-mini. o3-mini also supports key developer features, like Structured Outputs, function calling, Batch API, and more. Like other models in the o-series, it is designed to excel at science, math, and coding tasks.The knowledge cutoff for o3-mini models is October, 2023.";
+    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: "gpt-4-turbo";
+    readonly description: "GPT-4 is an older version of a high-intelligence GPT model, usable in Chat Completions. Learn more in the text generation guide. The knowledge cutoff for the latest GPT-4 Turbo version is December, 2023.";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 4096;
+    readonly inputTokenCost: 10;
+    readonly outputTokenCost: 30;
+    readonly disabled: true;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "gpt-4";
+    readonly description: "GPT-4 is an older version of a high-intelligence GPT model, usable in Chat Completions. Learn more in the text generation guide. The knowledge cutoff for the latest GPT-4 Turbo version is December, 2023.";
+    readonly maxInputTokens: 8192;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 30;
+    readonly outputTokenCost: 60;
+    readonly disabled: true;
+    readonly source: "openai";
+} | {
+    readonly type: "text";
+    readonly modelName: "gpt-3.5-turbo";
+    readonly description: "GPT-3.5 Turbo models can understand and generate natural language or code and have been optimized for chat using the Chat Completions API but work well for non-chat tasks as well. gpt-4o-mini should be used in place of gpt-3.5-turbo, as it is cheaper, more capable, multimodal, and just as fast.";
+    readonly maxInputTokens: 16385;
+    readonly maxOutputTokens: 4096;
+    readonly inputTokenCost: 0.5;
+    readonly outputTokenCost: 1.5;
+    readonly disabled: true;
+    readonly source: "openai";
+} | {
+    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 maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.15;
+    readonly outputTokenCost: 0.6;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-2.0-pro-exp-02-05";
+    readonly description: "Strongest model quality, especially for code & world knowledge; 2M long context. In private beta.";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.5;
+    readonly outputTokenCost: 1.5;
+    readonly disabled: true;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-2.0-flash-lite";
+    readonly description: "Our cost effective offering to support high throughput.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.075;
+    readonly outputTokenCost: 0.3;
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-1.5-flash";
+    readonly description: "Provides speed and efficiency for high-volume, quality, cost-effective apps. Note: prices ~double after the first 128k tokens.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.01875;
+    readonly outputTokenCost: 0.075;
+    readonly costUnit: "characters";
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-1.5-pro";
+    readonly description: "Supports text or chat prompts for a text or code response. Supports long-context understanding up to the maximum input token limit. Also does video?";
+    readonly maxInputTokens: 2097152;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.3125;
+    readonly outputTokenCost: 1.25;
+    readonly costUnit: "characters";
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "gemini-1.0-pro";
+    readonly description: "The best performing model for a wide range of text-only tasks.";
+    readonly maxInputTokens: 32760;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.125;
+    readonly outputTokenCost: 0.375;
+    readonly costUnit: "characters";
+    readonly source: "google";
+} | {
+    readonly type: "text";
+    readonly modelName: "claude-3-7-sonnet-latest";
+    readonly description: "Our most intelligent model to date and the first hybrid reasoning model on the market. Claude 3.7 Sonnet shows particularly strong improvements in coding and front-end web development.";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 3;
+    readonly outputTokenCost: 15;
+    readonly source: "anthropic";
+} | {
+    readonly type: "text";
+    readonly modelName: "claude-3-5-haiku-latest";
+    readonly description: "Our fastest model";
+    readonly maxInputTokens: 200000;
+    readonly maxOutputTokens: 8192;
+    readonly inputTokenCost: 0.8;
+    readonly outputTokenCost: 4;
+    readonly source: "anthropic";
+} | {
+    readonly type: "text";
+    readonly modelName: "deepseek-r1:8b";
+    readonly description: "Runs via ollama";
+    readonly source: "local-ollama";
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 128000;
+} | {
+    readonly type: "text";
+    readonly modelName: "mistral-adapters-chunk50-iters100";
+    readonly description: "Fine tuned Mistral 7B model fed on my stories, chunked into parts of 50 chars each, 100 iterations.";
+    readonly source: "local";
+    readonly maxInputTokens: 8192;
+    readonly maxOutputTokens: 8192;
+} | {
+    readonly type: "text";
+    readonly modelName: "llama-7b";
+    readonly source: "replicate";
+    readonly maxInputTokens: 256;
+    readonly maxOutputTokens: 256;
+} | {
+    readonly type: "text";
+    readonly modelName: "console.log text";
+    readonly source: "debug";
+    readonly description: "Fake model that just echoes the prompt to the console for debugging";
+    readonly maxInputTokens: 8192;
+    readonly maxOutputTokens: 8192;
+} | {
+    readonly type: "image";
+    readonly modelName: "google/imagen-3";
+    readonly source: "replicate";
+    readonly costPerImage: 0.05;
+} | {
+    readonly type: "image";
+    readonly modelName: "minimax/image-01";
+    readonly source: "replicate";
+    readonly costPerImage: 0.01;
+    readonly outputType: "Array";
+} | {
+    readonly type: "image";
+    readonly modelName: "flux-modal";
+    readonly source: "modal";
+    readonly costPerImage: 0.03;
+} | {
+    readonly type: "image";
+    readonly modelName: "gpt-image-1";
+    readonly source: "openai";
+    readonly costPerImage: 0.25;
+} | {
+    readonly type: "image";
+    readonly modelName: "gemini-2.5-flash-image-preview";
+    readonly source: "google";
+    readonly description: "aka nano-banana";
+    readonly costPerImage: 0.04;
+} | {
+    readonly type: "image";
+    readonly modelName: "console.log image";
+    readonly source: "debug";
+    readonly description: "Fake model that just echoes the prompt to the console for debugging";
+    readonly costPerImage: 0;
+} | undefined;
+export declare function isImageModel(model: Model): model is ImageModel;
+export declare function isTextModel(model: Model): model is TextModel;
+export declare function isSpeechToTextModel(model: Model): model is SpeechToTextModel;
+export declare function isEmbeddingsModel(model: Model): model is EmbeddingsModel;

package/dist/lib/models.js

@@ -0,0 +1,294 @@
+export const speechToTextModels = [
+    { type: "speech-to-text", modelName: "whisper-local", source: "local" },
+    {
+        type: "speech-to-text",
+        modelName: "whisper-web",
+        perMinuteCost: 0.006,
+        source: "openai",
+    },
+    // not a speech to text model?
+    /* {
+      type: "speech-to-text",
+      modelName: "gpt-4o-audio-preview",
+      description:
+        "This is a preview release of the GPT-4o Audio models. These models accept audio inputs and outputs, and can be used in the Chat Completions REST API. Learn more. The knowledge cutoff for GPT-4o Audio models is October, 2023.",
+      inputTokenCost: 2.5,
+      outputTokenCost: 10,
+      source: "openai",
+    }, */
+];
+export const textModels = [
+    {
+        type: "text",
+        modelName: "gpt-4o-mini",
+        description: "GPT-4o mini (“o” for “omni”) is a fast, affordable small model for focused tasks. It accepts both text and image inputs, and produces text outputs (including Structured Outputs). It is ideal for fine-tuning, and model outputs from a larger model like GPT-4o can be distilled to GPT-4o-mini to produce similar results at lower cost and latency. The knowledge cutoff for GPT-4o-mini models is October, 2023.",
+        maxInputTokens: 128000,
+        maxOutputTokens: 16384,
+        inputTokenCost: 0.15,
+        cachedInputTokenCost: 0.075,
+        outputTokenCost: 0.6,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gpt-4o",
+        description: "GPT-4o (“o” for “omni”) is our versatile, high-intelligence flagship model. It accepts both text and image inputs, and produces text outputs (including Structured Outputs). The knowledge cutoff for GPT-4o-mini models is October, 2023.",
+        maxInputTokens: 128000,
+        maxOutputTokens: 16384,
+        inputTokenCost: 2.5,
+        cachedInputTokenCost: 1.25,
+        outputTokenCost: 10,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "o3-mini",
+        description: "o3-mini is our most recent small reasoning model, providing high intelligence at the same cost and latency targets of o1-mini. o3-mini also supports key developer features, like Structured Outputs, function calling, Batch API, and more. Like other models in the o-series, it is designed to excel at science, math, and coding tasks.The knowledge cutoff for o3-mini models is October, 2023.",
+        maxInputTokens: 200000,
+        maxOutputTokens: 100000,
+        inputTokenCost: 1.1,
+        cachedInputTokenCost: 0.55,
+        outputTokenCost: 4.4,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gpt-4-turbo",
+        description: "GPT-4 is an older version of a high-intelligence GPT model, usable in Chat Completions. Learn more in the text generation guide. The knowledge cutoff for the latest GPT-4 Turbo version is December, 2023.",
+        maxInputTokens: 128000,
+        maxOutputTokens: 4096,
+        inputTokenCost: 10,
+        outputTokenCost: 30,
+        disabled: true,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gpt-4",
+        description: "GPT-4 is an older version of a high-intelligence GPT model, usable in Chat Completions. Learn more in the text generation guide. The knowledge cutoff for the latest GPT-4 Turbo version is December, 2023.",
+        maxInputTokens: 8192,
+        maxOutputTokens: 8192,
+        inputTokenCost: 30,
+        outputTokenCost: 60,
+        disabled: true,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gpt-3.5-turbo",
+        description: "GPT-3.5 Turbo models can understand and generate natural language or code and have been optimized for chat using the Chat Completions API but work well for non-chat tasks as well. gpt-4o-mini should be used in place of gpt-3.5-turbo, as it is cheaper, more capable, multimodal, and just as fast.",
+        maxInputTokens: 16385,
+        maxOutputTokens: 4096,
+        inputTokenCost: 0.5,
+        outputTokenCost: 1.5,
+        disabled: true,
+        source: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gemini-2.0-flash",
+        description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API",
+        maxInputTokens: 1_048_576,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.15,
+        outputTokenCost: 0.6,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-2.0-pro-exp-02-05",
+        description: "Strongest model quality, especially for code & world knowledge; 2M long context. In private beta.",
+        maxInputTokens: 2_097_152,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.5,
+        outputTokenCost: 1.5,
+        disabled: true,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-2.0-flash-lite",
+        description: "Our cost effective offering to support high throughput.",
+        maxInputTokens: 1_048_576,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.075,
+        outputTokenCost: 0.3,
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-1.5-flash",
+        description: "Provides speed and efficiency for high-volume, quality, cost-effective apps. Note: prices ~double after the first 128k tokens.",
+        maxInputTokens: 1_048_576,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.01875,
+        outputTokenCost: 0.075,
+        costUnit: "characters",
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-1.5-pro",
+        description: "Supports text or chat prompts for a text or code response. Supports long-context understanding up to the maximum input token limit. Also does video?",
+        maxInputTokens: 2_097_152,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.3125,
+        outputTokenCost: 1.25,
+        costUnit: "characters",
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "gemini-1.0-pro",
+        description: "The best performing model for a wide range of text-only tasks.",
+        maxInputTokens: 32_760,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.125,
+        outputTokenCost: 0.375,
+        costUnit: "characters",
+        source: "google",
+    },
+    {
+        type: "text",
+        modelName: "claude-3-7-sonnet-latest",
+        description: "Our most intelligent model to date and the first hybrid reasoning model on the market. Claude 3.7 Sonnet shows particularly strong improvements in coding and front-end web development.",
+        maxInputTokens: 200_000,
+        maxOutputTokens: 8192,
+        inputTokenCost: 3,
+        outputTokenCost: 15,
+        source: "anthropic",
+    },
+    {
+        type: "text",
+        modelName: "claude-3-5-haiku-latest",
+        description: "Our fastest model",
+        maxInputTokens: 200_000,
+        maxOutputTokens: 8192,
+        inputTokenCost: 0.8,
+        outputTokenCost: 4,
+        source: "anthropic",
+    },
+    /*  {
+      type: "text",
+      modelName: "llama.cpp",
+      maxInputTokens: 4000,
+      maxOutputTokens: 4000,
+    }, */
+    /*  {
+      type: "text",
+      modelName: "claude-3-opus-20240229",
+      maxInputTokens: 4096,
+      maxOutputTokens: 4096,
+    },
+    {
+      type: "text",
+      modelName: "claude-3-sonnet-20240229",
+      maxInputTokens: 4096,
+      maxOutputTokens: 4096,
+    },
+    {
+      type: "text",
+      modelName: "gemini-pro",
+      maxInputTokens: 4096,
+      maxOutputTokens: 4096,
+    },
+    {
+      type: "text",
+      modelName: "gemini-pro-vision",
+      maxInputTokens: 4096,
+      maxOutputTokens: 4096,
+    }, */
+    {
+        type: "text",
+        modelName: "deepseek-r1:8b",
+        description: "Runs via ollama",
+        source: "local-ollama",
+        maxInputTokens: 128000,
+        maxOutputTokens: 128000,
+    },
+    {
+        type: "text",
+        modelName: "mistral-adapters-chunk50-iters100",
+        description: "Fine tuned Mistral 7B model fed on my stories, chunked into parts of 50 chars each, 100 iterations.",
+        source: "local",
+        // https://huggingface.co/mistralai/Mistral-7B-v0.1/discussions/104
+        maxInputTokens: 8192,
+        maxOutputTokens: 8192,
+    },
+    {
+        type: "text",
+        modelName: "llama-7b",
+        source: "replicate",
+        maxInputTokens: 256,
+        maxOutputTokens: 256,
+    },
+    {
+        type: "text",
+        modelName: "console.log text",
+        source: "debug",
+        description: "Fake model that just echoes the prompt to the console for debugging",
+        maxInputTokens: 8192,
+        maxOutputTokens: 8192,
+    },
+];
+export const imageModels = [
+    {
+        type: "image",
+        modelName: "google/imagen-3",
+        source: "replicate",
+        costPerImage: 0.05,
+    },
+    {
+        type: "image",
+        modelName: "minimax/image-01",
+        source: "replicate",
+        costPerImage: 0.01,
+        outputType: "Array",
+    },
+    {
+        type: "image",
+        modelName: "flux-modal",
+        source: "modal",
+        costPerImage: 0.03,
+    },
+    {
+        type: "image",
+        modelName: "gpt-image-1",
+        source: "openai",
+        // varies: https://platform.openai.com/docs/models/gpt-image-1
+        costPerImage: 0.25,
+    },
+    {
+        type: "image",
+        modelName: "gemini-2.5-flash-image-preview",
+        source: "google",
+        description: "aka nano-banana",
+        costPerImage: 0.04,
+    },
+    {
+        type: "image",
+        modelName: "console.log image",
+        source: "debug",
+        description: "Fake model that just echoes the prompt to the console for debugging",
+        costPerImage: 0,
+    },
+];
+export const embeddingsModels = [
+    { type: "embeddings", modelName: "text-embedding-3-small", tokenCost: 0.02 },
+];
+export function getModel(modelName) {
+    const allModels = [...textModels, ...imageModels, ...speechToTextModels];
+    return allModels.find((model) => model.modelName === modelName);
+}
+export function isImageModel(model) {
+    return model.type === "image";
+}
+export function isTextModel(model) {
+    return model.type === "text";
+}
+export function isSpeechToTextModel(model) {
+    return model.type === "speech-to-text";
+}
+export function isEmbeddingsModel(model) {
+    return model.type === "embeddings";
+}

package/dist/lib/smolError.d.ts

@@ -0,0 +1,3 @@
+export declare class SmolError extends Error {
+    constructor(message: string);
+}

package/dist/lib/smolError.js

@@ -0,0 +1,6 @@
+export class SmolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SmolTalkError";
+    }
+}

package/dist/lib/types/result.d.ts

@@ -0,0 +1,12 @@
+export type Success<T> = {
+    success: true;
+    value: T;
+};
+export type Failure = {
+    success: false;
+    error: string;
+};
+export type Result<T> = Success<T> | Failure;
+export declare function success<T>(value: T): Success<T>;
+export declare function failure(error: string): Failure;
+export declare function mergeResults<T>(results: Result<T>[]): Result<T[]>;

package/dist/lib/types/result.js

@@ -0,0 +1,16 @@
+export function success(value) {
+    return { success: true, value };
+}
+export function failure(error) {
+    return { success: false, error };
+}
+export function mergeResults(results) {
+    const values = [];
+    for (const result of results) {
+        if (!result.success) {
+            return failure(result.error);
+        }
+        values.push(result.value);
+    }
+    return success(values);
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,30 @@
+export * from "./types/result.js";
+import { EgonLog, LogLevel } from "egonlog";
+import { ModelName } from "./models.js";
+import { Result } from "./index.js";
+export type PromptConfig<Tool = any> = {
+    messages?: {
+        role: string;
+        content: string;
+    }[];
+    instructions?: string;
+    maxTokens?: number;
+    temperature?: number;
+    numSuggestions?: number;
+    parallelToolCalls?: boolean;
+    tools?: Tool[];
+};
+export type SmolConfig = {
+    apiKey: string;
+    model: ModelName;
+    logLevel?: LogLevel;
+};
+export type BaseClientConfig = SmolConfig & {
+    logger: EgonLog;
+};
+export type PromptResult = {
+    output: string;
+};
+export interface SmolClient {
+    text(content: string, config?: PromptConfig): Promise<Result<PromptResult>>;
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export * from "./types/result.js";

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "smoltalk",
+  "version": "0.0.1",
+  "description": "A common interface for LLM APIs",
+  "homepage": "https://github.com/egonSchiele/smoltalk",
+  "scripts": {
+    "test": "vitest",
+    "test:tsc": "tsc -p tests/tsconfig.json",
+    "coverage": "vitest --coverage",
+    "build": "rm -rf dist && tsc",
+    "start": "cd dist && node index.js"
+  },
+  "files": [
+    "./dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "keywords": [
+    "smoltalk",
+    "llm",
+    "api"
+  ],
+  "author": "Aditya Bhargava",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "@google/genai": "^1.34.0",
+    "egonlog": "^0.0.2",
+    "openai": "^6.15.0"
+  }
+}