@fusionkit/adapter-ai-sdk 0.1.0

package/dist/swarm-tools.js

@@ -0,0 +1,324 @@
+import { jsonSchema, tool } from "ai";
+import { agents, handoff, scorecardFor, targets } from "@fusionkit/handoff";
+import { PolicyDeniedError, verifyReceiptBundle } from "@fusionkit/protocol";
+import { PlaneClient } from "@fusionkit/sdk";
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_DIFF_EXCERPT_BYTES = 4 * 1024;
+const DEFAULT_WORKER_SESSION = "hermetic";
+const DEFAULT_CLOUD_SESSION = "process";
+/** Distinct workspace paths a run changed, from its receipt's boundary events. */
+function changedPaths(bundle) {
+    const paths = new Set();
+    for (const entry of bundle.events) {
+        if (entry.event.type === "file.changed")
+            paths.add(entry.event.path);
+    }
+    return [...paths];
+}
+function withScope(task) {
+    if (!task.fileScope || task.fileScope.length === 0)
+        return task.prompt;
+    return (`${task.prompt}\n\nScope: confine your changes to these files: ` +
+        `${task.fileScope.join(", ")}. Do not modify files outside this set.`);
+}
+function receiptEvidence(bundle) {
+    return {
+        contractHash: bundle.receipt.contractHash,
+        eventsHead: bundle.receipt.eventsHead,
+        verified: verifyReceiptBundle(bundle).ok
+    };
+}
+export function swarmTools(config) {
+    const context = "context" in config
+        ? config.context
+        : handoff({
+            workspace: config.workspace,
+            plane: config.plane,
+            // The default agent is pi: dispatched workers are pi runs unless a
+            // call overrides. Escalations pass the cloud agent explicitly.
+            agent: config.workerAgent ?? agents.pi(),
+            ...(config.actor ? { actor: config.actor } : {}),
+            ...(config.policy ? { policy: config.policy } : {}),
+            ...(config.secrets ? { secrets: config.secrets } : {}),
+            ...(config.allowHosts ? { allowHosts: config.allowHosts } : {}),
+            ...(config.allowUntracked ? { allowUntracked: config.allowUntracked } : {})
+        });
+    const workerTarget = targets.pool(config.workerPool);
+    const cloudTarget = targets.pool(config.cloudPool);
+    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const diffExcerptBytes = config.diffExcerptBytes ?? DEFAULT_DIFF_EXCERPT_BYTES;
+    const workerAgent = config.workerAgent ?? agents.pi();
+    const workerSession = config.workerSession ?? DEFAULT_WORKER_SESSION;
+    const cloudSession = config.cloudSession ?? DEFAULT_CLOUD_SESSION;
+    const cloudAgent = config.cloudAgent ?? agents.claudeCode();
+    const maxEscalations = config.maxEscalations;
+    // State across tool calls within one orchestrator session.
+    const runsById = new Map();
+    const pulledPaths = new Set();
+    const records = [];
+    let escalations = 0;
+    const client = config && "context" in config
+        ? undefined
+        : config.plane instanceof PlaneClient
+            ? config.plane
+            : new PlaneClient(config.plane.url, config.plane.adminToken);
+    async function diffExcerptFor(bundle) {
+        const diffHash = bundle.receipt.workspaceOut.diffHash;
+        if (!diffHash || !client)
+            return "";
+        const blob = await client.getBlob(diffHash);
+        const text = blob.toString("utf8");
+        return text.length > diffExcerptBytes ? text.slice(0, diffExcerptBytes) : text;
+    }
+    const dispatch_workers = tool({
+        description: "Fan a set of independent worker tasks out across cheap local Pi agents, " +
+            "each a governed run with a signed receipt. Returns one run id per task. " +
+            "Make the tasks independent and their file scopes disjoint; overlap is " +
+            "detected later from receipts and downgraded to escalation. Refused with " +
+            "budgetExceeded=true if the fan-out exceeds the continuation policy ceiling.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                tasks: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            prompt: { type: "string", description: "What this worker should do." },
+                            fileScope: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Files this worker is meant to touch (kept disjoint across workers)."
+                            }
+                        },
+                        required: ["prompt"],
+                        additionalProperties: false
+                    }
+                }
+            },
+            required: ["tasks"],
+            additionalProperties: false
+        }),
+        execute: async ({ tasks }) => {
+            if (tasks.length === 0) {
+                return { dispatched: [], budgetExceeded: false, reason: "no tasks supplied" };
+            }
+            const prompts = tasks.map(withScope);
+            try {
+                const runs = await context.parallel(prompts, workerTarget, {
+                    agent: workerAgent,
+                    session: workerSession,
+                    reason: `swarm fan-out of ${tasks.length} worker(s)`
+                });
+                const dispatched = runs.map((run, i) => {
+                    const prompt = prompts[i] ?? "";
+                    runsById.set(run.runId, { run, prompt });
+                    records.push({ tool: "dispatch_workers", runId: run.runId, status: "created" });
+                    return { runId: run.runId, prompt };
+                });
+                return {
+                    dispatched,
+                    budgetExceeded: false,
+                    reason: `dispatched ${dispatched.length} worker(s) to pool "${config.workerPool}"`
+                };
+            }
+            catch (error) {
+                if (error instanceof PolicyDeniedError) {
+                    // Mirror Codex's budget_limited semantics with Warrant's own policy
+                    // ceiling: the orchestrator sees the refusal as a tool result and
+                    // can dispatch a smaller batch or escalate instead.
+                    return {
+                        dispatched: [],
+                        budgetExceeded: true,
+                        reason: error.reasons.join("; ")
+                    };
+                }
+                throw error;
+            }
+        }
+    });
+    const worker_status = tool({
+        description: "Report the current status of dispatched workers without blocking, so the " +
+            "orchestrator can interleave its own work while the swarm runs.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                runIds: { type: "array", items: { type: "string" } }
+            },
+            required: ["runIds"],
+            additionalProperties: false
+        }),
+        execute: async ({ runIds }) => {
+            const statuses = await Promise.all(runIds.map(async (runId) => {
+                const entry = runsById.get(runId);
+                if (!entry)
+                    return { runId, status: "created", known: false };
+                return { runId, status: await entry.run.status(), known: true };
+            }));
+            return { statuses };
+        }
+    });
+    const pull_worker = tool({
+        description: "Wait for one worker to finish, then judge it from evidence. A failed worker " +
+            "or one whose files overlap already-pulled work is returned with verdict " +
+            "'escalate' and is NOT pulled. A clean, disjoint, completed worker is pulled " +
+            "onto the workspace of record and returned with verdict 'accepted', its " +
+            "deterministic scorecard, a diff excerpt, and its receipt.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: { runId: { type: "string" } },
+            required: ["runId"],
+            additionalProperties: false
+        }),
+        execute: async ({ runId }) => {
+            const entry = runsById.get(runId);
+            if (!entry) {
+                return {
+                    runId,
+                    status: "created",
+                    verdict: "escalate",
+                    reason: "unknown run id; dispatch it before pulling",
+                    filesChanged: []
+                };
+            }
+            const outcome = await entry.run.wait({ timeoutMs });
+            if (outcome.status !== "completed") {
+                records.push({
+                    tool: "pull_worker",
+                    runId,
+                    status: outcome.status,
+                    verdict: "escalate"
+                });
+                return {
+                    runId,
+                    status: outcome.status,
+                    verdict: "escalate",
+                    reason: outcome.status === "awaiting_approval"
+                        ? `blocked on consent: ${outcome.consentRequirements.join("; ")}`
+                        : `worker did not complete (status ${outcome.status})`,
+                    filesChanged: []
+                };
+            }
+            const bundle = await entry.run.receipt();
+            const paths = changedPaths(bundle);
+            const conflicting = paths.filter((path) => pulledPaths.has(path));
+            const evidence = receiptEvidence(bundle);
+            if (conflicting.length > 0) {
+                // Deterministic overlap, computed from receipts — never asked of a
+                // model. Refuse the pull so two workers never both write a file; the
+                // orchestrator escalates this task to start from the updated tree.
+                records.push({
+                    tool: "pull_worker",
+                    runId,
+                    status: outcome.status,
+                    verdict: "escalate",
+                    contractHash: evidence.contractHash,
+                    receiptVerified: evidence.verified
+                });
+                return {
+                    runId,
+                    status: outcome.status,
+                    verdict: "escalate",
+                    reason: `output overlaps already-pulled files: ${conflicting.join(", ")}`,
+                    filesChanged: paths,
+                    conflictingPaths: conflicting,
+                    receipt: evidence
+                };
+            }
+            const diffHash = bundle.receipt.workspaceOut.diffHash;
+            const diffBytes = diffHash && client ? (await client.getBlob(diffHash)).length : 0;
+            const scorecard = scorecardFor(bundle, diffBytes);
+            const diffExcerpt = await diffExcerptFor(bundle);
+            await entry.run.pull();
+            for (const path of paths)
+                pulledPaths.add(path);
+            records.push({
+                tool: "pull_worker",
+                runId,
+                status: outcome.status,
+                verdict: "accepted",
+                contractHash: evidence.contractHash,
+                receiptVerified: evidence.verified
+            });
+            return {
+                runId,
+                status: outcome.status,
+                verdict: "accepted",
+                reason: "completed, disjoint, and pulled onto the workspace of record",
+                filesChanged: paths,
+                scorecard,
+                diffExcerpt,
+                receipt: evidence
+            };
+        }
+    });
+    const escalate_task = tool({
+        description: "Re-run one task on the cloud target (a capable agent on a real-OS tier) " +
+            "as a governed run, then pull its result. Use for tasks a local worker " +
+            "failed or whose output collided. Bounded: refused with budgetExceeded=true " +
+            "once the escalation budget is exhausted.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                task: { type: "string" },
+                reason: { type: "string" }
+            },
+            required: ["task"],
+            additionalProperties: false
+        }),
+        execute: async ({ task, reason }) => {
+            if (maxEscalations !== undefined && escalations >= maxEscalations) {
+                return {
+                    budgetExceeded: true,
+                    reason: `escalation budget exhausted (${maxEscalations})`
+                };
+            }
+            escalations += 1;
+            const run = await context.continueIn(cloudTarget, {
+                task,
+                agent: cloudAgent,
+                session: cloudSession,
+                reason: reason ?? "swarm escalation to cloud target"
+            });
+            const outcome = await run.wait({ timeoutMs });
+            const status = outcome.status;
+            if (status !== "completed") {
+                records.push({ tool: "escalate_task", runId: run.runId, status });
+                return {
+                    budgetExceeded: false,
+                    runId: run.runId,
+                    status,
+                    reason: status === "awaiting_approval"
+                        ? `blocked on consent: ${outcome.consentRequirements.join("; ")}`
+                        : `escalation did not complete (status ${status})`
+                };
+            }
+            const bundle = await run.receipt();
+            const paths = changedPaths(bundle);
+            const evidence = receiptEvidence(bundle);
+            await run.pull();
+            for (const path of paths)
+                pulledPaths.add(path);
+            records.push({
+                tool: "escalate_task",
+                runId: run.runId,
+                status,
+                contractHash: evidence.contractHash,
+                receiptVerified: evidence.verified
+            });
+            return {
+                budgetExceeded: false,
+                runId: run.runId,
+                status,
+                reason: "escalated, completed, and pulled onto the workspace of record",
+                filesChanged: paths,
+                receipt: evidence
+            };
+        }
+    });
+    return {
+        tools: { dispatch_workers, worker_status, pull_worker, escalate_task },
+        calls: () => [...records],
+        context
+    };
+}

