@pulseai/sdk 0.1.0 → 0.1.1

package/dist/index.js

@@ -34,12 +34,11 @@ var TESTNET_ADDRESSES = {
   reputationRegistry: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
   usdm: "0x939Ff43f7c4A2E94069af7DBbc4497377DdcCE3f"
 };
-var PLACEHOLDER_ADDRESS = "0x0";
 var MAINNET_ADDRESSES = {
-  pulseExtension: PLACEHOLDER_ADDRESS,
-  serviceMarketplace: PLACEHOLDER_ADDRESS,
-  jobEngine: PLACEHOLDER_ADDRESS,
-  feeDistributor: PLACEHOLDER_ADDRESS,
+  pulseExtension: "0xf1616D2008c4Ff5Ed7BDBd448DAE68615b7A71f0",
+  serviceMarketplace: "0xfC180058FCB69531818B832C12473302811dfFF6",
+  jobEngine: "0xb5E56262b55aE453E8B16470228F0a5Ef617FF67",
+  feeDistributor: "0x51EdD8E4C4B423b952821fc9e2a7dad15a858B56",
   identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
   reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63",
   usdm: "0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7"
@@ -2387,13 +2386,29 @@ async function acceptJob(client, jobId, warrenTermsHash) {
     args: [jobId, signature]
   });
 }
-async function submitDeliverable(client, jobId, deliverableHash) {
-  return write(client, {
+async function submitDeliverable(client, jobId, deliverableHash, options) {
+  const txHash = await write(client, {
     address: client.addresses.jobEngine,
     abi: jobEngineAbi,
     functionName: "submitDeliverable",
     args: [jobId, deliverableHash]
   });
+  if (options?.content && options?.indexerUrl) {
+    try {
+      await fetch(`${options.indexerUrl.replace(/\/$/, "")}/deliverables`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jobId: Number(jobId),
+          content: options.content,
+          contentHash: deliverableHash,
+          storageType: "indexer"
+        })
+      });
+    } catch {
+    }
+  }
+  return txHash;
 }
 async function evaluate(client, jobId, approved, feedback) {
   return write(client, {
@@ -2435,6 +2450,17 @@ async function getJobCount(client) {
     functionName: "getJobCount"
   });
 }
+async function rejectJob(client, jobId, feedback) {
+  return evaluate(client, jobId, false, feedback);
+}
+async function resolveDispute(client, jobId, favorBuyer) {
+  return write(client, {
+    address: client.addresses.jobEngine,
+    abi: jobEngineAbi,
+    functionName: "resolveDispute",
+    args: [jobId, favorBuyer]
+  });
+}
 
 // src/warren/index.ts
 import { keccak256, toHex as toHex2 } from "viem";
@@ -2664,6 +2690,21 @@ async function deployDeliverable(client, agentId, jobId, params, indexerUrl) {
     } catch {
     }
   }
