@trymirai/uzu 0.3.1 → 0.4.0

package/LICENSE

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -4,81 +4,60 @@
   </picture>
 </p>
 
-<a href="https://discord.com/invite/trymirai"><img src="https://img.shields.io/discord/1377764166764462120?label=Discord" alt="Discord"></a>
-<a href="mailto:contact@getmirai.co?subject=Interested%20in%20Mirai"><img src="https://img.shields.io/badge/Send-Email-green" alt="Contact us"></a>
-<a href="https://docs.trymirai.com/app-integration/overview"><img src="https://img.shields.io/badge/Read-Docs-blue" alt="Read docs"></a>
-[![npm (scoped)](https://img.shields.io/npm/v/%40trymirai%2Fuzu)](https://www.npmjs.com/package/@trymirai/uzu)
-[![License](https://img.shields.io/badge/License-MIT-blue)](LICENSE)
+<a href="https://discord.com/invite/trymirai"><img src="https://img.shields.io/discord/1377764166764462120?label=Discord&color=brightgreen" alt="Discord"></a> <a href="mailto:contact@getmirai.co?subject=Interested%20in%20Mirai"><img src="https://img.shields.io/badge/Send-Email-brightgreen" alt="Contact us"></a> <a href="https://docs.trymirai.com"><img src="https://img.shields.io/badge/Read-Docs-brightgreen" alt="Read docs"></a> [![License](https://img.shields.io/badge/License-MIT-brightgreen)](LICENSE) [![Build](https://github.com/trymirai/uzu/actions/workflows/tests.yml/badge.svg)](https://github.com/trymirai/uzu/actions) [![TypeScript](https://img.shields.io/badge/TypeScript-yellow)](bindings/typescript) [![Package](https://img.shields.io/npm/v/@trymirai/uzu?color=yellow&label=Package)](https://www.npmjs.com/package/@trymirai/uzu) [![Downloads](https://img.shields.io/npm/dm/@trymirai/uzu?color=yellow&label=Downloads)](https://www.npmjs.com/package/@trymirai/uzu) 
 
-# uzu-ts
+# uzu
 
-Node package for [uzu](https://github.com/trymirai/uzu), a **high-performance** inference engine for AI models on Apple Silicon. It allows you to deploy AI directly in your app with **zero latency**, **full data privacy**, and **no inference costs**. You don’t need an ML team or weeks of setup - one developer can handle everything in minutes. Key features:
+A high-performance inference engine for AI models. It allows you to deploy AI directly in your app with **zero latency**, **full data privacy**, and **no inference costs**. Key features:
 
 - Simple, high-level API
-- Specialized configurations with significant performance boosts for common use cases like classification and summarization
+- Unified model configurations, making it easy to add support for new models
+- Traceable computations to ensure correctness against the source-of-truth implementation
+- Utilizes unified memory on Apple devices
 - [Broad model support](https://trymirai.com/models)
 
 ## Quick Start
 
-Add the `uzu` dependency to your project's `package.json`:
 
-```json
-"dependencies": {
-    "@trymirai/uzu": "0.3.1"
-}
-```
 
-Set up your project through [Platform](https://platform.trymirai.com) and obtain an `API_KEY`. Then, choose the model you want from the [library](https://platform.trymirai.com/models) and run it with the following snippet using the corresponding identifier:
+Add the dependency:
 
-```ts
-const output = await Engine
-    .create('API_KEY')
-    .chatModel('Qwen/Qwen3-0.6B')
-    .reply('Tell me a short, funny story about a robot');
+```bash
+pnpm add @trymirai/uzu@0.4.0
 ```
 
-Everything from model downloading to inference configuration is handled automatically. Refer to the [documentation](https://docs.trymirai.com) for details on how to customize each step of the process.
+Run the code below:
 
-## Examples
+```ts
+import { ChatConfig, ChatMessage, ChatReplyConfig, Engine, EngineConfig } from '@trymirai/uzu';
 
-Place the `API_KEY` you obtained earlier in the corresponding example file, and then run it using one of the following commands:
+async function main() {
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
 
-```bash
-pnpm run tsn examples/chat.ts
-pnpm run tsn examples/chatWithSpeculator.ts
-pnpm run tsn examples/chatDynamicContext.ts
-pnpm run tsn examples/chatStaticContext.ts
-pnpm run tsn examples/summarization.ts
-pnpm run tsn examples/classification.ts
-pnpm run tsn examples/cloud.ts
-pnpm run tsn examples/structuredOutput.ts
-pnpm run tsn examples/classifier.ts
-pnpm run tsn examples/textToSpeech.ts
-```
+    let model = await engine.model('Qwen/Qwen3-0.6B');
+    if (!model) {
+        throw new Error('Model not found');
+    }
 
-### Chat
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
 
-In this example, we will download a model and get a reply to a specific list of messages:
+    let session = await engine.chat(model, ChatConfig.create());
 
-```ts
-import Engine, { Message } from '@trymirai/uzu';
+    let messages = [
+        ChatMessage.system().withText('You are a helpful assistant'),
+        ChatMessage.user().withText('Tell me a short, funny story about a robot')
+    ];
 
-async function main() {
-    const output = await Engine.create('API_KEY')
-        .chatModel('Qwen/Qwen3-0.6B')
-        .download((update) => {
-            console.log('Progress:', update.progress);
-        })
-        .replyToMessages(
-            [
-                Message.system('You are a helpful assistant'),
-                Message.user('Tell me a short, funny story about a robot')
-            ],
-            (partialOutput) => {
-                return true;
-            },
-        );
-    console.log(output.text.original);
+    let reply = await session.reply(messages, ChatReplyConfig.create());
+    let message = reply[0]?.message;
+
+    if (message) {
+        console.log('Reasoning: ', message.reasoning);
+        console.log('Text: ', message.text);
+    }
 }
 
 main().catch((error) => {
@@ -86,44 +65,51 @@ main().catch((error) => {
 });
 ```
 
-### Speedup with speculative decoding
 
-Speculative decoding allows a significant increase in generation speed. For each model, we train a small n-gram model (under 50 MB) tailored to a specific domain or use case. In general chat scenarios, you can use the `Chat` preset, which will automatically use the corresponding speculator:
+<br>
+
+Everything from model downloading to inference configuration is handled automatically. Refer to the [documentation](https://docs.trymirai.com) for details on how to customize each step of the process.
+
+## Examples
+
+You can run any example via `cargo tools example` \<**typescript**\> \<**chat** | **chat-cloud** | **chat-speculation-classification** | **chat-speculation-summarization** | **chat-structured-output** | **classification** | **quick-start** | **text-to-speech**\>:
+
+### Chat
+
+In this example, we will download a model and get a reply to a specific list of messages:
 
 ```ts
-import Engine, { Message, Preset } from '@trymirai/uzu';
+import { ChatConfig, ChatMessage, ChatReplyConfig, ChatSessionStreamChunkError, ChatSessionStreamChunkReplies, Engine, EngineConfig } from '@trymirai/uzu';
 
 async function main() {
-    const engine = Engine.create('API_KEY');
-    const model = engine
-        .chatModel('Qwen/Qwen3-0.6B')
-        .download((update) => {
-            console.log('Progress:', update.progress);
-        });
-
-    const messages = [
-        Message.system('You are a helpful assistant'),
-        Message.user('Tell me a short, funny story about a robot')
-    ];
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('Qwen/Qwen3-0.6B');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
 
-    const outputGeneral = await model
-        .replyToMessages(
-            messages,
-            (partialOutput) => {
-                return true;
-            },
-        );
-    console.log('Generation speed t/s (general):', outputGeneral.stats.generateStats?.tokensPerSecond ?? 0);
-
-    const outputWithSpeculator = await model
-        .preset(Preset.chat())
-        .replyToMessages(
-            messages,
-            (partialOutput) => {
-                return true;
-            },
-        );
-    console.log('Generation speed t/s (with chat speculator):', outputWithSpeculator.stats.generateStats?.tokensPerSecond ?? 0);
+    let messages = [
+        ChatMessage.system().withText('You are a helpful assistant'),
+        ChatMessage.user().withText('Tell me a short, funny story about a robot')
+    ];
+    let session = await engine.chat(model, ChatConfig.create());
+    let stream = await session.replyWithStream(messages, ChatReplyConfig.create());
+    let message: ChatMessage | undefined;
+    for await (const chunk of stream) {
+        if (chunk instanceof ChatSessionStreamChunkReplies) {
+            message = chunk.replies[0]?.message;
+            console.log('Generated tokens: ', chunk.replies[0]?.stats.tokensCountOutput);
+        } else if (chunk instanceof ChatSessionStreamChunkError) {
+            console.error('Error: ', chunk.error);
+        }
+    }
+    console.log('Reasoning: ', message?.reasoning);
+    console.log('Text: ', message?.text);
 }
 
 main().catch((error) => {
@@ -131,44 +117,35 @@ main().catch((error) => {
 });
 ```
 
-### Chat with dynamic context
+<br>Once loaded, the same `ChatSession` can be reused for multiple requests until you drop it. Each model may consume a significant amount of RAM, so it's important to keep only one session loaded at a time. For iOS apps, we recommend adding the [Increased Memory Capability](https://developer.apple.com/documentation/bundleresources/entitlements/com.apple.developer.kernel.increased-memory-limit) entitlement to ensure your app can allocate the required memory.
 
-In this example, we will use the dynamic `ContextMode`, which automatically maintains a continuous conversation history instead of resetting the context with each new input. Every new message is added to the ongoing chat, allowing the model to remember what has already been said and respond with full context.
+### Chat with the cloud model
+
+In this example, we will get a reply to a specific list of messages from a cloud model:
 
 ```ts
-import Engine, { Config, ContextMode, Input, RunConfig } from '@trymirai/uzu';
+import { ChatConfig, ChatMessage, ChatReplyConfig, Engine, EngineConfig, ReasoningEffort } from '@trymirai/uzu';
 
 async function main() {
-    const engine = await Engine.load('API_KEY');
-
-    const model = await engine.chatModel('Qwen/Qwen3-0.6B');
-    await engine.downloadModel(model, (update) => {
-        console.log('Progress:', update.progress);
-    });
-
-    const config = Config
-        .default()
-        .withContextMode(ContextMode.dynamic());
-    const session = engine.chatSession(model, config);
-
-    const requests = [
-        'Tell about London',
-        'Compare with New York',
-        'Compare the population of the two',
+    let engineConfig = EngineConfig.create().withOpenaiApiKey('OPENAI_API_KEY');
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('gpt-5');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+
+    let messages = [
+        ChatMessage.system().withReasoningEffort("Low" as ReasoningEffort),
+        ChatMessage.user().withText('How LLMs work')
     ];
-    const runConfig = RunConfig
-        .default()
-        .withTokensLimit(1024)
-        .withEnableThinking(false);
-
-    for (const request of requests) {
-        const output = session.run(Input.text(request), runConfig, (partialOutput) => {
-            return true;
-        });
-
-        console.log('Request:', request);
-        console.log('Response:', output.text.original.trim());
-        console.log('-------------------------');
+
+    let session = await engine.chat(model, ChatConfig.create());
+    let reply = await session.reply(messages, ChatReplyConfig.create());
+    let message = reply[0]?.message;
+    if (message) {
+        console.log('Reasoning: ', message.reasoning);
+        console.log('Text: ', message.text);
     }
 }
 
@@ -177,49 +154,52 @@ main().catch((error) => {
 });
 ```
 
-### Chat with static context
+### Chat using speculation preset for classification
 
-In this example, we will use the static `ContextMode`, which begins with an initial list of messages defining the base context of the conversation, such as predefined instructions. Unlike dynamic mode, this context is fixed and does not evolve with new messages. Each inference request is processed independently, using only the initial context and the latest input, without retaining any previous conversation history.
+In this example, we will use the `classification` speculation preset to determine the sentiment of the user's input:
 
 ```ts
-import Engine, { Config, ContextMode, Input, Message, RunConfig } from '@trymirai/uzu';
-
-function listToString(list: string[]): string {
-    return "[" + list.map((item) => `"${item}"`).join(", ") + "]";
-}
+import { ChatConfig, ChatMessage, ChatReplyConfig, ChatSpeculationPresetClassification, Engine, EngineConfig, Feature, ReasoningEffort, SamplingMethodGreedy } from '@trymirai/uzu';
 
 async function main() {
-    const engine = await Engine.load('API_KEY');
-
-    const model = await engine.chatModel('Qwen/Qwen3-0.6B');
-    await engine.downloadModel(model, (update) => {
-        console.log('Progress:', update.progress);
-    });
-
-    const instructions =
-        `Your task is to name countries for each city in the given list.
-        For example for ${listToString(["Helsenki", "Stockholm", "Barcelona"])} the answer should be ${listToString(["Finland", "Sweden", "Spain"])}.`;
-    const config = Config
-        .default()
-        .withContextMode(ContextMode.static(Input.messages([Message.system(instructions)])));
-    const session = engine.chatSession(model, config);
-
-    const requests = [
-        listToString(["New York", "London", "Lisbon", "Paris", "Berlin"]),
-        listToString(["Bangkok", "Tokyo", "Seoul", "Beijing", "Delhi"]),
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('Qwen/Qwen3-0.6B');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
+
+    const feature = new Feature('sentiment', [
+        'Happy',
+        'Sad',
+        'Angry',
+        'Fearful',
+        'Surprised',
+        'Disgusted',
+    ]);
+    let chatConfig = ChatConfig.create().withSpeculationPreset(new ChatSpeculationPresetClassification(feature));
+    let session = await engine.chat(model, chatConfig);
+
+    const textToDetectFeature =
+        "Today's been awesome! Everything just feels right, and I can't stop smiling.";
+    const prompt =
+        `Text is: "${textToDetectFeature}". Choose ${feature.name} from the list: ${feature.values.join(', ')}. ` +
+        "Answer with one word. Don't add a dot at the end.";
+    let messages = [
+        ChatMessage.system().withReasoningEffort("Disabled" as ReasoningEffort),
+        ChatMessage.user().withText(prompt)
     ];
-    const runConfig = RunConfig
-        .default()
-        .withEnableThinking(false);
-
-    for (const request of requests) {
-        const output = session.run(Input.text(request), runConfig, (partialOutput) => {
-            return true;
-        });
-
-        console.log('Request:', request);
-        console.log('Response:', output.text.original.trim());
-        console.log('-------------------------');
+
+    let chatReplyConfig = ChatReplyConfig.create().withTokenLimit(32).withSamplingMethod(new SamplingMethodGreedy());
+    let reply = (await session.reply(messages, chatReplyConfig))[0];
+
+    if (reply) {
+        console.log('Prediction: ', reply.message.text);
+        console.log('Generated tokens: ', reply.stats.tokensCountOutput);
     }
 }
 
@@ -228,36 +208,45 @@ main().catch((error) => {
 });
 ```
 
-### Summarization
+<br>You can view the stats to see that the answer will be ready immediately after the prefill step, and actual generation won’t even start due to speculative decoding, which significantly improves generation speed.
 
-In this example, we will use the `summarization` preset to generate a summary of the input text:
+### Chat using speculation preset for summarization
+
+In this example, we will use the `summarization` speculation preset to generate a summary of the input text:
 
 ```ts
-import Engine, { Preset, SamplingMethod } from '@trymirai/uzu';
+import { ChatConfig, ChatMessage, ChatReplyConfig, ChatSpeculationPresetSummarization, Engine, EngineConfig, ReasoningEffort, SamplingMethodGreedy } from '@trymirai/uzu';
 
 async function main() {
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('Qwen/Qwen3-0.6B');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
+
     const textToSummarize =
         "A Large Language Model (LLM) is a type of artificial intelligence that processes and generates human-like text. It is trained on vast datasets containing books, articles, and web content, allowing it to understand and predict language patterns. LLMs use deep learning, particularly transformer-based architectures, to analyze text, recognize context, and generate coherent responses. These models have a wide range of applications, including chatbots, content creation, translation, and code generation. One of the key strengths of LLMs is their ability to generate contextually relevant text based on prompts. They utilize self-attention mechanisms to weigh the importance of words within a sentence, improving accuracy and fluency. Examples of popular LLMs include OpenAI's GPT series, Google's BERT, and Meta's LLaMA. As these models grow in size and sophistication, they continue to enhance human-computer interactions, making AI-powered communication more natural and effective.";
     const prompt = `Text is: "${textToSummarize}". Write only summary itself.`;
+    let messages = [
+        ChatMessage.system().withReasoningEffort("Disabled" as ReasoningEffort),
+        ChatMessage.user().withText(prompt)
+    ];
+
+    let chatConfig = ChatConfig.create().withSpeculationPreset(new ChatSpeculationPresetSummarization);
+    let session = await engine.chat(model, chatConfig);
+
+    let chatReplyConfig = ChatReplyConfig.create().withTokenLimit(256).withSamplingMethod(new SamplingMethodGreedy());
+    let reply = (await session.reply(messages, chatReplyConfig))[0];
 
-    const output = await Engine.create('API_KEY')
-        .chatModel('Qwen/Qwen3-0.6B')
-        .download((update) => {
-            console.log('Progress:', update.progress);
-        })
-        .preset(Preset.summarization())
-        .session()
-        .tokensLimit(256)
-        .enableThinking(false)
-        .samplingMethod(SamplingMethod.greedy())
-        .reply(prompt);
-
-    console.log('Summary:', output.text.original);
-    console.log(
-        'Model runs:',
-        output.stats.prefillStats.modelRun.count + (output.stats.generateStats?.modelRun.count ?? 0),
-    );
-    console.log('Tokens count:', output.stats.totalStats.tokensCountOutput);
+    if (reply) {
+        console.log('Summary: ', reply.message.text);
+        console.log('Generation t\\s: ', reply.stats.generateTokensPerSecond);
+    }
 }
 
 main().catch((error) => {
@@ -265,44 +254,55 @@ main().catch((error) => {
 });
 ```
 
-You will notice that the model’s run count is lower than the actual number of generated tokens due to speculative decoding, which significantly improves generation speed.
+<br>You will notice that the model’s run count is lower than the actual number of generated tokens due to speculative decoding, which significantly improves generation speed.
 
-### Classification
+### Chat with structured output
 
-In this example, we will use the `classification` preset to determine the sentiment of the user's input:
+Sometimes you want the generated output to be valid JSON with predefined fields. You can use `Grammar` to manually specify a JSON schema for the response you want to receive:
 
 ```ts
-import Engine, { ClassificationFeature, Preset, SamplingMethod } from '@trymirai/uzu';
+import { ChatConfig, ChatMessage, ChatReplyConfig, Engine, EngineConfig, GrammarJsonSchema, ReasoningEffort } from '@trymirai/uzu';
+import * as z from "zod";
+
+const CountryType = z.object({
+    name: z.string(),
+    capital: z.string(),
+});
+const CountryListType = z.array(CountryType);
+
+function structuredResponse<T extends z.ZodType>(response: string | null | undefined, type: T): z.infer<T> | undefined {
+    if (!response) {
+        return undefined;
+    }
+    const data = JSON.parse(response);
+    const result = type.parse(data);
+    return result;
+}
 
 async function main() {
-    const feature = new ClassificationFeature('sentiment', [
-        'Happy',
-        'Sad',
-        'Angry',
-        'Fearful',
-        'Surprised',
-        'Disgusted',
-    ]);
-    const textToDetectFeature =
-        "Today's been awesome! Everything just feels right, and I can't stop smiling.";
-    const prompt =
-        `Text is: "${textToDetectFeature}". Choose ${feature.name} from the list: ${feature.values.join(', ')}. ` +
-        "Answer with one word. Don't add a dot at the end.";
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('Qwen/Qwen3-0.6B');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
+
+    let schema = z.toJSONSchema(CountryListType);
+    let schemaString = JSON.stringify(schema);
+    let messages = [
+        ChatMessage.system().withReasoningEffort("Disabled" as ReasoningEffort),
+        ChatMessage.user().withText('Give me a JSON object containing a list of 3 countries, where each country has name and capital fields')
+    ];
 
-    const output = await Engine.create('API_KEY')
-        .chatModel('Qwen/Qwen3-0.6B')
-        .download((update) => {
-            console.log('Progress:', update.progress);
-        })
-        .preset(Preset.classification(feature))
-        .session()
-        .tokensLimit(32)
-        .enableThinking(false)
-        .samplingMethod(SamplingMethod.greedy())
-        .reply(prompt);
-
-    console.log('Prediction:', output.text.original);
-    console.log('Stats:', output.stats);
+    let session = await engine.chat(model, ChatConfig.create());
+    let reply = await session.reply(messages, ChatReplyConfig.create().withGrammar(new GrammarJsonSchema(schemaString)));
+    let message = reply[0]?.message;
+    let countries = structuredResponse(message?.text, CountryListType);
+    console.log(countries);
 }
 
 main().catch((error) => {
@@ -310,21 +310,32 @@ main().catch((error) => {
 });
 ```
 
-You can view the stats to see that the answer will be ready immediately after the prefill step, and actual generation won’t even start due to speculative decoding, which significantly improves generation speed.
-
-### Cloud
+### Classification
 
-Sometimes you want to create a complex pipeline where some requests are processed on-device and the more complex ones are handled in the cloud using a larger model. With `uzu`, you can do this easily: just choose the cloud model you want to use and perform all requests through the same API:
+In this example, we will use a classification model to determine whether the user's input is safe from a moderation perspective:
 
 ```ts
-import Engine from '@trymirai/uzu';
+import { ClassificationMessage, Engine, EngineConfig } from '@trymirai/uzu';
 
 async function main() {
-    const output = await Engine
-        .create('API_KEY')
-        .chatModel('openai/gpt-oss-120b')
-        .reply('How LLMs work');
-    console.log(output.text.original);
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('trymirai/chat-moderation-router');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
+
+    let messages = [
+        ClassificationMessage.user('Hi')
+    ];
+
+    let session = await engine.classification(model);
+    let output = await session.classify(messages);
+    console.log('Output: ', output.probabilities.values);
 }
 
 main().catch((error) => {
@@ -332,38 +343,33 @@ main().catch((error) => {
 });
 ```
 
-### Structured Output
+### Text to Speech
 
-Sometimes you want the generated output to be valid JSON with predefined fields. You can use `GrammarConfig` to manually specify a JSON schema, or define the schema using [Zod](https://github.com/colinhacks/zod).
+In this example, we will generate audio from text:
 
 ```ts
-import Engine, { GrammarConfig } from '@trymirai/uzu';
-import * as z from "zod";
-
-const CountryType = z.object({
-    name: z.string(),
-    capital: z.string(),
-});
-const CountryListType = z.array(CountryType);
+import { Engine, EngineConfig } from '@trymirai/uzu';
+import { homedir } from "os";
+import { join } from "path";
 
 async function main() {
-    const output = await Engine.create('API_KEY')
-        .chatModel('Qwen/Qwen3-0.6B')
-        .download((update) => {
-            console.log('Progress:', update.progress);
-        })
-        .session()
-        .enableThinking(false)
-        .grammarConfig(GrammarConfig.fromType(CountryListType))
-        .reply(
-            "Give me a JSON object containing a list of 3 countries, where each country has name and capital fields",
-            (partialOutput) => {
-                return true;
-            },
-        );
-
-    const countries = output.text.parsed.structuredResponse(CountryListType);
-    console.log(countries);
+    let engineConfig = EngineConfig.create();
+    let engine = await Engine.create(engineConfig);
+
+    let model = await engine.model('fishaudio/s1-mini');
+    if (!model) {
+        throw new Error('Model not found');
+    }
+    for await (const update of await engine.download(model)) {
+        console.log('Download progress:', update.progress);
+    }
+
+    const text = "London is the capital of United Kingdom and one of the world’s most influential cities, known for its rich history, cultural diversity, and global significance in finance, politics, and the arts. Situated along the River Thames, the city blends historic landmarks like Tower of London and Buckingham Palace with modern architecture such as The Shard. London is also home to renowned institutions including the British Museum and vibrant areas like Covent Garden, offering a mix of history, entertainment, and innovation that attracts millions of visitors each year.";
+    const outputPath = join(homedir(), "Desktop", "output.wav");
+    let session = await engine.textToSpeech(model);
+    let pcmBatch = await session.synthesize(text);
+    pcmBatch.saveAsWav(outputPath);
+    console.log('Output saved to: ', outputPath);
 }
 
 main().catch((error) => {
@@ -371,6 +377,8 @@ main().catch((error) => {
 });
 ```
 
+
+
 ## Troubleshooting
 
 If you experience any problems, please contact us via [Discord](https://discord.com/invite/trymirai) or [email](mailto:contact@getmirai.co).