package/dist/test/golden.test.d.ts

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

package/dist/test/golden.test.js

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { after, before, test } from "node:test";
+import { generateText, jsonSchema, stepCountIs, tool } from "ai";
+import { MockLanguageModelV3 } from "ai/test";
+import { agents, handoff, localFirst, targets } from "@fusionkit/handoff";
+import { makeRepo, startStack } from "@fusionkit/testkit";
+const POOL = "eng-prod";
+let stack;
+let repoDir;
+let h;
+const usage = {
+    inputTokens: {
+        total: 1,
+        noCache: 1,
+        cacheRead: undefined,
+        cacheWrite: undefined
+    },
+    outputTokens: { total: 1, text: 1, reasoning: undefined }
+};
+before(async () => {
+    stack = await startStack({
+        pool: POOL,
+        startRunner: true,
+        policy: (policy) => {
+            policy.agents.allow = ["mock", "command"];
+        }
+    });
+    repoDir = makeRepo({ files: { "README.md": "# golden fixture\n" } });
+    h = handoff({
+        workspace: repoDir,
+        plane: { url: stack.planeUrl, adminToken: stack.adminToken },
+        actor: { kind: "human", id: "golden-tester" },
+        agent: agents.mock(),
+        policy: localFirst({ allowPools: [POOL] })
+    });
+});
+after(async () => {
+    await stack.stop();
+    rmSync(repoDir, { recursive: true, force: true });
+});
+test("the golden shape: generateText with h.tools, then h.needs/continueIn carrying the journal", async () => {
+    // Local tools wrapped by the context: capture, not orchestration.
+    const lookups = [];
+    const tools = h.tools({
+        lookup: tool({
+            description: "look up a fact in the local knowledge base",
+            inputSchema: jsonSchema({
+                type: "object",
+                properties: { key: { type: "string" } },
+                required: ["key"]
+            }),
+            execute: async ({ key }) => {
+                lookups.push(key);
+                return { key, value: `fact-about-${key}` };
+            }
+        })
+    });
+    let modelCalls = 0;
+    const model = new MockLanguageModelV3({
+        doGenerate: async () => {
+            modelCalls++;
+            if (modelCalls === 1) {
+                return {
+                    content: [
+                        {
+                            type: "tool-call",
+                            toolCallId: "call-1",
+                            toolName: "lookup",
+                            input: JSON.stringify({ key: "deploy-window" })
+                        }
+                    ],
+                    finishReason: { unified: "tool-calls", raw: "tool-calls" },
+                    usage,
+                    warnings: []
+                };
+            }
+            return {
+                content: [{ type: "text", text: "deploys are fine after 14:00" }],
+                finishReason: { unified: "stop", raw: "stop" },
+                usage,
+                warnings: []
+            };
+        }
+    });
+    const result = await generateText({
+        model,
+        tools,
+        prompt: "when can we deploy?",
+        stopWhen: stepCountIs(2)
+    });
+    assert.equal(result.text, "deploys are fine after 14:00");
+    assert.deepEqual(lookups, ["deploy-window"], "the tool executed locally");
+    // The journaled call is in the local trace, hashes only.
+    const toolEvents = h.trace().filter((e) => e.type === "tool.called");
+    assert.equal(toolEvents.length, 1);
+    // The golden gesture, guarded by the deterministic policy check.
+    assert.equal(h.needs(targets.pool(POOL)), true);
+    assert.equal(h.needs(targets.pool("not-allowlisted")), false);
+    const run = await h.continueIn(targets.pool(POOL), {
+        task: "apply the deploy-window fact to the rollout plan",
+        reason: "loop established the fact; continue under governance"
+    });
+    const outcome = await run.wait({ timeoutMs: 60_000 });
+    assert.equal(outcome.status, "completed");
+    // The continuation carried the tool journal as content-addressed
+    // semantic state, pinned via the envelope inside the signed contract.
+    const journalHash = run.envelope.checkpoint.semantic?.toolJournalHash;
+    assert.ok(journalHash, "checkpoint must reference the tool journal");
+    const journal = JSON.parse((await stack.client.getBlob(journalHash)).toString("utf8"));
+    assert.equal(journal.version, "warrant.tooljournal.v1");
+    assert.equal(journal.entries.length, 1);
+    const entry = journal.entries[0];
+    assert.ok(entry);
+    assert.equal(entry.toolName, "lookup");
+    assert.deepEqual(entry.input, { key: "deploy-window" });
+    assert.deepEqual(entry.output, { key: "deploy-window", value: "fact-about-deploy-window" });
+    // And the summary recomputes the whole story.
+    const summary = await h.summary();
+    assert.equal(summary.toolCalls, 1);
+    assert.equal(summary.checkpoints, 1);
+    assert.equal(summary.continuations.planned >= 1, true);
+    assert.equal(summary.runs.length, 1);
+    const summaryRun = summary.runs[0];
+    assert.ok(summaryRun);
+    assert.equal(summaryRun.runId, run.runId);
+    assert.equal(summaryRun.status, "completed");
+    assert.equal(summaryRun.target, `pool:${POOL}`);
+});

