@halot/sdk 1.0.2 → 1.0.4

package/README.md

@@ -45,7 +45,7 @@ against the Halot facilitator endpoints.
 
 ### Before you use it
 
-The route must use a real registered `serviceId`.
+The route must use a real registered `serviceId` and provider-signed report headers.
 
 The actual order is:
 
@@ -59,18 +59,37 @@ If you are using middleware for a service, you do not need `halot provider run`
 
 ```ts
 import express from 'express';
-import { halot } from '@halot/sdk';
+import { Wallet } from 'ethers';
+import { createActorAuthHeaders, halot, nowIso } from '@halot/sdk';
 
 const app = express();
 app.use(express.json());
 
+const providerId = process.env.HALOT_PROVIDER_ID!;
+const providerWallet = new Wallet(process.env.HALOT_PROVIDER_PRIVATE_KEY!);
+
+const providerHeaders = async (_req, context) => {
+  if (context.providerId !== providerId) {
+    throw new Error(`Assigned provider ${context.providerId} does not match configured provider ${providerId}`);
+  }
+
+  return createActorAuthHeaders(providerWallet, {
+    actorId: providerId,
+    role: 'provider',
+    method: 'POST',
+    path: '/facilitator/report',
+    timestamp: nowIso(),
+  });
+};
+
 app.post('/text', halot({
   serviceId: 'svc_text_gpt54',
+  providerHeaders,
 }), async (req, res) => {
-  const { jobId, providerId, requesterAddress } = req.halot;
+  const { jobId, providerId: assignedProviderId, requesterAddress } = req.halot;
   const text = await runProviderLogic(req.body.message, {
     jobId,
-    providerId,
+    providerId: assignedProviderId,
     requesterAddress,
   });
 
@@ -78,6 +97,8 @@ app.post('/text', halot({
 });
 ```
 
+`HALOT_PROVIDER_ID` is the provider ID returned by provider registration. `HALOT_PROVIDER_PRIVATE_KEY` is the private key for that provider actor authority. You can load those values from a secret manager or the CLI-generated authority file instead of env; the important part is that `/facilitator/report` is signed by the same provider actor that owns the registered service.
+
 ### One route, multiple services
 
 If one route fronts multiple registered services, resolve `serviceId` from the request:
@@ -90,47 +111,19 @@ app.post('/text', halot({
         return 'svc_text_gpt54';
       case 'gpt-5.4-mini':
         return 'svc_text_gpt54mini';
+      case 'gpt-5.4-nano':
+        return 'svc_text_gpt54nano';
       default:
         throw new Error('Unsupported model');
     }
   },
+  providerHeaders,
 }), async (req, res) => {
   const text = await runProviderLogic(req.body.message);
   res.json({ text, model: req.body.model });
 });
 ```
 
-### Signing facilitator report requests
-
-Use `providerHeaders` when your provider app needs to sign `/facilitator/report` as the registered provider:
-
-```ts
-import express from 'express';
-import { createActorAuthHeaders, halot } from '@halot/sdk';
-
-const app = express();
-app.use(express.json());
-
-const providerWallet = {
-  address: process.env.PROVIDER_ADDRESS!,
-  signMessage: async (message: string) => signWithWallet(message),
-};
-
-app.post('/text', halot({
-  serviceId: 'svc_text_gpt54',
-  providerHeaders: async (_req, context) => createActorAuthHeaders(providerWallet, {
-    actorId: context.providerId,
-    role: 'provider',
-    method: 'POST',
-    path: '/facilitator/report',
-    timestamp: new Date().toISOString(),
-  }),
-}), async (req, res) => {
-  const text = await runProviderLogic(req.body.message);
-  res.json({ text });
-});
-```
-
 ### Middleware flow
 
 When a requester calls your middleware route:

package/dist/network-config.d.ts

@@ -2,6 +2,7 @@ import { SettlementNetwork } from './types/common';
 export type HalotNetworkMode = 'testnet' | 'mainnet';
 export type ZeroGAuthorityNetwork = Extract<SettlementNetwork, '0g:testnet' | '0g:mainnet'>;
 export type StellarNetwork = Extract<SettlementNetwork, 'stellar:testnet' | 'stellar:mainnet'>;
+export declare const DEFAULT_ZERO_G_VERIFIER_EVALUATION_MODEL = "openai/gpt-oss-20b";
 export type SpaceIdDefaults = {
     tldId: number;
     chainId: number;
@@ -34,3 +35,4 @@ export declare function resolveZeroGAuthorityProfile(network: ZeroGAuthorityNetw
 export declare function resolveStellarNetworkProfile(network: StellarNetwork): StellarNetworkProfile;
 export declare function resolveZeroGAuthorityByChainId(chainId: number): ZeroGAuthorityNetwork;
 export declare function createZeroGStorageUri(rootHash: string): string;
+export declare function normalizeZeroGVerifierEvaluationModel(model: string): string;

package/dist/network-config.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ZERO_G_VERIFIER_EVALUATION_MODEL = void 0;
 exports.resolveZeroGAuthorityProfile = resolveZeroGAuthorityProfile;
 exports.resolveStellarNetworkProfile = resolveStellarNetworkProfile;
 exports.resolveZeroGAuthorityByChainId = resolveZeroGAuthorityByChainId;
 exports.createZeroGStorageUri = createZeroGStorageUri;
+exports.normalizeZeroGVerifierEvaluationModel = normalizeZeroGVerifierEvaluationModel;
+exports.DEFAULT_ZERO_G_VERIFIER_EVALUATION_MODEL = 'openai/gpt-oss-20b';
+const zeroGVerifierModelAliases = {
+    'gpt-oss-20b': 'openai/gpt-oss-20b',
+    'gemma-3-27b-it': 'google/gemma-3-27b-it',
+    'qwen-2.5-7b-instruct': 'qwen/qwen-2.5-7b-instruct',
+};
 const zeroGAuthorityProfiles = {
     '0g:testnet': {
         network: '0g:testnet',
@@ -62,3 +70,8 @@ function resolveZeroGAuthorityByChainId(chainId) {
 function createZeroGStorageUri(rootHash) {
     return `0g://${rootHash}`;
 }
