llm-fns 1.0.24 → 1.0.26

package/dist/createCandidateSelector.js

@@ -1,7 +1,6 @@
-import crypto from 'crypto';
 export function createCandidateSelector(params) {
     const { candidateCount, generate, judge, onCandidateError } = params;
-    async function run(input, baseSalt = crypto.randomUUID()) {
+    async function run(input, baseSalt = 'candidate') {
         // 1. Generate Candidates in Parallel
         const promises = [];
         for (let i = 0; i < candidateCount; i++) {

package/dist/createLlmClient.d.ts

@@ -23,6 +23,7 @@ export type OpenRouterResponseFormat = {
         schema: object;
     };
 };
+export type LlmAudioTransport = 'auto' | 'chat' | 'chat-stream';
 /**
  * Request-level options passed to the OpenAI SDK.
  * These are separate from the body parameters.
@@ -49,6 +50,12 @@ export interface LlmCommonOptions {
     response_format?: OpenRouterResponseFormat;
     modalities?: string[];
     audio?: OpenAI.Chat.Completions.ChatCompletionAudioParam;
+    /**
+     * Selects how audio output is requested. `auto` prefers streaming because
+     * OpenRouter audio output requires it, then falls back to non-streaming chat
+     * if streaming is rejected by the provider.
+     */
+    audioTransport?: LlmAudioTransport;
     image_config?: {
         aspect_ratio?: string;
     };
@@ -64,6 +71,7 @@ export interface LlmCommonOptions {
     user?: string;
     tools?: OpenAI.Chat.Completions.ChatCompletionTool[];
     tool_choice?: OpenAI.Chat.Completions.ChatCompletionToolChoiceOption;
+    stream_options?: OpenAI.Chat.Completions.ChatCompletionStreamOptions;
 }
 /**
  * Options for the individual "prompt" function calls.
@@ -119,8 +127,13 @@ export declare function createLlmClient(params: CreateLlmClientParams): {
         (content: string, options?: LlmCommonOptions): Promise<Buffer>;
         (options: LlmPromptOptions): Promise<Buffer>;
     };
+    promptAudioStream: {
+        (content: string, options?: LlmCommonOptions): AsyncIterable<Buffer>;
+        (options: LlmPromptOptions): AsyncIterable<Buffer>;
+    };
 };
 export type PromptFunction = ReturnType<typeof createLlmClient>['prompt'];
 export type PromptTextFunction = ReturnType<typeof createLlmClient>['promptText'];
 export type PromptImageFunction = ReturnType<typeof createLlmClient>['promptImage'];
 export type PromptAudioFunction = ReturnType<typeof createLlmClient>['promptAudio'];
+export type PromptAudioStreamFunction = ReturnType<typeof createLlmClient>['promptAudioStream'];

package/dist/createLlmClient.js

@@ -1,6 +1,6 @@
 import { executeWithRetry } from './retryUtils.js';
 import { truncateMessages, getPromptSummary } from './util.js';
-import { extractImageBuffer, extractAudioBuffer } from './extractBinary.js';
+import { extractImageBuffer, extractAudioBuffer, extractAudioDeltaData } from './extractBinary.js';
 import { createDnsFetcher } from './createDnsFetcher.js';
 export class LlmFatalError extends Error {
     cause;
@@ -63,8 +63,47 @@ export function normalizeOptions(arg1, arg2) {
 export function createLlmClient(params) {
     const { openai, defaultModel: factoryDefaultModel, maxConversationChars, queue, defaultRequestOptions, retryBaseDelay: factoryRetryBaseDelay = 1000, fetch: factoryFetch } = params;
     const fetchImpl = factoryFetch ?? createDnsFetcher();
+    const getErrorMessage = (error) => [
+        error?.message,
+        error?.cause?.message,
+        error?.error?.message,
+        error?.cause?.error?.message,
+        error?.response?.data?.error?.message
+    ].filter(Boolean).join('\n');
+    const isStreamingUnsupportedError = (error) => {
+        const message = getErrorMessage(error);
+        return /stream(ing)?\s+(is\s+)?not\s+supported|does\s+not\s+support\s+stream|stream\s+unsupported/i.test(message);
+    };
+    const withAudioOutputDefaults = (promptParams, defaultFormat) => {
+        const factoryModelConfig = typeof factoryDefaultModel === 'object' && factoryDefaultModel !== null
+            ? factoryDefaultModel
+            : {};
+        const callModelConfig = typeof promptParams.model === 'object' && promptParams.model !== null
+            ? promptParams.model
+            : {};
+        const nextModalities = [
+            ...(factoryModelConfig.modalities ?? []),
+            ...(callModelConfig.modalities ?? []),
+            ...(promptParams.modalities ?? [])
+        ];
+        if (!nextModalities.includes('text'))
+            nextModalities.push('text');
+        if (!nextModalities.includes('audio'))
+            nextModalities.push('audio');
+        return {
+            ...promptParams,
+            modalities: [...new Set(nextModalities)],
+            audio: {
+                voice: 'alloy',
+                format: defaultFormat,
+                ...(factoryModelConfig.audio ?? {}),
+                ...(callModelConfig.audio ?? {}),
+                ...(promptParams.audio ?? {})
+            }
+        };
+    };
     const getCompletionParams = (promptParams) => {
-        const { model: callSpecificModel, messages, retries, retryBaseDelay: callSpecificRetryBaseDelay, requestOptions, ...restApiOptions } = promptParams;
+        const { model: callSpecificModel, messages, retries, retryBaseDelay: callSpecificRetryBaseDelay, requestOptions, audioTransport: _audioTransport, ...restApiOptions } = promptParams;
         const finalMessages = maxConversationChars
             ? truncateMessages(messages, maxConversationChars)
             : messages;
@@ -146,11 +185,115 @@ export function createLlmClient(params) {
         return extractImageBuffer(response, fetchImpl);
     }
     async function promptAudio(arg1, arg2) {
-        const promptParams = normalizeOptions(arg1, arg2);
-        // Ensure modalities includes audio if not explicitly set, though user should ideally provide it.
-        // We won't force it here to avoid overriding user intent, but promptAudio implies audio output.
-        const response = await prompt(promptParams);
-        return extractAudioBuffer(response);
+        const normalizedParams = normalizeOptions(arg1, arg2);
+        const transport = normalizedParams.audioTransport ?? 'auto';
+        if (transport === 'chat') {
+            const response = await prompt(withAudioOutputDefaults(normalizedParams, 'mp3'));
+            return extractAudioBuffer(response);
+        }
+        const streamParams = withAudioOutputDefaults(normalizedParams, 'pcm16');
+        try {
+            return await promptAudioViaChatStream(streamParams);
+        }
+        catch (error) {
+            if (transport === 'auto' && isStreamingUnsupportedError(error)) {
+                const response = await prompt(withAudioOutputDefaults(normalizedParams, 'mp3'));
+                return extractAudioBuffer(response);
+            }
+            throw error;
+        }
+    }
+    async function* promptAudioStream(arg1, arg2) {
+        const promptParams = withAudioOutputDefaults(normalizeOptions(arg1, arg2), 'pcm16');
+        const { completionParams, finalMessages, retries, requestOptions, retryBaseDelay: baseDelay } = getCompletionParams(promptParams);
+        const promptSummary = getPromptSummary(finalMessages);
+        const streamParams = {
+            ...completionParams,
+            stream: true
+        };
+        const streamEvents = [];
+        let wakeConsumer;
+        const pushStreamEvent = (event) => {
+            streamEvents.push(event);
+            wakeConsumer?.();
+            wakeConsumer = undefined;
+        };
+        const nextStreamEvent = async () => {
+            while (streamEvents.length === 0) {
+                await new Promise(resolve => {
+                    wakeConsumer = resolve;
+                });
+            }
+            return streamEvents.shift();
+        };
+        let emittedChunkCount = 0;
+        async function readStream() {
+            let chunkCount = 0;
+            try {
+                const stream = await openai.chat.completions.create(streamParams, requestOptions);
+                for await (const chunk of stream) {
+                    const audioData = extractAudioDeltaData(chunk);
+                    if (audioData) {
+                        chunkCount += 1;
+                        emittedChunkCount += 1;
+                        pushStreamEvent({ type: 'chunk', chunk: Buffer.from(audioData, 'base64') });
+                    }
+                }
+                return chunkCount;
+            }
+            catch (error) {
+                if (error?.status === 400 || error?.status === 401 || error?.status === 403) {
+                    throw new LlmFatalError(error.message || 'Fatal API Error', error, finalMessages);
+                }
+                throw error;
+            }
+        }
+        const task = () => executeWithRetry(() => readStream(), async (chunkCount) => {
+            if (chunkCount === 0) {
+                return {
+                    isValid: false,
+                    feedbackForNextAttempt: {
+                        type: 'EMPTY_AUDIO_STREAM',
+                        message: 'LLM returned no streamed audio content.'
+                    }
+                };
+            }
+            return { isValid: true, data: chunkCount };
+        }, retries ?? 3, undefined, (error) => {
+            if (emittedChunkCount > 0)
+                return false;
+            if (error instanceof LlmFatalError)
+                return false;
+            if (error?.status === 400 || error?.status === 401 || error?.status === 403 || error?.code === 'invalid_api_key') {
+                return false;
+            }
+            return true;
+        }, baseDelay);
+        const producer = (queue
+            ? queue.add(task, { id: promptSummary, messages: finalMessages })
+            : task());
+        producer
+            .then(() => pushStreamEvent({ type: 'done' }))
+            .catch(error => pushStreamEvent({ type: 'error', error }));
+        while (true) {
+            const event = await nextStreamEvent();
+            if (event.type === 'chunk') {
+                yield event.chunk;
+            }
+            else if (event.type === 'error') {
+                throw event.error;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    async function promptAudioViaChatStream(promptParams) {
+        const chunks = [];
+        for await (const chunk of promptAudioStream(promptParams)) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
     }
-    return { prompt, promptText, promptImage, promptAudio };
+    return { prompt, promptText, promptImage, promptAudio, promptAudioStream };
 }

package/dist/createLlmRetryClient.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { PromptFunction, LlmCommonOptions, LlmPromptOptions } from "./createLlmClient.js";
+import { PromptFunction, PromptAudioFunction, LlmCommonOptions, LlmPromptOptions } from "./createLlmClient.js";
 import { ConversationState } from './createConversation.js';
 export declare class LlmRetryError extends Error {
     readonly message: string;
@@ -38,6 +38,7 @@ export interface LlmRetryOptions<T = any> extends LlmCommonOptions {
 }
 export interface CreateLlmRetryClientParams {
     prompt: PromptFunction;
+    promptAudio?: PromptAudioFunction;
     fallbackPrompt?: PromptFunction;
     retryBaseDelay?: number;
     /** Optional custom fetch implementation for binary extraction */

package/dist/createLlmRetryClient.js

@@ -68,7 +68,7 @@ function constructLlmMessages(initialMessages, attemptNumber, previousError) {
     return messages;
 }
 export function createLlmRetryClient(params) {
-    const { prompt, fallbackPrompt, retryBaseDelay: factoryRetryBaseDelay = 0, fetch: factoryFetch } = params;
+    const { prompt, promptAudio, fallbackPrompt, retryBaseDelay: factoryRetryBaseDelay = 0, fetch: factoryFetch } = params;
     const fetchImpl = factoryFetch ?? createDnsFetcher();
     async function runPromptLoop(retryParams) {
         const { maxRetries = 3, validate, messages: initialMessages, retryBaseDelay = factoryRetryBaseDelay, state, ...restOptions } = retryParams;
@@ -192,6 +192,13 @@ export function createLlmRetryClient(params) {
     async function promptAudioRetry(arg1, arg2) {
         const retryParams = normalizeRetryOptions(arg1, arg2);
         const userValidate = retryParams.validate;
+        if (promptAudio && !userValidate && !retryParams.state && !fallbackPrompt) {
+            const { maxRetries, validate, state, ...promptOptions } = retryParams;
+            return await promptAudio({
+                ...promptOptions,
+                retries: maxRetries ?? promptOptions.retries
+            });
+        }
         retryParams.validate = async (completion, info) => {
             try {
                 const buffer = extractAudioBuffer(completion);

package/dist/createMockOpenAi.js

@@ -1,59 +1,59 @@
 import { getPromptSummary } from "./util.js";
 import { LlmFatalError } from "./createLlmClient.js";
-import { vi } from "vitest";
 export function createMockOpenAI(responses) {
     let callCount = 0;
+    const createFn = async (params) => {
+        let response;
+        const currentCall = callCount + 1;
+        const summary = getPromptSummary(params.messages);
+        console.log(`\n--- [Mock OpenAI] Call #${currentCall} ---`);
+        console.log(`Prompt: ${summary}`);
+        if (typeof responses === 'function') {
+            response = responses(params.messages);
+            if (response === undefined || response === null) {
+                throw new LlmFatalError(`[Mock OpenAI] Resolver function returned null/undefined.\n` +
+                    `Requested Call: #${currentCall}\n` +
+                    `Prompt Summary: ${summary}\n\n` +
+                    `Check your mock resolver logic to ensure it returns a valid response for this prompt.`, undefined, params.messages);
+            }
+            console.log(`Response (Resolver): ${typeof response === 'string' ? response : JSON.stringify(response, null, 2)}`);
+            callCount++;
+        }
+        else {
+            if (callCount >= responses.length) {
+                throw new LlmFatalError(`[Mock OpenAI] No more responses configured.\n` +
+                    `Requested Call: #${currentCall}\n` +
+                    `Configured Responses: ${responses.length}\n` +
+                    `Prompt Summary: ${summary}\n\n` +
+                    `Please check responses in your mock configuration array.`, undefined, params.messages);
+            }
+            response = responses[callCount];
+            console.log(`Response (Array[${callCount}]): ${typeof response === 'string' ? response : JSON.stringify(response, null, 2)}`);
+            callCount++;
+        }
+        console.log(`---------------------------------------\n`);
+        // If response is a string, wrap it in a standard text message
+        if (typeof response === 'string') {
+            return {
+                id: 'mock-id',
+                choices: [{
+                        message: { content: response }
+                    }]
+            };
+        }
+        // If response is an object, assume it's a full message object (e.g. for images/audio)
+        // or a partial choice object
+        return {
+            id: 'mock-id',
+            choices: [{
+                    message: response
+                }]
+        };
+    };
     return {
         chat: {
             completions: {
-                create: vi.fn(async (params) => {
-                    let response;
-                    const currentCall = callCount + 1;
-                    const summary = getPromptSummary(params.messages);
-                    console.log(`\n--- [Mock OpenAI] Call #${currentCall} ---`);
-                    console.log(`Prompt: ${summary}`);
-                    if (typeof responses === 'function') {
-                        response = responses(params.messages);
-                        if (response === undefined || response === null) {
-                            throw new LlmFatalError(`[Mock OpenAI] Resolver function returned null/undefined.\n` +
-                                `Requested Call: #${currentCall}\n` +
-                                `Prompt Summary: ${summary}\n\n` +
-                                `Check your mock resolver logic to ensure it returns a valid response for this prompt.`, undefined, params.messages);
-                        }
-                        console.log(`Response (Resolver): ${typeof response === 'string' ? response : JSON.stringify(response, null, 2)}`);
-                        callCount++;
-                    }
-                    else {
-                        if (callCount >= responses.length) {
-                            throw new LlmFatalError(`[Mock OpenAI] No more responses configured.\n` +
-                                `Requested Call: #${currentCall}\n` +
-                                `Configured Responses: ${responses.length}\n` +
-                                `Prompt Summary: ${summary}\n\n` +
-                                `Please check responses in your mock configuration array.`, undefined, params.messages);
-                        }
-                        response = responses[callCount];
-                        console.log(`Response (Array[${callCount}]): ${typeof response === 'string' ? response : JSON.stringify(response, null, 2)}`);
-                        callCount++;
-                    }
-                    console.log(`---------------------------------------\n`);
-                    // If response is a string, wrap it in a standard text message
-                    if (typeof response === 'string') {
-                        return {
-                            id: 'mock-id',
-                            choices: [{
-                                    message: { content: response }
-                                }]
-                        };
-                    }
-                    // If response is an object, assume it's a full message object (e.g. for images/audio)
-                    // or a partial choice object
-                    return {
-                        id: 'mock-id',
-                        choices: [{
-                                message: response
-                            }]
-                    };
-                })
+                create: createFn
             }
         }
     };

package/dist/extractBinary.d.ts

@@ -19,3 +19,10 @@ export declare function extractImageBuffer(completion: OpenAI.Chat.Completions.C
  * Extracts an audio buffer from a ChatCompletion.
  */
 export declare function extractAudioBuffer(completion: OpenAI.Chat.Completions.ChatCompletion): Buffer;
+/**
+ * Extracts Base64 audio payloads from streamed Chat Completion chunks.
+ * OpenRouter delivers audio output at `choices[0].delta.audio.data`.
+ * Some OpenAI-compatible providers may use adjacent fields, so this accepts the
+ * common variants without widening the public client API.
+ */
+export declare function extractAudioDeltaData(chunk: unknown): string | undefined;

package/dist/extractBinary.js

@@ -18,7 +18,7 @@ export function isAudioResponse(completion) {
     if (message?.audio)
         return true;
     if (Array.isArray(message?.content)) {
-        return message.content.some((part) => part.type === 'input_audio');
+        return message.content.some((part) => part.type === 'input_audio' || part.type === 'audio');
     }
     return false;
 }
@@ -66,11 +66,30 @@ export function extractAudioBuffer(completion) {
     }
     // 2. Check standard content parts
     else if (Array.isArray(message?.content)) {
-        const part = message.content.find((p) => p.type === 'input_audio');
-        audioData = part?.input_audio?.data;
+        const part = message.content.find((p) => p.type === 'input_audio' || p.type === 'audio');
+        audioData = part?.input_audio?.data || part?.audio?.data || part?.data;
     }
     if (audioData) {
         return Buffer.from(audioData, 'base64');
     }
     throw new Error("LLM returned no audio content.");
 }
+/**
+ * Extracts Base64 audio payloads from streamed Chat Completion chunks.
+ * OpenRouter delivers audio output at `choices[0].delta.audio.data`.
+ * Some OpenAI-compatible providers may use adjacent fields, so this accepts the
+ * common variants without widening the public client API.
+ */
+export function extractAudioDeltaData(chunk) {
+    const delta = chunk?.choices?.[0]?.delta;
+    const audio = delta?.audio || delta?.output_audio;
+    if (typeof audio === 'string')
+        return audio;
+    if (audio?.data)
+        return audio.data;
+    if (audio?.delta)
+        return audio.delta;
+    if (delta?.audio_data)
+        return delta.audio_data;
+    return undefined;
+}

package/dist/llmFactory.d.ts

@@ -47,5 +47,9 @@ export declare function createLlm(params: CreateLlmFactoryParams): {
         (content: string, options?: import("./createLlmClient.js").LlmCommonOptions): Promise<Buffer>;
         (options: import("./createLlmClient.js").LlmPromptOptions): Promise<Buffer>;
     };
+    promptAudioStream: {
+        (content: string, options?: import("./createLlmClient.js").LlmCommonOptions): AsyncIterable<Buffer>;
+        (options: import("./createLlmClient.js").LlmPromptOptions): AsyncIterable<Buffer>;
+    };
 };
 export type LlmClient = ReturnType<typeof createLlm>;

package/dist/llmFactory.js

@@ -7,6 +7,7 @@ export function createLlm(params) {
     const baseClient = createLlmClient(params);
     const retryClient = createLlmRetryClient({
         prompt: baseClient.prompt,
+        promptAudio: baseClient.promptAudio,
         retryBaseDelay: params.retryBaseDelay,
         fetch: params.fetch
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-fns",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,9 +8,16 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "test": "vitest run",
+    "release": "scripts/release.sh",
+    "build": "tsc",
+    "watch": "tsc -b -w"
+  },
   "keywords": [],
   "author": "",
   "license": "MIT",
+  "packageManager": "pnpm@10.6.5",
   "dependencies": {
     "ajv": "^8.17.1",
     "openai": "^6.15.0",
@@ -26,11 +33,5 @@
     "p-queue": "^9.0.1",
     "typescript": "^5.9.3",
     "vitest": "^1.6.1"
-  },
-  "scripts": {
-    "test": "vitest run",
-    "release": "scripts/release.sh",
-    "build": "tsc",
-    "watch": "tsc -b -w"
   }
-}
+}

package/readme.md

@@ -22,7 +22,7 @@ const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
 const llm = createLlm({
     openai,
-    defaultModel: 'google/gemini-3-pro-preview',
+    defaultModel: '~google/gemini-pro-latest',
     // optional: 
     // cache: Cache instance (cache-manager)
     // queue: PQueue instance for concurrency control
@@ -251,7 +251,50 @@ const buffer2 = await llm.promptImage({
 
 ---
 
-# Use Case 3: Structured Data (`llm.promptJson` & `llm.promptZod`)
+# Use Case 3: Audio (`llm.promptAudio` / `llm.promptAudioStream`)
+
+Generates audio and returns it as a `Buffer`, or yields audio chunks as they arrive. This supports providers that only expose audio output through streaming Chat Completions, including OpenRouter routes to audio-capable OpenAI models.
+
+**Return Type:** `Promise<Buffer>` for `promptAudio`, `AsyncIterable<Buffer>` for `promptAudioStream`
+
+```typescript
+import fs from 'node:fs/promises';
+
+const audio = await llm.promptAudio({
+    model: 'openai/gpt-audio-mini',
+    messages: 'Say exactly: BatchPrompt audio test.',
+    modalities: ['text', 'audio'],
+    audio: {
+        voice: 'alloy',
+        format: 'pcm16'
+    },
+    audioTransport: 'chat-stream'
+});
+
+await fs.writeFile('batchprompt-audio-test.pcm', audio);
+```
+
+For callers that want to process chunks as they arrive, use `promptAudioStream`:
+
+```typescript
+const chunks: Buffer[] = [];
+
+for await (const chunk of llm.promptAudioStream({
+    model: 'openai/gpt-audio-mini',
+    messages: 'Read this sentence aloud.',
+    audio: { voice: 'alloy', format: 'pcm16' }
+})) {
+    chunks.push(chunk);
+}
+
+await fs.writeFile('streamed-audio.pcm', Buffer.concat(chunks));
+```
+
+`promptAudio` defaults to streaming transport because some providers require it for audio output. When streaming, the default audio format is `pcm16`; OpenAI rejects `mp3` for streamed `gpt-audio-mini` responses. If you need non-streaming Chat Completions audio, pass `audioTransport: 'chat'`, where the default format is `mp3`.
+
+---
+
+# Use Case 4: Structured Data (`llm.promptJson` & `llm.promptZod`)
 
 This is a high-level wrapper that employs a **Re-asking Loop**. If the LLM outputs invalid JSON or data that fails the schema validation, the client automatically feeds the error back to the LLM and asks it to fix it (up to `maxRetries`).
 
@@ -303,7 +346,7 @@ const gameState = await llm.promptZod(
     history,             // Arg 1: Context
     GameStateSchema,     // Arg 2: Schema
     {                    // Arg 3: Options Override
-        model: "google/gemini-flash-1.5", 
+        model: "~google/gemini-flash-latest",
         disableJsonFixer: true, // Turn off the automatic JSON repair agent
         maxRetries: 0,          // Fail immediately on error
     }
@@ -392,7 +435,7 @@ const SafeSchema = z.object({
 
 ---
 
-# Use Case 4: Agentic Retry Loops (`llm.promptTextRetry`)
+# Use Case 5: Agentic Retry Loops (`llm.promptTextRetry`)
 
 The library exposes the "Conversational Retry" engine used internally by `promptZod`. You can provide a `validate` function. If it throws a `LlmRetryError`, the error message is fed back to the LLM, and it tries again.
 
@@ -420,7 +463,7 @@ const poem = await llm.promptTextRetry({
 
 ---
 
-# Use Case 5: Iterative Refinement (`createIterativeRefiner`)
+# Use Case 6: Iterative Refinement (`createIterativeRefiner`)
 
 For complex tasks where an LLM needs to "try, check, and fix" its own output (like code generation or complex configuration), use the `IterativeRefiner`.
 
@@ -615,7 +658,7 @@ function getAllResponses(error: LlmRetryExhaustedError): string[] {
 
 ---
 
-# Use Case 6: Architecture & Composition
+# Use Case 7: Architecture & Composition
 
 How to build the client manually to enable **Fallback Chains** and **Smart Routing**.
 
@@ -628,13 +671,13 @@ import { createLlmClient } from './src';
 // 1. Define a CHEAP model
 const cheapClient = createLlmClient({ 
     openai, 
-    defaultModel: 'google/gemini-flash-1.5' 
+    defaultModel: '~google/gemini-flash-latest'
 });
 
 // 2. Define a STRONG model
 const strongClient = createLlmClient({ 
     openai, 
-    defaultModel: 'google/gemini-3-pro-preview' 
+    defaultModel: '~google/gemini-pro-latest'
 });
 ```