stellarium-ts 0.14.0 → 0.16.0

package/dist/tests/integration/network.test.js

@@ -7,7 +7,7 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { verifyData } from "../../crypto/utils.js";
 import { paymentVoucherPayload } from "../../resource/invoker.js";
 import { StellariumNode } from "../../server.js";
-import { COST, generateBase64KeyPair, RECIPIENT, temperatureSource, weatherResource } from "../helpers.js";
+import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, RECIPIENT, temperatureSource, weatherResource } from "../helpers.js";
 /** A free function only callers with a grant from the provider may run. */
 function vaultResource(baseUrl) {
     return {
@@ -22,6 +22,7 @@ function vaultResource(baseUrl) {
 const vaultSource = 'request OpenVault {\n  const vault: com.example.Vault\n\n  return vault.open(city: "Oslo")\n}';
 const vault = { resourcePath: "com.example", resourceName: "Vault" };
 const HOUR = 3_600_000;
+const completeSource = 'request Complete {\n  const model: com.example.Model\n\n  return model.complete(prompt: "Hello world!", maxTokens: 10)\n}';
 function freePort() {
     return new Promise((resolve, reject) => {
         const server = createServer();
@@ -36,9 +37,11 @@ function freePort() {
  * A provider node hosting the paid weather resource, a caller node that bootstraps from it,
  * and a fake operator that records settlements. Everything runs in-process over real HTTP.
  */
-describe("two-node network", () => {
+// Each test starts real HTTP nodes on SQLite files, which can take several seconds on a loaded CI runner.
+describe("two-node network", { timeout: 15_000 }, () => {
     const servers = [];
     const settlements = [];
+    const submissions = [];
     const callerKeys = generateBase64KeyPair();
     let dir;
     let operatorUrl;
@@ -72,10 +75,12 @@ describe("two-node network", () => {
     beforeEach(async () => {
         dir = await mkdtemp(path.join(tmpdir(), "stellarium-network-"));
         settlements.length = 0;
+        submissions.length = 0;
         const operator = Fastify();
         servers.push(operator);
         operator.post("/v1/payment", async (request) => {
             settlements.push(request.body.voucher);
+            submissions.push(request.body);
             return { status: "confirmed" };
         });
         operatorUrl = `${await operator.listen({ port: 0, host: "127.0.0.1" })}/v1`;
@@ -84,6 +89,7 @@ describe("two-node network", () => {
         provider = new StellariumNode();
         await provider.register(weatherResource(providerUrl));
         await provider.register(vaultResource(providerUrl));
+        await provider.register(modelResource(providerUrl));
         await startNode(provider, {
             port: providerPort,
             ...generateBase64KeyPair(),
@@ -106,7 +112,7 @@ describe("two-node network", () => {
         expect(callerResources.resources).toContainEqual(expect.objectContaining({
             name: "Weather",
             baseUrl: providerUrl,
-            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costLamports: COST, recipientAddress: RECIPIENT } })]),
+            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT } })]),
         }));
         expect(await run(caller.url)).toEqual({ returnValue: { value: 12, error: null } });
         await vi.waitFor(() => expect(settlements).toHaveLength(1));
@@ -179,10 +185,29 @@ describe("two-node network", () => {
         });
     });
     test("the caller refuses a call that costs more than its limit", async () => {
-        const caller = await startCaller({ costLimitLamports: COST - 1 });
+        const caller = await startCaller({ costLimitMicroUsdc: COST - 1 });
         const result = await run(caller.url);
         expect(result.returnValue.value).toBeNull();
         expect(result.returnValue.error.message).toContain("exceeds the cost limit");
         expect(settlements).toEqual([]);
     });
+    describe("inference functions", () => {
+        test("the caller prices a call with the provider's estimate, pays for it, and the provider settles its usage", async () => {
+            const caller = await startCaller();
+            const result = await run(caller.url, completeSource);
+            expect(result).toEqual({ returnValue: { value: "echo: Hello world!", error: null } });
+            await vi.waitFor(() => expect(submissions).toHaveLength(1));
+            // 3 input tokens at $3/M plus 10 output tokens at $15/M, rounded up.
+            expect(submissions[0]).toMatchObject({
+                voucher: { kind: "inference", maxAmount: 159, maxTokens: 10, ...INFERENCE_RATES, recipientAddress: RECIPIENT, publicKey: callerKeys.publicKey },
+                usage: { inputTokens: 3, outputTokens: 10 },
+            });
+        });
+        test("the caller refuses a call whose maxAmount is over its inference cost limit", async () => {
+            const caller = await startCaller({ inferenceCostLimitMicroUsdc: 158 });
+            const result = await run(caller.url, completeSource);
+            expect(result.returnValue.error.message).toContain("exceeds the inference cost limit");
+            expect(submissions).toEqual([]);
+        });
+    });
 });

package/dist/tests/resource/invoker.test.js

@@ -1,7 +1,8 @@
 import { generateKeyPairSync } from "node:crypto";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { verifyData } from "../../crypto/utils.js";
-import { CombinationResourceInvoker, EXTERNAL_INVOKE_MAX_RETRIES, invocationHash, paymentVoucherPayload } from "../../resource/invoker.js";
+import { CombinationResourceInvoker, EXTERNAL_INVOKE_MAX_RETRIES, inferenceVoucherPayload, invocationHash, paymentVoucherPayload } from "../../resource/invoker.js";
+import { inferenceCharge } from "../../resource/inference.js";
 function generateBase64KeyPair() {
     const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
         publicKeyEncoding: { type: "spki", format: "der" },
@@ -93,7 +94,7 @@ describe("external invoke retries", () => {
     });
     test("reuses the same payment voucher on every attempt", async () => {
         fetchMock.mockResolvedValueOnce(status(503)).mockResolvedValueOnce(status(503)).mockResolvedValueOnce(ok());
-        const invoker = createInvoker({ costLamports: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const invoker = createInvoker({ costMicroUsdc: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
         const pending = invoker.invoke(resource, "forecast", parameters);
         await vi.runAllTimersAsync();
         await pending;
@@ -139,7 +140,7 @@ describe("restricted functions", () => {
         fetchMock.mockResolvedValueOnce(new Response(null, { status: 503 })).mockResolvedValueOnce(new Response(JSON.stringify({ value: 42, error: null }), { status: 200 }));
         let nonce = 0;
         const authorize = vi.fn(() => ({ nonce: `nonce-${nonce++}` }));
-        const invoker = createInvoker({ chainFor: async () => chain, authorize }, { costLamports: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const invoker = createInvoker({ chainFor: async () => chain, authorize }, { costMicroUsdc: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
         const pending = invoker.invoke(resource, "forecast", parameters);
         await vi.runAllTimersAsync();
         await expect(pending).resolves.toEqual({ value: 42, error: null });
@@ -149,3 +150,88 @@ describe("restricted functions", () => {
         expect(authorize).toHaveBeenCalledWith(chain, { resourcePath: "com.example", resourceName: "Weather", functionName: "forecast", parameters });
     });
 });
+describe("inference functions", () => {
+    const RECIPIENT = "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2";
+    const resource = { path: "com.example", name: "Model", metadata: { baseUrl: "https://remote.example" }, functions: [] };
+    const parameters = [{ name: "prompt", value: "Hello" }, { name: "maxTokens", value: 1000 }];
+    const manifest = { inputCostMicroUsdcPerMillionTokens: 3_000_000, outputCostMicroUsdcPerMillionTokens: 15_000_000, recipientAddress: RECIPIENT };
+    // 2,000 input tokens and 1,000 output tokens: 6,000 + 15,000.
+    const MAX_AMOUNT = 21_000;
+    function createInvoker(inferenceCostLimit = 100_000, fn = { kind: "inference", paymentManifest: manifest }) {
+        const { publicKey, privateKey } = generateBase64KeyPair();
+        const repository = { getResourceFunction: async () => fn };
+        return { invoker: new CombinationResourceInvoker(repository, 100_000, publicKey, privateKey, undefined, inferenceCostLimit), publicKey };
+    }
+    const json = (body, status = 200) => new Response(JSON.stringify(body), { status });
+    let fetchMock;
+    beforeEach(() => {
+        fetchMock = vi.fn();
+        vi.stubGlobal("fetch", fetchMock);
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    test("inferenceCharge rounds up per million tokens", () => {
+        expect(inferenceCharge(manifest, 2_000, 1_000)).toBe(21_000);
+        expect(inferenceCharge({ inputCostMicroUsdcPerMillionTokens: 150_000, outputCostMicroUsdcPerMillionTokens: 0 }, 1, 1_000_000)).toBe(1);
+        expect(inferenceCharge({ inputCostMicroUsdcPerMillionTokens: 0, outputCostMicroUsdcPerMillionTokens: 0 }, 5, 5)).toBe(0);
+        expect(() => inferenceCharge({ inputCostMicroUsdcPerMillionTokens: Number.MAX_SAFE_INTEGER, outputCostMicroUsdcPerMillionTokens: 0 }, Number.MAX_SAFE_INTEGER, 0)).toThrow();
+    });
+    test("asks the provider for an estimate, then signs a voucher for its maxAmount at the advertised rates", async () => {
+        fetchMock.mockResolvedValueOnce(json({ inputTokens: 2_000, maxAmount: MAX_AMOUNT })).mockResolvedValueOnce(json({ value: "Hi", error: null, usage: { inputTokens: 1_500, outputTokens: 10 } }));
+        const { invoker, publicKey } = createInvoker();
+        const result = await invoker.invoke(resource, "complete", parameters);
+        expect(result).toEqual({ value: "Hi", error: null });
+        const [[estimateUrl, estimateInit], [runUrl, runInit]] = fetchMock.mock.calls;
+        expect(estimateUrl).toBe("https://remote.example/v1/run/resource/estimate");
+        expect(JSON.parse(estimateInit.body)).toEqual({ resourcePath: "com.example", resourceName: "Model", functionName: "complete", parameters });
+        expect(runUrl).toBe("https://remote.example/v1/run/resource");
+        const voucher = JSON.parse(runInit.body).paymentVoucher;
+        expect(voucher).toMatchObject({ kind: "inference", maxAmount: MAX_AMOUNT, maxTokens: 1000, ...manifest, publicKey });
+        expect(voucher.amount).toBeUndefined();
+        expect(Object.keys(inferenceVoucherPayload(voucher))).toEqual(["kind", "requestId", "invocationId", "maxAmount", "inputCostMicroUsdcPerMillionTokens", "outputCostMicroUsdcPerMillionTokens", "maxTokens", "recipientAddress", "expiresAt", "invocationHash", "publicKey"]);
+        expect(verifyData(inferenceVoucherPayload(voucher), publicKey, voucher.signature)).toBe(true);
+        expect(Date.parse(voucher.expiresAt) - Date.now()).toBeGreaterThan(1000 * 60 * 5);
+    });
+    test("refuses an estimate whose maxAmount doesn't follow from the advertised rates", async () => {
+        fetchMock.mockResolvedValueOnce(json({ inputTokens: 2_000, maxAmount: MAX_AMOUNT + 1 }));
+        const result = await createInvoker().invoker.invoke(resource, "complete", parameters);
+        expect(result.error?.message).toContain("doesn't match its advertised rates");
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    test("refuses a maxAmount above the inference cost limit before signing", async () => {
+        fetchMock.mockResolvedValueOnce(json({ inputTokens: 2_000, maxAmount: MAX_AMOUNT }));
+        await expect(createInvoker(MAX_AMOUNT - 1).invoker.invoke(resource, "complete", parameters)).rejects.toThrow("inference cost limit");
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    test("fails before any network call without a positive int32 maxTokens", async () => {
+        const { invoker } = createInvoker();
+        for (const value of [undefined, 0, -1, 1.5, "10", 2 ** 31]) {
+            const call = value === undefined ? [parameters[0]] : [parameters[0], { name: "maxTokens", value }];
+            const result = await invoker.invoke(resource, "complete", call);
+            expect(result.error?.message).toContain("maxTokens");
+        }
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    test("surfaces a failed estimate without signing a voucher", async () => {
+        fetchMock.mockResolvedValueOnce(json({ error: "Function is not a paid inference function" }, 400));
+        const result = await createInvoker().invoker.invoke(resource, "complete", parameters);
+        expect(result.error?.message).toContain("Function is not a paid inference function");
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    test("refuses per-token pricing on a function not declared as inference", async () => {
+        const result = await createInvoker(100_000, { paymentManifest: manifest }).invoker.invoke(resource, "complete", parameters);
+        expect(result.error?.message).toContain("isn't an inference function");
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    test("returns a local inference function's value with its usage", async () => {
+        const local = {
+            path: "com.example", name: "Model", metadata: {},
+            functions: [{ name: "complete", kind: "inference", parameters: [], returnType: "string", exec: async () => ({ value: "Hi", usage: { inputTokens: 3, outputTokens: 1 } }) }],
+        };
+        const broken = { ...local, functions: [{ ...local.functions[0], exec: async () => "Hi" }] };
+        const { invoker } = createInvoker();
+        expect(await invoker.invoke(local, "complete", parameters)).toEqual({ value: "Hi", error: null, usage: { inputTokens: 3, outputTokens: 1 } });
+        expect((await invoker.invoke(broken, "complete", parameters)).error?.message).toContain("must return { value, usage");
+    });
+});

package/dist/tests/resource/repository.test.js

@@ -51,6 +51,20 @@ describe("ResourceRepository", () => {
             ]);
             expect((await repository.getResourceFunction("com.provider", "Forecast", "tomorrow"))?.description).toBe("Tomorrow's forecast");
         });
+        test("keeps inference functions' kind and per-token pricing", async () => {
+            const pricing = { inputCostMicroUsdcPerMillionTokens: 3_000_000, outputCostMicroUsdcPerMillionTokens: 0, recipientAddress: RECIPIENT };
+            await repository.learn(resource("Model", [
+                { name: "complete", kind: "inference", parameters: [{ name: "maxTokens", type: "int32" }], paymentManifest: pricing },
+                { name: "count", paymentManifest: { costMicroUsdc: 5, recipientAddress: RECIPIENT } },
+            ]));
+            const complete = await repository.getResourceFunction("com.provider", "Model", "complete");
+            expect(complete).toMatchObject({ kind: "inference", paymentManifest: pricing });
+            const count = await repository.getResourceFunction("com.provider", "Model", "count");
+            expect(count?.kind).toBeUndefined();
+            expect(count?.paymentManifest).toEqual({ id: expect.any(Number), costMicroUsdc: 5, recipientAddress: RECIPIENT });
+            const functions = (await repository.getResource("com.provider.Model"))?.functions;
+            expect(functions.find(fn => fn.name === "complete")).toMatchObject({ kind: "inference", paymentManifest: pricing });
+        });
         test("is idempotent, so startup can run on every boot", async () => {
             const learned = resource("Forecast", [{ name: "tomorrow" }]);
             await repository.learn(learned);
@@ -88,12 +102,12 @@ describe("ResourceRepository", () => {
         test("returns each function's own payment manifest", async () => {
             await repository.learn(resource("Forecast", [
                 { name: "free" },
-                { name: "paid", paymentManifest: { costLamports: 250, recipientAddress: RECIPIENT } },
+                { name: "paid", paymentManifest: { costMicroUsdc: 250, recipientAddress: RECIPIENT } },
             ]));
             const found = await repository.getResource("com.provider.Forecast");
             expect(found.metadata).toEqual({ baseUrl: PROVIDER });
             expect(found.functions.find(f => f.name === "free")?.paymentManifest).toBeUndefined();
-            expect(found.functions.find(f => f.name === "paid")?.paymentManifest).toMatchObject({ costLamports: 250, recipientAddress: RECIPIENT });
+            expect(found.functions.find(f => f.name === "paid")?.paymentManifest).toMatchObject({ costMicroUsdc: 250, recipientAddress: RECIPIENT });
         });
         test("prefers the internal resource", async () => {
             const found = await repository.getResource("com.example.Weather");
@@ -119,13 +133,13 @@ describe("ResourceRepository", () => {
         test("adds new functions, parameters and payment manifests to a known resource", async () => {
             await save([resource("Forecast", [{ name: "today" }])]);
             const result = await save([resource("Forecast", [
-                    { name: "today", parameters: [{ name: "city", type: "string" }], paymentManifest: { costLamports: 100, recipientAddress: RECIPIENT } },
+                    { name: "today", parameters: [{ name: "city", type: "string" }], paymentManifest: { costMicroUsdc: 100, recipientAddress: RECIPIENT } },
                     { name: "tomorrow" },
                 ])]);
             expect(result).toEqual({ ok: true, rejected: [] });
             const today = await repository.getResourceFunction("com.provider", "Forecast", "today");
             expect(today?.parameters).toEqual([{ name: "city", type: "string" }]);
-            expect(today?.paymentManifest).toMatchObject({ costLamports: 100 });
+            expect(today?.paymentManifest).toMatchObject({ costMicroUsdc: 100 });
             expect(await repository.getResourceFunction("com.provider", "Forecast", "tomorrow")).toBeDefined();
         });
         test("drops descriptions that aren't strings and websites that aren't http(s) URLs", async () => {
@@ -142,7 +156,7 @@ describe("ResourceRepository", () => {
             expect([radar.website, radar.description]).toEqual(["https://radar.example", "Rain radar"]);
         });
         test("removes functions and payment manifests the peer no longer advertises", async () => {
-            await save([resource("Forecast", [{ name: "today", paymentManifest: { costLamports: 100, recipientAddress: RECIPIENT } }, { name: "old" }])]);
+            await save([resource("Forecast", [{ name: "today", paymentManifest: { costMicroUsdc: 100, recipientAddress: RECIPIENT } }, { name: "old" }])]);
             await save([resource("Forecast", [{ name: "today" }])]);
             expect((await repository.getResourceFunction("com.provider", "Forecast", "today"))?.paymentManifest).toBeUndefined();
             expect(await repository.getResourceFunction("com.provider", "Forecast", "old")).toBeUndefined();

package/dist/tests/routes.test.js

@@ -6,11 +6,11 @@ import { grantRenewalPayload, grantRequestPayload } from "../grant/grant.js";
 import { GrantRepository } from "../grant/repository.js";
 import { GrantService } from "../grant/service.js";
 import { peerAnnouncementPayload } from "../peer/repository.js";
-import { CombinationResourceInvoker, paymentVoucherPayload } from "../resource/invoker.js";
+import { CombinationResourceInvoker, inferenceVoucherPayload, paymentVoucherPayload } from "../resource/invoker.js";
 import { resourceAnnouncementPayload } from "../resource/repository.js";
 import routes from "../routes.js";
 import { createService } from "../service.js";
-import { COST, generateBase64KeyPair, RECIPIENT, temperatureSource, testConfig, weatherResource } from "./helpers.js";
+import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, RECIPIENT, temperatureSource, testConfig, weatherResource } from "./helpers.js";
 const parameters = [{ name: "city", value: "Oslo" }];
 const inMinutes = (minutes) => new Date(Date.now() + minutes * 60_000).toISOString();
 describe("routes", () => {
@@ -270,7 +270,7 @@ describe("routes", () => {
                     parameters: [{ name: "city", type: "string" }],
                     returnType: "string",
                     exec: async () => "sunny",
-                    paymentManifest: { costLamports: 500, recipientAddress: RECIPIENT },
+                    paymentManifest: { costMicroUsdc: 500, recipientAddress: RECIPIENT },
                 }],
         });
         function broadcast(resources, privateKey = keys.privateKey, publicKey = keys.publicKey) {
@@ -294,7 +294,7 @@ describe("routes", () => {
             const resources = (await fastify.inject({ method: "GET", url: "/v1/resources" })).json().resources;
             expect(resources.find((r) => r.name === "Forecast")).toMatchObject({
                 baseUrl: peer.baseUrl,
-                functions: [{ name: "tomorrow", paymentManifest: { costLamports: 500, recipientAddress: RECIPIENT } }],
+                functions: [{ name: "tomorrow", paymentManifest: { costMicroUsdc: 500, recipientAddress: RECIPIENT } }],
             });
         });
         test("rejects a broadcast from an unknown peer", async () => {
@@ -366,7 +366,7 @@ describe("restricted functions", () => {
         name: "Vault",
         functions: [
             { name: "open", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 7, restricted: true },
-            { name: "premium", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 9, restricted: true, paymentManifest: { costLamports: COST, recipientAddress: RECIPIENT } },
+            { name: "premium", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 9, restricted: true, paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT } },
         ],
     };
     const call = (functionName) => ({ resourcePath: "com.example", resourceName: "Vault", functionName, parameters });
@@ -563,3 +563,141 @@ describe("restricted functions", () => {
         });
     });
 });
+describe("inference functions", () => {
+    const weather = weatherResource();
+    const model = modelResource();
+    const caller = generateBase64KeyPair();
+    const callerInvoker = new CombinationResourceInvoker(undefined, 100_000, caller.publicKey, caller.privateKey);
+    // "Hello world!" is 3 input tokens by the fixture's estimator. 3 at $3/M plus 1,000 at $15/M, rounded up.
+    const parameters = [{ name: "prompt", value: "Hello world!" }, { name: "maxTokens", value: 1000 }];
+    const MAX_AMOUNT = 15_009;
+    const manifest = { ...INFERENCE_RATES, recipientAddress: RECIPIENT };
+    let db;
+    let service;
+    let fastify;
+    let settlePayment;
+    beforeEach(async () => {
+        db = await openDatabase(":memory:");
+        service = createService(db, [weather, model], testConfig());
+        settlePayment = vi.spyOn(service.operatorClient, "settlePayment").mockResolvedValue(undefined);
+        fastify = Fastify();
+        await fastify.register(routes, { prefix: "/v1", service });
+        await fastify.ready();
+    });
+    afterEach(async () => {
+        await fastify.close();
+        await db.close();
+        vi.restoreAllMocks();
+    });
+    const flushSettlement = () => new Promise((resolve) => setTimeout(resolve, 10));
+    function voucherFor(functionName = "complete", overrides = {}) {
+        const voucher = callerInvoker.createInferenceVoucher(manifest, MAX_AMOUNT, 1000, model.path, model.name, functionName, parameters);
+        const resigned = { ...voucher, ...overrides };
+        return { ...resigned, signature: signData(inferenceVoucherPayload(resigned), caller.privateKey) };
+    }
+    function call(url, body = {}) {
+        return fastify.inject({
+            method: "POST",
+            url,
+            payload: { resourcePath: model.path, resourceName: model.name, functionName: "complete", parameters, ...body },
+        });
+    }
+    describe("POST /v1/run/resource/estimate", () => {
+        test("returns the estimator's input tokens and the maxAmount they imply", async () => {
+            const response = await call("/v1/run/resource/estimate");
+            expect(response.statusCode).toBe(200);
+            expect(response.json()).toEqual({ inputTokens: 3, maxAmount: MAX_AMOUNT });
+        });
+        test.each([
+            ["a free inference function", { functionName: "draft" }],
+            ["a fixed function", { resourceName: weather.name, functionName: "temperature", parameters: [{ name: "city", value: "Oslo" }] }],
+        ])("refuses %s", async (_, body) => {
+            const response = await call("/v1/run/resource/estimate", body);
+            expect(response.statusCode).toBe(400);
+            expect(response.json()).toEqual({ error: "Function is not a paid inference function" });
+        });
+        test("refuses a call without a positive maxTokens", async () => {
+            const response = await call("/v1/run/resource/estimate", { parameters: [{ name: "prompt", value: "Hi" }, { name: "maxTokens", value: 0 }] });
+            expect(response.statusCode).toBe(400);
+        });
+        test("requires authorization for a restricted function, before running the estimator", async () => {
+            const estimator = vi.spyOn(model.functions[1], "estimateInputTokens");
+            const response = await call("/v1/run/resource/estimate", { functionName: "completePrivate" });
+            expect(response.statusCode).toBe(403);
+            expect(estimator).not.toHaveBeenCalled();
+        });
+        test("answers 500 when the estimator throws", async () => {
+            vi.spyOn(model.functions[0], "estimateInputTokens").mockRejectedValue(new Error("token counter is down"));
+            const response = await call("/v1/run/resource/estimate");
+            expect(response.statusCode).toBe(500);
+        });
+    });
+    describe("POST /v1/run/resource", () => {
+        test("runs with a voucher covering the estimate and settles the reported usage", async () => {
+            const paymentVoucher = voucherFor();
+            const response = await call("/v1/run/resource", { paymentVoucher });
+            expect(response.statusCode).toBe(200);
+            expect(response.json()).toEqual({ value: "echo: Hello world!", error: null, usage: { inputTokens: 3, outputTokens: 1000 } });
+            await flushSettlement();
+            expect(settlePayment).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
+        });
+        test("refuses a voucher below the estimator's requirement without running inference", async () => {
+            const exec = vi.spyOn(model.functions[0], "exec");
+            const response = await call("/v1/run/resource", { paymentVoucher: voucherFor("complete", { maxAmount: MAX_AMOUNT - 1 }) });
+            expect(response.statusCode).toBe(402);
+            expect(response.json()).toMatchObject({ requiredMaxAmount: MAX_AMOUNT });
+            expect(exec).not.toHaveBeenCalled();
+            await flushSettlement();
+            expect(settlePayment).not.toHaveBeenCalled();
+        });
+        test.each([
+            ["a different input rate", { inputCostMicroUsdcPerMillionTokens: 1 }],
+            ["a different output rate", { outputCostMicroUsdcPerMillionTokens: 1 }],
+            ["a maxTokens other than the call's", { maxTokens: 999 }],
+            ["a different recipient", { recipientAddress: "11111111111111111111111111111111" }],
+        ])("rejects a voucher with %s", async (_, overrides) => {
+            const response = await call("/v1/run/resource", { paymentVoucher: voucherFor("complete", overrides) });
+            expect(response.statusCode).toBe(400);
+            expect(response.json()).toEqual({ error: "Invalid payment voucher" });
+        });
+        test("rejects a fixed voucher for an inference function, and an inference voucher for a fixed function", async () => {
+            const fixed = callerInvoker.createPaymentVoucher(RECIPIENT, MAX_AMOUNT, model.path, model.name, "complete", parameters);
+            expect((await call("/v1/run/resource", { paymentVoucher: fixed })).statusCode).toBe(400);
+            const weatherParameters = [{ name: "city", value: "Oslo" }];
+            const inference = callerInvoker.createInferenceVoucher(manifest, MAX_AMOUNT, 1000, weather.path, weather.name, "temperature", weatherParameters);
+            const response = await call("/v1/run/resource", { resourceName: weather.name, functionName: "temperature", parameters: weatherParameters, paymentVoucher: inference });
+            expect(response.statusCode).toBe(400);
+        });
+        test("caps reported output at maxTokens", async () => {
+            vi.spyOn(model.functions[0], "exec").mockResolvedValue({ value: "long", usage: { inputTokens: 3, outputTokens: 5000 } });
+            const paymentVoucher = voucherFor();
+            const response = await call("/v1/run/resource", { paymentVoucher });
+            expect(response.json().usage).toEqual({ inputTokens: 3, outputTokens: 1000 });
+            await flushSettlement();
+            expect(settlePayment).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
+        });
+        test("does not settle a call that charges nothing", async () => {
+            vi.spyOn(model.functions[0], "exec").mockResolvedValue({ value: "", usage: { inputTokens: 0, outputTokens: 0 } });
+            const response = await call("/v1/run/resource", { paymentVoucher: voucherFor() });
+            expect(response.statusCode).toBe(200);
+            await flushSettlement();
+            expect(settlePayment).not.toHaveBeenCalled();
+        });
+        test("does not settle when the function doesn't report usage", async () => {
+            vi.spyOn(model.functions[0], "exec").mockResolvedValue("no usage");
+            const response = await call("/v1/run/resource", { paymentVoucher: voucherFor() });
+            expect(response.json().error.message).toContain("must return { value, usage");
+            await flushSettlement();
+            expect(settlePayment).not.toHaveBeenCalled();
+        });
+    });
+    test("GET /v1/resources announces the kind and per-token pricing", async () => {
+        const response = await fastify.inject({ method: "GET", url: "/v1/resources" });
+        const functions = response.json().resources.find((resource) => resource.name === "Model").functions;
+        expect(functions[0]).toMatchObject({ name: "complete", kind: "inference", paymentManifest: manifest });
+        expect(functions[2]).toMatchObject({ name: "draft", kind: "inference" });
+        expect(functions[2].paymentManifest).toBeUndefined();
+        const temperature = response.json().resources.find((resource) => resource.name === "Weather").functions[0];
+        expect(temperature.kind).toBeUndefined();
+    });
+});

package/dist/tests/server.test.js

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, test, vi } from "vitest";
-import { DEFAULT_COST_LIMIT_LAMPORTS, resolveConfig } from "../server.js";
-import { weatherResource } from "./helpers.js";
+import { DEFAULT_COST_LIMIT_MICRO_USDC, resolveConfig } from "../server.js";
+import { modelResource, weatherResource } from "./helpers.js";
 describe("resolveConfig", () => {
     const keys = { baseUrl: "http://node.example", publicKey: "public", privateKey: "private" };
     afterEach(() => {
@@ -15,15 +15,15 @@ describe("resolveConfig", () => {
         vi.stubEnv("BASE_URL", "http://env.example");
         vi.stubEnv("SIGNING_PUBLIC_KEY", "env-public");
         vi.stubEnv("SIGNING_PRIVATE_KEY", "env-private");
-        vi.stubEnv("COST_LIMIT_LAMPORTS", "500");
-        expect(resolveConfig({})).toMatchObject({ baseUrl: "http://env.example", publicKey: "env-public", privateKey: "env-private", costLimitLamports: 500 });
+        vi.stubEnv("COST_LIMIT_MICRO_USDC", "500");
+        expect(resolveConfig({})).toMatchObject({ baseUrl: "http://env.example", publicKey: "env-public", privateKey: "env-private", costLimitMicroUsdc: 500 });
     });
     test("defaults the cost limit", () => {
-        vi.stubEnv("COST_LIMIT_LAMPORTS", undefined);
-        expect(resolveConfig(keys).costLimitLamports).toBe(DEFAULT_COST_LIMIT_LAMPORTS);
+        vi.stubEnv("COST_LIMIT_MICRO_USDC", undefined);
+        expect(resolveConfig(keys).costLimitMicroUsdc).toBe(DEFAULT_COST_LIMIT_MICRO_USDC);
     });
-    test.each([-1, 1.5, Number.NaN])("rejects a cost limit of %s", (costLimitLamports) => {
-        expect(() => resolveConfig({ ...keys, costLimitLamports })).toThrow("costLimitLamports");
+    test.each([-1, 1.5, Number.NaN])("rejects a cost limit of %s", (costLimitMicroUsdc) => {
+        expect(() => resolveConfig({ ...keys, costLimitMicroUsdc })).toThrow("costLimitMicroUsdc");
     });
     test("requires the signing keys and base URL", () => {
         vi.stubEnv("SIGNING_PRIVATE_KEY", undefined);
@@ -34,4 +34,31 @@ describe("resolveConfig", () => {
         expect(resolveConfig(keys, []).operatorUrl).toBeUndefined();
         expect(() => resolveConfig(keys, [weatherResource()])).toThrow("OPERATOR_URL is required");
     });
+    test("defaults the inference cost limit to the cost limit, and reads its own option or environment variable", () => {
+        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USDC", undefined);
+        expect(resolveConfig({ ...keys, costLimitMicroUsdc: 700 }).inferenceCostLimitMicroUsdc).toBe(700);
+        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USDC", "900");
+        expect(resolveConfig({ ...keys, costLimitMicroUsdc: 700 }).inferenceCostLimitMicroUsdc).toBe(900);
+        expect(resolveConfig({ ...keys, inferenceCostLimitMicroUsdc: 1_000 }).inferenceCostLimitMicroUsdc).toBe(1_000);
+        expect(() => resolveConfig({ ...keys, inferenceCostLimitMicroUsdc: -1 })).toThrow("inferenceCostLimitMicroUsdc");
+    });
+    test("accepts well-declared inference functions", () => {
+        expect(() => resolveConfig({ ...keys, operatorUrl: "http://operator.example" }, [modelResource()])).not.toThrow();
+    });
+    test.each([
+        ["without a maxTokens parameter", { parameters: [{ name: "prompt", type: "string" }] }, "maxTokens: int32"],
+        ["whose maxTokens isn't an int32", { parameters: [{ name: "maxTokens", type: "int64" }] }, "maxTokens: int32"],
+        ["that is paid but has no estimator", { estimateInputTokens: undefined }, "estimateInputTokens"],
+        ["priced with a flat cost", { paymentManifest: { costMicroUsdc: 5, recipientAddress: "r" } }, "per million tokens"],
+        ["with a negative rate", { paymentManifest: { inputCostMicroUsdcPerMillionTokens: -1, outputCostMicroUsdcPerMillionTokens: 0, recipientAddress: "r" } }, "per million tokens"],
+    ])("rejects an inference function %s", (_, overrides, message) => {
+        const model = modelResource();
+        model.functions = [{ ...model.functions[0], ...overrides }];
+        expect(() => resolveConfig({ ...keys, operatorUrl: "http://operator.example" }, [model])).toThrow(message);
+    });
+    test("rejects per-token pricing on a function not declared as inference", () => {
+        const model = modelResource();
+        model.functions = [{ ...model.functions[0], kind: undefined }];
+        expect(() => resolveConfig({ ...keys, operatorUrl: "http://operator.example" }, [model])).toThrow("kind 'inference'");
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stellarium-ts",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "A Stellarium Node in TypeScript.",
   "homepage": "https://github.com/qualletio/stellarium-ts#readme",
   "bugs": {