@qvac/sdk 0.9.2 → 0.10.1

package/dist/examples/llamacpp-dynamic-tools.js

@@ -0,0 +1,144 @@
+/**
+ * Dynamic-tools mode example.
+ *
+ * In `dynamic` mode each user prompt can carry its own tool set: the addon
+ * anchors tools after the last user message, runs the tool-call chain, then
+ * trims the tools + chain output from the kv-cache so a later turn can ship
+ * a different tool list without poisoning the cache. Compare with
+ * `llamacpp-native-tools.ts`, which uses the default `static` mode where
+ * one shared tool set lives at the top of the session.
+ *
+ * Run with:
+ *   bun run build
+ *   bun run bare:example dist/examples/llamacpp-dynamic-tools.js
+ */
+import { z } from "zod";
+import { completion, loadModel, unloadModel, QWEN3_1_7B_INST_Q4, } from "@qvac/sdk";
+const weatherSchema = z.object({
+    city: z.string().describe("City name"),
+});
+const horoscopeSchema = z.object({
+    sign: z.string().describe("An astrological sign, e.g. Taurus or Aquarius"),
+});
+const dateSchema = z.object({});
+const toolSchemas = {
+    get_weather: weatherSchema,
+    get_horoscope: horoscopeSchema,
+    get_date: dateSchema,
+};
+const weatherTools = [
+    {
+        name: "get_weather",
+        description: "Get current weather for a city",
+        parameters: weatherSchema,
+    },
+];
+const horoscopeTools = [
+    {
+        name: "get_horoscope",
+        description: "Get today's horoscope for an astrological sign",
+        parameters: horoscopeSchema,
+    },
+];
+const dateTools = [
+    {
+        name: "get_date",
+        description: "Get today's date",
+        parameters: dateSchema,
+    },
+];
+function executeToolCall(call) {
+    if (call.name === "get_weather") {
+        const args = call.arguments;
+        return `The weather in ${args.city} is rainy, 8°C with heavy clouds.`;
+    }
+    if (call.name === "get_horoscope") {
+        const args = call.arguments;
+        return `Horoscope for ${args.sign}: a great day for new beginnings.`;
+    }
+    if (call.name === "get_date") {
+        return new Date().toISOString().slice(0, 10);
+    }
+    return `Unknown tool: ${call.name}`;
+}
+async function chatTurn({ modelId, kvCache, history, tools }) {
+    const result = completion({
+        modelId,
+        history,
+        tools,
+        kvCache,
+        stream: true,
+    });
+    const tokensTask = (async () => {
+        for await (const token of result.tokenStream) {
+            process.stdout.write(token);
+        }
+    })();
+    const toolEventsTask = (async () => {
+        for await (const evt of result.toolCallStream) {
+            console.log(`\n→ tool call: ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
+        }
+    })();
+    await Promise.all([tokensTask, toolEventsTask]);
+    const text = await result.text;
+    const toolCalls = await result.toolCalls;
+    if (toolCalls.length === 0) {
+        history.push({ role: "assistant", content: text });
+        return;
+    }
+    for (const call of toolCalls) {
+        const schema = toolSchemas[call.name];
+        if (schema) {
+            const parsed = schema.safeParse(call.arguments);
+            if (!parsed.success) {
+                console.warn(`   ✗ validation failed for ${call.name}:`, parsed.error);
+            }
+        }
+    }
+    history.push({ role: "assistant", content: text });
+    for (const call of toolCalls) {
+        history.push({ role: "tool", content: executeToolCall(call) });
+    }
+    // Follow-up turn so the model can incorporate the tool results.
+    await chatTurn({ modelId, kvCache, history, tools });
+}
+async function main() {
+    const modelId = await loadModel({
+        modelSrc: QWEN3_1_7B_INST_Q4,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+            tools: true,
+            toolsMode: "dynamic",
+        },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`✅ Model loaded: ${modelId}`);
+    const kvCache = `dynamic-tools-${Date.now()}`;
+    const history = [
+        {
+            role: "system",
+            content: "You are a helpful assistant that uses tools when they are available. " +
+                "User's cat is named Windy and dog is named Butch.",
+        },
+    ];
+    // Turn 1 — only weather tools available.
+    history.push({ role: "user", content: "What's the weather in Tokyo?" });
+    console.log("\n🤖 Turn 1 (tools=weather):\n");
+    await chatTurn({ modelId, kvCache, history, tools: weatherTools });
+    // Turn 2 — same session, swap to horoscope tools. Dynamic mode lets the
+    // model see a different tool set without invalidating the kv-cache.
+    history.push({ role: "user", content: "Now check my horoscope for Aquarius." });
+    console.log("\n\n🤖 Turn 2 (tools=horoscope):\n");
+    await chatTurn({ modelId, kvCache, history, tools: horoscopeTools });
+    // Turn 3 — swap to a parameterless tool to confirm empty-arg flows work.
+    history.push({ role: "user", content: "What's today's date?" });
+    console.log("\n\n🤖 Turn 3 (tools=date):\n");
+    await chatTurn({ modelId, kvCache, history, tools: dateTools });
+    console.log("\n\n🎉 Done.");
+    await unloadModel({ modelId, clearStorage: false });
+}
+main().catch((err) => {
+    console.error("❌ Error:", err);
+    process.exit(1);
+});

package/dist/examples/llamacpp-structured-output.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-structured-output.d.ts.map

package/dist/examples/llamacpp-structured-output.js

@@ -0,0 +1,106 @@
+import { loadModel, completion, unloadModel, QWEN3_600M_INST_Q4, } from "@qvac/sdk";
+// Demonstrates per-request structured output via `responseFormat`.
+// Three modes are exercised against the same model so you can eyeball the
+// difference between free-form text, free-form JSON, and a strict JSON Schema.
+//
+// Usage:
+//   bun run examples/llamacpp-structured-output.ts
+const PERSON_SCHEMA = {
+    type: "object",
+    properties: {
+        name: { type: "string" },
+        age: { type: "integer" },
+        occupation: { type: "string" },
+    },
+    required: ["name", "age", "occupation"],
+    additionalProperties: false,
+};
+const HISTORY = [
+    {
+        role: "system",
+        content: "You extract structured information about people from short bios. /no_think",
+    },
+    {
+        role: "user",
+        content: "Hi, I'm Alice, I'm 30 years old and I work as a data engineer.",
+    },
+];
+// `json_object` mode only enforces that the output is *some* valid JSON object
+// — it doesn't pin the keys. Small models (Qwen3-0.6B in this example) will
+// often emit `{}` because that's the shortest valid completion under the
+// grammar. The same gotcha is documented for OpenAI's `response_format:
+// json_object`. To get useful keys you either need a stronger prompt + a
+// larger model, or — better — switch to `json_schema` (mode 3 below) so the
+// grammar itself forces the keys.
+const JSON_OBJECT_HISTORY = [
+    {
+        role: "system",
+        content: 'You extract structured information about people from short bios and reply ONLY with a JSON object containing "name", "age", and "occupation". /no_think',
+    },
+    {
+        role: "user",
+        content: "Hi, I'm Alice, I'm 30 years old and I work as a data engineer.",
+    },
+];
+// Drains the run via the canonical `events` / `final` surface and returns the
+// content text. `tokenStream` / `text` / `stats` still work but are legacy and
+// will be deprecated, so new code should consume `events` for streaming and
+// await `final.contentText` for the aggregated result.
+async function runToContent(run) {
+    for await (const event of run.events) {
+        if (event.type === "contentDelta")
+            process.stdout.write(event.text);
+    }
+    const final = await run.final;
+    process.stdout.write("\n");
+    return final.contentText;
+}
+try {
+    const modelId = await loadModel({
+        modelSrc: QWEN3_600M_INST_Q4,
+        modelType: "llm",
+        onProgress: (p) => process.stdout.write(`\rLoading: ${p.percentage.toFixed(1)}%`),
+    });
+    console.log(`\nModel loaded: ${modelId}\n`);
+    console.log("--- 1. responseFormat: text (baseline, free-form) ---");
+    await runToContent(completion({
+        modelId,
+        history: HISTORY,
+        stream: true,
+        responseFormat: { type: "text" },
+    }));
+    console.log("\n--- 2. responseFormat: json_object (any valid JSON) ---");
+    const jsonObjectOut = await runToContent(completion({
+        modelId,
+        history: JSON_OBJECT_HISTORY,
+        stream: true,
+        responseFormat: { type: "json_object" },
+    }));
+    console.log("parsed:", JSON.parse(jsonObjectOut.trim()));
+    console.log("\n--- 3. responseFormat: json_schema (strict shape) ---");
+    const jsonSchemaOut = await runToContent(completion({
+        modelId,
+        history: HISTORY,
+        stream: true,
+        responseFormat: {
+            type: "json_schema",
+            json_schema: {
+                name: "person",
+                schema: PERSON_SCHEMA,
+            },
+        },
+    }));
+    // Output is guaranteed schema-valid JSON: object with exactly
+    // {name: string, age: integer, occupation: string}, no extras.
+    const parsed = JSON.parse(jsonSchemaOut.trim());
+    console.log("parsed:", parsed);
+    console.log("schema-valid:", typeof parsed.name === "string" &&
+        Number.isInteger(parsed.age) &&
+        typeof parsed.occupation === "string" &&
+        Object.keys(parsed).sort().join(",") === "age,name,occupation");
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+}

package/dist/examples/plugins.js

@@ -46,7 +46,7 @@ process.on("exit", cleanup);
 // Point config before importing the SDK.
 // In a real app, place qvac.config.json (or .js/.ts) in your project root (auto-discovered).
 process.env["QVAC_CONFIG_PATH"] = configPath;
-const { completion, translate, embed, loadModel, unloadModel, LLAMA_3_2_1B_INST_Q4_0, MARIAN_OPUS_EN_IT_Q4_0, GTE_LARGE_FP16, } = await import("@qvac/sdk");
+const { completion, translate, embed, loadModel, unloadModel, LLAMA_3_2_1B_INST_Q4_0, BERGAMOT_EN_ES, GTE_LARGE_FP16, } = await import("@qvac/sdk");
 console.log("1. LLM Completion (llamacpp-completion plugin)");
 try {
     const llmModelId = await loadModel({
@@ -78,12 +78,12 @@ catch (error) {
 console.log("2. Translation (nmtcpp-translation plugin)");
 try {
     const nmtModelId = await loadModel({
-        modelSrc: MARIAN_OPUS_EN_IT_Q4_0,
+        modelSrc: BERGAMOT_EN_ES,
         modelType: "nmt",
         modelConfig: {
-            engine: "Opus",
+            engine: "Bergamot",
             from: "en",
-            to: "it",
+            to: "es",
         },
         onProgress: (p) => console.log(`   Loading NMT: ${p.percentage.toFixed(1)}%`),
     });

package/dist/examples/suspend-resume.js

@@ -1,4 +1,4 @@
-import { loadModel, LLAMA_3_2_1B_INST_Q4_0, completion, unloadModel, suspend, resume, } from "@qvac/sdk";
+import { loadModel, LLAMA_3_2_1B_INST_Q4_0, completion, unloadModel, suspend, resume, state, } from "@qvac/sdk";
 try {
     // Load a model
     const modelId = await loadModel({
@@ -9,6 +9,7 @@ try {
         },
     });
     console.log("✅ Model loaded\n");
+    console.log(`📊 Lifecycle state: ${await state()}\n`);
     // Run a completion before suspending
     console.log("--- Completion before suspend ---");
     const result1 = completion({
@@ -23,14 +24,30 @@ try {
     // Suspend all networking and storage (e.g. app going to background)
     console.log("⏸️  Suspending...");
     await suspend();
-    console.log("✅ Suspended — Hyperswarm and Corestore resources are paused\n");
+    console.log(`📊 Lifecycle state: ${await state()}\n`);
+    try {
+        await completion({
+            modelId,
+            history: [{ role: "user", content: "This should fail" }],
+            stream: false,
+        }).text;
+    }
+    catch (error) {
+        const name = error.name;
+        if (name === "LIFECYCLE_OPERATION_BLOCKED") {
+            console.log(`🚫 Operation blocked while suspended (${name})`);
+        }
+        else {
+            throw error;
+        }
+    }
     // Simulate time in background
-    console.log("💤 Simulating 3 seconds in background...");
+    console.log("\n💤 Simulating 3 seconds in background...");
     await new Promise((resolve) => setTimeout(resolve, 3000));
     // Resume when returning to foreground
     console.log("▶️  Resuming...");
     await resume();
-    console.log("✅ Resumed — networking and storage restored\n");
+    console.log(`📊 Lifecycle state: ${await state()}\n`);
     // Run another completion after resuming
     console.log("--- Completion after resume ---");
     const result2 = completion({

package/dist/examples/{llamacpp-native-tools.js → tools/llamacpp-native-tools.js}

@@ -1,44 +1,16 @@
-import { z } from "zod";
-import { completion, loadModel, unloadModel, QWEN3_1_7B_INST_Q4, } from "../index.js";
-// Define Zod schemas for tool parameters
-const weatherSchema = z.object({
-    city: z.string().describe("City name"),
-    country: z.string().describe("Country code").optional(),
-});
-const horoscopeSchema = z.object({
-    sign: z.string().describe("An astrological sign like Taurus or Aquarius"),
-});
-// Map tool names to their schemas for runtime validation
-const toolSchemas = {
-    get_weather: weatherSchema,
-    get_horoscope: horoscopeSchema,
-};
-// Simple tool definitions - just name, description, and Zod schema!
-const tools = [
-    {
-        name: "get_weather",
-        description: "Get current weather for a city",
-        parameters: weatherSchema,
-    },
-    {
-        name: "get_horoscope",
-        description: "Get today's horoscope for an astrological sign",
-        parameters: horoscopeSchema,
-    },
-];
+import { completion, loadModel, unloadModel, QWEN3_1_7B_INST_Q4, } from "@qvac/sdk";
+import { tools, toolSchemas, mockExecute } from "./shared.js";
 try {
-    // Load model from provided file path with tools support enabled
     const modelId = await loadModel({
         modelSrc: QWEN3_1_7B_INST_Q4,
         modelType: "llm",
         modelConfig: {
             ctx_size: 4096,
-            tools: true, // Enable tools support
+            tools: true,
         },
         onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
     });
     console.log(`✅ Model loaded successfully! Model ID: ${modelId}`);
-    // Create conversation history
     const history = [
         {
             role: "system",
@@ -52,23 +24,15 @@ try {
     console.log("\n🤖 AI Response:");
     console.log("(Streaming with tool definitions in prompt)\n");
     const result = completion({ modelId, history, stream: true, tools });
-    // Consume token stream
     const tokensTask = (async () => {
         for await (const token of result.tokenStream) {
             process.stdout.write(token);
         }
     })();
-    // Consume tool call events
     const toolsTask = (async () => {
         for await (const evt of result.toolCallStream) {
-            if (evt.type === "toolCall") {
-                console.log(`\n\n→ Tool Call Detected: ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
-                console.log(`   ID: ${evt.call.id}`);
-            }
-            else if (evt.type === "toolCallError") {
-                console.warn(`\n⚠️  Tool Error: ${evt.error.message}`);
-                console.warn(`   Code: ${evt.error.code}`);
-            }
+            console.log(`\n\n→ Tool Call Detected: ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
+            console.log(`   ID: ${evt.call.id}`);
         }
     })();
     await Promise.all([tokensTask, toolsTask]);
@@ -94,36 +58,23 @@ try {
         console.log("  No tool calls detected in response");
     }
     console.log("\n📊 Performance Stats:", stats);
-    // Execute tool calls and send results back to the model
     if (toolCalls.length > 0) {
         console.log("\n\n🔧 Simulating Tool Execution...");
-        // Simulate tool execution (in a real app, you'd call actual APIs)
         const toolResults = toolCalls.map((call) => {
-            let result = "";
-            if (call.name === "get_weather") {
-                const args = call.arguments;
-                result = `The weather in ${args.city} is sunny, 22°C with light clouds.`;
-            }
-            else if (call.name === "get_horoscope") {
-                const args = call.arguments;
-                result = `Horoscope for ${args.sign}: Today is a great day for new beginnings and creative endeavors!`;
-            }
+            const result = mockExecute(call.name, call.arguments);
             console.log(`  ✓ ${call.name}: ${result}`);
             return { toolCallId: call.id, result };
         });
-        // Add tool results to conversation history
         history.push({
             role: "assistant",
             content: await result.text,
         });
-        // Add tool results as tool messages
         for (const toolResult of toolResults) {
             history.push({
                 role: "tool",
                 content: toolResult.result,
             });
         }
-        // Send follow-up question with tool results
         console.log("\n\n🤖 Follow-up Response with Tool Results:");
         const followUpResult = completion({
             modelId,

package/dist/examples/tools/llamacpp-tools-harmony-multiturn.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-tools-harmony-multiturn.d.ts.map

package/dist/examples/tools/llamacpp-tools-harmony-multiturn.js

@@ -0,0 +1,81 @@
+/**
+ * Multi-turn tool-calling example using the GPT-OSS model (Harmony dialect).
+ *
+ * GPT-OSS emits one tool call per generation, so multi-tool requests need
+ * a turn-by-turn loop: send prompt + tools → mock-execute the returned
+ * `ToolCall` → append the raw assistant frame + tool result to history →
+ * repeat until the model produces a final answer (no tool call).
+ *
+ */
+import { completion, loadModel, unloadModel, GPT_OSS_20B_INST_Q4_K_M, } from "@qvac/sdk";
+import { tools, mockExecute } from "./shared.js";
+const MAX_TURNS = 5;
+let modelId;
+try {
+    modelId = await loadModel({
+        modelSrc: GPT_OSS_20B_INST_Q4_K_M,
+        modelConfig: { ctx_size: 4096, tools: true },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`✅ Model loaded: ${modelId}`);
+    const history = [
+        {
+            role: "system",
+            content: "You are a helpful assistant that can use tools to get the weather and horoscope.",
+        },
+        {
+            role: "user",
+            content: "What's the weather in Tokyo and my horoscope for Aquarius?",
+        },
+    ];
+    for (let turn = 1; turn <= MAX_TURNS; turn++) {
+        console.log(`\n========== TURN ${turn} ==========`);
+        const result = completion({ modelId, history, tools, stream: true });
+        for await (const token of result.tokenStream) {
+            process.stdout.write(token);
+        }
+        console.log();
+        const final = await result.final;
+        console.log(`\n--- TURN ${turn} SUMMARY ---`);
+        console.log(`[sdk toolCalls] ${final.toolCalls.length}`);
+        for (const call of final.toolCalls) {
+            console.log(`  → ${call.name}(${JSON.stringify(call.arguments)})`);
+        }
+        if (final.toolCalls.length === 0) {
+            console.log(`\n🎉 Final response received — exiting loop.`);
+            break;
+        }
+        // Raw, not result.text — GPT-OSS needs its own framed output in history
+        // to anchor the next turn.
+        const assistantContent = final.raw.fullText;
+        history.push({ role: "assistant", content: assistantContent });
+        for (const call of final.toolCalls) {
+            const toolResult = mockExecute(call.name, call.arguments);
+            console.log(`  ✓ mock-executed ${call.name}: ${toolResult}`);
+            history.push({ role: "tool", content: toolResult });
+        }
+        if (turn === MAX_TURNS) {
+            console.log(`\n⚠️  MAX_TURNS (${MAX_TURNS}) reached — stopping.`);
+        }
+    }
+    console.log(`\n========== HISTORY ==========`);
+    for (const msg of history) {
+        const preview = msg.content.slice(0, 120).replace(/\n/g, "\\n");
+        console.log(`[${msg.role}] ${preview}${msg.content.length > 120 ? "…" : ""}`);
+    }
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}
+finally {
+    if (modelId) {
+        try {
+            await unloadModel({ modelId, clearStorage: false });
+            console.log(`\n[unload] done`);
+        }
+        catch (unloadError) {
+            console.error("[unload] failed:", unloadError);
+        }
+    }
+}

package/dist/examples/tools/llamacpp-tools-pythonic.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-tools-pythonic.d.ts.map

package/dist/examples/tools/llamacpp-tools-pythonic.js

@@ -0,0 +1,50 @@
+import { completion, loadModel, unloadModel, } from "@qvac/sdk";
+import { tools } from "./shared.js";
+const LFM_TOOL_HF = "https://huggingface.co/LiquidAI/LFM2-1.2B-Tool-GGUF/resolve/main/LFM2-1.2B-Tool-Q4_K_M.gguf";
+try {
+    const modelId = await loadModel({
+        modelSrc: LFM_TOOL_HF,
+        modelType: "llm",
+        modelConfig: { ctx_size: 4096, tools: true },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`✅ Model loaded: ${modelId}`);
+    const history = [
+        {
+            role: "system",
+            content: "You are a helpful assistant that can call tools to look up weather and horoscopes.",
+        },
+        {
+            role: "user",
+            content: "What's the weather in Tokyo and my horoscope for Aquarius?",
+        },
+    ];
+    console.log("\n🤖 Streaming...\n");
+    const result = completion({ modelId, history, stream: true, tools });
+    const tokensTask = (async () => {
+        for await (const token of result.tokenStream) {
+            process.stdout.write(token);
+        }
+    })();
+    const toolsTask = (async () => {
+        for await (const evt of result.toolCallStream) {
+            console.log(`\n→ ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
+        }
+    })();
+    await Promise.all([tokensTask, toolsTask]);
+    const toolCalls = await result.toolCalls;
+    console.log("\n\n📋 Final tool calls:");
+    if (toolCalls.length > 0) {
+        for (const call of toolCalls) {
+            console.log(`  - ${call.name}(${JSON.stringify(call.arguments)})`);
+        }
+    }
+    else {
+        console.log("  (none)");
+    }
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/tools/shared.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { ToolInput } from "@qvac/sdk";
+export declare const weatherSchema: z.ZodObject<{
+    city: z.ZodString;
+    country: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const horoscopeSchema: z.ZodObject<{
+    sign: z.ZodString;
+}, z.core.$strip>;
+export declare const toolSchemas: {
+    readonly get_weather: z.ZodObject<{
+        city: z.ZodString;
+        country: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly get_horoscope: z.ZodObject<{
+        sign: z.ZodString;
+    }, z.core.$strip>;
+};
+export declare const tools: ToolInput[];
+export declare function mockExecute(name: string, args: Record<string, unknown>): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/examples/tools/shared.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export const weatherSchema = z.object({
+    city: z.string().describe("City name"),
+    country: z.string().describe("Country code").optional(),
+});
+export const horoscopeSchema = z.object({
+    sign: z.string().describe("An astrological sign like Taurus or Aquarius"),
+});
+export const toolSchemas = {
+    get_weather: weatherSchema,
+    get_horoscope: horoscopeSchema,
+};
+export const tools = [
+    {
+        name: "get_weather",
+        description: "Get current weather for a city",
+        parameters: weatherSchema,
+    },
+    {
+        name: "get_horoscope",
+        description: "Get today's horoscope for an astrological sign",
+        parameters: horoscopeSchema,
+    },
+];
+export function mockExecute(name, args) {
+    if (name === "get_weather") {
+        const a = args;
+        return JSON.stringify({
+            city: a.city,
+            country: a.country ?? "unknown",
+            temperature: "22°C",
+            condition: "Partly cloudy",
+        });
+    }
+    if (name === "get_horoscope") {
+        return JSON.stringify({
+            sign: args.sign,
+            horoscope: "Today is a great day for new beginnings.",
+        });
+    }
+    return JSON.stringify({ error: `Unknown tool: ${name}` });
+}