stellarium-ts 0.14.0 → 0.16.0

package/dist/resource/repository.js

@@ -1,4 +1,5 @@
 import { isFreshExpiry, safeVerifyData } from "../crypto/utils.js";
+import { isInferenceManifest } from "./inference.js";
 /**
  * The object a node signs to broadcast its resources. Key order is part of the signed bytes.
  * Functions' `exec` implementations are dropped by JSON serialization on both ends.
@@ -114,13 +115,23 @@ export class ResourceRepository {
     async insertFunctions(resourceId, functions) {
         const createdAt = new Date().toISOString();
         for (const fn of functions) {
-            const functionResult = await this.db.run('INSERT INTO resource_function (resource_id, name, return_type, description, restricted, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [resourceId, fn.name, fn.returnType, optionalText(fn.description), fn.restricted === true ? 1 : 0, createdAt, createdAt]);
+            const functionResult = await this.db.run('INSERT INTO resource_function (resource_id, name, return_type, description, restricted, kind, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)', [resourceId, fn.name, fn.returnType, optionalText(fn.description), fn.restricted === true ? 1 : 0, fn.kind === 'inference' ? 'inference' : 'fixed', createdAt, createdAt]);
             const functionId = functionResult.lastID;
             for (const parameter of fn.parameters) {
                 await this.db.run('INSERT INTO resource_function_parameter (resource_function_id, name, parameter_type, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)', [functionId, parameter.name, parameter.type, optionalText(parameter.description), createdAt, createdAt]);
             }
-            if (fn.paymentManifest) {
-                await this.db.run('INSERT INTO resource_function_payment_manifest (resource_function_id, cost_lamports, recipient_address, created_at, updated_at) VALUES (?, ?, ?, ?, ?)', [functionId, fn.paymentManifest.costLamports, fn.paymentManifest.recipientAddress, createdAt, createdAt]);
+            const manifest = fn.paymentManifest;
+            if (manifest) {
+                const inference = isInferenceManifest(manifest);
+                await this.db.run('INSERT INTO resource_function_payment_manifest (resource_function_id, cost_micro_usdc, input_cost_micro_usdc_per_million_tokens, output_cost_micro_usdc_per_million_tokens, recipient_address, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [
+                    functionId,
+                    inference ? null : manifest.costMicroUsdc,
+                    inference ? manifest.inputCostMicroUsdcPerMillionTokens : null,
+                    inference ? manifest.outputCostMicroUsdcPerMillionTokens : null,
+                    manifest.recipientAddress,
+                    createdAt,
+                    createdAt,
+                ]);
             }
         }
     }
@@ -191,6 +202,7 @@ export class ResourceRepository {
             exec: async () => undefined,
             paymentManifest: await this.getResourceFunctionPaymentManifest(fn.id),
             restricted: fn.restricted === 1 || undefined,
+            kind: fn.kind === 'inference' ? 'inference' : undefined,
         };
     }
     async getResourceFunctions(resourceId) {
@@ -204,6 +216,7 @@ export class ResourceRepository {
             exec: async () => undefined,
             paymentManifest: await this.getResourceFunctionPaymentManifest(f.id),
             restricted: f.restricted === 1 || undefined,
+            kind: f.kind === 'inference' ? 'inference' : undefined,
         })));
     }
     async getResourceParameters(resourceFunctionId) {
@@ -218,9 +231,17 @@ export class ResourceRepository {
         if (!result) {
             return undefined;
         }
+        if (result.cost_micro_usdc === null) {
+            return {
+                id: result.id,
+                inputCostMicroUsdcPerMillionTokens: result.input_cost_micro_usdc_per_million_tokens,
+                outputCostMicroUsdcPerMillionTokens: result.output_cost_micro_usdc_per_million_tokens,
+                recipientAddress: result.recipient_address,
+            };
+        }
         return {
             id: result.id,
-            costLamports: result.cost_lamports,
+            costMicroUsdc: result.cost_micro_usdc,
             recipientAddress: result.recipient_address,
         };
     }

package/dist/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAgC,MAAM,SAAS,CAAC;AAKhF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,MAAM,WAAW,eAAe;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;CAC/B;AAED,UAAU,YAAY;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAiDD,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,aAAa,MAAM,CAAC;AAsHjC;;;;GAIG;AACH,QAAA,MAAM,MAAM,EAAE,kBAAkB,CAAC,YAAY,CAqS5C,CAAC;eAGa,MAAM"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAgC,MAAM,SAAS,CAAC;AAMhF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,MAAM,WAAW,eAAe;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;CAC/B;AAED,UAAU,YAAY;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAoDD,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,aAAa,MAAM,CAAC;AA4LjC;;;;GAIG;AACH,QAAA,MAAM,MAAM,EAAE,kBAAkB,CAAC,YAAY,CAuX5C,CAAC;eAGa,MAAM"}

package/dist/routes.js

@@ -1,7 +1,8 @@
 import { createHash, timingSafeEqual } from 'node:crypto';
 import rateLimit from '@fastify/rate-limit';
 import { interpretParsed, parseScript } from 'requestscript';
-import { invocationHash, paymentVoucherPayload } from './resource/invoker.js';
+import { inferenceVoucherPayload, invocationHash, isInferenceVoucher, paymentVoucherPayload } from './resource/invoker.js';
+import { inferenceCharge, isInferenceFunction, isInferenceManifest, parseMaxTokens } from './resource/inference.js';
 import { safeVerifyData } from './crypto/utils.js';
 import { InvalidPublicKeyError } from './grant/service.js';
 // Body schemas check only the shape the handlers rely on. Signed payloads (resources) are
@@ -48,35 +49,63 @@ const runRequestSchema = {
     required: ['source'],
     properties: { source: { type: 'string' } },
 };
+const resourceCallProperties = {
+    resourcePath: { type: 'string' },
+    resourceName: { type: 'string' },
+    functionName: { type: 'string' },
+    parameters: {
+        type: 'array',
+        items: { type: 'object', required: ['name'], properties: { name: { type: 'string' } } },
+    },
+    // Shape only: the grants inside are signed, so coercing them would change the signed bytes.
+    authorization: { type: 'object' },
+};
+const fixedVoucherSchema = {
+    type: 'object',
+    required: ['requestId', 'invocationId', 'amount', 'recipientAddress', 'signature', 'expiresAt', 'invocationHash', 'publicKey'],
+    properties: {
+        requestId: { type: 'string' },
+        invocationId: { type: 'string' },
+        amount: { type: 'integer' },
+        recipientAddress: { type: 'string' },
+        signature: { type: 'string' },
+        expiresAt: { type: 'string' },
+        invocationHash: { type: 'string' },
+        publicKey: { type: 'string' },
+    },
+};
+const inferenceVoucherSchema = {
+    type: 'object',
+    required: ['kind', 'requestId', 'invocationId', 'maxAmount', 'inputCostMicroUsdcPerMillionTokens', 'outputCostMicroUsdcPerMillionTokens', 'maxTokens', 'recipientAddress', 'signature', 'expiresAt', 'invocationHash', 'publicKey'],
+    properties: {
+        kind: { const: 'inference' },
+        requestId: { type: 'string' },
+        invocationId: { type: 'string' },
+        maxAmount: { type: 'integer', minimum: 0 },
+        inputCostMicroUsdcPerMillionTokens: { type: 'integer', minimum: 0 },
+        outputCostMicroUsdcPerMillionTokens: { type: 'integer', minimum: 0 },
+        maxTokens: { type: 'integer', minimum: 1 },
+        recipientAddress: { type: 'string' },
+        signature: { type: 'string' },
+        expiresAt: { type: 'string' },
+        invocationHash: { type: 'string' },
+        publicKey: { type: 'string' },
+    },
+};
 const resourceRunRequestSchema = {
     type: 'object',
     required: ['resourcePath', 'resourceName', 'functionName', 'parameters'],
     properties: {
-        resourcePath: { type: 'string' },
-        resourceName: { type: 'string' },
-        functionName: { type: 'string' },
-        parameters: {
-            type: 'array',
-            items: { type: 'object', required: ['name'], properties: { name: { type: 'string' } } },
-        },
-        paymentVoucher: {
-            type: 'object',
-            required: ['requestId', 'invocationId', 'amount', 'recipientAddress', 'signature', 'expiresAt', 'invocationHash', 'publicKey'],
-            properties: {
-                requestId: { type: 'string' },
-                invocationId: { type: 'string' },
-                amount: { type: 'integer' },
-                recipientAddress: { type: 'string' },
-                signature: { type: 'string' },
-                expiresAt: { type: 'string' },
-                invocationHash: { type: 'string' },
-                publicKey: { type: 'string' },
-            },
-        },
-        // Shape only: the grants inside are signed, so coercing them would change the signed bytes.
-        authorization: { type: 'object' },
+        ...resourceCallProperties,
+        // An inference voucher has `kind` and no `amount`, so at most one shape matches.
+        paymentVoucher: { oneOf: [fixedVoucherSchema, inferenceVoucherSchema] },
     },
 };
+const resourceEstimateRequestSchema = {
+    type: 'object',
+    required: ['resourcePath', 'resourceName', 'functionName', 'parameters'],
+    properties: resourceCallProperties,
+};
 const grantRenewalRequestSchema = {
     type: 'object',
     required: ['grantId', 'publicKey', 'nonce', 'expiresAt', 'signature'],
@@ -102,16 +131,15 @@ function secretsEqual(a, b) {
 }
 /**
  * A voucher is valid when it is bound to this exact call, signed by its public key, unexpired,
- * and pays at least the function's cost to the function's recipient.
+ * and pays the function's recipient. A fixed voucher must pay at least the function's cost. An inference
+ * voucher must be for an inference function, carry its rates, and sign the call's `maxTokens`.
+ * Whether its `maxAmount` covers the call is checked separately, against the function's estimator.
  */