package/dist/test/managed-server.test.d.ts

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

package/dist/test/managed-server.test.js

@@ -0,0 +1,198 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, test } from "node:test";
+import { generateText, streamText } from "ai";
+import { MockLanguageModelV3 } from "ai/test";
+import { handoffModel } from "../model.js";
+import { managedModelServer } from "../managed-server.js";
+import { MlxCapabilityError } from "../mlx-env.js";
+/**
+ * Lifecycle tests against a fake OpenAI-compatible server (a node child
+ * process fully under the test's control) so they run on any host: lazy
+ * start, shared start across concurrent calls, idle scale-to-zero,
+ * transparent restart, stream leases, and cloud escalation when the env
+ * cannot be prepared.
+ */
+// Serves /v1/models (health) and /v1/chat/completions (plain + SSE).
+// FAKE_STREAM_GAP_MS inserts a mid-stream pause to exercise stream leases.
+const FAKE_SERVER_SOURCE = `
+const http = require("node:http");
+const port = Number(process.argv[2]);
+const gapMs = Number(process.env.FAKE_STREAM_GAP_MS || "0");
+const server = http.createServer((req, res) => {
+  if (req.url === "/v1/models") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ object: "list", data: [{ id: "fake", object: "model" }] }));
+    return;
+  }
+  if (req.url === "/v1/chat/completions" && req.method === "POST") {
+    let body = "";
+    req.on("data", (c) => (body += c));
+    req.on("end", () => {
+      const parsed = JSON.parse(body);
+      if (parsed.stream) {
+        res.writeHead(200, { "content-type": "text/event-stream" });
+        const chunk = (delta, finish) =>
+          "data: " + JSON.stringify({
+            id: "cmpl-1", object: "chat.completion.chunk", created: 1,
+            model: parsed.model,
+            choices: [{ index: 0, delta, finish_reason: finish }]
+          }) + "\\n\\n";
+        res.write(chunk({ role: "assistant", content: "hello " }, null));
+        setTimeout(() => {
+          res.write(chunk({ content: "world" }, null));
+          res.write(chunk({}, "stop"));
+          res.write("data: [DONE]\\n\\n");
+          res.end();
+        }, gapMs);
+        return;
+      }
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        id: "cmpl-1", object: "chat.completion", created: 1,
+        model: parsed.model,
+        choices: [{ index: 0, message: { role: "assistant", content: "hello from fake" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 2, total_tokens: 3 }
+      }));
+    });
+    return;
+  }
+  res.writeHead(404);
+  res.end();
+});
+server.listen(port, "127.0.0.1");
+`;
+const scratch = mkdtempSync(join(tmpdir(), "warrant-managed-"));
+const serverScript = join(scratch, "fake-server.cjs");
+writeFileSync(serverScript, FAKE_SERVER_SOURCE);
+after(() => rmSync(scratch, { recursive: true, force: true }));
+function fakePrepare(env = {}) {
+    return (port) => Promise.resolve({
+        cmd: process.execPath,
+        args: [serverScript, String(port)],
+        env
+    });
+}
+async function waitFor(predicate, timeoutMs = 5_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (!predicate()) {
+        if (Date.now() > deadline)
+            throw new Error("waitFor timed out");
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+}
+test("lazy start, shared start across concurrent calls, and roundtrip", async () => {
+    const events = [];
+    const model = managedModelServer({
+        prepare: fakePrepare(),
+        modelId: "fake-model",
+        idleShutdownMs: 0,
+        onEvent: (event) => events.push(event)
+    });
+    assert.equal(model.status(), "stopped", "nothing runs before the first call");
+    try {
+        const results = await Promise.all([
+            generateText({ model, prompt: "one" }),
+            generateText({ model, prompt: "two" }),
+            generateText({ model, prompt: "three" })
+        ]);
+        for (const result of results)
+            assert.equal(result.text, "hello from fake");
+        assert.equal(model.status(), "running");
+        assert.equal(events.filter((event) => event.type === "ready").length, 1, "three concurrent first calls share one server start");
+    }
+    finally {
+        await model.stop();
+    }
+    assert.equal(model.status(), "stopped");
+    const stopped = events.find((event) => event.type === "stopped");
+    assert.ok(stopped && stopped.type === "stopped" && stopped.reason === "explicit");
+});
+test("scales to zero when idle and transparently restarts", async () => {
+    const events = [];
+    const model = managedModelServer({
+        prepare: fakePrepare(),
+        modelId: "fake-model",
+        idleShutdownMs: 150,
+        onEvent: (event) => events.push(event)
+    });
+    try {
+        const first = await generateText({ model, prompt: "warm up" });
+        assert.equal(first.text, "hello from fake");
+        assert.equal(model.status(), "running");
+        await waitFor(() => model.status() === "stopped");
+        const stopped = events.find((event) => event.type === "stopped");
+        assert.ok(stopped && stopped.type === "stopped" && stopped.reason === "idle", "the idle sweep stopped the server");
+        // Next call cold-starts a fresh process without the caller noticing.
+        const second = await generateText({ model, prompt: "wake up" });
+        assert.equal(second.text, "hello from fake");
+        assert.equal(events.filter((event) => event.type === "ready").length, 2);
+    }
+    finally {
+        await model.stop();
+    }
+});
+test("a stream holds its lease: no idle shutdown mid-stream", async () => {
+    const events = [];
+    const model = managedModelServer({
+        // The mid-stream gap (400ms) far exceeds the idle window (120ms): only
+        // the held lease keeps the server alive across it.
+        prepare: fakePrepare({ FAKE_STREAM_GAP_MS: "400" }),
+        modelId: "fake-model",
+        idleShutdownMs: 120,
+        onEvent: (event) => events.push(event)
+    });
+    try {
+        const result = streamText({ model, prompt: "stream it" });
+        const text = await result.text;
+        assert.equal(text, "hello world");
+        assert.equal(events.filter((event) => event.type === "stopped").length, 0, "no shutdown while the stream was in flight");
+        await waitFor(() => model.status() === "stopped");
+        const stopped = events.find((event) => event.type === "stopped");
+        assert.ok(stopped && stopped.type === "stopped" && stopped.reason === "idle");
+    }
+    finally {
+        await model.stop();
+    }
+});
+test("startup failure surfaces with server output in the message", async () => {
+    const model = managedModelServer({
+        prepare: () => Promise.resolve({
+            cmd: process.execPath,
+            args: ["-e", "console.error('model weights not found'); process.exit(3)"],
+            env: {}
+        }),
+        modelId: "fake-model",
+        startupTimeoutMs: 5_000
+    });
+    await assert.rejects(() => generateText({ model, prompt: "boom" }), /exited during startup .*model weights not found/s);
+    assert.equal(model.status(), "stopped");
+});
+test("under handoffModel, an unpreparable env escalates to cloud", async () => {
+    const local = managedModelServer({
+        prepare: () => Promise.reject(new MlxCapabilityError("MLX requires macOS on Apple Silicon")),
+        modelId: "mlx-community/some-model"
+    });
+    const cloud = new MockLanguageModelV3({
+        modelId: "frontier-cloud",
+        doGenerate: async () => ({
+            content: [{ type: "text", text: "cloud handled it" }],
+            finishReason: { unified: "stop", raw: "stop" },
+            usage: {
+                inputTokens: {
+                    total: 1,
+                    noCache: 1,
+                    cacheRead: undefined,
+                    cacheWrite: undefined
+                },
+                outputTokens: { total: 1, text: 1, reasoning: undefined }
+            },
+            warnings: []
+        })
+    });
+    const model = handoffModel({ local, cloud });
+    const result = await generateText({ model, prompt: "hello" });
+    assert.equal(result.text, "cloud handled it");
+});

package/dist/test/mlx-env.test.d.ts

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