@blockrun/clawrouter 0.10.5 → 0.10.6

package/dist/index.d.ts

@@ -738,6 +738,10 @@ type UsageEntry = {
     baselineCost: number;
     savings: number;
     latencyMs: number;
+    /** Partner service ID (e.g., "x_users_lookup") — only set for partner API calls */
+    partnerId?: string;
+    /** Partner service name (e.g., "AttentionVC") — only set for partner API calls */
+    service?: string;
 };
 /**
  * Log a usage entry as a JSON line.
@@ -991,6 +995,81 @@ declare function getStats(days?: number): Promise<AggregatedStats>;
  */
 declare function formatStatsAscii(stats: AggregatedStats): string;
 
+/**
+ * Partner Service Registry
+ *
+ * Defines available partner APIs that can be called through ClawRouter's proxy.
+ * Partners provide specialized data (Twitter/X, etc.) via x402 micropayments.
+ * The same wallet used for LLM calls pays for partner API calls — zero extra setup.
+ */
+type PartnerServiceParam = {
+    name: string;
+    type: "string" | "string[]" | "number";
+    description: string;
+    required: boolean;
+};
+type PartnerServiceDefinition = {
+    /** Unique service ID used in tool names: blockrun_{id} */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Partner providing this service */
+    partner: string;
+    /** Short description for tool listing */
+    description: string;
+    /** Proxy path (relative to /v1) */
+    proxyPath: string;
+    /** HTTP method */
+    method: "GET" | "POST";
+    /** Parameters for the tool's JSON Schema */
+    params: PartnerServiceParam[];
+    /** Pricing info for display */
+    pricing: {
+        perUnit: string;
+        unit: string;
+        minimum: string;
+        maximum: string;
+    };
+    /** Example usage for help text */
+    example: {
+        input: Record<string, unknown>;
+        description: string;
+    };
+};
+/**
+ * All registered partner services.
+ * New partners are added here — the rest of the system picks them up automatically.
+ */
+declare const PARTNER_SERVICES: PartnerServiceDefinition[];
+/**
+ * Get a partner service by ID.
+ */
+declare function getPartnerService(id: string): PartnerServiceDefinition | undefined;
+
+/**
+ * Partner Tool Builder
+ *
+ * Converts partner service definitions into OpenClaw tool definitions.
+ * Each tool's execute() calls through the local proxy which handles
+ * x402 payment transparently using the same wallet.
+ */
+/** OpenClaw tool definition shape (duck-typed) */
+type PartnerToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required: string[];
+    };
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+};
+/**
+ * Build OpenClaw tool definitions for all registered partner services.
+ * @param proxyBaseUrl - Local proxy base URL (e.g., "http://127.0.0.1:8402")
+ */
+declare function buildPartnerTools(proxyBaseUrl: string): PartnerToolDefinition[];
+
 /**
  * @blockrun/clawrouter
  *
@@ -1012,4 +1091,4 @@ declare function formatStatsAscii(stats: AggregatedStats): string;
 
 declare const plugin: OpenClawPluginDefinition;
 
-export { type AggregatedStats, BALANCE_THRESHOLDS, BLOCKRUN_MODELS, type BalanceInfo, BalanceMonitor, type CachedLLMResponse, type CachedPaymentParams, type CachedResponse, DEFAULT_RETRY_CONFIG, DEFAULT_ROUTING_CONFIG, DEFAULT_SESSION_CONFIG, type DailyStats, EmptyWalletError, InsufficientFundsError, type InsufficientFundsInfo, type LowBalanceInfo, MODEL_ALIASES, OPENCLAW_MODELS, PaymentCache, type PaymentFetchResult, type PreAuthParams, type ProxyHandle, type ProxyOptions, RequestDeduplicator, ResponseCache, type ResponseCacheConfig, type RetryConfig, type RoutingConfig, type RoutingDecision, RpcError, type SessionConfig, type SessionEntry, SessionStore, type SufficiencyResult, type Tier, type UsageEntry, blockrunProvider, buildProviderModels, calculateModelCost, createPaymentFetch, plugin as default, fetchWithRetry, formatStatsAscii, getAgenticModels, getFallbackChain, getFallbackChainFiltered, getModelContextWindow, getProxyPort, getSessionId, getStats, isAgenticModel, isBalanceError, isEmptyWalletError, isInsufficientFundsError, isRetryable, isRpcError, logUsage, resolveModelAlias, route, startProxy };
+export { type AggregatedStats, BALANCE_THRESHOLDS, BLOCKRUN_MODELS, type BalanceInfo, BalanceMonitor, type CachedLLMResponse, type CachedPaymentParams, type CachedResponse, DEFAULT_RETRY_CONFIG, DEFAULT_ROUTING_CONFIG, DEFAULT_SESSION_CONFIG, type DailyStats, EmptyWalletError, InsufficientFundsError, type InsufficientFundsInfo, type LowBalanceInfo, MODEL_ALIASES, OPENCLAW_MODELS, PARTNER_SERVICES, type PartnerServiceDefinition, type PartnerToolDefinition, PaymentCache, type PaymentFetchResult, type PreAuthParams, type ProxyHandle, type ProxyOptions, RequestDeduplicator, ResponseCache, type ResponseCacheConfig, type RetryConfig, type RoutingConfig, type RoutingDecision, RpcError, type SessionConfig, type SessionEntry, SessionStore, type SufficiencyResult, type Tier, type UsageEntry, blockrunProvider, buildPartnerTools, buildProviderModels, calculateModelCost, createPaymentFetch, plugin as default, fetchWithRetry, formatStatsAscii, getAgenticModels, getFallbackChain, getFallbackChainFiltered, getModelContextWindow, getPartnerService, getProxyPort, getSessionId, getStats, isAgenticModel, isBalanceError, isEmptyWalletError, isInsufficientFundsError, isRetryable, isRpcError, logUsage, resolveModelAlias, route, startProxy };

package/dist/index.js

@@ -1,3 +1,126 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/partners/registry.ts
+function getPartnerService(id) {
+  return PARTNER_SERVICES.find((s) => s.id === id);
+}
+var PARTNER_SERVICES;
+var init_registry = __esm({
+  "src/partners/registry.ts"() {
+    "use strict";
+    PARTNER_SERVICES = [
+      {
+        id: "x_users_lookup",
+        name: "Twitter/X User Lookup",
+        partner: "AttentionVC",
+        description: "Look up Twitter/X user profiles by username. Returns follower counts, verification status, bio, and more. Accepts up to 100 usernames per request.",
+        proxyPath: "/x/users/lookup",
+        method: "POST",
+        params: [
+          {
+            name: "usernames",
+            type: "string[]",
+            description: 'Array of Twitter/X usernames to look up (without @ prefix). Example: ["elonmusk", "naval"]',
+            required: true
+          }
+        ],
+        pricing: {
+          perUnit: "$0.001",
+          unit: "user",
+          minimum: "$0.01 (10 users)",
+          maximum: "$0.10 (100 users)"
+        },
+        example: {
+          input: { usernames: ["elonmusk", "naval", "balaboris"] },
+          description: "Look up 3 Twitter/X user profiles"
+        }
+      }
+    ];
+  }
+});
+
+// src/partners/tools.ts
+function buildTool(service, proxyBaseUrl) {
+  const properties = {};
+  const required = [];
+  for (const param of service.params) {
+    const prop = {
+      description: param.description
+    };
+    if (param.type === "string[]") {
+      prop.type = "array";
+      prop.items = { type: "string" };
+    } else {
+      prop.type = param.type;
+    }
+    properties[param.name] = prop;
+    if (param.required) {
+      required.push(param.name);
+    }
+  }
+  return {
+    name: `blockrun_${service.id}`,
+    description: [
+      service.description,
+      "",
+      `Partner: ${service.partner}`,
+      `Pricing: ${service.pricing.perUnit} per ${service.pricing.unit} (min: ${service.pricing.minimum}, max: ${service.pricing.maximum})`
+    ].join("\n"),
+    inputSchema: {
+      type: "object",
+      properties,
+      required
+    },
+    execute: async (args) => {
+      const url = `${proxyBaseUrl}/v1${service.proxyPath}`;
+      const response = await fetch(url, {
+        method: service.method,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(args)
+      });
+      if (!response.ok) {
+        const errText = await response.text().catch(() => "");
+        throw new Error(
+          `Partner API error (${response.status}): ${errText || response.statusText}`
+        );
+      }
+      return response.json();
+    }
+  };
+}
+function buildPartnerTools(proxyBaseUrl) {
+  return PARTNER_SERVICES.map((service) => buildTool(service, proxyBaseUrl));
+}
+var init_tools = __esm({
+  "src/partners/tools.ts"() {
+    "use strict";
+    init_registry();
+  }
+});
+
+// src/partners/index.ts
+var partners_exports = {};
+__export(partners_exports, {
+  PARTNER_SERVICES: () => PARTNER_SERVICES,
+  buildPartnerTools: () => buildPartnerTools,
+  getPartnerService: () => getPartnerService
+});
+var init_partners = __esm({
+  "src/partners/index.ts"() {
+    "use strict";
+    init_registry();
+    init_tools();
+  }
+});
+
 // src/models.ts
 var MODEL_ALIASES = {
   // Claude - use newest versions (4.6)
@@ -2635,7 +2758,7 @@ function formatStatsAscii(stats) {
   lines.push(`\u2551  Avg Latency: ${stats.avgLatencyMs.toFixed(0)}ms`.padEnd(61) + "\u2551");
   lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
   lines.push("\u2551  Routing by Tier:                                          \u2551");
-  const knownTiers = ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING"];
+  const knownTiers = ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING", "DIRECT"];
   const allTiers = Object.keys(stats.byTier);
   const otherTiers = allTiers.filter((t) => !knownTiers.includes(t));
   const tierOrder = [...knownTiers.filter((t) => stats.byTier[t]), ...otherTiers];
@@ -4745,6 +4868,63 @@ function estimateAmount(modelId, bodyLength, maxTokens) {
   const amountMicros = Math.max(100, Math.ceil(costUsd * 1.2 * 1e6));
   return amountMicros.toString();
 }
+async function proxyPartnerRequest(req, res, apiBase, payFetch) {
+  const startTime = Date.now();
+  const upstreamUrl = `${apiBase}${req.url}`;
+  const bodyChunks = [];
+  for await (const chunk of req) {
+    bodyChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const body = Buffer.concat(bodyChunks);
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (key === "host" || key === "connection" || key === "transfer-encoding" || key === "content-length")
+      continue;
+    if (typeof value === "string") headers[key] = value;
+  }
+  if (!headers["content-type"]) headers["content-type"] = "application/json";
+  headers["user-agent"] = USER_AGENT;
+  console.log(`[ClawRouter] Partner request: ${req.method} ${req.url}`);
+  const upstream = await payFetch(upstreamUrl, {
+    method: req.method ?? "POST",
+    headers,
+    body: body.length > 0 ? new Uint8Array(body) : void 0
+  });
+  const responseHeaders = {};
+  upstream.headers.forEach((value, key) => {
+    if (key === "transfer-encoding" || key === "connection" || key === "content-encoding") return;
+    responseHeaders[key] = value;
+  });
+  res.writeHead(upstream.status, responseHeaders);
+  if (upstream.body) {
+    const reader = upstream.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        safeWrite(res, Buffer.from(value));
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  res.end();
+  const latencyMs = Date.now() - startTime;
+  console.log(`[ClawRouter] Partner response: ${upstream.status} (${latencyMs}ms)`);
+  logUsage({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    model: "partner",
+    tier: "PARTNER",
+    cost: 0,
+    // Actual cost handled by x402 settlement
+    baselineCost: 0,
+    savings: 0,
+    latencyMs,
+    partnerId: (req.url?.split("?")[0] ?? "").replace(/^\/v1\//, "").replace(/\//g, "_") || "unknown",
+    service: "partner"
+  }).catch(() => {
+  });
+}
 async function startProxy(options) {
   const apiBase = options.apiBase ?? BLOCKRUN_API;
   const listenPort = options.port ?? getProxyPort();
@@ -4855,6 +5035,23 @@ async function startProxy(options) {
       res.end(JSON.stringify({ object: "list", data: models }));
       return;
     }
+    if (req.url?.match(/^\/v1\/(?:x|partner)\//)) {
+      try {
+        await proxyPartnerRequest(req, res, apiBase, payFetch);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        options.onError?.(error);
+        if (!res.headersSent) {
+          res.writeHead(502, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              error: { message: `Partner proxy error: ${error.message}`, type: "partner_error" }
+            })
+          );
+        }
+      }
+      return;
+    }
     if (!req.url?.startsWith("/v1")) {
       res.writeHead(404, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Not found" }));
@@ -5717,10 +5914,11 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
     }
     throw err;
   }
-  if (routingDecision) {
+  const logModel = routingDecision?.model ?? modelId;
+  if (logModel) {
     const estimatedInputTokens = Math.ceil(body.length / 4);
     const accurateCosts = calculateModelCost(
-      routingDecision.model,
+      logModel,
       routerOpts.modelPricing,
       estimatedInputTokens,
       maxTokens,
@@ -5730,8 +5928,8 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
     const baselineWithBuffer = accurateCosts.baselineCost * 1.2;
     const entry = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      model: routingDecision.model,
-      tier: routingDecision.tier,
+      model: logModel,
+      tier: routingDecision?.tier ?? "DIRECT",
       cost: costWithBuffer,
       baselineCost: baselineWithBuffer,
       savings: accurateCosts.savings,
@@ -5869,6 +6067,7 @@ function isRetryable(errorOrResponse, config) {
 }
 
 // src/index.ts
+init_partners();
 async function waitForProxyHealth(port, timeoutMs = 3e3) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -6314,6 +6513,44 @@ var plugin = {
       models: OPENCLAW_MODELS
     };
     api.logger.info("BlockRun provider registered (30+ models via x402)");
+    try {
+      const { buildPartnerTools: buildPartnerTools2, PARTNER_SERVICES: PARTNER_SERVICES2 } = await Promise.resolve().then(() => (init_partners(), partners_exports));
+      const proxyBaseUrl = `http://127.0.0.1:${runtimePort}`;
+      const partnerTools = buildPartnerTools2(proxyBaseUrl);
+      for (const tool of partnerTools) {
+        api.registerTool(tool);
+      }
+      if (partnerTools.length > 0) {
+        api.logger.info(`Registered ${partnerTools.length} partner tool(s): ${partnerTools.map((t) => t.name).join(", ")}`);
+      }
+      api.registerCommand({
+        name: "partners",
+        description: "List available partner APIs and pricing",
+        acceptsArgs: false,
+        requireAuth: false,
+        handler: async () => {
+          if (PARTNER_SERVICES2.length === 0) {
+            return { text: "No partner APIs available." };
+          }
+          const lines = [
+            "**Partner APIs** (paid via your ClawRouter wallet)",
+            ""
+          ];
+          for (const svc of PARTNER_SERVICES2) {
+            lines.push(`**${svc.name}** (${svc.partner})`);
+            lines.push(`  ${svc.description}`);
+            lines.push(`  Tool: \`${`blockrun_${svc.id}`}\``);
+            lines.push(`  Pricing: ${svc.pricing.perUnit} per ${svc.pricing.unit} (min ${svc.pricing.minimum}, max ${svc.pricing.maximum})`);
+            lines.push("");
+          }
+          return { text: lines.join("\n") };
+        }
+      });
+    } catch (err) {
+      api.logger.warn(
+        `Failed to register partner tools: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     createWalletCommand().then((walletCommand) => {
       api.registerCommand(walletCommand);
     }).catch((err) => {
@@ -6388,12 +6625,14 @@ export {
   InsufficientFundsError,
   MODEL_ALIASES,
   OPENCLAW_MODELS,
+  PARTNER_SERVICES,
   PaymentCache,
   RequestDeduplicator,
   ResponseCache,
   RpcError,
   SessionStore,
   blockrunProvider,
+  buildPartnerTools,
   buildProviderModels,
   calculateModelCost,
   createPaymentFetch,
@@ -6404,6 +6643,7 @@ export {
   getFallbackChain,
   getFallbackChainFiltered,
   getModelContextWindow,
+  getPartnerService,
   getProxyPort,
   getSessionId,
   getStats,