@pulseai/sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -41,8 +41,10 @@ var MAINNET_ADDRESSES = {
   feeDistributor: "0x51EdD8E4C4B423b952821fc9e2a7dad15a858B56",
   identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
   reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63",
-  usdm: "0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7"
+  usdm: "0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7",
+  buyerRelay: "0x633054593db34c5aAe36F784faeAe51b9604e037"
 };
+var PLATFORM_BUYER_AGENT_ID = 8154n;
 var DEFAULT_INDEXER_URLS = {
   testnet: "https://pulse-indexer.up.railway.app",
   mainnet: "https://pulse-indexer.up.railway.app"
@@ -2664,10 +2666,17 @@ async function deployJobTerms(client, agentId, params) {
   const { masterAddress } = await deployWarrenMaster(client, agentId, pageAddress, contentBytes.length, 0);
   return { masterAddress, pageAddress, hash, txHash };
 }
+function stripCodeFence(content) {
+  let result = content.trim();
+  result = result.replace(/^```\w*\n?/, "");
+  result = result.replace(/\n?```\s*$/, "");
+  return result;
+}
 async function deployDeliverable(client, agentId, jobId, params, indexerUrl) {
   const { json, hash } = createDeliverable(params);
-  const contentBytes = new TextEncoder().encode(json);
-  const { pageAddress, txHash } = await deployWarrenPage(client, json);
+  const warrenContent = params.type === "inline" && params.content ? stripCodeFence(params.content) : json;
+  const contentBytes = new TextEncoder().encode(warrenContent);
+  const { pageAddress, txHash } = await deployWarrenPage(client, warrenContent);
   const { masterAddress } = await deployWarrenMaster(client, agentId, pageAddress, contentBytes.length, 1);
   await write(client, {
     address: client.addresses.jobEngine,
@@ -2886,7 +2895,9 @@ async function callOpenAI(params) {
   if (!content) {
     throw new Error("OpenAI returned an empty response");
   }
-  return { content, raw: payload };
+  const truncated = payload?.choices?.[0]?.finish_reason === "length";
+  const usage = payload?.usage ? { inputTokens: payload.usage.prompt_tokens ?? 0, outputTokens: payload.usage.completion_tokens ?? 0 } : void 0;
+  return { content, truncated, raw: payload, usage };
 }
 async function callAnthropic(params) {
   const systemPrompt = params.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n").trim();
@@ -2919,7 +2930,9 @@ async function callAnthropic(params) {
   if (!content) {
     throw new Error("Anthropic returned an empty response");
   }
-  return { content, raw: payload };
+  const truncated = payload?.stop_reason === "max_tokens";
+  const usage = payload?.usage ? { inputTokens: payload.usage.input_tokens ?? 0, outputTokens: payload.usage.output_tokens ?? 0 } : void 0;
+  return { content, truncated, raw: payload, usage };
 }
 async function callGoogle(params) {
   const systemPrompt = params.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n").trim();
@@ -2953,7 +2966,9 @@ async function callGoogle(params) {
   if (!content) {
     throw new Error("Google returned an empty response");
   }
-  return { content, raw: payload };
+  const truncated = payload?.candidates?.[0]?.finishReason === "MAX_TOKENS";
+  const usage = payload?.usageMetadata ? { inputTokens: payload.usageMetadata.promptTokenCount ?? 0, outputTokens: payload.usageMetadata.candidatesTokenCount ?? 0 } : void 0;
+  return { content, truncated, raw: payload, usage };
 }
 async function callAI(params) {
   if (params.provider === "openai") {
@@ -2971,12 +2986,15 @@ async function callAI(params) {
 // src/handler/site-modifier.ts
 var FETCH_TIMEOUT_MS = 3e4;
 var MAX_HTML_BYTES = 500 * 1024;
-var DEFAULT_MAX_TOKENS = 4096;
+var DEFAULT_MAX_TOKENS = 16384;
+var AI_MAX_RETRIES = 3;
+var RETRY_DELAY_MS = 2e3;
+var GOOGLE_FALLBACK_MODEL = "gemini-2.5-pro";
 var SUPPORTED_PROVIDERS = ["anthropic", "google", "openai"];
 var DEFAULT_MODELS = {
-  openai: "gpt-4o-mini",
-  anthropic: "claude-3-5-sonnet-latest",
-  google: "gemini-1.5-pro"
+  openai: "gpt-5.2",
+  anthropic: "claude-sonnet-4-6",
+  google: "gemini-3.1-pro-preview"
 };
 var DEFAULT_SYSTEM_PROMPT = [
   "You are an expert frontend engineer modifying an existing HTML document.",
@@ -3029,6 +3047,10 @@ function isHtmlContentType(contentType) {
   const lower = contentType.toLowerCase();
   return lower.includes("text/html") || lower.includes("application/xhtml+xml");
 }
+function isJsonContentType(contentType) {
+  const lower = contentType.toLowerCase();
+  return lower.includes("application/json") || lower.includes("text/json");
+}
 function extractHtmlFromText(text) {
   const htmlFence = text.match(/```html\s*([\s\S]*?)```/i);
   if (htmlFence?.[1]) {
@@ -3042,18 +3064,101 @@ function extractHtmlFromText(text) {
       return fencedContent;
     }
   }
+  const openFence = text.match(/```html?\s*\n?([\s\S]+)/i);
+  if (openFence?.[1]) {
+    const content = openFence[1].trim();
+    if (/<html[\s>]|<!doctype html/i.test(content)) {
+      return content;
+    }
+  }
   const trimmed = text.trim();
   if (/<html[\s>]|<!doctype html/i.test(trimmed)) {
     return trimmed;
   }
   return null;
 }
+function extractHtmlFromJson(jsonText) {
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (typeof parsed === "string") {
+      if (/<html[\s>]|<!doctype html/i.test(parsed)) return parsed;
+      return null;
+    }
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const obj = parsed;
+    const nested = obj.data && typeof obj.data === "object" ? obj.data : null;
+    const candidates = [
+      obj.html,
+      obj.content,
+      obj.body,
+      nested?.content,
+      nested?.html,
+      nested?.body
+    ];
+    for (const candidate of candidates) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        if (/<html[\s>]|<!doctype html|<head[\s>]|<body[\s>]|<div[\s>]/i.test(candidate)) {
+          return candidate.trim();
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function getByteLength(content) {
   return new TextEncoder().encode(content).byteLength;
 }
 var SiteModifierHandler = class {
   offeringId;
   autoAccept;
+  schema = {
+    version: 1,
+    serviceRequirements: {
+      type: "object",
+      properties: {
+        siteUrl: {
+          type: "string",
+          description: "URL of the site to modify (http/https)"
+        },
+        modificationRequest: {
+          type: "string",
+          description: "What changes to make"
+        },
+        provider: {
+          type: "string",
+          description: "AI provider",
+          enum: ["google", "anthropic", "openai"]
+        },
+        model: {
+          type: "string",
+          description: "Specific model override"
+        }
+      },
+      required: ["siteUrl", "modificationRequest"]
+    },
+    deliverableRequirements: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: 'Delivery type, always "inline"',
+          enum: ["inline"]
+        },
+        content: {
+          type: "string",
+          description: "Modified HTML content"
+        },
+        mimeType: {
+          type: "string",
+          description: 'Content type, always "text/html"',
+          enum: ["text/html"]
+        }
+      },
+      required: ["type", "content", "mimeType"]
+    }
+  };
   config;
   constructor(offeringId, config, options) {
     this.offeringId = offeringId;
@@ -3076,7 +3181,8 @@ var SiteModifierHandler = class {
     const targetUrl = parseAndValidateUrl(requirements.siteUrl);
     ensureAllowedUrl(targetUrl, this.config.allowedDomains);
     const provider = requirements.provider ?? this.config.defaultProvider ?? "openai";
-    const model = requirements.model?.trim() || this.config.defaultModel?.trim() || DEFAULT_MODELS[provider];
+    const useConfigModel = provider === (this.config.defaultProvider ?? "openai");
+    const model = requirements.model?.trim() || (useConfigModel ? this.config.defaultModel?.trim() : void 0) || DEFAULT_MODELS[provider];
     const maxTokens = this.config.maxTokens && this.config.maxTokens > 0 ? this.config.maxTokens : DEFAULT_MAX_TOKENS;
     if (!model) {
       throw new Error(
@@ -3102,17 +3208,71 @@ var SiteModifierHandler = class {
       originalHtml,
       "```"
     ].join("\n");
-    const aiResponse = await callAI({
-      provider,
-      model,
-      maxTokens,
-      apiKey,
-      signal: context.abortSignal,
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userPrompt }
-      ]
-    });
+    let aiResponse = null;
+    let lastError = null;
+    const aiMessages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ];
+    for (let attempt = 1; attempt <= AI_MAX_RETRIES; attempt++) {
+      try {
+        aiResponse = await callAI({
+          provider,
+          model,
+          maxTokens,
+          apiKey,
+          signal: context.abortSignal,
+          messages: aiMessages
+        });
+        if (aiResponse.truncated) {
+          throw new Error(
+            "AI output was truncated (hit token limit). The generated HTML is incomplete."
+          );
+        }
+        break;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        console.error(
+          `[site-modifier] ${model} failed (attempt ${attempt}/${AI_MAX_RETRIES}): ${lastError.message}`
+        );
+        if (provider === "google" && model !== GOOGLE_FALLBACK_MODEL) {
+          try {
+            console.log(
+              `[site-modifier] falling back to ${GOOGLE_FALLBACK_MODEL} (attempt ${attempt}/${AI_MAX_RETRIES})`
+            );
+            aiResponse = await callAI({
+              provider,
+              model: GOOGLE_FALLBACK_MODEL,
+              maxTokens,
+              apiKey,
+              signal: context.abortSignal,
+              messages: aiMessages
+            });
+            if (aiResponse.truncated) {
+              throw new Error(
+                "AI output was truncated (hit token limit). The generated HTML is incomplete."
+              );
+            }
+            break;
+          } catch (fallbackErr) {
+            lastError = fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr));
+            console.error(
+              `[site-modifier] ${GOOGLE_FALLBACK_MODEL} also failed (attempt ${attempt}/${AI_MAX_RETRIES}): ${lastError.message}`
+            );
+          }
+        }
+      }
+      if (attempt < AI_MAX_RETRIES) {
+        const delay = RETRY_DELAY_MS * attempt;
+        console.log(`[site-modifier] retrying in ${delay}ms...`);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    if (!aiResponse) {
+      throw new Error(
+        `AI generation failed after ${AI_MAX_RETRIES} attempts. Please try again later. Last error: ${lastError?.message ?? "unknown"}`
+      );
+    }
     const modifiedHtml = extractHtmlFromText(aiResponse.content);
     if (!modifiedHtml) {
       throw new Error("AI response did not contain valid HTML output");
@@ -3125,7 +3285,8 @@ var SiteModifierHandler = class {
     return {
       type: "inline",
       content: modifiedHtml,
-      mimeType: "text/html"
+      mimeType: "text/html",
+      usage: aiResponse.usage ? { provider, inputTokens: aiResponse.usage.inputTokens, outputTokens: aiResponse.usage.outputTokens } : void 0
     };
   }
   parseRequirements(requirements) {
@@ -3164,7 +3325,9 @@ var SiteModifierHandler = class {
   async fetchHtmlWithTimeout(siteUrl, parentSignal) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => {
-      controller.abort(new Error(`Site fetch timed out after ${FETCH_TIMEOUT_MS}ms`));
+      controller.abort(
+        new Error(`Site fetch timed out after ${FETCH_TIMEOUT_MS}ms for ${siteUrl}`)
+      );
     }, FETCH_TIMEOUT_MS);
     const parentAbort = () => controller.abort(parentSignal?.reason);
     if (parentSignal) {
@@ -3185,10 +3348,12 @@ var SiteModifierHandler = class {
           `Failed to fetch site HTML: ${response.status} ${response.statusText}`
         );
       }
-      const contentType = response.headers.get("content-type");
-      if (contentType && !isHtmlContentType(contentType)) {
+      const contentType = response.headers.get("content-type") ?? "";
+      const isHtml = !contentType || isHtmlContentType(contentType);
+      const isJson = isJsonContentType(contentType);
+      if (!isHtml && !isJson) {
         throw new Error(
-          `Fetched content is not HTML (content-type: ${contentType})`
+          `Fetched content is not HTML or JSON (content-type: ${contentType}, url: ${siteUrl})`
         );
       }
       const contentLengthHeader = response.headers.get("content-length");
@@ -3206,9 +3371,18 @@ var SiteModifierHandler = class {
           `HTML too large (${htmlBuffer.byteLength} bytes). Limit is ${MAX_HTML_BYTES} bytes`
         );
       }
-      const html = new TextDecoder().decode(htmlBuffer).trim();
+      let html = new TextDecoder().decode(htmlBuffer).trim();
       if (!html) {
-        throw new Error("Fetched HTML is empty");
+        throw new Error("Fetched content is empty");
+      }
+      if (isJson) {
+        const extracted = extractHtmlFromJson(html);
+        if (!extracted) {
+          throw new Error(
+            `JSON response from ${siteUrl} does not contain extractable HTML content`
+          );
+        }
+        html = extracted;
       }
       return html;
     } catch (error) {
@@ -3216,7 +3390,7 @@ var SiteModifierHandler = class {
         if (parentSignal?.aborted) {
           throw new Error("Site fetch aborted");
         }
-        throw new Error(`Site fetch timed out after ${FETCH_TIMEOUT_MS}ms`);
+        throw new Error(`Site fetch timed out after ${FETCH_TIMEOUT_MS}ms for ${siteUrl}`);
       }
       throw error;
     } finally {
@@ -3228,6 +3402,189 @@ var SiteModifierHandler = class {
   }
 };
 
+// src/types.ts
+var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
+  JobStatus2[JobStatus2["Created"] = 0] = "Created";
+  JobStatus2[JobStatus2["Accepted"] = 1] = "Accepted";
+  JobStatus2[JobStatus2["InProgress"] = 2] = "InProgress";
+  JobStatus2[JobStatus2["Delivered"] = 3] = "Delivered";
+  JobStatus2[JobStatus2["Evaluated"] = 4] = "Evaluated";
+  JobStatus2[JobStatus2["Completed"] = 5] = "Completed";
+  JobStatus2[JobStatus2["Disputed"] = 6] = "Disputed";
+  JobStatus2[JobStatus2["Cancelled"] = 7] = "Cancelled";
+  return JobStatus2;
+})(JobStatus || {});
+var ServiceType = /* @__PURE__ */ ((ServiceType2) => {
+  ServiceType2[ServiceType2["TextGeneration"] = 0] = "TextGeneration";
+  ServiceType2[ServiceType2["ImageGeneration"] = 1] = "ImageGeneration";
+  ServiceType2[ServiceType2["DataAnalysis"] = 2] = "DataAnalysis";
+  ServiceType2[ServiceType2["CodeGeneration"] = 3] = "CodeGeneration";
+  ServiceType2[ServiceType2["Translation"] = 4] = "Translation";
+  ServiceType2[ServiceType2["Custom"] = 5] = "Custom";
+  return ServiceType2;
+})(ServiceType || {});
+
+// src/handler/schema.ts
+var DEFAULT_SCHEMAS = {
+  [0 /* TextGeneration */]: {
+    version: 1,
+    serviceRequirements: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Text prompt to generate from" },
+        maxTokens: { type: "number", description: "Maximum output token count" }
+      },
+      required: ["prompt"]
+    },
+    deliverableRequirements: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Generated text output" },
+        tokenCount: { type: "number", description: "Tokens used to produce output" }
+      },
+      required: ["text"]
+    }
+  },
+  [1 /* ImageGeneration */]: {
+    version: 1,
+    serviceRequirements: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Image prompt to generate from" },
+        size: { type: "string", description: "Output size (for example: 1024x1024)" },
+        style: { type: "string", description: "Desired visual style" }
+      },
+      required: ["prompt"]
+    },
+    deliverableRequirements: {
+      type: "object",
+      properties: {
+        imageUrl: { type: "string", description: "URL of the generated image" },
+        mimeType: { type: "string", description: "Image MIME type" }
+      },
+      required: ["imageUrl"]
+    }
+  },
+  [2 /* DataAnalysis */]: {
+    version: 1,
+    serviceRequirements: {
+      type: "object",
+      properties: {
+        data: { type: "string", description: "Input data for analysis" },
+        analysisRequest: { type: "string", description: "Question or analysis task" }
+      },
+      required: ["data", "analysisRequest"]
+    },
+    deliverableRequirements: {
+      type: "object",
+      properties: {
+        summary: { type: "string", description: "Analysis summary" },
+        findings: {
+          type: "array",
+          description: "Structured key findings",
+          items: { type: "string" }
+        }
+      },
+      required: ["summary"]
+    }
+  },
+  [3 /* CodeGeneration */]: {
+    version: 1,
+    serviceRequirements: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Code generation request" },
+        language: { type: "string", description: "Target programming language" }
+      },
+      required: ["prompt"]
+    },
+    deliverableRequirements: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "Generated source code" },
+        language: { type: "string", description: "Detected or requested language" }
+      },
+      required: ["code"]
+    }
+  },
+  [4 /* Translation */]: {
+    version: 1,
+    serviceRequirements: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to translate" },
+        targetLanguage: { type: "string", description: "Target language code or name" },
+        sourceLanguage: { type: "string", description: "Optional source language code or name" }
+      },
+      required: ["text", "targetLanguage"]
+    },
+    deliverableRequirements: {
+      type: "object",
+      properties: {
+        translatedText: { type: "string", description: "Translated text output" },
+        sourceLanguage: { type: "string", description: "Detected or provided source language" }
+      },
+      required: ["translatedText"]
+    }
+  }
+};
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTypeMatch(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return isObjectRecord(value);
+    case "array":
+      return Array.isArray(value);
+    default:
+      return false;
+  }
+}
+function validateAgainstSchema(data, schema) {
+  if (!data || !isObjectRecord(data)) {
+    return { valid: false, reason: "Requirements must be a JSON object" };
+  }
+  for (const requiredField of schema.required ?? []) {
+    if (!(requiredField in data)) {
+      return { valid: false, reason: `Missing required field: ${requiredField}` };
+    }
+  }
+  for (const [field, fieldSchema] of Object.entries(schema.properties)) {
+    const value = data[field];
+    if (value === void 0) continue;
+    if (!isTypeMatch(value, fieldSchema.type)) {
+      return {
+        valid: false,
+        reason: `Field "${field}" must be of type ${fieldSchema.type}`
+      };
+    }
+    if (fieldSchema.enum && !fieldSchema.enum.some((enumValue) => Object.is(enumValue, value))) {
+      return {
+        valid: false,
+        reason: `Field "${field}" must be one of: ${fieldSchema.enum.map((v) => JSON.stringify(v)).join(", ")}`
+      };
+    }
+    if (fieldSchema.type === "array" && fieldSchema.items && Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        if (!isTypeMatch(value[i], fieldSchema.items.type)) {
+          return {
+            valid: false,
+            reason: `Field "${field}[${i}]" must be of type ${fieldSchema.items.type}`
+          };
+        }
+      }
+    }
+  }
+  return { valid: true };
+}
+
 // src/utils.ts
 var USDM_DECIMALS = 18;
 var USDM_SCALE = 10n ** BigInt(USDM_DECIMALS);