-function isValidPaymentVoucher(voucher, manifest, request) {
+function isValidPaymentVoucher(voucher, resourceFunction, manifest, request) {
     const expectedHash = invocationHash(request.resourcePath, request.resourceName, request.functionName, request.parameters);
     if (voucher.invocationHash !== expectedHash) {
         return false;
     }
-    if (voucher.amount < manifest.costLamports) {
-        return false;
-    }
     if (voucher.recipientAddress !== manifest.recipientAddress) {
         return false;
     }
@@ -119,8 +147,47 @@ function isValidPaymentVoucher(voucher, manifest, request) {
     if (!Number.isFinite(expiresAt) || expiresAt <= Date.now()) {
         return false;
     }
+    if (isInferenceVoucher(voucher)) {
+        if (!isInferenceFunction(resourceFunction) || !isInferenceManifest(manifest)) {
+            return false;
+        }
+        if (voucher.inputCostMicroUsdcPerMillionTokens !== manifest.inputCostMicroUsdcPerMillionTokens
+            || voucher.outputCostMicroUsdcPerMillionTokens !== manifest.outputCostMicroUsdcPerMillionTokens) {
+            return false;
+        }
+        if (voucher.maxTokens !== parseMaxTokens(request.parameters)) {
+            return false;
+        }
+        return safeVerifyData(inferenceVoucherPayload(voucher), voucher.publicKey, voucher.signature);
+    }
+    if (isInferenceFunction(resourceFunction) || isInferenceManifest(manifest)) {
+        return false;
+    }
+    if (voucher.amount < manifest.costMicroUsdc) {
+        return false;
+    }
     return safeVerifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature);
 }
+/** The function's own input-token estimate, or undefined if its estimator failed or returned something other than a count. */
+async function estimateInputTokens(resourceFunction, request) {
+    try {
+        const inputTokens = await resourceFunction.estimateInputTokens?.(request.parameters);
+        return Number.isSafeInteger(inputTokens) && inputTokens >= 0 ? inputTokens : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** What the operator will accrue for `usage`: its charge at the voucher's rates, capped at `maxAmount`. */
+function cappedInferenceCharge(voucher, usage) {
+    try {
+        return Math.min(inferenceCharge(voucher, usage.inputTokens, usage.outputTokens), voucher.maxAmount);
+    }
+    catch {
+        // The charge isn't a safe integer, so it is over any maxAmount.
+        return voucher.maxAmount;
+    }
+}
 /**
  * Encapsulates the routes
  * @param fastify Encapsulated Fastify Instance
@@ -187,11 +254,16 @@ const routes = async (fastify, options) => {
                         type: parameter.type,
                         description: parameter.description,
                     })),
-                    paymentManifest: fn.paymentManifest ? ({
-                        costLamports: fn.paymentManifest.costLamports,
+                    paymentManifest: !fn.paymentManifest ? undefined : isInferenceManifest(fn.paymentManifest) ? {
+                        inputCostMicroUsdcPerMillionTokens: fn.paymentManifest.inputCostMicroUsdcPerMillionTokens,
+                        outputCostMicroUsdcPerMillionTokens: fn.paymentManifest.outputCostMicroUsdcPerMillionTokens,
                         recipientAddress: fn.paymentManifest.recipientAddress,
-                    }) : undefined,
+                    } : {
+                        costMicroUsdc: fn.paymentManifest.costMicroUsdc,
+                        recipientAddress: fn.paymentManifest.recipientAddress,
+                    },
                     restricted: fn.restricted || undefined,
+                    kind: isInferenceFunction(fn) ? 'inference' : undefined,
                 })),
                 baseUrl: resource.baseUrl,
             })),
@@ -240,19 +312,20 @@ const routes = async (fastify, options) => {
             reply.status(500).send({ error: 'Internal server error' });
         }
     });
-    fastify.post('/run/resource', {
-        schema: { body: resourceRunRequestSchema },
-        config: { rateLimit: options.rateLimit ?? { max: 100, timeWindow: '1 minute' } },
-    }, async (request, reply) => {
-        const resourceRequest = request.body;
-        const paymentVoucher = resourceRequest.paymentVoucher;
+    /**
+     * Finds the local function a call names and checks its parameters and, for a restricted function,
+     * its authorization. Sends the refusal and returns undefined if a check fails.
+     */
+    async function checkCall(resourceRequest, reply) {
         const resource = await options.service.resourceRepository.getInternalResource(resourceRequest.resourcePath, resourceRequest.resourceName);
         if (!resource) {
-            return reply.status(400).send({ error: 'Resource not found' });
+            reply.status(400).send({ error: 'Resource not found' });
+            return undefined;
         }
         const resourceFunction = resource.functions.find(fn => fn.name === resourceRequest.functionName);
         if (!resourceFunction) {
-            return reply.status(400).send({ error: 'Function not found' });
+            reply.status(400).send({ error: 'Function not found' });
+            return undefined;
         }
         // Grant constraints and the function both read parameters by name, so each name must be
         // declared and appear once. Otherwise a duplicate or extra parameter could pass a
@@ -260,7 +333,8 @@ const routes = async (fastify, options) => {
         const declared = new Set(resourceFunction.parameters.map(parameter => parameter.name));
         const names = resourceRequest.parameters.map(parameter => parameter.name);
         if (new Set(names).size !== names.length || !names.every(name => declared.has(name))) {
-            return reply.status(400).send({ error: 'Parameters must be declared by the function and appear once each' });
+            reply.status(400).send({ error: 'Parameters must be declared by the function and appear once each' });
+            return undefined;
         }
         // A restricted function is never run without a grant from this node. Checked before the
         // voucher, so an unauthorized caller never gets near settlement.
@@ -268,33 +342,104 @@ const routes = async (fastify, options) => {
             // Tells a caller without a usable grant where it can ask for one.
             const grantEndpoint = options.service.grantService.acceptsRequests ? `${options.service.config.baseUrl}/v1/grants/request` : undefined;
             if (!resourceRequest.authorization) {
-                return reply.status(403).send({ error: 'Authorization is required', grantEndpoint });
+                reply.status(403).send({ error: 'Authorization is required', grantEndpoint });
+                return undefined;
             }
             if (!await options.service.grantService.verifyInvocation(resourceRequest.authorization, resourceRequest)) {
-                return reply.status(403).send({ error: 'Invalid authorization', grantEndpoint });
+                reply.status(403).send({ error: 'Invalid authorization', grantEndpoint });
+                return undefined;
             }
         }
+        return { resource, resourceFunction };
+    }
+    /**
+     * Prices a call to a paid inference function before the caller signs its voucher: the function's
+     * estimate of the input tokens, and `maxAmount`, the charge for those plus `maxTokens` output tokens.
+     * Runs the provider's estimator, so a restricted function needs authorization here too.
+     */
+    fastify.post('/run/resource/estimate', {
+        schema: { body: resourceEstimateRequestSchema },
+        config: { rateLimit: options.rateLimit ?? { max: 100, timeWindow: '1 minute' } },
+    }, async (request, reply) => {
+        const resourceRequest = request.body;
+        const call = await checkCall(resourceRequest, reply);
+        if (!call) {
+            return reply;
+        }
+        const { resourceFunction } = call;
+        const manifest = resourceFunction.paymentManifest;
+        if (!isInferenceFunction(resourceFunction) || !isInferenceManifest(manifest)) {
+            return reply.status(400).send({ error: 'Function is not a paid inference function' });
+        }
+        const maxTokens = parseMaxTokens(resourceRequest.parameters);
+        if (maxTokens === undefined) {
+            return reply.status(400).send({ error: 'maxTokens must be a positive int32' });
+        }
+        const inputTokens = await estimateInputTokens(resourceFunction, resourceRequest);
+        if (inputTokens === undefined) {
+            return reply.status(500).send({ error: 'Failed to estimate input tokens' });
+        }
+        return { inputTokens, maxAmount: inferenceCharge(manifest, inputTokens, maxTokens) };
+    });
+    fastify.post('/run/resource', {
+        schema: { body: resourceRunRequestSchema },
+        config: { rateLimit: options.rateLimit ?? { max: 100, timeWindow: '1 minute' } },
+    }, async (request, reply) => {
+        const resourceRequest = request.body;
+        const paymentVoucher = resourceRequest.paymentVoucher;
+        const call = await checkCall(resourceRequest, reply);
+        if (!call) {
+            return reply;
+        }
+        const { resource, resourceFunction } = call;
         // Payment manifests are per function. A paid function is never run without a valid voucher.
         const paymentManifest = resourceFunction.paymentManifest;
         if (paymentManifest) {
             if (!paymentVoucher) {
                 return reply.status(402).send({ error: 'Payment voucher is required' });
             }
-            if (!isValidPaymentVoucher(paymentVoucher, paymentManifest, resourceRequest)) {
+            if (!isValidPaymentVoucher(paymentVoucher, resourceFunction, paymentManifest, resourceRequest)) {
                 return reply.status(400).send({ error: 'Invalid payment voucher' });
             }
             if (await options.service.grantService.isBlocked(paymentVoucher.publicKey)) {
                 return reply.status(403).send({ error: 'Caller is blocked' });
             }
+            // Re-estimated here, so inference never runs on a voucher that can't cover the expected cost.
+            if (isInferenceVoucher(paymentVoucher)) {
+                const inputTokens = await estimateInputTokens(resourceFunction, resourceRequest);
+                if (inputTokens === undefined) {
+                    return reply.status(500).send({ error: 'Failed to estimate input tokens' });
+                }
+                const requiredMaxAmount = inferenceCharge(paymentVoucher, inputTokens, paymentVoucher.maxTokens);
+                if (paymentVoucher.maxAmount < requiredMaxAmount) {
+                    return reply.status(402).send({ error: `Payment voucher maxAmount ${paymentVoucher.maxAmount} is below the estimated ${requiredMaxAmount} micro-USDC`, requiredMaxAmount });
+                }
+            }
         }
         const result = await options.service.resourceInvoker.invoke(resource, resourceRequest.functionName, resourceRequest.parameters);
+        let settlement;
+        if (paymentManifest && paymentVoucher && !result.error) {
+            if (!isInferenceVoucher(paymentVoucher)) {
+                settlement = { voucher: paymentVoucher };
+            }
+            else if (result.usage) {
+                // The function may report more output than it was allowed; the caller only signed for maxTokens.
+                const usage = { inputTokens: result.usage.inputTokens, outputTokens: Math.min(result.usage.outputTokens, paymentVoucher.maxTokens) };
+                result.usage = usage;
+                // A free call has nothing to settle, and the operator refuses an empty receipt.
+                if (cappedInferenceCharge(paymentVoucher, usage) > 0) {
+                    settlement = { voucher: paymentVoucher, usage };
+                }
+            }
+        }
         // Settle only verified vouchers, and only after a successful invoke. A voucher sent to a free function is ignored.
         // Run this on a separate thread to avoid blocking the main thread.
-        if (paymentManifest && paymentVoucher && !result.error) {
+        if (settlement) {
+            const payment = settlement;
             setTimeout(async () => {
                 // Nothing awaits this callback, so an uncaught error here would be an unhandled rejection.
                 try {
-                    await options.service.operatorClient.settlePayment({ voucher: paymentVoucher });
+                    await options.service.operatorClient.settlePayment(payment);
                 }
                 catch (error) {
                     fastify.log.error(error, 'Failed to settle payment');

package/dist/server.d.ts

@@ -6,7 +6,7 @@ import type { ApproveGrant, GrantOptions } from './grant/service.js';
 import { StellariumResource } from './resource/repository.js';
 import { RateLimitConfig } from './routes.js';
 import { type NodeConfig } from './service.js';
-export declare const DEFAULT_COST_LIMIT_LAMPORTS = 10000;
+export declare const DEFAULT_COST_LIMIT_MICRO_USDC = 10000;
 export declare const DEFAULT_GRANT_REFRESH_INTERVAL_MS: number;
 export interface StellariumNodeOptions {
     port?: number;
@@ -24,8 +24,13 @@ export interface StellariumNodeOptions {
     apiKey?: string;
     /** Defaults to `OPERATOR_URL`. */
     operatorUrl?: string;
-    /** Most this node pays for one remote call. Defaults to `COST_LIMIT_LAMPORTS`, then 10,000. */
-    costLimitLamports?: number;
+    /** Most this node pays for one remote call. Defaults to `COST_LIMIT_MICRO_USDC`, then 10,000 ($0.01). */
+    costLimitMicroUsdc?: number;
+    /**
+     * Most this node signs for in one remote inference call (the voucher's `maxAmount`).
+     * Defaults to `INFERENCE_COST_LIMIT_MICRO_USDC`, then to the resolved `costLimitMicroUsdc`.
+     */
+    inferenceCostLimitMicroUsdc?: number;
     /** SQLite file. Defaults to `./requestscript.db`; use ':memory:' for tests. */
     databasePath?: string;
     /**

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/server.js

@@ -1,9 +1,10 @@
 import 'dotenv/config';
 import { DEFAULT_DATABASE_PATH, openDatabase } from './db/db.js';
+import { validateInferenceFunction } from './resource/inference.js';
 import routes from './routes.js';
 import { createService } from './service.js';
 import { StartupService } from './startup.js';
-export const DEFAULT_COST_LIMIT_LAMPORTS = 10_000;
+export const DEFAULT_COST_LIMIT_MICRO_USDC = 10_000;
 export const DEFAULT_GRANT_REFRESH_INTERVAL_MS = 1000 * 60 * 5;
 function required(name, value) {
     if (!value) {
@@ -15,9 +16,16 @@ function hostsPaidFunctions(resources) {
     return resources.some(resource => resource.functions.some(fn => fn.paymentManifest));
 }
 export function resolveConfig(options, resources = []) {
-    const costLimit = options.costLimitLamports ?? (process.env.COST_LIMIT_LAMPORTS ? Number(process.env.COST_LIMIT_LAMPORTS) : DEFAULT_COST_LIMIT_LAMPORTS);
+    const costLimit = options.costLimitMicroUsdc ?? (process.env.COST_LIMIT_MICRO_USDC ? Number(process.env.COST_LIMIT_MICRO_USDC) : DEFAULT_COST_LIMIT_MICRO_USDC);
     if (!Number.isSafeInteger(costLimit) || costLimit < 0) {
-        throw new Error('costLimitLamports must be a nonnegative integer');
+        throw new Error('costLimitMicroUsdc must be a nonnegative integer');
+    }
+    const inferenceCostLimit = options.inferenceCostLimitMicroUsdc ?? (process.env.INFERENCE_COST_LIMIT_MICRO_USDC ? Number(process.env.INFERENCE_COST_LIMIT_MICRO_USDC) : costLimit);
+    if (!Number.isSafeInteger(inferenceCostLimit) || inferenceCostLimit < 0) {
+        throw new Error('inferenceCostLimitMicroUsdc must be a nonnegative integer');
+    }
+    for (const resource of resources) {
+        resource.functions.forEach(validateInferenceFunction);
     }
     return {
         baseUrl: required('BASE_URL', options.baseUrl ?? process.env.BASE_URL),
@@ -28,7 +36,8 @@ export function resolveConfig(options, resources = []) {
         operatorUrl: hostsPaidFunctions(resources)
             ? required('OPERATOR_URL', options.operatorUrl ?? process.env.OPERATOR_URL)
             : options.operatorUrl ?? process.env.OPERATOR_URL,
-        costLimitLamports: costLimit,
+        costLimitMicroUsdc: costLimit,
+        inferenceCostLimitMicroUsdc: inferenceCostLimit,
     };
 }
 export class StellariumNode {

package/dist/service.d.ts

@@ -17,7 +17,9 @@ export interface NodeConfig {
     /** Operator base URL, including `/v1`. Required when the node hosts paid functions. */
     operatorUrl?: string;
     /** Most this node will pay for one remote call. */
-    costLimitLamports: number;
+    costLimitMicroUsdc: number;
+    /** Most this node will sign for in one remote inference call. */
+    inferenceCostLimitMicroUsdc: number;
 }
 export interface Service {
     config: NodeConfig;

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,KAAK,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAErE,4GAA4G;AAC5G,MAAM,WAAW,UAAU;IACvB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,OAAO;IACpB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,YAAY,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC3B,+EAA+E;IAC/E,YAAY,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAoBtI"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,KAAK,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAErE,4GAA4G;AAC5G,MAAM,WAAW,UAAU;IACvB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,2BAA2B,EAAE,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,OAAO;IACpB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,YAAY,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC3B,+EAA+E;IAC/E,YAAY,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAoBtI"}

package/dist/service.js

@@ -9,7 +9,7 @@ export function createService(db, resources, config, options = {}) {
     const resourceRepository = new ResourceRepository(db, resources, config.baseUrl);
     const resourceResolver = new CombinationResourceResolver(resourceRepository);
     const grantService = new GrantService(new GrantRepository(db), config, options.approveGrant);
-    const resourceInvoker = new CombinationResourceInvoker(resourceRepository, config.costLimitLamports, config.publicKey, config.privateKey, grantService);
+    const resourceInvoker = new CombinationResourceInvoker(resourceRepository, config.costLimitMicroUsdc, config.publicKey, config.privateKey, grantService, config.inferenceCostLimitMicroUsdc);
     const operatorClient = new OperatorClient(config.operatorUrl);
     return {
         config,

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: 3 });
+        expect(await db.get("PRAGMA user_version")).toEqual({ user_version: 5 });
         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 so inference functions can omit cost_micro_usdc", 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_usdc_per_million_tokens,
+            output_cost_micro_usdc_per_million_tokens, recipient_address, created_at, updated_at) VALUES (1, 3, 15, 'r', 'now', 'now')`);
+        await db.close();
+    });
 });

package/dist/tests/helpers.d.ts

@@ -9,5 +9,14 @@ 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: {
+    inputCostMicroUsdcPerMillionTokens: number;
+    outputCostMicroUsdcPerMillionTokens: 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,eAAO,MAAM,SAAS,iDAAiD,CAAC;AACxE,eAAO,MAAM,IAAI,QAAQ,CAAC;AAE1B,wBAAgB,UAAU,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAU1E;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CAuBrF;AAED,eAAO,MAAM,eAAe;IAAK,kCAAkC;IAAa,mCAAmC;CAAc,CAAC;AAElI;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CA0BnF;AAED,eAAO,MAAM,iBAAiB,sHAAoH,CAAC"}

package/dist/tests/helpers.js

@@ -17,7 +17,8 @@ export function testConfig(overrides = {}) {
         ...generateBase64KeyPair(),
         apiKey: "secret",
         operatorUrl: "http://operator.invalid/v1",
-        costLimitLamports: 100_000,
+        costLimitMicroUsdc: 100_000,
+        inferenceCostLimitMicroUsdc: 100_000,
         ...overrides,
     };
 }
@@ -35,7 +36,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: { costLamports: COST, recipientAddress: RECIPIENT },
+                paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT },
             },
             {
                 name: "humidity",
@@ -46,4 +47,36 @@ export function weatherResource(baseUrl = "http://127.0.0.1:3002") {
         ],
     };
 }
+export const INFERENCE_RATES = { inputCostMicroUsdcPerMillionTokens: 3_000_000, outputCostMicroUsdcPerMillionTokens: 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, recipientAddress: RECIPIENT },
+    };
+    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}';