+  if (indexerUrl) {
+    try {
+      await fetch(`${indexerUrl.replace(/\/$/, "")}/deliverables`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jobId: Number(jobId),
+          content: json,
+          contentHash: hash,
+          storageType: "warren"
+        })
+      });
+    } catch {
+    }
+  }
   return { masterAddress, pageAddress, hash, txHash };
 }
 async function readDeliverable(client, jobId, indexerUrl) {
@@ -2787,6 +2828,406 @@ function createRequirements(params) {
   return { json, hash };
 }
 
+// src/ai/provider.ts
+function parseErrorMessage(payload) {
+  if (typeof payload !== "object" || payload === null) return null;
+  const record = payload;
+  const error = record.error;
+  if (typeof error === "string") return error;
+  if (typeof error === "object" && error !== null) {
+    const message2 = error.message;
+    if (typeof message2 === "string" && message2.length > 0) return message2;
+  }
+  const message = record.message;
+  if (typeof message === "string" && message.length > 0) return message;
+  return null;
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((entry) => {
+    if (typeof entry === "string") return entry;
+    if (typeof entry !== "object" || entry === null) return "";
+    const text = entry.text;
+    return typeof text === "string" ? text : "";
+  }).join("\n").trim();
+}
+async function parseJsonResponse(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function callOpenAI(params) {
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${params.apiKey}`
+    },
+    body: JSON.stringify({
+      model: params.model,
+      messages: params.messages.map((message) => ({
+        role: message.role,
+        content: message.content
+      })),
+      max_tokens: params.maxTokens
+    }),
+    signal: params.signal
+  });
+  const payload = await parseJsonResponse(response);
+  if (!response.ok) {
+    throw new Error(
+      `OpenAI request failed (${response.status}): ${parseErrorMessage(payload) ?? response.statusText}`
+    );
+  }
+  const content = extractTextContent(payload?.choices?.[0]?.message?.content);
+  if (!content) {
+    throw new Error("OpenAI returned an empty response");
+  }
+  return { content, raw: payload };
+}
+async function callAnthropic(params) {
+  const systemPrompt = params.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n").trim();
+  const messages = params.messages.filter((message) => message.role !== "system").map((message) => ({
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: message.content
+  }));
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": params.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: params.model,
+      max_tokens: params.maxTokens ?? 1024,
+      system: systemPrompt.length > 0 ? systemPrompt : void 0,
+      messages
+    }),
+    signal: params.signal
+  });
+  const payload = await parseJsonResponse(response);
+  if (!response.ok) {
+    throw new Error(
+      `Anthropic request failed (${response.status}): ${parseErrorMessage(payload) ?? response.statusText}`
+    );
+  }
+  const content = extractTextContent(payload?.content);
+  if (!content) {
+    throw new Error("Anthropic returned an empty response");
+  }
+  return { content, raw: payload };
+}
+async function callGoogle(params) {
+  const systemPrompt = params.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n").trim();
+  const contents = params.messages.filter((message) => message.role !== "system").map((message) => ({
+    role: message.role === "assistant" ? "model" : "user",
+    parts: [{ text: message.content }]
+  }));
+  const url = new URL(
+    `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(params.model)}:generateContent`
+  );
+  url.searchParams.set("key", params.apiKey);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      contents,
+      systemInstruction: systemPrompt.length > 0 ? { parts: [{ text: systemPrompt }] } : void 0,
+      generationConfig: params.maxTokens !== void 0 ? { maxOutputTokens: params.maxTokens } : void 0
+    }),
+    signal: params.signal
+  });
+  const payload = await parseJsonResponse(response);
+  if (!response.ok) {
+    throw new Error(
+      `Google request failed (${response.status}): ${parseErrorMessage(payload) ?? response.statusText}`
+    );
+  }
+  const content = extractTextContent(payload?.candidates?.[0]?.content?.parts);
+  if (!content) {
+    throw new Error("Google returned an empty response");
+  }
+  return { content, raw: payload };
+}
+async function callAI(params) {
+  if (params.provider === "openai") {
+    return callOpenAI(params);
+  }
+  if (params.provider === "anthropic") {
+    return callAnthropic(params);
+  }
+  if (params.provider === "google") {
+    return callGoogle(params);
+  }
+  throw new Error(`Unsupported AI provider: ${String(params.provider)}`);
+}
+
+// src/handler/site-modifier.ts
+var FETCH_TIMEOUT_MS = 3e4;
+var MAX_HTML_BYTES = 500 * 1024;
+var DEFAULT_MAX_TOKENS = 4096;
+var SUPPORTED_PROVIDERS = ["anthropic", "google", "openai"];
+var DEFAULT_MODELS = {
+  openai: "gpt-4o-mini",
+  anthropic: "claude-3-5-sonnet-latest",
+  google: "gemini-1.5-pro"
+};
+var DEFAULT_SYSTEM_PROMPT = [
+  "You are an expert frontend engineer modifying an existing HTML document.",
+  "Return a complete, self-contained HTML file.",
+  "Inline all CSS in <style> tags and do not use external stylesheets.",
+  "Do not add any external dependencies (no CDNs, external scripts, fonts, or assets).",
+  "Preserve all existing functionality unless explicitly requested to change it.",
+  "Keep the output valid HTML and include all required tags.",
+  "Wrap the final HTML output in a ```html code block."
+].join("\n");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isSupportedProvider(value) {
+  return typeof value === "string" && SUPPORTED_PROVIDERS.includes(value);
+}
+function normalizeDomain(domain) {
+  return domain.trim().toLowerCase().replace(/^\*\./, "").replace(/\.$/, "");
+}
+function isAllowedDomain(hostname, allowedDomains) {
+  const host = normalizeDomain(hostname);
+  return allowedDomains.some((domain) => {
+    const normalized = normalizeDomain(domain);
+    if (!normalized) return false;
+    return host === normalized || host.endsWith(`.${normalized}`);
+  });
+}
+function parseAndValidateUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    throw new Error("siteUrl must be a valid URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("siteUrl must use http or https");
+  }
+  return url;
+}
+function ensureAllowedUrl(url, allowedDomains) {
+  if (!allowedDomains || allowedDomains.length === 0) return;
+  if (!isAllowedDomain(url.hostname, allowedDomains)) {
+    throw new Error(`siteUrl domain "${url.hostname}" is not allowed`);
+  }
+}
+function isHtmlContentType(contentType) {
+  const lower = contentType.toLowerCase();
+  return lower.includes("text/html") || lower.includes("application/xhtml+xml");
+}
+function extractHtmlFromText(text) {
+  const htmlFence = text.match(/```html\s*([\s\S]*?)```/i);
+  if (htmlFence?.[1]) {
+    const fencedHtml = htmlFence[1].trim();
+    if (fencedHtml) return fencedHtml;
+  }
+  const anyFence = text.match(/```\s*([\s\S]*?)```/);
+  if (anyFence?.[1]) {
+    const fencedContent = anyFence[1].trim();
+    if (/<html[\s>]|<!doctype html/i.test(fencedContent)) {
+      return fencedContent;
+    }
+  }
+  const trimmed = text.trim();
+  if (/<html[\s>]|<!doctype html/i.test(trimmed)) {
+    return trimmed;
+  }
+  return null;
+}
+function getByteLength(content) {
+  return new TextEncoder().encode(content).byteLength;
+}
+var SiteModifierHandler = class {
+  offeringId;
+  autoAccept;
+  config;
+  constructor(offeringId, config, options) {
+    this.offeringId = offeringId;
+    this.config = config;
+    this.autoAccept = options?.autoAccept;
+  }
+  async validateRequirements(context) {
+    try {
+      this.parseRequirements(context.requirements);
+      return { valid: true };
+    } catch (error) {
+      return {
+        valid: false,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async executeJob(context) {
+    const requirements = this.parseRequirements(context.requirements);
+    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 maxTokens = this.config.maxTokens && this.config.maxTokens > 0 ? this.config.maxTokens : DEFAULT_MAX_TOKENS;
+    if (!model) {
+      throw new Error(
+        `No model configured for provider "${provider}". Set defaultModel or provide requirements.model`
+      );
+    }
+    const originalHtml = await this.fetchHtmlWithTimeout(
+      targetUrl.toString(),
+      context.abortSignal
+    );
+    const apiKey = await this.config.getApiKey(provider);
+    if (!isNonEmptyString(apiKey)) {
+      throw new Error(
+        `Missing API key for provider "${provider}". Check BYOK setup for indexer ${this.config.indexerUrl}`
+      );
+    }
+    const systemPrompt = this.config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
+    const userPrompt = [
+      `Modification request: ${requirements.modificationRequest}`,
+      "",
+      "Current HTML:",
+      "```html",
+      originalHtml,
+      "```"
+    ].join("\n");
+    const aiResponse = await callAI({
+      provider,
+      model,
+      maxTokens,
+      apiKey,
+      signal: context.abortSignal,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ]
+    });
+    const modifiedHtml = extractHtmlFromText(aiResponse.content);
+    if (!modifiedHtml) {
+      throw new Error("AI response did not contain valid HTML output");
+    }
+    if (getByteLength(modifiedHtml) > MAX_HTML_BYTES) {
+      throw new Error(
+        `Modified HTML exceeds size limit (${MAX_HTML_BYTES} bytes)`
+      );
+    }
+    return {
+      type: "inline",
+      content: modifiedHtml,
+      mimeType: "text/html"
+    };
+  }
+  parseRequirements(requirements) {
+    if (!isRecord(requirements)) {
+      throw new Error("Missing requirements object");
+    }
+    const siteUrl = requirements.siteUrl;
+    if (!isNonEmptyString(siteUrl)) {
+      throw new Error("requirements.siteUrl must be a non-empty string");
+    }
+    const parsedUrl = parseAndValidateUrl(siteUrl);
+    ensureAllowedUrl(parsedUrl, this.config.allowedDomains);
+    const modificationRequest = requirements.modificationRequest;
+    if (!isNonEmptyString(modificationRequest)) {
+      throw new Error(
+        "requirements.modificationRequest must be a non-empty string"
+      );
+    }
+    const provider = requirements.provider;
+    if (provider !== void 0 && !isSupportedProvider(provider)) {
+      throw new Error(
+        `requirements.provider must be one of: ${SUPPORTED_PROVIDERS.join(", ")}`
+      );
+    }
+    const model = requirements.model;
+    if (model !== void 0 && !isNonEmptyString(model)) {
+      throw new Error("requirements.model must be a non-empty string");
+    }
+    return {
+      siteUrl: siteUrl.trim(),
+      modificationRequest: modificationRequest.trim(),
+      provider,
+      model: typeof model === "string" ? model.trim() : void 0
+    };
+  }
+  async fetchHtmlWithTimeout(siteUrl, parentSignal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort(new Error(`Site fetch timed out after ${FETCH_TIMEOUT_MS}ms`));
+    }, FETCH_TIMEOUT_MS);
+    const parentAbort = () => controller.abort(parentSignal?.reason);
+    if (parentSignal) {
+      if (parentSignal.aborted) {
+        controller.abort(parentSignal.reason);
+      } else {
+        parentSignal.addEventListener("abort", parentAbort, { once: true });
+      }
+    }
+    try {
+      const response = await fetch(siteUrl, {
+        method: "GET",
+        headers: { Accept: "text/html,application/xhtml+xml" },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch site HTML: ${response.status} ${response.statusText}`
+        );
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType && !isHtmlContentType(contentType)) {
+        throw new Error(
+          `Fetched content is not HTML (content-type: ${contentType})`
+        );
+      }
+      const contentLengthHeader = response.headers.get("content-length");
+      if (contentLengthHeader) {
+        const contentLength = Number.parseInt(contentLengthHeader, 10);
+        if (Number.isFinite(contentLength) && contentLength > MAX_HTML_BYTES) {
+          throw new Error(
+            `HTML too large (${contentLength} bytes). Limit is ${MAX_HTML_BYTES} bytes`
+          );
+        }
+      }
+      const htmlBuffer = await response.arrayBuffer();
+      if (htmlBuffer.byteLength > MAX_HTML_BYTES) {
+        throw new Error(
+          `HTML too large (${htmlBuffer.byteLength} bytes). Limit is ${MAX_HTML_BYTES} bytes`
+        );
+      }
+      const html = new TextDecoder().decode(htmlBuffer).trim();
+      if (!html) {
+        throw new Error("Fetched HTML is empty");
+      }
+      return html;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (parentSignal?.aborted) {
+          throw new Error("Site fetch aborted");
+        }
+        throw new Error(`Site fetch timed out after ${FETCH_TIMEOUT_MS}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+      if (parentSignal) {
+        parentSignal.removeEventListener("abort", parentAbort);
+      }
+    }
+  }
+};
+
 // src/utils.ts
 var USDM_DECIMALS = 18;
 var USDM_SCALE = 10n ** BigInt(USDM_DECIMALS);
@@ -2858,7 +3299,7 @@ var IndexerClientError = class extends Error {
     this.body = options.body;
   }
 };
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function toIndexerAgent(raw) {
@@ -2986,6 +3427,31 @@ var IndexerClient = class {
     );
     return toIndexerWarrenLinks(payload.data);
   }
+  async postDeliverable(jobId, content, contentHash, storageType) {
+    await this.requestJson("/deliverables", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jobId,
+        content,
+        contentHash,
+        storageType: storageType ?? "indexer"
+      })
+    });
+  }
+  async getDeliverable(jobId) {
+    try {
+      const response = await this.request(`/deliverables/${jobId}`);
+      if (response.status === 404) return null;
+      const payload = await this.parseResponse(
+        response,
+        `/deliverables/${jobId}`
+      );
+      return { content: payload.data.content, storageType: payload.data.storage_type };
+    } catch {
+      return null;
+    }
+  }
   async request(path, init) {
     const url = `${this.baseUrl}${path}`;
     const controller = new AbortController();
@@ -3021,7 +3487,7 @@ var IndexerClient = class {
       });
     }
     if (!response.ok) {
-      const apiError = isRecord(payload) ? payload : void 0;
+      const apiError = isRecord2(payload) ? payload : void 0;
       const message = response.status === 404 && notFoundMessage ? notFoundMessage : apiError?.error ?? apiError?.message ?? `Indexer request failed (${response.status})`;
       throw new IndexerClientError(message, {
         url,
@@ -3075,10 +3541,11 @@ var ProviderRuntime = class {
     });
     const jobs = await this.indexer.getJobs({ status: 0 });
     for (const job of jobs) {
-      if (this.processedJobs.has(job.jobId)) continue;
+      const newKey = `new:${job.jobId}`;
+      if (this.processedJobs.has(newKey)) continue;
       const matchesOffering = offerings.some((o) => o.offeringId === job.offeringId);
       if (!matchesOffering) continue;
-      this.processedJobs.add(job.jobId);
+      this.processedJobs.add(newKey);
       if (this.callbacks.onJobReceived) {
         try {
           const accept = await this.callbacks.onJobReceived(job);
@@ -3103,7 +3570,7 @@ var ProviderRuntime = class {
       agentId: Number(this.agentId)
     });
     for (const job of inProgressJobs) {
-      const deliverKey = job.jobId * 1e3;
+      const deliverKey = `deliver:${job.jobId}`;
       if (this.processedJobs.has(deliverKey)) continue;
       if (this.callbacks.onDeliverableRequested) {
         try {
@@ -3130,7 +3597,7 @@ var ProviderRuntime = class {
       agentId: Number(this.agentId)
     });
     for (const job of completedJobs) {
-      const completeKey = job.jobId * 1e4;
+      const completeKey = `complete:${job.jobId}`;
       if (this.processedJobs.has(completeKey)) continue;
       this.processedJobs.add(completeKey);
       this.callbacks.onJobCompleted?.(job);
@@ -3241,8 +3708,9 @@ var BuyerRuntime = class {
       agentId: Number(this.agentId)
     });
     for (const job of deliveredJobs) {
-      if (this.processedJobs.has(job.jobId)) continue;
-      this.processedJobs.add(job.jobId);
+      const deliveredKey = `delivered:${job.jobId}`;
+      if (this.processedJobs.has(deliveredKey)) continue;
+      this.processedJobs.add(deliveredKey);
       try {
         const deliverable = await readDeliverable(
           this.client,
@@ -3267,7 +3735,7 @@ var BuyerRuntime = class {
       agentId: Number(this.agentId)
     });
     for (const job of completedJobs) {
-      const completeKey = job.jobId * 1e3;
+      const completeKey = `complete:${job.jobId}`;
       if (this.processedJobs.has(completeKey)) continue;
       this.processedJobs.add(completeKey);
       this.callbacks.onJobCompleted?.(job);
@@ -3283,8 +3751,11 @@ var HandlerProviderRuntime = class {
   indexer;
   indexerUrl;
   pollInterval;
+  executionTimeoutMs;
   running = false;
   processedJobs = /* @__PURE__ */ new Set();
+  failedJobs = /* @__PURE__ */ new Map();
+  maxRetries = 3;
   onError;
   constructor(client, agentId, options) {
     this.client = client;
@@ -3292,6 +3763,7 @@ var HandlerProviderRuntime = class {
     this.indexer = new IndexerClient({ baseUrl: options.indexerUrl });
     this.indexerUrl = options.indexerUrl.replace(/\/$/, "");
     this.pollInterval = options.pollInterval ?? 5e3;
+    this.executionTimeoutMs = options.executionTimeoutMs ?? 5 * 60 * 1e3;
   }
   registerHandler(handler) {
     this.handlers.set(handler.offeringId, handler);
@@ -3324,13 +3796,38 @@ var HandlerProviderRuntime = class {
     });
     const jobs = await this.indexer.getJobs({ status: 0 });
     for (const job of jobs) {
-      if (this.processedJobs.has(job.jobId)) continue;
+      const newKey = `new:${job.jobId}`;
+      if (!this.canProcess(newKey)) continue;
       const matchesOffering = offerings.some((o) => o.offeringId === job.offeringId);
       if (!matchesOffering) continue;
       const handler = this.handlers.get(job.offeringId);
       if (!handler) continue;
-      this.processedJobs.add(job.jobId);
       try {
+        if (job.slaMinutes === null) {
+          throw new Error(`Job ${job.jobId} is missing slaMinutes`);
+        }
+        const context = {
+          jobId: BigInt(job.jobId),
+          offeringId: BigInt(job.offeringId),
+          buyerAgentId: BigInt(job.buyerAgentId),
+          providerAgentId: BigInt(job.providerAgentId),
+          priceUsdm: job.priceUsdm,
+          slaMinutes: job.slaMinutes
+        };
+        const reqData = await readRequirements(
+          this.client,
+          BigInt(job.jobId),
+          this.indexerUrl
+        );
+        if (reqData) {
+          context.requirements = reqData.requirements;
+        }
+        if (handler.validateRequirements) {
+          const validation = await handler.validateRequirements(context);
+          if (!validation.valid) {
+            throw new Error(`Validation failed for job ${job.jobId}: ${validation.reason}`);
+          }
+        }
         if (handler.autoAccept !== false) {
           await acceptJob(
             this.client,
@@ -3338,8 +3835,9 @@ var HandlerProviderRuntime = class {
             job.warrenTermsHash
           );
         }
+        this.markProcessed(newKey);
       } catch (e) {
-        this.onError?.(e instanceof Error ? e : new Error(String(e)));
+        this.markFailed(newKey, e);
       }
     }
   }
@@ -3349,15 +3847,13 @@ var HandlerProviderRuntime = class {
       agentId: Number(this.agentId)
     });
     for (const job of inProgressJobs) {
-      const deliverKey = job.jobId * 1e3;
-      if (this.processedJobs.has(deliverKey)) continue;
+      const deliverKey = `deliver:${job.jobId}`;
+      if (!this.canProcess(deliverKey)) continue;
       const handler = this.handlers.get(job.offeringId);
       if (!handler) continue;
-      this.processedJobs.add(deliverKey);
       try {
         if (job.slaMinutes === null) {
-          this.onError?.(new Error(`Job ${job.jobId} is missing slaMinutes`));
-          continue;
+          throw new Error(`Job ${job.jobId} is missing slaMinutes`);
         }
         const context = {
           jobId: BigInt(job.jobId),
@@ -3378,32 +3874,85 @@ var HandlerProviderRuntime = class {
         if (handler.validateRequirements) {
           const validation = await handler.validateRequirements(context);
           if (!validation.valid) {
-            this.onError?.(
+            this.markFailed(
+              deliverKey,
               new Error(`Validation failed for job ${job.jobId}: ${validation.reason}`)
             );
             continue;
           }
         }
-        const result = await handler.executeJob(context);
-        const deliverableParams = {
-          type: result.type,
-          content: result.content,
-          url: result.url,
-          mimeType: result.mimeType,
-          jobId: BigInt(job.jobId)
-        };
-        await deployDeliverable(
-          this.client,
-          this.agentId,
-          BigInt(job.jobId),
-          deliverableParams,
-          this.indexerUrl
-        );
+        const remainingSlaMs = this.getRemainingSlaMs(job.createdAt, job.acceptedAt, job.slaMinutes);
+        if (remainingSlaMs !== null && remainingSlaMs < 10 * 60 * 1e3) {
+          console.warn(
+            `Skipping job ${job.jobId}: SLA remaining ${Math.max(0, Math.floor(remainingSlaMs / 1e3))}s is below 10 minutes`
+          );
+          this.markProcessed(deliverKey);
+          continue;
+        }
+        const controller = new AbortController();
+        const executionContext = { ...context, abortSignal: controller.signal };
+        let timeoutId;
+        try {
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              controller.abort();
+              reject(
+                new Error(
+                  `Execution timed out for job ${job.jobId} after ${this.executionTimeoutMs}ms`
+                )
+              );
+            }, this.executionTimeoutMs);
+          });
+          const result = await Promise.race([
+            handler.executeJob(executionContext),
+            timeoutPromise
+          ]);
+          const deliverableParams = {
+            type: result.type,
+            content: result.content,
+            url: result.url,
+            mimeType: result.mimeType,
+            jobId: BigInt(job.jobId)
+          };
+          await deployDeliverable(
+            this.client,
+            this.agentId,
+            BigInt(job.jobId),
+            deliverableParams,
+            this.indexerUrl
+          );
+        } finally {
+          if (timeoutId) clearTimeout(timeoutId);
+        }
+        this.markProcessed(deliverKey);
       } catch (e) {
-        this.onError?.(e instanceof Error ? e : new Error(String(e)));
+        this.markFailed(deliverKey, e);
       }
     }
   }
+  canProcess(key) {
+    if (this.processedJobs.has(key)) return false;
+    return (this.failedJobs.get(key) ?? 0) < this.maxRetries;
+  }
+  markProcessed(key) {
+    this.failedJobs.delete(key);
+    this.processedJobs.add(key);
+  }
+  markFailed(key, error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    this.onError?.(err);
+    const retries = (this.failedJobs.get(key) ?? 0) + 1;
+    this.failedJobs.set(key, retries);
+    if (retries >= this.maxRetries) {
+      this.onError?.(new Error(`Giving up on ${key} after ${retries} failed attempts`));
+    }
+  }
+  getRemainingSlaMs(createdAt, acceptedAt, slaMinutes) {
+    const start = acceptedAt ?? createdAt;
+    if (start === null) return null;
+    const startMs = start > 1e12 ? start : start * 1e3;
+    return startMs + slaMinutes * 60 * 1e3 - Date.now();
+  }
 };
 
 // src/abis/FeeDistributor.ts
@@ -4270,11 +4819,13 @@ export {
   ProviderRuntime,
   RISK_POOL_BPS,
   ServiceType,
+  SiteModifierHandler,
   TESTNET_ADDRESSES,
   TREASURY_BPS,
   USDM_MAINNET,
   acceptJob,
   activateOffering,
+  callAI,
   cancelJob,
   createAgentCard,
   createDeliverable,
@@ -4317,6 +4868,8 @@ export {
   readWarrenMaster,
   readWarrenPage,
   registerAgent,
+  rejectJob,
+  resolveDispute,
   serviceMarketplaceAbi,
   setOperator,
   setWarrenContract,