smoltalk 0.0.1 → 0.0.3

package/README.md

@@ -1,222 +1,26 @@
-# Typestache: static typing for mustache
+# Smoltalk
 
-> Get your templates to "if it compiles, it probably works!"
+## Install
 
-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.
+```bash 
+pnpm install smoltalk
 ```
 
-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:
+## Usage
 
 ```typescript
-type TemplateType = {
-  person: boolean;
-  name: string | boolean | number;
-};
-```
+import { getClient } from "smoltalk";
 
-## 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}}
-```
+const client = getClient({
+  apiKey: process.env.GEMINI_API_KEY || "",
+  logLevel: "debug",
+  model: "gemini-2.0-flash-lite",
+});
 
-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;
-  }
+async function main() {
+  const resp = await client.text("Hello, how are you?");
+  console.log(resp);
 }
-```
-
-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.
+main();
+```

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

@@ -34,6 +34,6 @@ export class SmolGoogle {
         //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 });
+        return success({ output: result.text, toolCalls: [] });
     }
 }

package/dist/clients/openai.js

@@ -0,0 +1,45 @@
+import OpenAI from "openai";
+import { success, } from "../types.js";
+import { isFunctionToolCall, openAIToToolCall } from "../util.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 completion = await this.client.chat.completions.create({
+            model: this.model,
+            messages,
+            tools: config?.tools,
+            response_format: config?.responseFormat,
+        });
+        this.logger.debug("Response from OpenAI:", JSON.stringify(completion, null, 2));
+        const message = completion.choices[0].message;
+        const output = message.content;
+        const _toolCalls = message.tool_calls;
+        const toolCalls = [];
+        if (_toolCalls) {
+            for (const tc of _toolCalls) {
+                if (isFunctionToolCall(tc)) {
+                    toolCalls.push(openAIToToolCall(tc));
+                }
+                else {
+                    this.logger.warn(`Unsupported tool call type: ${tc.type} for tool call ID: ${tc.id}`);
+                }
+            }
+        }
+        if (toolCalls.length > 0) {
+            this.logger.info("Tool calls detected:", toolCalls);
+        }
+        return success({ output, toolCalls });
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,11 +1,5 @@
-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();
+export * from "./client.js";
+export * from "./types.js";
+export * from "./models.js";
+export * from "./smolError.js";
+export * from "./util.js";

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

@@ -247,7 +247,7 @@ 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 type ModelName = TextModelName | ImageModelName | SpeechToTextModelName;
 export declare function getModel(modelName: ModelName): {
     readonly type: "speech-to-text";
     readonly modelName: "whisper-local";

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

@@ -3,16 +3,18 @@ import { EgonLog, LogLevel } from "egonlog";
 import { ModelName } from "./models.js";
 import { Result } from "./index.js";
 export type PromptConfig<Tool = any> = {
+    tools?: Tool[];
     messages?: {
         role: string;
         content: string;
+        name?: string;
     }[];
     instructions?: string;
     maxTokens?: number;
     temperature?: number;
     numSuggestions?: number;
     parallelToolCalls?: boolean;
-    tools?: Tool[];
+    responseFormat?: any;
 };
 export type SmolConfig = {
     apiKey: string;
@@ -22,8 +24,14 @@ export type SmolConfig = {
 export type BaseClientConfig = SmolConfig & {
     logger: EgonLog;
 };
+export type ToolCall = {
+    id: string;
+    name: string;
+    arguments: Record<string, any>;
+};
 export type PromptResult = {
-    output: string;
+    output: string | null;
+    toolCalls: ToolCall[];
 };
 export interface SmolClient {
     text(content: string, config?: PromptConfig): Promise<Result<PromptResult>>;

package/dist/util/openai.d.ts

@@ -0,0 +1,4 @@
+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,10 @@
+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";
+}

package/dist/util.d.ts

@@ -0,0 +1 @@
+export * from "./util/openai.js";

package/dist/util.js

@@ -0,0 +1 @@
+export * from "./util/openai.js";

package/package.json

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

package/dist/lib/clients/openai.js

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

@@ -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/client.js → client.js}

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