+function normalizeZeroGVerifierEvaluationModel(model) {
+    const trimmed = model.trim();
+    const alias = zeroGVerifierModelAliases[trimmed.toLowerCase()];
+    return alias ?? trimmed;
+}

package/dist/types/verifier.d.ts

@@ -35,11 +35,12 @@ export declare const VerifierConfigSchema: z.ZodObject<{
         computeBudgetPerJob: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const EvaluationModelConfigSchema: z.ZodObject<{
+    model: z.ZodString;
+}, z.core.$strip>;
 export declare const ModelConfigSchema: z.ZodObject<{
     evaluationModel: z.ZodObject<{
-        providerAddress: z.ZodDefault<z.ZodString>;
-        serviceType: z.ZodDefault<z.ZodString>;
-        verifiability: z.ZodDefault<z.ZodString>;
+        model: z.ZodString;
     }, z.core.$strip>;
     sdk: z.ZodObject<{
         network: z.ZodString;

package/dist/types/verifier.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VerifierStatsSchema = exports.RegisteredVerifierSchema = exports.SpecializationsSchema = exports.InferenceTemplateSchema = exports.ModelConfigSchema = exports.VerifierConfigSchema = void 0;
+exports.VerifierStatsSchema = exports.RegisteredVerifierSchema = exports.SpecializationsSchema = exports.InferenceTemplateSchema = exports.ModelConfigSchema = exports.EvaluationModelConfigSchema = exports.VerifierConfigSchema = void 0;
 const zod_1 = require("zod");
 const common_1 = require("./common");
 exports.VerifierConfigSchema = zod_1.z.object({
@@ -31,12 +31,11 @@ exports.VerifierConfigSchema = zod_1.z.object({
         computeBudgetPerJob: zod_1.z.string(),
     }),
 });
+exports.EvaluationModelConfigSchema = zod_1.z.object({
+    model: zod_1.z.string().trim().min(1),
+});
 exports.ModelConfigSchema = zod_1.z.object({
-    evaluationModel: zod_1.z.object({
-        providerAddress: zod_1.z.string().default(''),
-        serviceType: zod_1.z.string().default('chatbot'),
-        verifiability: zod_1.z.string().default('TeeML'),
-    }),
+    evaluationModel: exports.EvaluationModelConfigSchema,
     sdk: zod_1.z.object({
         network: zod_1.z.string(),
         rpcUrl: zod_1.z.string().optional(),

package/dist/zero-g/compute.d.ts

@@ -7,13 +7,12 @@ export type ComputeEvaluationInput = {
     input: unknown;
     result: unknown;
     service: Service;
-    providerAddress?: string;
+    model: string;
     systemPrompt?: string;
     promptTemplate?: string;
     outputSchema?: Record<string, string>;
     maxTokens?: number;
     temperature?: number;
-    model?: string;
 };
 export type ComputeEvaluationOutput = {
     decision: Decision;
@@ -26,16 +25,23 @@ export type ComputeEvaluationOutput = {
 export type ZeroGComputeOptions = {
     rpcUrl?: string;
     privateKey?: string;
-    providerAddress?: string;
     ledgerContractAddress?: string;
     inferenceContractAddress?: string;
     fineTuningContractAddress?: string;
     fetchImplementation?: typeof fetch;
 };
+type ZeroGInferenceServiceRecord = {
+    provider: string;
+    serviceType: string;
+    url: string;
+    model: string;
+    verifiability: string;
+    teeSignerAcknowledged: boolean;
+};
+export declare function selectZeroGComputeProvider(services: ZeroGInferenceServiceRecord[], requestedModel: string): ZeroGInferenceServiceRecord;
 export declare class ZeroGComputeService {
     private readonly rpcUrl?;
     private readonly privateKey?;
-    private readonly providerAddress?;
     private readonly ledgerContractAddress?;
     private readonly inferenceContractAddress?;
     private readonly fineTuningContractAddress?;
@@ -51,3 +57,4 @@ export declare class ZeroGComputeService {
     private parseDecision;
     private createWallet;
 }
+export {};

package/dist/zero-g/compute.js

@@ -1,15 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZeroGComputeService = void 0;
+exports.selectZeroGComputeProvider = selectZeroGComputeProvider;
 const _0g_serving_broker_1 = require("@0glabs/0g-serving-broker");
 const ethers_1 = require("ethers");
+const network_config_1 = require("../network-config");
 const artifacts_1 = require("../utils/artifacts");
 const hash_1 = require("../utils/hash");
 const id_1 = require("../utils/id");
+function normalizeModel(model) {
+    return (0, network_config_1.normalizeZeroGVerifierEvaluationModel)(model).toLowerCase();
+}
+function formatAvailableModels(services) {
+    return [...new Set(services
+            .filter((service) => service.serviceType === 'chatbot' && service.verifiability === 'TeeML')
+            .map((service) => service.model))].sort().join(', ');
+}
+function selectZeroGComputeProvider(services, requestedModel) {
+    const normalizedRequestedModel = normalizeModel(requestedModel);
+    const matchingModel = services.filter((service) => normalizeModel(service.model) === normalizedRequestedModel);
+    if (matchingModel.length === 0) {
+        const availableModels = formatAvailableModels(services);
+        throw new Error(availableModels
+            ? `0G model "${requestedModel}" is not available. Current TeeML chatbot models: ${availableModels}.`
+            : `0G model "${requestedModel}" is not available.`);
+    }
+    const teeMlChatbotMatches = matchingModel.filter((service) => (service.serviceType === 'chatbot' &&
+        service.verifiability === 'TeeML'));
+    if (teeMlChatbotMatches.length === 0) {
+        throw new Error(`0G model "${requestedModel}" is registered but not as a TeeML chatbot service.`);
+    }
+    if (teeMlChatbotMatches.length === 1) {
+        return teeMlChatbotMatches[0];
+    }
+    const acknowledgedMatches = teeMlChatbotMatches.filter((service) => service.teeSignerAcknowledged);
+    if (acknowledgedMatches.length === 1) {
+        return acknowledgedMatches[0];
+    }
+    throw new Error(`0G model "${requestedModel}" resolves to multiple TeeML chatbot providers: ${teeMlChatbotMatches.map((service) => service.provider).join(', ')}.`);
+}
 class ZeroGComputeService {
     rpcUrl;
     privateKey;
-    providerAddress;
     ledgerContractAddress;
     inferenceContractAddress;
     fineTuningContractAddress;
@@ -17,7 +49,6 @@ class ZeroGComputeService {
     constructor(options = {}) {
         this.rpcUrl = options.rpcUrl;
         this.privateKey = options.privateKey;
-        this.providerAddress = options.providerAddress;
         this.ledgerContractAddress = options.ledgerContractAddress;
         this.inferenceContractAddress = options.inferenceContractAddress;
         this.fineTuningContractAddress = options.fineTuningContractAddress;
@@ -27,20 +58,21 @@ class ZeroGComputeService {
         return this.evaluateWithZeroG(input);
     }
     async evaluateWithZeroG(input) {
-        const providerAddress = (0, ethers_1.getAddress)(input.providerAddress ?? this.providerAddress ?? '');
         const wallet = this.createWallet();
         const broker = await (0, _0g_serving_broker_1.createZGComputeNetworkBroker)(wallet, this.ledgerContractAddress, this.inferenceContractAddress, this.fineTuningContractAddress);
+        const selectedService = selectZeroGComputeProvider(await broker.inference.listService(0, 100, true), input.model);
+        const providerAddress = (0, ethers_1.getAddress)(selectedService.provider);
+        const endpoint = `${selectedService.url}/v1/proxy`;
         if (!(await broker.inference.acknowledged(providerAddress))) {
             await broker.inference.acknowledgeProviderSigner(providerAddress);
         }
-        const { endpoint, model } = await broker.inference.getServiceMetadata(providerAddress);
         const artifacts = await (0, artifacts_1.resolveImageArtifacts)(input.input, input.result, {
             fetchImplementation: this.fetchImplementation,
             outputFormat: input.service.output.format,
         });
         const prompt = this.renderPrompt(input, artifacts);
         const requestBody = {
-            model: input.model ?? model,
+            model: selectedService.model,
             messages: [
                 {
                     role: 'system',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halot/sdk",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Shared Halot protocol SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",