@@ -3264,28 +3621,6 @@ function formatUsdm(amount) {
   return `${whole}.${trimmedFraction.padEnd(2, "0")}`;
 }
 
-// src/types.ts
-var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
-  JobStatus2[JobStatus2["Created"] = 0] = "Created";
-  JobStatus2[JobStatus2["Accepted"] = 1] = "Accepted";
-  JobStatus2[JobStatus2["InProgress"] = 2] = "InProgress";
-  JobStatus2[JobStatus2["Delivered"] = 3] = "Delivered";
-  JobStatus2[JobStatus2["Evaluated"] = 4] = "Evaluated";
-  JobStatus2[JobStatus2["Completed"] = 5] = "Completed";
-  JobStatus2[JobStatus2["Disputed"] = 6] = "Disputed";
-  JobStatus2[JobStatus2["Cancelled"] = 7] = "Cancelled";
-  return JobStatus2;
-})(JobStatus || {});
-var ServiceType = /* @__PURE__ */ ((ServiceType2) => {
-  ServiceType2[ServiceType2["TextGeneration"] = 0] = "TextGeneration";
-  ServiceType2[ServiceType2["ImageGeneration"] = 1] = "ImageGeneration";
-  ServiceType2[ServiceType2["DataAnalysis"] = 2] = "DataAnalysis";
-  ServiceType2[ServiceType2["CodeGeneration"] = 3] = "CodeGeneration";
-  ServiceType2[ServiceType2["Translation"] = 4] = "Translation";
-  ServiceType2[ServiceType2["Custom"] = 5] = "Custom";
-  return ServiceType2;
-})(ServiceType || {});
-
 // src/indexer/client.ts
 var IndexerClientError = class extends Error {
   status;
@@ -3323,6 +3658,7 @@ function toIndexerOffering(raw) {
     priceUsdm: raw.price_usdm,
     slaMinutes: raw.sla_minutes,
     description: raw.description,
+    requirementsSchemaUri: raw.requirements_schema_uri ?? void 0,
     active: raw.active === 1,
     blockNumber: raw.block_number,
     txHash: raw.tx_hash
@@ -3755,6 +4091,7 @@ var HandlerProviderRuntime = class {
   running = false;
   processedJobs = /* @__PURE__ */ new Set();
   failedJobs = /* @__PURE__ */ new Map();
+  schemaCache = /* @__PURE__ */ new Map();
   maxRetries = 3;
   onError;
   constructor(client, agentId, options) {
@@ -3783,6 +4120,7 @@ var HandlerProviderRuntime = class {
       try {
         await this.checkNewJobs();
         await this.checkInProgressJobs();
+        await this.checkEvaluatedJobs();
       } catch (e) {
         this.onError?.(e instanceof Error ? e : new Error(String(e)));
       }
@@ -3798,8 +4136,8 @@ var HandlerProviderRuntime = class {
     for (const job of jobs) {
       const newKey = `new:${job.jobId}`;
       if (!this.canProcess(newKey)) continue;
-      const matchesOffering = offerings.some((o) => o.offeringId === job.offeringId);
-      if (!matchesOffering) continue;
+      const offering = offerings.find((o) => o.offeringId === job.offeringId);
+      if (!offering) continue;
       const handler = this.handlers.get(job.offeringId);
       if (!handler) continue;
       try {
@@ -3822,6 +4160,10 @@ var HandlerProviderRuntime = class {
         if (reqData) {
           context.requirements = reqData.requirements;
         }
+        const schemaValidation = await this.validateSchemaRequirements(context, handler, offering);
+        if (!schemaValidation.valid) {
+          throw new Error(`Schema validation failed for job ${job.jobId}: ${schemaValidation.reason}`);
+        }
         if (handler.validateRequirements) {
           const validation = await handler.validateRequirements(context);
           if (!validation.valid) {
@@ -3842,6 +4184,10 @@ var HandlerProviderRuntime = class {
     }
   }
   async checkInProgressJobs() {
+    const offerings = await this.indexer.getOfferings({ agentId: Number(this.agentId) });
+    const offeringsById = new Map(
+      offerings.map((offering) => [offering.offeringId, offering])
+    );
     const inProgressJobs = await this.indexer.getJobs({
       status: 2,
       agentId: Number(this.agentId)
@@ -3851,6 +4197,7 @@ var HandlerProviderRuntime = class {
       if (!this.canProcess(deliverKey)) continue;
       const handler = this.handlers.get(job.offeringId);
       if (!handler) continue;
+      const offering = offeringsById.get(job.offeringId);
       try {
         if (job.slaMinutes === null) {
           throw new Error(`Job ${job.jobId} is missing slaMinutes`);
@@ -3871,6 +4218,14 @@ var HandlerProviderRuntime = class {
         if (reqData) {
           context.requirements = reqData.requirements;
         }
+        const schemaValidation = await this.validateSchemaRequirements(context, handler, offering);
+        if (!schemaValidation.valid) {
+          this.markFailed(
+            deliverKey,
+            new Error(`Schema validation failed for job ${job.jobId}: ${schemaValidation.reason}`)
+          );
+          continue;
+        }
         if (handler.validateRequirements) {
           const validation = await handler.validateRequirements(context);
           if (!validation.valid) {
@@ -3930,6 +4285,23 @@ var HandlerProviderRuntime = class {
       }
     }
   }
+  async checkEvaluatedJobs() {
+    const evaluatedJobs = await this.indexer.getJobs({
+      status: 4,
+      agentId: Number(this.agentId)
+    });
+    for (const job of evaluatedJobs) {
+      const settleKey = `settle:${job.jobId}`;
+      if (!this.canProcess(settleKey)) continue;
+      try {
+        await settle(this.client, BigInt(job.jobId));
+        console.log(`[handler-provider] auto-settled job ${job.jobId}`);
+        this.markProcessed(settleKey);
+      } catch (e) {
+        this.markFailed(settleKey, e);
+      }
+    }
+  }
   canProcess(key) {
     if (this.processedJobs.has(key)) return false;
     return (this.failedJobs.get(key) ?? 0) < this.maxRetries;
@@ -3947,6 +4319,75 @@ var HandlerProviderRuntime = class {
       this.onError?.(new Error(`Giving up on ${key} after ${retries} failed attempts`));
     }
   }
+  async validateSchemaRequirements(context, handler, offering) {
+    if (offering?.requirementsSchemaUri) {
+      try {
+        const offeringSchema = await this.resolveOfferingSchemaFromUri(offering.requirementsSchemaUri);
+        if (!offeringSchema) {
+          return {
+            valid: false,
+            reason: `Unsupported requirementsSchemaUri format: ${offering.requirementsSchemaUri}`
+          };
+        }
+        return validateAgainstSchema(context.requirements, offeringSchema.serviceRequirements);
+      } catch (error) {
+        return {
+          valid: false,
+          reason: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+    const defaultSchema = offering ? DEFAULT_SCHEMAS[offering.serviceType] : void 0;
+    const schema = handler.schema ?? defaultSchema;
+    if (!schema) return { valid: true };
+    return validateAgainstSchema(context.requirements, schema.serviceRequirements);
+  }
+  async resolveOfferingSchemaFromUri(schemaUri) {
+    const cached = this.schemaCache.get(schemaUri);
+    if (cached !== void 0) {
+      return cached;
+    }
+    let schemaPayload;
+    if (schemaUri.startsWith("data:")) {
+      schemaPayload = this.parseDataUriJson(schemaUri);
+    } else if (schemaUri.startsWith("http://") || schemaUri.startsWith("https://")) {
+      const response = await fetch(schemaUri);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch requirements schema URI (${response.status} ${response.statusText})`);
+      }
+      schemaPayload = await response.json();
+    } else if (schemaUri.trim().startsWith("{")) {
+      schemaPayload = JSON.parse(schemaUri);
+    } else {
+      this.schemaCache.set(schemaUri, null);
+      return null;
+    }
+    if (!this.isOfferingSchema(schemaPayload)) {
+      throw new Error("requirementsSchemaUri did not resolve to a valid OfferingSchema document");
+    }
+    this.schemaCache.set(schemaUri, schemaPayload);
+    return schemaPayload;
+  }
+  parseDataUriJson(dataUri) {
+    const commaIndex = dataUri.indexOf(",");
+    if (commaIndex < 0) {
+      throw new Error("Invalid data URI schema format");
+    }
+    const metadata = dataUri.slice(5, commaIndex);
+    const payload = dataUri.slice(commaIndex + 1);
+    const decoded = metadata.includes(";base64") ? new TextDecoder().decode(Uint8Array.from(atob(payload), (char) => char.charCodeAt(0))) : decodeURIComponent(payload);
+    return JSON.parse(decoded);
+  }
+  isOfferingSchema(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const candidate = value;
+    return typeof candidate.version === "number" && this.isJsonSchema(candidate.serviceRequirements) && this.isJsonSchema(candidate.deliverableRequirements);
+  }
+  isJsonSchema(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const candidate = value;
+    return candidate.type === "object" && typeof candidate.properties === "object" && candidate.properties !== null;
+  }
   getRemainingSlaMs(createdAt, acceptedAt, slaMinutes) {
     const start = acceptedAt ?? createdAt;
     if (start === null) return null;
@@ -4802,11 +5243,534 @@ var erc8004ReputationAbi = [
     "anonymous": false
   }
 ];
+
+// src/abis/BuyerRelay.ts
+var buyerRelayAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "owner_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "identityRegistry_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "pulseExtension_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "jobEngine_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "serviceMarketplace_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "usdm_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "buyerAgentId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "cancelFor",
+    "inputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "claimRefund",
+    "inputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "createJobFor",
+    "inputs": [
+      {
+        "name": "offeringId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "termsHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maxPrice",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "evaluateFor",
+    "inputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "feedback",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "identityRegistry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IERC8004Identity"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "jobDeposit",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "jobEngine",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IJobEngine"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "jobPayer",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "jobRefundState",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "enum IBuyerRelay.RefundState"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onERC721Received",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pulseExtension",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IPulseExtension"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "renounceOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "serviceMarketplace",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IServiceMarketplace"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setup",
+    "inputs": [
+      {
+        "name": "agentURI",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "usdm",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "EvaluatedFor",
+    "inputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "payer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "JobCreatedFor",
+    "inputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "payer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "price",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RefundClaimed",
+    "inputs": [
+      {
+        "name": "jobId",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "payer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AgentAlreadyInitialized",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "AgentNotActive",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InsufficientPayment",
+    "inputs": [
+      {
+        "name": "required",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "provided",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidJobStatus",
+    "inputs": [
+      {
+        "name": "current",
+        "type": "uint8",
+        "internalType": "enum DataTypes.JobStatus"
+      },
+      {
+        "name": "expected",
+        "type": "uint8",
+        "internalType": "enum DataTypes.JobStatus"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidRefundState",
+    "inputs": [
+      {
+        "name": "current",
+        "type": "uint8",
+        "internalType": "enum IBuyerRelay.RefundState"
+      },
+      {
+        "name": "expected",
+        "type": "uint8",
+        "internalType": "enum IBuyerRelay.RefundState"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OnlyBuyer",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OwnableInvalidOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OwnableUnauthorizedAccount",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "Reentrancy",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroAddress",
+    "inputs": []
+  }
+];
 export {
   ACCEPT_TIMEOUT,
   BPS_DENOMINATOR,
   BuyerRuntime,
   DEFAULT_INDEXER_URLS,
+  DEFAULT_SCHEMAS,
   EVALUATION_TIMEOUT,
   FEE_BPS,
   HandlerProviderRuntime,
@@ -4815,6 +5779,7 @@ export {
   JobStatus,
   MAINNET_ADDRESSES,
   MEMO_TYPES,
+  PLATFORM_BUYER_AGENT_ID,
   PULSE_DOMAIN,
   ProviderRuntime,
   RISK_POOL_BPS,
@@ -4825,6 +5790,7 @@ export {
   USDM_MAINNET,
   acceptJob,
   activateOffering,
+  buyerRelayAbi,
   callAI,
   cancelJob,
   createAgentCard,
@@ -4878,6 +5844,7 @@ export {
   submitDeliverable,
   testnetERC8004,
   updateOffering,
+  validateAgainstSchema,
   verifyContentHash
 };
 //# sourceMappingURL=index.js.map