@agrentingai/paperclip-adapter 0.2.0

package/dist/server/index.cjs

@@ -0,0 +1,1406 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// server/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgrentingClient: () => AgrentingClient,
+  MAX_POLLS: () => MAX_POLLS,
+  POLL_INTERVALS_MS: () => POLL_INTERVALS_MS,
+  autoSelectAgent: () => autoSelectAgent,
+  canSubmitTask: () => canSubmitTask,
+  checkBalance: () => checkBalance,
+  createServerAdapter: () => createServerAdapter,
+  createWebhookHandler: () => createWebhookHandler,
+  deregisterWebhook: () => deregisterWebhook,
+  executeWithRetry: () => executeWithRetry,
+  formatAgentResponse: () => formatAgentResponse,
+  formatInsufficientBalanceComment: () => formatInsufficientBalanceComment,
+  formatLowBalanceComment: () => formatLowBalanceComment,
+  forwardCommentToAgrenting: () => forwardCommentToAgrenting,
+  getActiveTaskMappings: () => getActiveTaskMappings,
+  getAgentProfile: () => getAgentProfile,
+  getBackoffMs: () => getBackoffMs,
+  getHiring: () => getHiring,
+  getHiringMessages: () => getHiringMessages,
+  getTaskMessages: () => getTaskMessages,
+  getWebhookGracePeriodMs: () => getWebhookGracePeriodMs,
+  hireAgent: () => hireAgent,
+  listCapabilities: () => listCapabilities,
+  listHirings: () => listHirings,
+  pollTaskUntilDone: () => pollTaskUntilDone,
+  processIncomingMessage: () => processIncomingMessage,
+  reassignTask: () => reassignTask,
+  registerTaskMapping: () => registerTaskMapping,
+  registerWebhook: () => registerWebhook,
+  retryHiring: () => retryHiring,
+  sendMessageToHiring: () => sendMessageToHiring,
+  sendMessageToTask: () => sendMessageToTask,
+  unregisterTaskMapping: () => unregisterTaskMapping,
+  verifyWebhookSignature: () => verifyWebhookSignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// server/src/client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 3;
+var AgrentingClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.agrentingUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey
+    };
+  }
+  async request(method, path, body) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+      try {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+          method,
+          headers: this.headers(),
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          const shouldRetry = response.status === 429 || response.status >= 500;
+          if (shouldRetry && attempt < MAX_RETRIES) {
+            clearTimeout(timer);
+            const retryAfter = response.headers.get("Retry-After");
+            let delayMs = Math.min(1e3 * 2 ** attempt, 3e4);
+            if (retryAfter) {
+              const seconds = parseInt(retryAfter, 10);
+              if (!Number.isNaN(seconds) && seconds > 0) {
+                delayMs = seconds * 1e3;
+              } else {
+                const dateMs = Date.parse(retryAfter);
+                if (!Number.isNaN(dateMs)) {
+                  delayMs = Math.max(0, dateMs - Date.now());
+                }
+              }
+            }
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            continue;
+          }
+          throw new Error(
+            `Agrenting API ${response.status}: ${text.slice(0, 500)}`
+          );
+        }
+        const envelope = await response.json();
+        if (Array.isArray(envelope.errors) && envelope.errors.length) {
+          throw new Error(`API errors: ${envelope.errors.join(", ")}`);
+        }
+        return envelope.data ?? envelope;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < MAX_RETRIES) {
+          clearTimeout(timer);
+          const delayMs = Math.min(1e3 * 2 ** attempt, 3e4);
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+          continue;
+        }
+        throw lastError;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastError ?? new Error("Unexpected retry loop exit");
+  }
+  /** Submit a new task to Agrenting.
+   * When `maxPrice` is set, the task includes pricing info.
+   * Call `createTaskPayment` after this to actually lock escrow funds.
+   */
+  async createTask(params) {
+    const body = {
+      provider_agent_id: params.providerAgentId,
+      capability: params.capability,
+      input: params.input
+    };
+    if (params.maxPrice) {
+      body.max_price = params.maxPrice;
+    }
+    return this.request("POST", "/api/v1/tasks", body);
+  }
+  /** Create a payment for an existing task to lock escrow funds.
+   * This is the step that actually deducts funds from the client's balance
+   * and places them in escrow for the task.
+   */
+  async createTaskPayment(taskId, options = {}) {
+    const body = {
+      task_id: taskId
+    };
+    if (options.cryptoCurrency) body.crypto_currency = options.cryptoCurrency;
+    if (options.paymentType) body.payment_type = options.paymentType;
+    return this.request("POST", `/api/v1/tasks/${taskId}/payments`, body);
+  }
+  /** Get payment info for a task */
+  async getTaskPayment(taskId) {
+    return this.request("GET", `/api/v1/tasks/${taskId}/payments`);
+  }
+  /** Get the status and result of a task */
+  async getTask(taskId) {
+    return this.request("GET", `/api/v1/tasks/${taskId}`);
+  }
+  /** Get task timeline events (progress, attempts, status changes) */
+  async getTaskTimeline(taskId) {
+    return this.request("GET", `/api/v1/tasks/${taskId}/timeline`);
+  }
+  /** Get attempt history for a task */
+  async getTaskAttempts(taskId) {
+    return this.request("GET", `/api/v1/tasks/${taskId}/attempts`);
+  }
+  /** Get current progress of a task */
+  async getTaskProgress(taskId) {
+    const task = await this.getTask(taskId);
+    return {
+      status: task.status,
+      progress_percent: task.progress_percent ?? 0,
+      progress_message: task.progress_message,
+      updated_at: task.updated_at
+    };
+  }
+  /** Register a webhook to receive task lifecycle events.
+   * Sends a flat request body matching the backend's expected shape.
+   */
+  async registerWebhook(params) {
+    return this.request("POST", "/api/v1/webhooks", {
+      callback_url: params.callbackUrl,
+      event_types: params.eventTypes ?? [
+        "task.created",
+        "task.claimed",
+        "task.in_progress",
+        "task.completed",
+        "task.failed",
+        "task.cancelled"
+      ]
+    });
+  }
+  /** List registered webhooks */
+  async listWebhooks() {
+    return this.request("GET", "/api/v1/webhooks");
+  }
+  /** Delete a registered webhook */
+  async deleteWebhook(webhookId) {
+    return this.request("DELETE", `/api/v1/webhooks/${webhookId}`);
+  }
+  /** Cancel a task by ID */
+  async cancelTask(taskId) {
+    return this.request("POST", `/api/v1/tasks/${taskId}/cancel`);
+  }
+  /** Discover marketplace agents available for hire.
+   * Filters by capability, price range, reputation, and availability.
+   */
+  async discoverAgents(options = {}) {
+    const params = new URLSearchParams();
+    if (options.capability) params.set("capability", options.capability);
+    if (options.minPrice) params.set("min_price", options.minPrice.toFixed(2));
+    if (options.maxPrice) params.set("max_price", options.maxPrice.toFixed(2));
+    if (options.minReputation)
+      params.set("min_reputation", String(options.minReputation));
+    if (options.sortBy) params.set("sort_by", options.sortBy);
+    if (options.limit) params.set("limit", String(options.limit));
+    return this.request(
+      "GET",
+      `/api/v1/agents/discover?${params}`
+    );
+  }
+  /** Fetch the current platform balance including available, escrowed, and total. */
+  async getBalance() {
+    return this.request("GET", "/api/v1/ledger/balance");
+  }
+  /** List recent transactions for the authenticated agent. */
+  async getTransactions(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    if (options.type) params.set("type", options.type);
+    return this.request(
+      "GET",
+      `/api/v1/ledger/transactions?${params}`
+    );
+  }
+  /** Deposit funds into the Agrenting ledger. */
+  async deposit(params) {
+    return this.request("POST", "/api/v1/ledger/deposit", {
+      amount: params.amount,
+      currency: params.currency ?? "USD",
+      payment_method: params.paymentMethod ?? "crypto"
+    });
+  }
+  /** Withdraw funds from the Agrenting ledger to an external wallet. */
+  async withdraw(params) {
+    return this.request("POST", "/api/v1/ledger/withdraw", {
+      amount: params.amount,
+      currency: params.currency ?? "USD",
+      withdrawal_address_id: params.withdrawalAddressId
+    });
+  }
+  /** Create a payment intent for off-platform payment processing. */
+  async createPaymentIntent(params) {
+    return this.request("POST", "/api/v1/payments/create-intent", {
+      amount: params.amount,
+      currency: params.currency ?? "USD",
+      payment_type: params.paymentType ?? "crypto"
+    });
+  }
+  /** Validate connectivity and API key by fetching the account balance */
+  async testConnection() {
+    try {
+      const data = await this.request("GET", "/api/v1/ledger/balance");
+      return {
+        ok: true,
+        message: `Connected. Balance: ${data.total ?? data.available ?? "N/A"} ${data.currency ?? "USD"} (Available: ${data.available ?? "N/A"})`
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        message: err instanceof Error ? err.message : "Unknown connection error"
+      };
+    }
+  }
+  /** Upload a document (e.g. instructions) to Agrenting.
+   * Uses the dedicated uploads endpoint which accepts base64-encoded content,
+   * separate from the deal-scoped `/api/v1/documents` endpoint.
+   */
+  async uploadDocument(params) {
+    const contentBase64 = Buffer.from(params.content).toString("base64");
+    return this.request("POST", "/api/v1/uploads", {
+      name: params.name,
+      content: contentBase64,
+      content_type: params.contentType ?? "text/plain",
+      document_type: params.documentType ?? "instructions",
+      task_id: params.taskId
+    });
+  }
+  /** Get the full profile of an agent by DID.
+   * Returns capabilities, pricing tiers, reviews, and availability.
+   */
+  async getAgentProfile(agentDid) {
+    return this.request("GET", `/api/v1/agents/${encodeURIComponent(agentDid)}`);
+  }
+  /** Hire/bind an agent to your account.
+   * Returns adapter config so Paperclip can auto-provision the agent.
+   */
+  async hireAgent(agentDid, options = {}) {
+    const body = {};
+    if (options.pricingModel) body.pricing_model = options.pricingModel;
+    return this.request(
+      "POST",
+      `/api/v1/agents/${encodeURIComponent(agentDid)}/hire`,
+      body
+    );
+  }
+  /** Send a message to a running task (mid-task instructions, feedback, or questions).
+   * Enables bidirectional communication between the Paperclip user and the remote agent.
+   */
+  async sendMessageToTask(taskId, options) {
+    return this.request("POST", `/api/v1/tasks/${taskId}/messages`, {
+      message: options.message,
+      message_type: options.messageType ?? "instruction"
+    });
+  }
+  /** Get messages for a task.
+   * GET /api/v1/tasks/:id/messages
+   */
+  async getTaskMessages(taskId) {
+    return this.request(
+      "GET",
+      `/api/v1/tasks/${taskId}/messages`
+    );
+  }
+  /** Reassign a failed or cancelled task to a different agent.
+   * If `newAgentDid` is omitted, the platform picks the best available agent.
+   */
+  async reassignTask(taskId, newAgentDid) {
+    const body = {};
+    if (newAgentDid) {
+      body.new_provider_agent_did = newAgentDid;
+    }
+    return this.request(
+      "POST",
+      `/api/v1/tasks/${taskId}/reassign`,
+      body
+    );
+  }
+  /** List all available capabilities with descriptions and usage stats.
+   * GET /api/v1/capabilities
+   */
+  async listCapabilities() {
+    return this.request("GET", "/api/v1/capabilities");
+  }
+  /** Send a message to a hiring for communication with the hired agent.
+   * POST /api/v1/hirings/:id/messages
+   */
+  async sendMessageToHiring(hiringId, content) {
+    if (content.length > 5e3) {
+      throw new Error("Message content exceeds 5000 character limit");
+    }
+    return this.request(
+      "POST",
+      `/api/v1/hirings/${hiringId}/messages`,
+      { content }
+    );
+  }
+  /** Get messages for a hiring.
+   * GET /api/v1/hirings/:id/messages
+   */
+  async getHiringMessages(hiringId) {
+    return this.request(
+      "GET",
+      `/api/v1/hirings/${hiringId}/messages`
+    );
+  }
+  /** Retry a failed hiring.
+   * POST /api/v1/hirings/:id/retry
+   */
+  async retryHiring(hiringId, options = {}) {
+    const body = {};
+    if (options.reason) {
+      body.reason = options.reason;
+    }
+    return this.request(
+      "POST",
+      `/api/v1/hirings/${hiringId}/retry`,
+      body
+    );
+  }
+  /** Get a hiring by ID.
+   * GET /api/v1/hirings/:id
+   */
+  async getHiring(hiringId) {
+    return this.request("GET", `/api/v1/hirings/${hiringId}`);
+  }
+  /** List hirings for the authenticated agent.
+   * GET /api/v1/hirings
+   */
+  async listHirings(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.set("status", options.status);
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const query = params.toString() ? `?${params}` : "";
+    return this.request("GET", `/api/v1/hirings${query}`);
+  }
+  /** List agents filtered by capability for auto-select.
+   * GET /api/v1/agents?capability=X
+   */
+  async listAgentsByCapability(capability) {
+    return this.request(
+      "GET",
+      `/api/v1/agents?capability=${encodeURIComponent(capability)}`
+    );
+  }
+};
+
+// server/src/crypto.ts
+async function verifyWebhookSignature(rawBody, signature, secret) {
+  const crypto = await import("crypto");
+  const expected = crypto.createHmac("sha256", secret).update(rawBody).digest("base64");
+  const sigBuf = Buffer.from(signature);
+  const expectedBuf = Buffer.from(expected);
+  if (sigBuf.byteLength !== expectedBuf.byteLength) {
+    return false;
+  }
+  return crypto.timingSafeEqual(sigBuf, expectedBuf);
+}
+
+// server/src/webhook-handler.ts
+var taskRegistry = /* @__PURE__ */ new Map();
+var TASK_REGISTRY_TTL_MS = 2 * 60 * 60 * 1e3;
+var TASK_REGISTRY_CLEANUP_INTERVAL_MS = 6e4;
+var registryCleanupTimer = null;
+function sweepStaleRegistryEntries() {
+  const now = Date.now();
+  for (const [id, entry] of taskRegistry) {
+    if (now - entry.startedAt > TASK_REGISTRY_TTL_MS) {
+      taskRegistry.delete(id);
+    }
+  }
+}
+function startRegistryCleanup() {
+  if (registryCleanupTimer) return;
+  registryCleanupTimer = setInterval(sweepStaleRegistryEntries, TASK_REGISTRY_CLEANUP_INTERVAL_MS);
+  registryCleanupTimer.unref();
+}
+function registerTaskMapping(taskId, issueId, companyId, config) {
+  taskRegistry.set(taskId, {
+    issueId,
+    companyId,
+    config,
+    startedAt: Date.now(),
+    status: "pending"
+  });
+}
+function unregisterTaskMapping(taskId) {
+  taskRegistry.delete(taskId);
+}
+function getActiveTaskMappings() {
+  return taskRegistry;
+}
+var eventHandlers = {
+  "task.created": async (ctx) => {
+    ctx.mapping.status = "pending";
+    await ctx.api.postComment(
+      ctx.mapping.issueId,
+      `**Agrenting task created** \u2014 Task \`${ctx.payload.task_id}\` submitted and awaiting claim.`
+    );
+  },
+  "task.claimed": async (ctx) => {
+    ctx.mapping.status = "claimed";
+    await ctx.api.postComment(
+      ctx.mapping.issueId,
+      `**Agrenting task claimed** \u2014 An agent has picked up the task and is preparing to work.`
+    );
+  },
+  "task.in_progress": async (ctx) => {
+    ctx.mapping.status = "in_progress";
+    const progress = ctx.payload.progress_percent ? ` (${ctx.payload.progress_percent}%)` : "";
+    const message = ctx.payload.progress_message ? ` \u2014 ${ctx.payload.progress_message}` : "";
+    await ctx.api.postComment(
+      ctx.mapping.issueId,
+      `**Task in progress**${progress}${message}`
+    );
+  },
+  "task.completed": async (ctx) => {
+    ctx.mapping.status = "completed";
+    const duration = ((Date.now() - ctx.mapping.startedAt) / 1e3).toFixed(1);
+    await ctx.api.updateIssue(ctx.mapping.issueId, {
+      status: "done",
+      comment: `**Agrenting task completed** \u2014 Task \`${ctx.payload.task_id}\` finished in ${duration}s.${ctx.payload.output ? `
+
+### Output
+
+${ctx.payload.output}` : ""}`
+    });
+    unregisterTaskMapping(ctx.payload.task_id);
+  },
+  "task.failed": async (ctx) => {
+    ctx.mapping.status = "failed";
+    await ctx.api.updateIssue(ctx.mapping.issueId, {
+      status: "blocked",
+      comment: `**Agrenting task failed** \u2014 Task \`${ctx.payload.task_id}\` encountered an error.
+
+**Error:** ${ctx.payload.error_reason ?? "No error reason provided."}`
+    });
+    unregisterTaskMapping(ctx.payload.task_id);
+  },
+  "task.cancelled": async (ctx) => {
+    ctx.mapping.status = "cancelled";
+    await ctx.api.updateIssue(ctx.mapping.issueId, {
+      status: "cancelled",
+      comment: `**Agrenting task cancelled** \u2014 Task \`${ctx.payload.task_id}\` was cancelled.`
+    });
+    unregisterTaskMapping(ctx.payload.task_id);
+  }
+};
+function createWebhookHandler(options) {
+  startRegistryCleanup();
+  return async function handleWebhookRequest(rawBody, headers) {
+    const signature = headers["x-webhook-signature"] ?? headers["X-Webhook-Signature"] ?? "";
+    const eventType = headers["x-webhook-event"] ?? headers["X-Webhook-Event"] ?? "";
+    let payload;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      return { status: 400, body: "Invalid JSON" };
+    }
+    const valid = await verifyWebhookSignature(
+      rawBody,
+      signature,
+      options.webhookSecret
+    );
+    if (!valid) {
+      return { status: 401, body: "Invalid signature" };
+    }
+    const taskId = payload.task_id;
+    if (!taskId) {
+      return { status: 400, body: "Missing task_id in payload" };
+    }
+    const mapping = taskRegistry.get(taskId);
+    if (!mapping) {
+      return { status: 200, body: "OK (no active mapping)" };
+    }
+    const handler = eventHandlers[eventType];
+    if (handler) {
+      try {
+        await handler({ api: options.api, mapping, payload });
+      } catch (err) {
+        console.error("[adapter-agrenting] Webhook handler error:", err);
+        return {
+          status: 500,
+          body: "Internal error"
+        };
+      }
+    } else {
+      options.onUnknownEvent?.(eventType, payload);
+    }
+    return { status: 200, body: "OK" };
+  };
+}
+
+// server/src/polling.ts
+var POLL_INTERVALS_MS = [1e4, 3e4, 6e4, 12e4];
+var MAX_POLLS = 10;
+function getBackoffMs(attempt) {
+  const index = Math.min(attempt, POLL_INTERVALS_MS.length - 1);
+  return POLL_INTERVALS_MS[index];
+}
+async function pollTaskUntilDone(options) {
+  const client = new AgrentingClient(options.config);
+  let pollAttempt = options.startAttempt ?? 0;
+  const startTime = Date.now();
+  while (pollAttempt < MAX_POLLS) {
+    if (options.signal?.aborted) {
+      return {
+        result: {
+          success: false,
+          error: "Polling aborted",
+          taskId: options.taskId,
+          durationMs: Date.now() - startTime
+        },
+        pollCount: pollAttempt,
+        viaPolling: true
+      };
+    }
+    const now = Date.now();
+    if (now >= options.deadline) {
+      return {
+        result: {
+          success: false,
+          error: `Task timed out after ${options.config.timeoutSec ?? 600}s`,
+          taskId: options.taskId,
+          durationMs: now - startTime
+        },
+        pollCount: pollAttempt,
+        viaPolling: true
+      };
+    }
+    if (pollAttempt > 0) {
+      const waitMs = getBackoffMs(pollAttempt);
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, waitMs);
+        if (options.signal) {
+          options.signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+          }, { once: true });
+        }
+      });
+    }
+    const task = await client.getTask(options.taskId);
+    pollAttempt++;
+    options.onStatusUpdate?.(task, pollAttempt);
+    if (task.status === "completed") {
+      return {
+        result: {
+          success: true,
+          output: task.output,
+          taskId: options.taskId,
+          durationMs: Date.now() - startTime
+        },
+        pollCount: pollAttempt,
+        viaPolling: true
+      };
+    }
+    if (task.status === "failed") {
+      return {
+        result: {
+          success: false,
+          error: task.error_reason ?? "Task failed with no reason provided",
+          taskId: options.taskId,
+          durationMs: Date.now() - startTime
+        },
+        pollCount: pollAttempt,
+        viaPolling: true
+      };
+    }
+    if (task.status === "cancelled") {
+      return {
+        result: {
+          success: false,
+          error: "Task was cancelled",
+          taskId: options.taskId,
+          durationMs: Date.now() - startTime
+        },
+        pollCount: pollAttempt,
+        viaPolling: true
+      };
+    }
+  }
+  const finalTask = await client.getTask(options.taskId);
+  if (finalTask.status === "completed") {
+    return {
+      result: {
+        success: true,
+        output: finalTask.output,
+        taskId: options.taskId,
+        durationMs: Date.now() - startTime
+      },
+      pollCount: pollAttempt + 1,
+      viaPolling: true
+    };
+  }
+  return {
+    result: {
+      success: false,
+      error: `Task did not complete after ${pollAttempt} polls (max ${MAX_POLLS})`,
+      taskId: options.taskId,
+      durationMs: Date.now() - startTime
+    },
+    pollCount: pollAttempt,
+    viaPolling: true
+  };
+}
+function getWebhookGracePeriodMs(config) {
+  const timeoutMs = (config.timeoutSec ?? 600) * 1e3;
+  return Math.min(6e4, timeoutMs * 0.1);
+}
+
+// server/src/balance-monitor.ts
+async function checkBalance(options) {
+  const client = new AgrentingClient(options.config);
+  const lowThreshold = options.lowBalanceThresholdUsd ?? 10;
+  const minSubmission = options.minSubmissionBalanceUsd ?? 1;
+  try {
+    const raw = await client.getBalance();
+    const available = parseFloat(raw.available);
+    const escrow = parseFloat(raw.escrow);
+    const total = parseFloat(raw.total);
+    const anyNaN = Number.isNaN(available) || Number.isNaN(escrow) || Number.isNaN(total);
+    if (anyNaN) {
+      return {
+        available: 0,
+        escrow: 0,
+        total: 0,
+        currency: raw.currency ?? "USD",
+        isLow: true,
+        isInsufficient: true
+      };
+    }
+    return {
+      available,
+      escrow,
+      total,
+      currency: raw.currency ?? "USD",
+      isLow: available < lowThreshold,
+      isInsufficient: available < minSubmission
+    };
+  } catch {
+    return {
+      available: 0,
+      escrow: 0,
+      total: 0,
+      currency: "USD",
+      isLow: true,
+      isInsufficient: true
+    };
+  }
+}
+async function canSubmitTask(options) {
+  const balanceInfo = await checkBalance(options);
+  if (balanceInfo.isInsufficient) {
+    return {
+      ok: false,
+      reason: `Insufficient balance: ${formatUsd(balanceInfo.available)}. Minimum required: ${formatUsd(options.minSubmissionBalanceUsd ?? 1)}.`
+    };
+  }
+  return { ok: true };
+}
+function formatUsd(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function formatLowBalanceComment(balanceInfo) {
+  return `**Agrenting balance warning** \u2014 Available: ${formatUsd(balanceInfo.available)} ${balanceInfo.currency} (Escrowed: ${formatUsd(balanceInfo.escrow)}). Funds are running low. Add credits to avoid task submission failures.`;
+}
+function formatInsufficientBalanceComment(balanceInfo) {
+  return `**Agrenting task blocked** \u2014 Insufficient balance: ${formatUsd(balanceInfo.available)} ${balanceInfo.currency}. Please add credits to your Agrenting account before retrying.`;
+}
+
+// server/src/comment-sync.ts
+function formatAgentResponse(agentName, message) {
+  return `**${agentName} says:**
+
+${message}`;
+}
+async function forwardCommentToAgrenting(config, taskId, comment, authorName) {
+  const client = new AgrentingClient(config);
+  const formattedComment = authorName ? `[${authorName}]: ${comment}` : comment;
+  try {
+    return await client.sendMessageToTask(taskId, { message: formattedComment });
+  } catch (err) {
+    console.error(
+      `[adapter-agrenting] Failed to forward comment to task ${taskId}:`,
+      err instanceof Error ? err.message : String(err)
+    );
+    return null;
+  }
+}
+function processIncomingMessage(message) {
+  const senderName = message.sender_name ?? "Agent";
+  return formatAgentResponse(senderName, message.content);
+}
+
+// server/src/adapter.ts
+var DEFAULT_WEBHOOK_PORT = 8765;
+var MAX_WEBHOOK_BODY_SIZE = 1024 * 1024;
+var STALE_TASK_CLEANUP_INTERVAL_MS = 6e4;
+var STALE_TASK_TTL_MS = 2 * 60 * 60 * 1e3;
+var pendingTasks = /* @__PURE__ */ new Map();
+var webhookServer = null;
+var staleCleanupTimer = null;
+function sweepStaleTasks() {
+  const now = Date.now();
+  for (const [id, entry] of pendingTasks) {
+    if (entry.settled || now - entry.createdAt > STALE_TASK_TTL_MS) {
+      pendingTasks.delete(id);
+    }
+  }
+}
+function getConfigSchema() {
+  return {
+    type: "object",
+    required: ["agrentingUrl", "apiKey", "agentDid"],
+    properties: {
+      agrentingUrl: {
+        type: "string",
+        format: "uri",
+        description: "Agrenting platform URL (e.g. https://www.agrenting.com)",
+        default: "https://www.agrenting.com"
+      },
+      apiKey: {
+        type: "string",
+        description: "Agrenting API key for authentication",
+        sensitive: true
+      },
+      agentDid: {
+        type: "string",
+        description: "Decentralized identifier of the target agent (did:agrenting:...)"
+      },
+      webhookSecret: {
+        type: "string",
+        description: "Webhook signing secret for task completion callbacks",
+        sensitive: true
+      },
+      webhookCallbackUrl: {
+        type: "string",
+        format: "uri",
+        description: "URL where Agrenting should POST task events (e.g. https://your-host:8765/webhook)"
+      },
+      pricingModel: {
+        type: "string",
+        enum: ["fixed", "per-token", "subscription"],
+        description: "Pricing model for this agent",
+        default: "fixed"
+      },
+      timeoutSec: {
+        type: "integer",
+        minimum: 10,
+        maximum: 3600,
+        description: "Task timeout in seconds",
+        default: 600
+      },
+      instructionsBundleMode: {
+        type: "string",
+        enum: ["managed", "inline"],
+        description: "How agent instructions are delivered",
+        default: "inline"
+      }
+    }
+  };
+}
+async function testEnvironment(config) {
+  const client = new AgrentingClient(config);
+  return client.testConnection();
+}
+async function startWebhookListener(config) {
+  if (webhookServer) {
+    const addr = webhookServer.address();
+    const port2 = typeof addr === "object" && addr ? addr.port : DEFAULT_WEBHOOK_PORT;
+    return `http://localhost:${port2}/webhook`;
+  }
+  const http = await import("http");
+  const port = process.env.PAPERCLIP_WEBHOOK_PORT ? parseInt(process.env.PAPERCLIP_WEBHOOK_PORT, 10) : DEFAULT_WEBHOOK_PORT;
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      if (req.method !== "POST" || req.url !== "/webhook") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      let bodyChunks = [];
+      let bodyLength = 0;
+      let bodyTooLarge = false;
+      req.on("data", (chunk) => {
+        bodyLength += chunk.length;
+        if (bodyLength > MAX_WEBHOOK_BODY_SIZE) {
+          bodyTooLarge = true;
+          res.writeHead(413);
+          res.end("Request body too large");
+          req.destroy();
+          return;
+        }
+        bodyChunks.push(chunk);
+      });
+      req.on("end", async () => {
+        if (bodyTooLarge) return;
+        const rawBody = Buffer.concat(bodyChunks).toString("utf8");
+        bodyChunks = [];
+        const taskId = req.headers["x-webhook-task-id"];
+        const signature = req.headers["x-webhook-signature"] || "";
+        let payload;
+        try {
+          payload = JSON.parse(rawBody);
+        } catch {
+          res.writeHead(400);
+          res.end("Invalid JSON");
+          return;
+        }
+        if (config.webhookSecret) {
+          if (!signature) {
+            res.writeHead(401);
+            res.end("Missing signature");
+            return;
+          }
+          const valid = await verifyWebhookSignature(
+            rawBody,
+            signature,
+            config.webhookSecret
+          );
+          if (!valid) {
+            res.writeHead(401);
+            res.end("Invalid signature");
+            return;
+          }
+        }
+        const resolvedTaskId = taskId ?? payload.task_id ?? payload.taskId;
+        if (resolvedTaskId) {
+          const pending = pendingTasks.get(resolvedTaskId);
+          if (pending && !pending.settled) {
+            const status = payload.status ?? pending.status;
+            pending.status = status;
+            pending.progressPercent = payload.progress_percent ?? pending.progressPercent;
+            pending.progressMessage = payload.progress_message ?? pending.progressMessage;
+            if (status === "completed") {
+              pending.settled = true;
+              pending.resolve({
+                success: true,
+                output: payload.output ?? JSON.stringify(payload.output ?? {}),
+                taskId: resolvedTaskId,
+                durationMs: Date.now() - pending.startedAt
+              });
+            } else if (status === "failed") {
+              pending.settled = true;
+              pending.resolve({
+                success: false,
+                error: payload.error_reason ?? "Task failed with no reason provided",
+                taskId: resolvedTaskId,
+                durationMs: Date.now() - pending.startedAt
+              });
+            } else if (status === "cancelled") {
+              pending.settled = true;
+              pending.resolve({
+                success: false,
+                error: "Task was cancelled",
+                taskId: resolvedTaskId,
+                durationMs: Date.now() - pending.startedAt
+              });
+            }
+          }
+        }
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end("OK");
+      });
+    });
+    server.listen(port, () => {
+      webhookServer = server;
+      if (!staleCleanupTimer) {
+        staleCleanupTimer = setInterval(sweepStaleTasks, STALE_TASK_CLEANUP_INTERVAL_MS);
+        staleCleanupTimer.unref();
+      }
+      resolve(`http://localhost:${port}/webhook`);
+    });
+    server.on("error", reject);
+  });
+}
+var WEBHOOK_STOP_TIMEOUT_MS = 5e3;
+async function stopWebhookListener() {
+  if (!webhookServer) {
+    return;
+  }
+  if (staleCleanupTimer) {
+    clearInterval(staleCleanupTimer);
+    staleCleanupTimer = null;
+  }
+  const server = webhookServer;
+  webhookServer = null;
+  if ("closeAllConnections" in server && typeof server.closeAllConnections === "function") {
+    server.closeAllConnections();
+  }
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve();
+    }, WEBHOOK_STOP_TIMEOUT_MS);
+    timeout.unref();
+    server.close(() => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+async function registerWebhook(config, callbackUrl) {
+  const client = new AgrentingClient(config);
+  const url = callbackUrl ?? await startWebhookListener(config);
+  const result = await client.registerWebhook({
+    callbackUrl: url,
+    eventTypes: [
+      "task.created",
+      "task.claimed",
+      "task.in_progress",
+      "task.completed",
+      "task.failed",
+      "task.cancelled"
+    ]
+  });
+  return {
+    id: result.id,
+    secretKey: result.secret_key,
+    callbackUrl: result.callback_url
+  };
+}
+async function deregisterWebhook(config, webhookId) {
+  const client = new AgrentingClient(config);
+  await client.deleteWebhook(webhookId);
+}
+async function execute(config, params) {
+  const client = new AgrentingClient(config);
+  const startTime = Date.now();
+  if (config.instructionsBundleMode === "managed" && params.instructions) {
+    await client.uploadDocument({
+      name: "instructions",
+      content: params.instructions,
+      documentType: "instructions"
+    });
+  }
+  const balanceCheck = await canSubmitTask({ config });
+  if (!balanceCheck.ok) {
+    console.warn(`[adapter-agrenting] ${balanceCheck.reason}`);
+  }
+  const task = await client.createTask({
+    providerAgentId: config.agentDid,
+    capability: params.capability,
+    input: params.input,
+    maxPrice: params.maxPrice,
+    paymentType: params.paymentType
+  });
+  const taskId = task.id;
+  let payment;
+  if (params.maxPrice) {
+    try {
+      const paymentOptions = {};
+      if (params.paymentType) paymentOptions.paymentType = params.paymentType;
+      payment = await client.createTaskPayment(taskId, paymentOptions);
+      console.log(`[adapter-agrenting] Escrow locked for task ${taskId}: ${payment.amount} ${payment.currency} (${payment.status})`);
+    } catch (err) {
+      console.error(`[adapter-agrenting] Failed to lock escrow for task ${taskId}, cancelling orphaned task:`, err);
+      try {
+        await client.cancelTask(taskId);
+      } catch {
+      }
+      return {
+        success: false,
+        error: `Escrow payment failed: ${err instanceof Error ? err.message : String(err)}`,
+        taskId,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  if (config.webhookCallbackUrl || config.webhookSecret) {
+    registerTaskMapping(taskId, taskId, config.agrentingUrl, config);
+    return executeWithWebhook(client, config, taskId, startTime);
+  }
+  return executeWithPolling(config, taskId, startTime);
+}
+async function executeWithWebhook(_client, config, taskId, startTime) {
+  await startWebhookListener(config);
+  const deadline = startTime + (config.timeoutSec ?? 600) * 1e3;
+  const abortController = new AbortController();
+  const pending = new Promise((resolve) => {
+    pendingTasks.set(taskId, {
+      resolve,
+      status: "pending",
+      progressPercent: 0,
+      startedAt: startTime,
+      createdAt: Date.now(),
+      settled: false
+    });
+  }).then((result) => {
+    abortController.abort();
+    return result;
+  });
+  const timeout = new Promise((resolve) => {
+    const ms = deadline - Date.now();
+    setTimeout(() => {
+      const entry = pendingTasks.get(taskId);
+      if (entry && !entry.settled) {
+        entry.settled = true;
+      }
+      resolve({
+        success: false,
+        error: `Task timed out after ${config.timeoutSec ?? 600}s`,
+        taskId,
+        durationMs: Date.now() - startTime
+      });
+    }, Math.max(ms, 0));
+  });
+  return Promise.race([pending, timeout.then(async (result) => {
+    if (!result.success && result.error?.includes("timed out")) {
+      const pollingFallback = await pollTaskUntilDone({
+        config,
+        taskId,
+        deadline,
+        signal: abortController.signal
+      });
+      return pollingFallback.result;
+    }
+    return result;
+  })]);
+}
+async function executeWithPolling(config, taskId, startTime) {
+  const deadline = startTime + (config.timeoutSec ?? 600) * 1e3;
+  const { result } = await pollTaskUntilDone({ config, taskId, deadline });
+  return result;
+}
+async function getTaskProgress(config, taskId) {
+  const client = new AgrentingClient(config);
+  const [progress, timeline] = await Promise.all([
+    client.getTaskProgress(taskId),
+    client.getTaskTimeline(taskId)
+  ]);
+  return {
+    status: progress.status,
+    progressPercent: progress.progress_percent,
+    progressMessage: progress.progress_message,
+    timeline: timeline.events
+  };
+}
+async function discoverAgents(config, options = {}) {
+  const client = new AgrentingClient(config);
+  return client.discoverAgents(options);
+}
+async function getBalance(config) {
+  const client = new AgrentingClient(config);
+  return client.getBalance();
+}
+async function getTransactions(config, options = {}) {
+  const client = new AgrentingClient(config);
+  return client.getTransactions(options);
+}
+async function deposit(config, params) {
+  const client = new AgrentingClient(config);
+  return client.deposit(params);
+}
+async function withdraw(config, params) {
+  const client = new AgrentingClient(config);
+  return client.withdraw(params);
+}
+async function getTaskPayment(config, taskId) {
+  const client = new AgrentingClient(config);
+  try {
+    return await client.getTaskPayment(taskId);
+  } catch {
+    return void 0;
+  }
+}
+async function cancelTask(config, taskId) {
+  const client = new AgrentingClient(config);
+  try {
+    await client.cancelTask(taskId);
+    pendingTasks.delete(taskId);
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Failed to cancel task"
+    };
+  }
+}
+var TASK_MAX_RETRIES = 2;
+var TASK_RETRY_BASE_DELAY_MS = 1e3;
+var TASK_RETRY_MAX_DELAY_MS = 3e4;
+async function hireAgent(config, agentDid) {
+  const client = new AgrentingClient(config);
+  return client.hireAgent(agentDid);
+}
+async function getAgentProfile(config, agentDid) {
+  const client = new AgrentingClient(config);
+  return client.getAgentProfile(agentDid);
+}
+async function sendMessageToTask(config, taskId, message) {
+  const client = new AgrentingClient(config);
+  return client.sendMessageToTask(taskId, { message });
+}
+async function getTaskMessages(config, taskId) {
+  const client = new AgrentingClient(config);
+  return client.getTaskMessages(taskId);
+}
+async function reassignTask(config, taskId, newAgentDid) {
+  const client = new AgrentingClient(config);
+  return client.reassignTask(taskId, newAgentDid);
+}
+async function listCapabilities(config) {
+  const client = new AgrentingClient(config);
+  return client.listCapabilities();
+}
+async function sendMessageToHiring(config, hiringId, message) {
+  const client = new AgrentingClient(config);
+  return client.sendMessageToHiring(hiringId, message);
+}
+async function getHiringMessages(config, hiringId) {
+  const client = new AgrentingClient(config);
+  return client.getHiringMessages(hiringId);
+}
+async function retryHiring(config, hiringId, options) {
+  const client = new AgrentingClient(config);
+  return client.retryHiring(hiringId, options);
+}
+async function getHiring(config, hiringId) {
+  const client = new AgrentingClient(config);
+  return client.getHiring(hiringId);
+}
+async function listHirings(config, options) {
+  const client = new AgrentingClient(config);
+  return client.listHirings(options);
+}
+async function autoSelectAgent(config, options) {
+  const client = new AgrentingClient(config);
+  const capabilities = await client.listCapabilities();
+  const capabilityExists = capabilities.some(
+    (c) => c.name === options.capability || c.name.toLowerCase() === options.capability.toLowerCase()
+  );
+  if (!capabilityExists) {
+    throw new Error(`Capability "${options.capability}" not found. Available: ${capabilities.map((c) => c.name).join(", ")}`);
+  }
+  const agents = await client.listAgentsByCapability(options.capability);
+  if (agents.length === 0) {
+    throw new Error(`No agents available for capability "${options.capability}"`);
+  }
+  let filtered = agents;
+  if (options.maxPrice) {
+    const maxPriceNum = parseFloat(options.maxPrice);
+    filtered = filtered.filter((a) => {
+      if (!a.base_price) return true;
+      return parseFloat(a.base_price) <= maxPriceNum;
+    });
+  }
+  if (options.minReputation) {
+    const minRep = options.minReputation;
+    filtered = filtered.filter((a) => {
+      if (!a.reputation_score) return false;
+      return a.reputation_score >= minRep;
+    });
+  }
+  if (filtered.length === 0) {
+    throw new Error(
+      `No agents match criteria for capability "${options.capability}" (maxPrice=${options.maxPrice ?? "any"}, minReputation=${options.minReputation ?? "any"})`
+    );
+  }
+  const sortBy = options.sortBy ?? "reputation_score";
+  if (options.preferAvailable ?? true) {
+    filtered.sort((a, b) => {
+      const aAvail = a.availability_status === "available" ? 0 : 1;
+      const bAvail = b.availability_status === "available" ? 0 : 1;
+      if (aAvail !== bAvail) return aAvail - bAvail;
+      return 0;
+    });
+  }
+  filtered.sort((a, b) => {
+    if (sortBy === "reputation_score") {
+      return (b.reputation_score ?? 0) - (a.reputation_score ?? 0);
+    }
+    if (sortBy === "base_price") {
+      const aPrice = parseFloat(a.base_price ?? "999999");
+      const bPrice = parseFloat(b.base_price ?? "999999");
+      return aPrice - bPrice;
+    }
+    if (sortBy === "availability") {
+      const aAvail = a.availability_status === "available" ? 0 : 1;
+      const bAvail = b.availability_status === "available" ? 0 : 1;
+      return aAvail - bAvail;
+    }
+    return 0;
+  });
+  const selectedAgent = filtered[0];
+  const hireResult = await client.hireAgent(selectedAgent.did);
+  return {
+    ...hireResult,
+    selectedAgent
+  };
+}
+async function executeWithRetry(config, params) {
+  const maxRetries = params.maxRetries ?? TASK_MAX_RETRIES;
+  let lastResult;
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      lastResult = await execute(config, params);
+      if (lastResult.success) {
+        return lastResult;
+      }
+      if (attempt < maxRetries && lastResult.error) {
+        const delayMs = Math.min(
+          TASK_RETRY_BASE_DELAY_MS * Math.pow(2, attempt),
+          TASK_RETRY_MAX_DELAY_MS
+        );
+        console.warn(
+          `[adapter-agrenting] Task failed on attempt ${attempt + 1}, retrying in ${delayMs}ms: ${lastResult.error}`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        continue;
+      }
+      return lastResult;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < maxRetries) {
+        const delayMs = Math.min(
+          TASK_RETRY_BASE_DELAY_MS * Math.pow(2, attempt),
+          TASK_RETRY_MAX_DELAY_MS
+        );
+        console.warn(
+          `[adapter-agrenting] Execution error on attempt ${attempt + 1}, retrying in ${delayMs}ms: ${lastError.message}`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        continue;
+      }
+    }
+  }
+  return {
+    success: false,
+    error: lastError?.message ?? lastResult?.error ?? "Task failed after all retries",
+    taskId: lastResult?.taskId,
+    durationMs: lastResult?.durationMs ?? 0
+  };
+}
+async function forwardCommentToAgrenting2(config, taskId, comment, authorName) {
+  const client = new AgrentingClient(config);
+  const formattedComment = authorName ? `[${authorName}]: ${comment}` : comment;
+  try {
+    return await client.sendMessageToTask(taskId, { message: formattedComment });
+  } catch (err) {
+    console.error(
+      `[adapter-agrenting] Failed to forward comment to task ${taskId}:`,
+      err instanceof Error ? err.message : String(err)
+    );
+    return null;
+  }
+}
+function processIncomingMessage2(message) {
+  const senderName = message.sender_name ?? "Agent";
+  return formatAgentResponse(senderName, message.content);
+}
+function createServerAdapter() {
+  return {
+    name: "agrenting",
+    execute,
+    testEnvironment,
+    getConfigSchema,
+    startWebhookListener,
+    stopWebhookListener,
+    registerWebhook,
+    deregisterWebhook,
+    getTaskProgress,
+    getTaskPayment,
+    cancelTask,
+    discoverAgents,
+    getAgentProfile,
+    hireAgent,
+    sendMessageToTask,
+    getTaskMessages,
+    reassignTask,
+    listCapabilities,
+    sendMessageToHiring,
+    getHiringMessages,
+    retryHiring,
+    getHiring,
+    listHirings,
+    autoSelectAgent,
+    executeWithRetry,
+    forwardCommentToAgrenting: forwardCommentToAgrenting2,
+    processIncomingMessage: processIncomingMessage2,
+    getBalance,
+    getTransactions,
+    deposit,
+    withdraw
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgrentingClient,
+  MAX_POLLS,
+  POLL_INTERVALS_MS,
+  autoSelectAgent,
+  canSubmitTask,
+  checkBalance,
+  createServerAdapter,
+  createWebhookHandler,
+  deregisterWebhook,
+  executeWithRetry,
+  formatAgentResponse,
+  formatInsufficientBalanceComment,
+  formatLowBalanceComment,
+  forwardCommentToAgrenting,
+  getActiveTaskMappings,
+  getAgentProfile,
+  getBackoffMs,
+  getHiring,
+  getHiringMessages,
+  getTaskMessages,
+  getWebhookGracePeriodMs,
+  hireAgent,
+  listCapabilities,
+  listHirings,
+  pollTaskUntilDone,
+  processIncomingMessage,
+  reassignTask,
+  registerTaskMapping,
+  registerWebhook,
+  retryHiring,
+  sendMessageToHiring,
+  sendMessageToTask,
+  unregisterTaskMapping,
+  verifyWebhookSignature
+});
+//# sourceMappingURL=index.cjs.map