stellarium-ts 0.15.0 → 0.17.0

package/dist/tests/client/operatorClient.test.js

@@ -1,39 +1,94 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { OperatorClient, SETTLE_PAYMENT_MAX_RETRIES } from "../../client/operatorClient.js";
-describe("settle payment retries", () => {
-    const payment = {
-        voucher: {
-            requestId: "request-1",
-            invocationId: "invocation-1",
-            amount: 10000,
-            recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2",
-            signature: "signature",
-            expiresAt: "2030-01-01T00:00:00.000Z",
-            invocationHash: "hash",
-            publicKey: "public-key",
-        },
-    };
-    const ok = () => new Response(JSON.stringify({ success: true }), { status: 200 });
-    const status = (code, headers) => new Response(null, { status: code, headers });
-    const networkError = (code) => new TypeError("fetch failed", { cause: Object.assign(new Error(code), { code }) });
-    let fetchMock;
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.spyOn(console, "error").mockImplementation(() => { });
-        fetchMock = vi.fn();
-        vi.stubGlobal("fetch", fetchMock);
+import { AUTHORIZE_MAX_RETRIES, OPERATOR_MAX_RETRIES, OperatorClient } from "../../client/operatorClient.js";
+import { OPERATOR_AUTH_SCHEME, operatorRequestPayload } from "../../client/operatorAuth.js";
+import { verifyData } from "../../crypto/utils.js";
+import { generateBase64KeyPair } from "../helpers.js";
+const keys = generateBase64KeyPair();
+const client = () => new OperatorClient("https://operator.example/v1", keys.publicKey, keys.privateKey);
+const payment = {
+    voucher: {
+        requestId: "request-1",
+        invocationId: "invocation-1",
+        amount: 10000,
+        recipientOrganizationId: "org_provider",
+        signature: "signature",
+        expiresAt: "2030-01-01T00:00:00.000Z",
+        invocationHash: "hash",
+        publicKey: "public-key",
+    },
+};
+const ok = (body = { success: true }) => new Response(JSON.stringify(body), { status: 200 });
+const status = (code, headers) => new Response(null, { status: code, headers });
+const refusal = (code, error) => new Response(JSON.stringify({ error }), { status: code });
+const networkError = (code) => new TypeError("fetch failed", { cause: Object.assign(new Error(code), { code }) });
+let fetchMock;
+beforeEach(() => {
+    vi.useFakeTimers();
+    vi.spyOn(console, "error").mockImplementation(() => { });
+    fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+});
+afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+describe("request signing", () => {
+    test("signs the method, path, body hash and timestamp with the node key", async () => {
+        fetchMock.mockResolvedValue(ok());
+        await client().capture(payment);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe("https://operator.example/v1/payments/capture");
+        const [scheme, encoded] = init.headers.Authorization.split(" ");
+        expect(scheme).toBe(OPERATOR_AUTH_SCHEME);
+        const credentials = JSON.parse(Buffer.from(encoded, "base64url").toString());
+        expect(credentials.publicKey).toBe(keys.publicKey);
+        const payload = operatorRequestPayload("POST", "/v1/payments/capture", JSON.parse(init.body), credentials.timestamp);
+        expect(verifyData(payload, keys.publicKey, credentials.signature)).toBe(true);
+    });
+});
+describe("session", () => {
+    test("returns the node's organization, sending the enrollment token when given", async () => {
+        fetchMock.mockResolvedValue(ok({ organizationId: "org_provider" }));
+        await expect(client().session("enroll-1")).resolves.toEqual({ organizationId: "org_provider" });
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ enrollmentToken: "enroll-1" });
     });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
+    test("throws the operator's refusal", async () => {
+        fetchMock.mockResolvedValue(refusal(403, "Node is not enrolled in an organization"));
+        await expect(client().session()).rejects.toThrow("Node is not enrolled in an organization");
+    });
+});
+describe("authorize", () => {
+    test("reports a hold as ok", async () => {
+        fetchMock.mockResolvedValue(ok());
+        await expect(client().authorize(payment.voucher)).resolves.toEqual({ ok: true });
+    });
+    test.each([[402, "Insufficient balance"], [403, "Payer organization is frozen"], [422, "Recipient organization can't receive payouts"]])("passes a %i refusal through without retrying", async (code, error) => {
+        fetchMock.mockResolvedValue(refusal(code, error));
+        await expect(client().authorize(payment.voucher)).resolves.toEqual({ ok: false, status: code, error });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
     });
+    test("reports a persistent server error as 503 after its few retries", async () => {
+        fetchMock.mockResolvedValue(status(500));
+        const pending = client().authorize(payment.voucher);
+        await vi.runAllTimersAsync();
+        await expect(pending).resolves.toMatchObject({ ok: false, status: 503 });
+        expect(fetchMock).toHaveBeenCalledTimes(1 + AUTHORIZE_MAX_RETRIES);
+    });
+    test("reports an unreachable operator as 503", async () => {
+        fetchMock.mockRejectedValue(networkError("ECONNREFUSED"));
+        const pending = client().authorize(payment.voucher);
+        await vi.runAllTimersAsync();
+        await expect(pending).resolves.toEqual({ ok: false, status: 503, error: "Payment operator is unavailable" });
+    });
+});
+describe("capture and release retries", () => {
     test("retries 429 responses with exponential backoff, then succeeds", async () => {
         fetchMock
             .mockResolvedValueOnce(status(429))
             .mockResolvedValueOnce(status(429))
             .mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.advanceTimersByTimeAsync(0);
         expect(fetchMock).toHaveBeenCalledTimes(1);
         await vi.advanceTimersByTimeAsync(999);
@@ -49,7 +104,7 @@ describe("settle payment retries", () => {
     });
     test("waits for Retry-After when it is longer than the backoff", async () => {
         fetchMock.mockResolvedValueOnce(status(429, { "retry-after": "30" })).mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().release(payment.voucher);
         await vi.advanceTimersByTimeAsync(29_999);
         expect(fetchMock).toHaveBeenCalledTimes(1);
         await vi.advanceTimersByTimeAsync(1);
@@ -58,7 +113,7 @@ describe("settle payment retries", () => {
     });
     test.each([408, 500, 502, 503, 504])("retries %i responses", async (code) => {
         fetchMock.mockResolvedValueOnce(status(code)).mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.runAllTimersAsync();
         await pending;
         expect(fetchMock).toHaveBeenCalledTimes(2);
@@ -66,31 +121,34 @@ describe("settle payment retries", () => {
     });
     test.each([400, 401, 404, 409, 422])("does not retry %i responses", async (code) => {
         fetchMock.mockResolvedValue(status(code));
-        await new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        await client().capture(payment);
         expect(fetchMock).toHaveBeenCalledTimes(1);
         expect(console.error).toHaveBeenCalledOnce();
     });
     test.each(["ECONNREFUSED", "ECONNRESET"])("retries %s network errors", async (code) => {
         fetchMock.mockRejectedValueOnce(networkError(code)).mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.runAllTimersAsync();
         await pending;
         expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     test("rethrows the last network error once retries are exhausted", async () => {
         fetchMock.mockRejectedValue(networkError("ECONNREFUSED"));
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         const assertion = expect(pending).rejects.toThrow("fetch failed");
         await vi.runAllTimersAsync();
         await assertion;
-        expect(fetchMock).toHaveBeenCalledTimes(1 + SETTLE_PAYMENT_MAX_RETRIES);
+        expect(fetchMock).toHaveBeenCalledTimes(1 + OPERATOR_MAX_RETRIES);
     });
     test("gives up after the maximum number of retries", async () => {
         fetchMock.mockResolvedValue(status(429));
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.runAllTimersAsync();
         await pending;
-        expect(fetchMock).toHaveBeenCalledTimes(1 + SETTLE_PAYMENT_MAX_RETRIES);
+        expect(fetchMock).toHaveBeenCalledTimes(1 + OPERATOR_MAX_RETRIES);
         expect(console.error).toHaveBeenCalledOnce();
     });
+    test("throws when no operator URL is configured", async () => {
+        await expect(new OperatorClient(undefined, keys.publicKey, keys.privateKey).capture(payment)).rejects.toThrow("No operator URL is configured");
+    });
 });

package/dist/tests/db/db.test.js

@@ -17,7 +17,7 @@ describe("openDatabase", () => {
         const filename = path.join(dir, "node.db");
         await (await openDatabase(filename)).close();
         const db = await openDatabase(filename);
-        expect(await db.get("PRAGMA user_version")).toEqual({ user_version: 4 });
+        expect(await db.get("PRAGMA user_version")).toEqual({ user_version: 6 });
         await db.close();
     });
     test("rebuilds resource tables from the old schema and keeps peers", async () => {
@@ -61,4 +61,21 @@ describe("openDatabase", () => {
         expect(await reopened.all("SELECT id FROM held_grant")).toEqual([{ id: "g" }]);
         await reopened.close();
     });
+    test("rebuilds a version 4 manifest table into the micro-USD, organization-recipient schema", async () => {
+        const filename = path.join(dir, "v4.db");
+        const old = await open({ filename, driver: sqlite3.Database });
+        await old.exec(`
+            CREATE TABLE resource_function_payment_manifest (id INTEGER PRIMARY KEY AUTOINCREMENT, resource_function_id INTEGER NOT NULL,
+                cost_micro_usdc INTEGER NOT NULL, recipient_address TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+                UNIQUE (resource_function_id));
+            PRAGMA user_version = 4;
+        `);
+        await old.close();
+        const db = await openDatabase(filename);
+        const functionColumns = await db.all("PRAGMA table_info(resource_function)");
+        expect(functionColumns.map(column => column.name)).toContain("kind");
+        await db.run(`INSERT INTO resource_function_payment_manifest (resource_function_id, input_cost_micro_usd_per_million_tokens,
+            output_cost_micro_usd_per_million_tokens, recipient_organization_id, created_at, updated_at) VALUES (1, 3, 15, 'r', 'now', 'now')`);
+        await db.close();
+    });
 });

package/dist/tests/helpers.d.ts

@@ -4,10 +4,20 @@ export declare function generateBase64KeyPair(): {
     publicKey: string;
     privateKey: string;
 };
-export declare const RECIPIENT = "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2";
+/** The operator organization the fixture provider is enrolled in. */
+export declare const ORGANIZATION = "org_provider";
 export declare const COST = 10000;
 export declare function testConfig(overrides?: Partial<NodeConfig>): NodeConfig;
 /** The fixture provider's resource: paid `temperature` and free `humidity`. */
 export declare function weatherResource(baseUrl?: string): StellariumResource;
+export declare const INFERENCE_RATES: {
+    inputCostMicroUsdPerMillionTokens: number;
+    outputCostMicroUsdPerMillionTokens: number;
+};
+/**
+ * A fixture provider's model: paid inference `complete`, which counts one token per four prompt characters
+ * and answers with `maxTokens` tokens, a restricted paid copy `completePrivate`, and free inference `draft`.
+ */
+export declare function modelResource(baseUrl?: string): StellariumResource;
 export declare const temperatureSource = "request GetTemperature {\n  const weather: com.example.Weather\n\n  return weather.temperature(city: \"Oslo\")\n}";
 //# sourceMappingURL=helpers.d.ts.map

package/dist/tests/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/tests/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,wBAAgB,qBAAqB;IAM7B,SAAS;IACT,UAAU;EAEjB;AAED,eAAO,MAAM,SAAS,iDAAiD,CAAC;AACxE,eAAO,MAAM,IAAI,QAAQ,CAAC;AAE1B,wBAAgB,UAAU,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAS1E;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CAuBrF;AAED,eAAO,MAAM,iBAAiB,sHAAoH,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/tests/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,wBAAgB,qBAAqB;IAM7B,SAAS;IACT,UAAU;EAEjB;AAED,qEAAqE;AACrE,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,IAAI,QAAQ,CAAC;AAE1B,wBAAgB,UAAU,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAW1E;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CAuBrF;AAED,eAAO,MAAM,eAAe;IAAK,iCAAiC;IAAa,kCAAkC;CAAc,CAAC;AAEhI;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CA0BnF;AAED,eAAO,MAAM,iBAAiB,sHAAoH,CAAC"}

package/dist/tests/helpers.js

@@ -9,7 +9,8 @@ export function generateBase64KeyPair() {
         privateKey: privateKey.toString("base64url"),
     };
 }
-export const RECIPIENT = "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2";
+/** The operator organization the fixture provider is enrolled in. */
+export const ORGANIZATION = "org_provider";
 export const COST = 10000;
 export function testConfig(overrides = {}) {
     return {
@@ -17,7 +18,9 @@ export function testConfig(overrides = {}) {
         ...generateBase64KeyPair(),
         apiKey: "secret",
         operatorUrl: "http://operator.invalid/v1",
-        costLimitMicroUsdc: 100_000,
+        organizationId: ORGANIZATION,
+        costLimitMicroUsd: 100_000,
+        inferenceCostLimitMicroUsd: 100_000,
         ...overrides,
     };
 }
@@ -35,7 +38,7 @@ export function weatherResource(baseUrl = "http://127.0.0.1:3002") {
                 parameters: [{ name: "city", type: "string" }],
                 returnType: "int32",
                 exec: async (args) => (args.find((arg) => arg.name === "city")?.value === "Oslo" ? 12 : 20),
-                paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT },
+                paymentManifest: { costMicroUsd: COST },
             },
             {
                 name: "humidity",
@@ -46,4 +49,36 @@ export function weatherResource(baseUrl = "http://127.0.0.1:3002") {
         ],
     };
 }
+export const INFERENCE_RATES = { inputCostMicroUsdPerMillionTokens: 3_000_000, outputCostMicroUsdPerMillionTokens: 15_000_000 };
+/**
+ * A fixture provider's model: paid inference `complete`, which counts one token per four prompt characters
+ * and answers with `maxTokens` tokens, a restricted paid copy `completePrivate`, and free inference `draft`.
+ */
+export function modelResource(baseUrl = "http://127.0.0.1:3002") {
+    const prompt = (args) => String(args.find((arg) => arg.name === "prompt")?.value ?? "");
+    const complete = {
+        name: "complete",
+        kind: "inference",
+        parameters: [{ name: "prompt", type: "string" }, { name: "maxTokens", type: "int32" }],
+        returnType: "string",
+        estimateInputTokens: async (args) => Math.ceil(prompt(args).length / 4),
+        exec: async (args) => ({
+            value: `echo: ${prompt(args)}`,
+            usage: { inputTokens: Math.ceil(prompt(args).length / 4), outputTokens: Number(args.find((arg) => arg.name === "maxTokens")?.value) },
+        }),
+        paymentManifest: { ...INFERENCE_RATES },
+    };
+    return {
+        id: 2,
+        baseUrl,
+        metadata: {},
+        path: "com.example",
+        name: "Model",
+        functions: [
+            complete,
+            { ...complete, name: "completePrivate", restricted: true },
+            { ...complete, name: "draft", paymentManifest: undefined, estimateInputTokens: undefined },
+        ],
+    };
+}
 export const temperatureSource = 'request GetTemperature {\n  const weather: com.example.Weather\n\n  return weather.temperature(city: "Oslo")\n}';

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, ORGANIZATION, 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();
@@ -34,12 +35,18 @@ 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.
+ * and a fake operator that enrolls the provider and records holds and captures. Everything runs in-process over real HTTP.
  */
 // 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 authorizations = [];
+    const releases = [];
+    const sessions = [];
+    /** What the fake operator answers to the next authorizations; undefined places the hold. */
+    let refuseAuthorization;
     const callerKeys = generateBase64KeyPair();
     let dir;
     let operatorUrl;
@@ -73,11 +80,35 @@ describe("two-node network", { timeout: 15_000 }, () => {
     beforeEach(async () => {
         dir = await mkdtemp(path.join(tmpdir(), "stellarium-network-"));
         settlements.length = 0;
+        submissions.length = 0;
+        authorizations.length = 0;
+        releases.length = 0;
+        sessions.length = 0;
+        refuseAuthorization = undefined;
         const operator = Fastify();
         servers.push(operator);
-        operator.post("/v1/payment", async (request) => {
+        operator.post("/v1/nodes/session", async (request, reply) => {
+            if (!String(request.headers.authorization).startsWith("Stellarium ")) {
+                return reply.status(401).send({ error: "Unsigned request" });
+            }
+            sessions.push(request.body);
+            return { organizationId: ORGANIZATION };
+        });
+        operator.post("/v1/payments/authorize", async (request, reply) => {
+            authorizations.push(request.body);
+            if (refuseAuthorization) {
+                return reply.status(refuseAuthorization.status).send({ error: refuseAuthorization.error });
+            }
+            return { status: "held" };
+        });
+        operator.post("/v1/payments/capture", async (request) => {
             settlements.push(request.body.voucher);
-            return { status: "confirmed" };
+            submissions.push(request.body);
+            return { status: "captured" };
+        });
+        operator.post("/v1/payments/release", async (request) => {
+            releases.push(request.body);
+            return { status: "released" };
         });
         operatorUrl = `${await operator.listen({ port: 0, host: "127.0.0.1" })}/v1`;
         const providerPort = await freePort();
@@ -85,6 +116,7 @@ describe("two-node network", { timeout: 15_000 }, () => {
         provider = new StellariumNode();
         await provider.register(weatherResource(providerUrl));
         await provider.register(vaultResource(providerUrl));
+        await provider.register(modelResource(providerUrl));
         await startNode(provider, {
             port: providerPort,
             ...generateBase64KeyPair(),
@@ -107,12 +139,13 @@ describe("two-node network", { timeout: 15_000 }, () => {
         expect(callerResources.resources).toContainEqual(expect.objectContaining({
             name: "Weather",
             baseUrl: providerUrl,
-            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT } })]),
+            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costMicroUsd: COST, recipientOrganizationId: ORGANIZATION } })]),
         }));
         expect(await run(caller.url)).toEqual({ returnValue: { value: 12, error: null } });
         await vi.waitFor(() => expect(settlements).toHaveLength(1));
         const [voucher] = settlements;
-        expect(voucher).toMatchObject({ amount: COST, recipientAddress: RECIPIENT, publicKey: callerKeys.publicKey });
+        expect(authorizations).toEqual([{ voucher }]);
+        expect(voucher).toMatchObject({ amount: COST, recipientOrganizationId: ORGANIZATION, publicKey: callerKeys.publicKey });
         expect(verifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
     });
     test("the caller restarts on the same database without failing", async () => {
@@ -180,10 +213,48 @@ describe("two-node network", { timeout: 15_000 }, () => {
         });
     });
     test("the caller refuses a call that costs more than its limit", async () => {
-        const caller = await startCaller({ costLimitMicroUsdc: COST - 1 });
+        const caller = await startCaller({ costLimitMicroUsd: 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([]);
+        expect(authorizations).toEqual([]);
+    });
+    test("a caller with an enrollment token enrolls at startup; one without doesn't contact the operator", async () => {
+        sessions.length = 0;
+        await startCaller({ operatorUrl, enrollmentToken: "enr_caller" });
+        expect(sessions).toEqual([{ enrollmentToken: "enr_caller" }]);
+        sessions.length = 0;
+        await startCaller({ operatorUrl, databasePath: path.join(dir, "caller-2.db") });
+        expect(sessions).toEqual([]);
+    });
+    test("the provider refuses to run a call the operator won't hold, and the caller sees why", async () => {
+        const caller = await startCaller();
+        refuseAuthorization = { status: 402, error: "Insufficient balance" };
+        const result = await run(caller.url);
+        expect(result.returnValue.value).toBeNull();
+        expect(result.returnValue.error.message).toContain("Insufficient balance");
+        expect(authorizations).toHaveLength(1);
+        expect(settlements).toEqual([]);
+        expect(releases).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, recipientOrganizationId: ORGANIZATION, 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({ inferenceCostLimitMicroUsd: 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" },
@@ -17,7 +18,7 @@ describe("payment voucher", () => {
         const { publicKey, privateKey } = generateBase64KeyPair();
         const invoker = new CombinationResourceInvoker({}, 100_000, publicKey, privateKey);
         const parameters = [{ name: "city", value: "Oslo" }];
-        const voucher = invoker.createPaymentVoucher("4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2", 10000, "com.example", "Weather", "forecast", parameters);
+        const voucher = invoker.createPaymentVoucher("org_provider", 10000, "com.example", "Weather", "forecast", parameters);
         expect(voucher.invocationHash).toBe(invocationHash("com.example", "Weather", "forecast", parameters));
         expect(verifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
         expect(verifyData(voucher, voucher.publicKey, voucher.signature)).toBe(false);
@@ -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({ costMicroUsdc: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const invoker = createInvoker({ costMicroUsd: 10000, recipientOrganizationId: "org_provider" });
         const pending = invoker.invoke(resource, "forecast", parameters);
         await vi.runAllTimersAsync();
         await pending;
@@ -103,6 +104,11 @@ describe("external invoke retries", () => {
         expect(JSON.parse(bodies[0]).paymentVoucher.requestId).toBeDefined();
         expect(JSON.parse(bodies[0]).paymentVoucher.invocationHash).toBe(invocationHash("com.example", "Weather", "forecast", parameters));
     });
+    test("refuses a paid function whose manifest names no recipient organization, without signing a voucher", async () => {
+        const result = await createInvoker({ costMicroUsd: 10000 }).invoke(resource, "forecast", parameters);
+        expect(fetchMock).not.toHaveBeenCalled();
+        expect(result.error?.message).toContain("names no recipient organization");
+    });
 });
 describe("restricted functions", () => {
     const resource = { path: "com.example", name: "Weather", metadata: { baseUrl: "https://remote.example" }, functions: [] };
@@ -139,7 +145,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 }, { costMicroUsdc: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const invoker = createInvoker({ chainFor: async () => chain, authorize }, { costMicroUsd: 10000, recipientOrganizationId: "org_provider" });
         const pending = invoker.invoke(resource, "forecast", parameters);
         await vi.runAllTimersAsync();
         await expect(pending).resolves.toEqual({ value: 42, error: null });
@@ -149,3 +155,88 @@ describe("restricted functions", () => {
         expect(authorize).toHaveBeenCalledWith(chain, { resourcePath: "com.example", resourceName: "Weather", functionName: "forecast", parameters });
     });
 });
+describe("inference functions", () => {
+    const ORGANIZATION = "org_provider";
+    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 = { inputCostMicroUsdPerMillionTokens: 3_000_000, outputCostMicroUsdPerMillionTokens: 15_000_000, recipientOrganizationId: ORGANIZATION };
+    // 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({ inputCostMicroUsdPerMillionTokens: 150_000, outputCostMicroUsdPerMillionTokens: 0 }, 1, 1_000_000)).toBe(1);
+        expect(inferenceCharge({ inputCostMicroUsdPerMillionTokens: 0, outputCostMicroUsdPerMillionTokens: 0 }, 5, 5)).toBe(0);
+        expect(() => inferenceCharge({ inputCostMicroUsdPerMillionTokens: Number.MAX_SAFE_INTEGER, outputCostMicroUsdPerMillionTokens: 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", "inputCostMicroUsdPerMillionTokens", "outputCostMicroUsdPerMillionTokens", "maxTokens", "recipientOrganizationId", "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");
+    });
+});