@halot/sdk 1.0.3 → 1.0.4

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,31 +35,13 @@ export declare const VerifierConfigSchema: z.ZodObject<{
         computeBudgetPerJob: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const EvaluationModelConfigSchema: z.ZodPipe<z.ZodObject<{
-    zeroGComputeProviderAddress: z.ZodOptional<z.ZodString>;
-    providerAddress: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodTransform<{
-    model?: string | undefined;
-    zeroGComputeProviderAddress: string;
-}, {
-    zeroGComputeProviderAddress?: string | undefined;
-    providerAddress?: string | undefined;
-    model?: string | undefined;
-}>>;
+export declare const EvaluationModelConfigSchema: z.ZodObject<{
+    model: z.ZodString;
+}, z.core.$strip>;
 export declare const ModelConfigSchema: z.ZodObject<{
-    evaluationModel: z.ZodPipe<z.ZodObject<{
-        zeroGComputeProviderAddress: z.ZodOptional<z.ZodString>;
-        providerAddress: z.ZodOptional<z.ZodString>;
-        model: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodTransform<{
-        model?: string | undefined;
-        zeroGComputeProviderAddress: string;
-    }, {
-        zeroGComputeProviderAddress?: string | undefined;
-        providerAddress?: string | undefined;
-        model?: string | undefined;
-    }>>;
+    evaluationModel: z.ZodObject<{
+        model: z.ZodString;
+    }, z.core.$strip>;
     sdk: z.ZodObject<{
         network: z.ZodString;
         rpcUrl: z.ZodOptional<z.ZodString>;

package/dist/types/verifier.js

@@ -32,13 +32,8 @@ exports.VerifierConfigSchema = zod_1.z.object({
     }),
 });
 exports.EvaluationModelConfigSchema = zod_1.z.object({
-    zeroGComputeProviderAddress: zod_1.z.string().optional(),
-    providerAddress: zod_1.z.string().optional(),
-    model: zod_1.z.string().optional(),
-}).transform((config) => ({
-    zeroGComputeProviderAddress: config.zeroGComputeProviderAddress ?? config.providerAddress ?? '',
-    ...(config.model && config.model.trim() ? { model: config.model.trim() } : {}),
-}));
+    model: zod_1.z.string().trim().min(1),
+});
 exports.ModelConfigSchema = zod_1.z.object({
     evaluationModel: exports.EvaluationModelConfigSchema,
     sdk: zod_1.z.object({

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.3",
+  "version": "1.0.4",
   "description": "Shared Halot protocol SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",