stellarium-ts 0.15.0 → 0.17.0

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

@@ -3,7 +3,7 @@ import { signData } from "../../crypto/utils.js";
 import { openDatabase } from "../../db/db.js";
 import { PeerRepository } from "../../peer/repository.js";
 import { resourceAnnouncementPayload, ResourceRepository } from "../../resource/repository.js";
-import { generateBase64KeyPair, RECIPIENT, weatherResource } from "../helpers.js";
+import { generateBase64KeyPair, ORGANIZATION, weatherResource } from "../helpers.js";
 const SELF = "http://self.example";
 const PROVIDER = "http://provider.example";
 function resource(name, functions, baseUrl = PROVIDER) {
@@ -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 = { inputCostMicroUsdPerMillionTokens: 3_000_000, outputCostMicroUsdPerMillionTokens: 0, recipientOrganizationId: ORGANIZATION };
+            await repository.learn(resource("Model", [
+                { name: "complete", kind: "inference", parameters: [{ name: "maxTokens", type: "int32" }], paymentManifest: pricing },
+                { name: "count", paymentManifest: { costMicroUsd: 5, recipientOrganizationId: ORGANIZATION } },
+            ]));
+            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), costMicroUsd: 5, recipientOrganizationId: ORGANIZATION });
+            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: { costMicroUsdc: 250, recipientAddress: RECIPIENT } },
+                { name: "paid", paymentManifest: { costMicroUsd: 250, recipientOrganizationId: ORGANIZATION } },
             ]));
             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({ costMicroUsdc: 250, recipientAddress: RECIPIENT });
+            expect(found.functions.find(f => f.name === "paid")?.paymentManifest).toMatchObject({ costMicroUsd: 250, recipientOrganizationId: ORGANIZATION });
         });
         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: { costMicroUsdc: 100, recipientAddress: RECIPIENT } },
+                    { name: "today", parameters: [{ name: "city", type: "string" }], paymentManifest: { costMicroUsd: 100, recipientOrganizationId: ORGANIZATION } },
                     { 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({ costMicroUsdc: 100 });
+            expect(today?.paymentManifest).toMatchObject({ costMicroUsd: 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: { costMicroUsdc: 100, recipientAddress: RECIPIENT } }, { name: "old" }])]);
+            await save([resource("Forecast", [{ name: "today", paymentManifest: { costMicroUsd: 100, recipientOrganizationId: ORGANIZATION } }, { 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, ORGANIZATION, 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", () => {
@@ -22,12 +22,16 @@ describe("routes", () => {
     let config;
     let service;
     let fastify;
-    let settlePayment;
+    let authorize;
+    let capture;
+    let release;
     beforeEach(async () => {
         db = await openDatabase(":memory:");
         config = testConfig();
         service = createService(db, [weather], config);
-        settlePayment = vi.spyOn(service.operatorClient, "settlePayment").mockResolvedValue(undefined);
+        authorize = vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
+        capture = vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
+        release = vi.spyOn(service.operatorClient, "release").mockResolvedValue(undefined);
         fastify = Fastify();
         await fastify.register(routes, { prefix: "/v1", service });
         await fastify.ready();
@@ -41,7 +45,7 @@ describe("routes", () => {
     const flushSettlement = () => new Promise((resolve) => setTimeout(resolve, 10));
     describe("POST /v1/run/resource", () => {
         function voucherFor(functionName = "temperature", overrides = {}) {
-            const voucher = callerInvoker.createPaymentVoucher(RECIPIENT, COST, weather.path, weather.name, functionName, parameters);
+            const voucher = callerInvoker.createPaymentVoucher(ORGANIZATION, COST, weather.path, weather.name, functionName, parameters);
             if (Object.keys(overrides).length === 0) {
                 return voucher;
             }
@@ -56,13 +60,30 @@ describe("routes", () => {
                 payload: { resourcePath: weather.path, resourceName: weather.name, functionName: "temperature", parameters, ...body },
             });
         }
-        test("runs a paid function with a valid voucher and settles it", async () => {
+        test("authorizes a paid function's voucher, runs it, then captures it", async () => {
             const paymentVoucher = voucherFor();
             const response = await runResource({ paymentVoucher });
             expect(response.statusCode).toBe(200);
             expect(response.json()).toEqual({ value: 12, error: null });
+            expect(authorize).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
             await flushSettlement();
-            expect(settlePayment).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher });
+            expect(capture).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher });
+            expect(release).not.toHaveBeenCalled();
+        });
+        test.each([
+            [402, "Insufficient balance"],
+            [403, "Payer organization is frozen"],
+            [503, "Payment operator is unavailable"],
+        ])("answers the operator's %i refusal without running the function", async (status, error) => {
+            authorize.mockResolvedValueOnce({ ok: false, status, error });
+            const exec = vi.spyOn(weather.functions[0], "exec");
+            const response = await runResource({ paymentVoucher: voucherFor() });
+            expect(response.statusCode).toBe(status);
+            expect(response.json()).toEqual({ error });
+            expect(exec).not.toHaveBeenCalled();
+            await flushSettlement();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).not.toHaveBeenCalled();
         });
         test("refuses a voucher from a blocked caller, even for an unrestricted function", async () => {
             await service.grantService.block(caller.publicKey);
@@ -70,7 +91,7 @@ describe("routes", () => {
             expect(response.statusCode).toBe(403);
             expect(response.json()).toEqual({ error: "Caller is blocked" });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test("accepts a voucher that pays more than the cost", async () => {
             const response = await runResource({ paymentVoucher: voucherFor("temperature", { amount: COST + 1 }) });
@@ -80,11 +101,11 @@ describe("routes", () => {
             const response = await runResource({});
             expect(response.statusCode).toBe(402);
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test.each([
             ["pays less than the cost", { amount: COST - 1 }],
-            ["pays a different recipient", { recipientAddress: "11111111111111111111111111111111" }],
+            ["pays a different recipient", { recipientOrganizationId: "org_other" }],
             ["has expired", { expiresAt: new Date(Date.now() - 1000).toISOString() }],
             ["has an unparseable expiry", { expiresAt: "not-a-date" }],
         ])("rejects a voucher that %s", async (_, overrides) => {
@@ -92,14 +113,14 @@ describe("routes", () => {
             expect(response.statusCode).toBe(400);
             expect(response.json()).toEqual({ error: "Invalid payment voucher" });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test("rejects a voucher whose parameters were tampered with", async () => {
             const response = await runResource({ paymentVoucher: voucherFor(), parameters: [{ name: "city", value: "Bergen" }] });
             expect(response.statusCode).toBe(400);
         });
         test("rejects a voucher issued for a different function", async () => {
-            const paymentVoucher = callerInvoker.createPaymentVoucher(RECIPIENT, COST, weather.path, weather.name, "humidity", parameters);
+            const paymentVoucher = callerInvoker.createPaymentVoucher(ORGANIZATION, COST, weather.path, weather.name, "humidity", parameters);
             const response = await runResource({ paymentVoucher });
             expect(response.statusCode).toBe(400);
         });
@@ -122,21 +143,23 @@ describe("routes", () => {
             expect(response.statusCode).toBe(200);
             expect(response.json()).toEqual({ value: 80, error: null });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test("rejects an unknown function without settling the voucher", async () => {
             const response = await runResource({ functionName: "missing", paymentVoucher: voucherFor("missing") });
             expect(response.statusCode).toBe(400);
             expect(response.json()).toEqual({ error: "Function not found" });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
-        test("does not settle when the invoke returns an error", async () => {
+        test("releases the hold when the invoke returns an error", async () => {
             vi.spyOn(service.resourceInvoker, "invoke").mockResolvedValueOnce({ value: null, error: { message: "boom" } });
-            const response = await runResource({ paymentVoucher: voucherFor() });
+            const paymentVoucher = voucherFor();
+            const response = await runResource({ paymentVoucher });
             expect(response.statusCode).toBe(200);
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
         });
         test("rejects an unknown resource", async () => {
             const response = await runResource({ resourceName: "Missing" });
@@ -270,7 +293,7 @@ describe("routes", () => {
                     parameters: [{ name: "city", type: "string" }],
                     returnType: "string",
                     exec: async () => "sunny",
-                    paymentManifest: { costMicroUsdc: 500, recipientAddress: RECIPIENT },
+                    paymentManifest: { costMicroUsd: 500, recipientOrganizationId: ORGANIZATION },
                 }],
         });
         function broadcast(resources, privateKey = keys.privateKey, publicKey = keys.publicKey) {
@@ -294,7 +317,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: { costMicroUsdc: 500, recipientAddress: RECIPIENT } }],
+                functions: [{ name: "tomorrow", paymentManifest: { costMicroUsd: 500, recipientOrganizationId: ORGANIZATION } }],
             });
         });
         test("rejects a broadcast from an unknown peer", async () => {
@@ -366,7 +389,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: { costMicroUsdc: COST, recipientAddress: RECIPIENT } },
+            { name: "premium", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 9, restricted: true, paymentManifest: { costMicroUsd: COST, recipientOrganizationId: ORGANIZATION } },
         ],
     };
     const call = (functionName) => ({ resourcePath: "com.example", resourceName: "Vault", functionName, parameters });
@@ -379,7 +402,9 @@ describe("restricted functions", () => {
     beforeEach(async () => {
         db = await openDatabase(":memory:");
         service = createService(db, [restricted], testConfig());
-        vi.spyOn(service.operatorClient, "settlePayment").mockResolvedValue(undefined);
+        vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
+        vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
+        vi.spyOn(service.operatorClient, "release").mockResolvedValue(undefined);
         callerDb = await openDatabase(":memory:");
         callerGrants = new GrantService(new GrantRepository(callerDb), { baseUrl: "http://caller", ...caller });
         grant = await service.grantService.issue(caller.publicKey, [{ resourcePath: "com.example", resourceName: "Vault" }], { lifetimeMs: 3_600_000 });
@@ -491,11 +516,11 @@ describe("restricted functions", () => {
         expect(response.statusCode).toBe(403);
     });
     test("checks the authorization before the voucher, and needs both for a paid function", async () => {
-        const paymentVoucher = callerInvoker.createPaymentVoucher(RECIPIENT, COST, "com.example", "Vault", "premium", parameters);
+        const paymentVoucher = callerInvoker.createPaymentVoucher(ORGANIZATION, COST, "com.example", "Vault", "premium", parameters);
         const unauthorized = await runResource({ ...call("premium"), paymentVoucher });
         expect(unauthorized.statusCode).toBe(403);
         await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(service.operatorClient.settlePayment).not.toHaveBeenCalled();
+        expect(service.operatorClient.authorize).not.toHaveBeenCalled();
         const unpaid = await runResource({ ...call("premium"), authorization: callerGrants.authorize(grant, call("premium")) });
         expect(unpaid.statusCode).toBe(402);
         const paid = await runResource({ ...call("premium"), paymentVoucher, authorization: callerGrants.authorize(grant, call("premium")) });
@@ -563,3 +588,149 @@ 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, recipientOrganizationId: ORGANIZATION };
+    let db;
+    let service;
+    let fastify;
+    let authorize;
+    let capture;
+    let release;
+    beforeEach(async () => {
+        db = await openDatabase(":memory:");
+        service = createService(db, [weather, model], testConfig());
+        authorize = vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
+        capture = vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
+        release = vi.spyOn(service.operatorClient, "release").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(capture).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(capture).not.toHaveBeenCalled();
+        });
+        test.each([
+            ["a different input rate", { inputCostMicroUsdPerMillionTokens: 1 }],
+            ["a different output rate", { outputCostMicroUsdPerMillionTokens: 1 }],
+            ["a maxTokens other than the call's", { maxTokens: 999 }],
+            ["a different recipient", { recipientOrganizationId: "org_other" }],
+        ])("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(ORGANIZATION, 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(capture).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
+        });
+        test("releases the hold of a call that charges nothing", async () => {
+            vi.spyOn(model.functions[0], "exec").mockResolvedValue({ value: "", usage: { inputTokens: 0, outputTokens: 0 } });
+            const paymentVoucher = voucherFor();
+            const response = await call("/v1/run/resource", { paymentVoucher });
+            expect(response.statusCode).toBe(200);
+            await flushSettlement();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
+        });
+        test("releases the hold when the function doesn't report usage", async () => {
+            vi.spyOn(model.functions[0], "exec").mockResolvedValue("no usage");
+            const paymentVoucher = voucherFor();
+            const response = await call("/v1/run/resource", { paymentVoucher });
+            expect(response.json().error.message).toContain("must return { value, usage");
+            await flushSettlement();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
+        });
+    });
+    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_MICRO_USDC, resolveConfig } from "../server.js";
-import { weatherResource } from "./helpers.js";
+import { DEFAULT_COST_LIMIT_MICRO_USD, 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_MICRO_USDC", "500");
-        expect(resolveConfig({})).toMatchObject({ baseUrl: "http://env.example", publicKey: "env-public", privateKey: "env-private", costLimitMicroUsdc: 500 });
+        vi.stubEnv("COST_LIMIT_MICRO_USD", "500");
+        expect(resolveConfig({})).toMatchObject({ baseUrl: "http://env.example", publicKey: "env-public", privateKey: "env-private", costLimitMicroUsd: 500 });
     });
     test("defaults the cost limit", () => {
-        vi.stubEnv("COST_LIMIT_MICRO_USDC", undefined);
-        expect(resolveConfig(keys).costLimitMicroUsdc).toBe(DEFAULT_COST_LIMIT_MICRO_USDC);
+        vi.stubEnv("COST_LIMIT_MICRO_USD", undefined);
+        expect(resolveConfig(keys).costLimitMicroUsd).toBe(DEFAULT_COST_LIMIT_MICRO_USD);
     });
-    test.each([-1, 1.5, Number.NaN])("rejects a cost limit of %s", (costLimitMicroUsdc) => {
-        expect(() => resolveConfig({ ...keys, costLimitMicroUsdc })).toThrow("costLimitMicroUsdc");
+    test.each([-1, 1.5, Number.NaN])("rejects a cost limit of %s", (costLimitMicroUsd) => {
+        expect(() => resolveConfig({ ...keys, costLimitMicroUsd })).toThrow("costLimitMicroUsd");
     });
     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_USD", undefined);
+        expect(resolveConfig({ ...keys, costLimitMicroUsd: 700 }).inferenceCostLimitMicroUsd).toBe(700);
+        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USD", "900");
+        expect(resolveConfig({ ...keys, costLimitMicroUsd: 700 }).inferenceCostLimitMicroUsd).toBe(900);
+        expect(resolveConfig({ ...keys, inferenceCostLimitMicroUsd: 1_000 }).inferenceCostLimitMicroUsd).toBe(1_000);
+        expect(() => resolveConfig({ ...keys, inferenceCostLimitMicroUsd: -1 })).toThrow("inferenceCostLimitMicroUsd");
+    });
+    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: { costMicroUsd: 5, recipientOrganizationId: "r" } }, "per million tokens"],
+        ["with a negative rate", { paymentManifest: { inputCostMicroUsdPerMillionTokens: -1, outputCostMicroUsdPerMillionTokens: 0, recipientOrganizationId: "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.15.0",
+  "version": "0.17.0",
   "description": "A Stellarium Node in TypeScript.",
   "homepage": "https://github.com/qualletio/stellarium-ts#readme",
   "bugs": {