@blockrun/clawrouter 0.1.0

package/dist/index.js

@@ -0,0 +1,888 @@
+// src/auth.ts
+import { writeFile, readFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var WALLET_DIR = join(homedir(), ".openclaw", "blockrun");
+var WALLET_FILE = join(WALLET_DIR, "wallet.key");
+async function loadSavedWallet() {
+  try {
+    const key = (await readFile(WALLET_FILE, "utf-8")).trim();
+    if (key.startsWith("0x") && key.length === 66) return key;
+  } catch {
+  }
+  return void 0;
+}
+async function generateAndSaveWallet() {
+  const key = generatePrivateKey();
+  const account = privateKeyToAccount(key);
+  await mkdir(WALLET_DIR, { recursive: true });
+  await writeFile(WALLET_FILE, key + "\n", { mode: 384 });
+  return { key, address: account.address };
+}
+async function resolveOrGenerateWalletKey() {
+  const saved = await loadSavedWallet();
+  if (saved) {
+    const account = privateKeyToAccount(saved);
+    return { key: saved, address: account.address, source: "saved" };
+  }
+  const envKey = process.env.BLOCKRUN_WALLET_KEY;
+  if (typeof envKey === "string" && envKey.startsWith("0x") && envKey.length === 66) {
+    const account = privateKeyToAccount(envKey);
+    return { key: envKey, address: account.address, source: "env" };
+  }
+  const { key, address } = await generateAndSaveWallet();
+  return { key, address, source: "generated" };
+}
+var walletKeyAuth = {
+  id: "wallet-key",
+  label: "Wallet Private Key",
+  hint: "Enter your EVM wallet private key (0x...) for x402 payments to BlockRun",
+  kind: "api_key",
+  run: async (ctx) => {
+    const key = await ctx.prompter.text({
+      message: "Enter your wallet private key (0x...)",
+      validate: (value) => {
+        const trimmed = value.trim();
+        if (!trimmed.startsWith("0x")) return "Key must start with 0x";
+        if (trimmed.length !== 66) return "Key must be 66 characters (0x + 64 hex)";
+        if (!/^0x[0-9a-fA-F]{64}$/.test(trimmed)) return "Key must be valid hex";
+        return void 0;
+      }
+    });
+    if (!key || typeof key !== "string") {
+      throw new Error("Wallet key is required");
+    }
+    return {
+      profiles: [
+        {
+          profileId: "default",
+          credential: { apiKey: key.trim() }
+        }
+      ],
+      notes: [
+        "Wallet key stored securely in OpenClaw credentials.",
+        "Your wallet signs x402 USDC payments on Base for each LLM call.",
+        "Fund your wallet with USDC on Base to start using BlockRun models."
+      ]
+    };
+  }
+};
+var envKeyAuth = {
+  id: "env-key",
+  label: "Environment Variable",
+  hint: "Use BLOCKRUN_WALLET_KEY environment variable",
+  kind: "api_key",
+  run: async () => {
+    const key = process.env.BLOCKRUN_WALLET_KEY;
+    if (!key) {
+      throw new Error(
+        "BLOCKRUN_WALLET_KEY environment variable is not set. Set it to your EVM wallet private key (0x...)."
+      );
+    }
+    return {
+      profiles: [
+        {
+          profileId: "default",
+          credential: { apiKey: key.trim() }
+        }
+      ],
+      notes: ["Using wallet key from BLOCKRUN_WALLET_KEY environment variable."]
+    };
+  }
+};
+
+// src/models.ts
+var BLOCKRUN_MODELS = [
+  // Smart routing meta-model — proxy replaces with actual model
+  { id: "blockrun/auto", name: "BlockRun Smart Router", inputPrice: 0, outputPrice: 0, contextWindow: 105e4, maxOutput: 128e3 },
+  // OpenAI GPT-5 Family
+  { id: "openai/gpt-5.2", name: "GPT-5.2", inputPrice: 1.75, outputPrice: 14, contextWindow: 4e5, maxOutput: 128e3, reasoning: true, vision: true },
+  { id: "openai/gpt-5-mini", name: "GPT-5 Mini", inputPrice: 0.25, outputPrice: 2, contextWindow: 2e5, maxOutput: 65536 },
+  { id: "openai/gpt-5-nano", name: "GPT-5 Nano", inputPrice: 0.05, outputPrice: 0.4, contextWindow: 128e3, maxOutput: 32768 },
+  { id: "openai/gpt-5.2-pro", name: "GPT-5.2 Pro", inputPrice: 21, outputPrice: 168, contextWindow: 4e5, maxOutput: 128e3, reasoning: true },
+  // OpenAI GPT-4 Family
+  { id: "openai/gpt-4.1", name: "GPT-4.1", inputPrice: 2, outputPrice: 8, contextWindow: 128e3, maxOutput: 16384, vision: true },
+  { id: "openai/gpt-4.1-mini", name: "GPT-4.1 Mini", inputPrice: 0.4, outputPrice: 1.6, contextWindow: 128e3, maxOutput: 16384 },
+  { id: "openai/gpt-4.1-nano", name: "GPT-4.1 Nano", inputPrice: 0.1, outputPrice: 0.4, contextWindow: 128e3, maxOutput: 16384 },
+  { id: "openai/gpt-4o", name: "GPT-4o", inputPrice: 2.5, outputPrice: 10, contextWindow: 128e3, maxOutput: 16384, vision: true },
+  { id: "openai/gpt-4o-mini", name: "GPT-4o Mini", inputPrice: 0.15, outputPrice: 0.6, contextWindow: 128e3, maxOutput: 16384 },
+  // OpenAI O-series (Reasoning)
+  { id: "openai/o1", name: "o1", inputPrice: 15, outputPrice: 60, contextWindow: 2e5, maxOutput: 1e5, reasoning: true },
+  { id: "openai/o1-mini", name: "o1-mini", inputPrice: 1.1, outputPrice: 4.4, contextWindow: 128e3, maxOutput: 65536, reasoning: true },
+  { id: "openai/o3", name: "o3", inputPrice: 2, outputPrice: 8, contextWindow: 2e5, maxOutput: 1e5, reasoning: true },
+  { id: "openai/o3-mini", name: "o3-mini", inputPrice: 1.1, outputPrice: 4.4, contextWindow: 128e3, maxOutput: 65536, reasoning: true },
+  { id: "openai/o4-mini", name: "o4-mini", inputPrice: 1.1, outputPrice: 4.4, contextWindow: 128e3, maxOutput: 65536, reasoning: true },
+  // Anthropic
+  { id: "anthropic/claude-haiku-4.5", name: "Claude Haiku 4.5", inputPrice: 1, outputPrice: 5, contextWindow: 2e5, maxOutput: 8192 },
+  { id: "anthropic/claude-sonnet-4", name: "Claude Sonnet 4", inputPrice: 3, outputPrice: 15, contextWindow: 2e5, maxOutput: 64e3, reasoning: true },
+  { id: "anthropic/claude-opus-4", name: "Claude Opus 4", inputPrice: 15, outputPrice: 75, contextWindow: 2e5, maxOutput: 32e3, reasoning: true },
+  { id: "anthropic/claude-opus-4.5", name: "Claude Opus 4.5", inputPrice: 15, outputPrice: 75, contextWindow: 2e5, maxOutput: 32e3, reasoning: true },
+  // Google
+  { id: "google/gemini-3-pro-preview", name: "Gemini 3 Pro Preview", inputPrice: 2, outputPrice: 12, contextWindow: 105e4, maxOutput: 65536, reasoning: true, vision: true },
+  { id: "google/gemini-2.5-pro", name: "Gemini 2.5 Pro", inputPrice: 1.25, outputPrice: 10, contextWindow: 105e4, maxOutput: 65536, reasoning: true, vision: true },
+  { id: "google/gemini-2.5-flash", name: "Gemini 2.5 Flash", inputPrice: 0.15, outputPrice: 0.6, contextWindow: 1e6, maxOutput: 65536 },
+  // DeepSeek
+  { id: "deepseek/deepseek-chat", name: "DeepSeek V3.2 Chat", inputPrice: 0.28, outputPrice: 0.42, contextWindow: 128e3, maxOutput: 8192 },
+  { id: "deepseek/deepseek-reasoner", name: "DeepSeek V3.2 Reasoner", inputPrice: 0.28, outputPrice: 0.42, contextWindow: 128e3, maxOutput: 8192, reasoning: true },
+  // xAI / Grok
+  { id: "xai/grok-3", name: "Grok 3", inputPrice: 3, outputPrice: 15, contextWindow: 131072, maxOutput: 16384, reasoning: true },
+  { id: "xai/grok-3-fast", name: "Grok 3 Fast", inputPrice: 5, outputPrice: 25, contextWindow: 131072, maxOutput: 16384, reasoning: true },
+  { id: "xai/grok-3-mini", name: "Grok 3 Mini", inputPrice: 0.3, outputPrice: 0.5, contextWindow: 131072, maxOutput: 16384 }
+];
+function toOpenClawModel(m) {
+  return {
+    id: m.id,
+    name: m.name,
+    api: "openai-completions",
+    reasoning: m.reasoning ?? false,
+    input: m.vision ? ["text", "image"] : ["text"],
+    cost: {
+      input: m.inputPrice,
+      output: m.outputPrice,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    contextWindow: m.contextWindow,
+    maxTokens: m.maxOutput
+  };
+}
+var OPENCLAW_MODELS = BLOCKRUN_MODELS.map(toOpenClawModel);
+function buildProviderModels(baseUrl) {
+  return {
+    baseUrl: `${baseUrl}/v1`,
+    api: "openai-completions",
+    models: OPENCLAW_MODELS
+  };
+}
+
+// src/provider.ts
+var activeProxy = null;
+function setActiveProxy(proxy) {
+  activeProxy = proxy;
+}
+var blockrunProvider = {
+  id: "blockrun",
+  label: "BlockRun",
+  docsPath: "https://blockrun.ai/docs",
+  aliases: ["br"],
+  envVars: ["BLOCKRUN_WALLET_KEY"],
+  // Model definitions — dynamically set to proxy URL
+  get models() {
+    if (!activeProxy) {
+      return buildProviderModels("https://blockrun.ai/api");
+    }
+    return buildProviderModels(activeProxy.baseUrl);
+  },
+  // Auth methods
+  auth: [envKeyAuth, walletKeyAuth],
+  // Format the stored credential as the wallet key
+  formatApiKey: (cred) => {
+    if ("apiKey" in cred && typeof cred.apiKey === "string") {
+      return cred.apiKey;
+    }
+    throw new Error("BlockRun credential must contain an apiKey (wallet private key)");
+  }
+};
+
+// src/proxy.ts
+import { createServer } from "http";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+
+// src/x402.ts
+import { signTypedData, privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+var BASE_CHAIN_ID = 8453;
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var USDC_DOMAIN = {
+  name: "USD Coin",
+  version: "2",
+  chainId: BASE_CHAIN_ID,
+  verifyingContract: USDC_BASE
+};
+var TRANSFER_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function createNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function parsePaymentRequired(headerValue) {
+  const decoded = atob(headerValue);
+  return JSON.parse(decoded);
+}
+async function createPaymentPayload(privateKey, fromAddress, recipient, amount, resourceUrl) {
+  const now = Math.floor(Date.now() / 1e3);
+  const validAfter = now - 600;
+  const validBefore = now + 300;
+  const nonce = createNonce();
+  const signature = await signTypedData({
+    privateKey,
+    domain: USDC_DOMAIN,
+    types: TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: fromAddress,
+      to: recipient,
+      value: BigInt(amount),
+      validAfter: BigInt(validAfter),
+      validBefore: BigInt(validBefore),
+      nonce
+    }
+  });
+  const paymentData = {
+    x402Version: 2,
+    resource: {
+      url: resourceUrl,
+      description: "BlockRun AI API call",
+      mimeType: "application/json"
+    },
+    accepted: {
+      scheme: "exact",
+      network: "eip155:8453",
+      amount,
+      asset: USDC_BASE,
+      payTo: recipient,
+      maxTimeoutSeconds: 300,
+      extra: { name: "USD Coin", version: "2" }
+    },
+    payload: {
+      signature,
+      authorization: {
+        from: fromAddress,
+        to: recipient,
+        value: amount,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce
+      }
+    },
+    extensions: {}
+  };
+  return btoa(JSON.stringify(paymentData));
+}
+function createPaymentFetch(privateKey) {
+  const account = privateKeyToAccount2(privateKey);
+  const walletAddress = account.address;
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const response = await fetch(input, init);
+    if (response.status !== 402) {
+      return response;
+    }
+    const paymentHeader = response.headers.get("x-payment-required");
+    if (!paymentHeader) {
+      throw new Error("402 response missing x-payment-required header");
+    }
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const option = paymentRequired.accepts?.[0];
+    if (!option) {
+      throw new Error("No payment options in 402 response");
+    }
+    const amount = option.amount || option.maxAmountRequired;
+    if (!amount) {
+      throw new Error("No amount in payment requirements");
+    }
+    const paymentPayload = await createPaymentPayload(
+      privateKey,
+      walletAddress,
+      option.payTo,
+      amount,
+      url
+    );
+    const retryHeaders = new Headers(init?.headers);
+    retryHeaders.set("payment-signature", paymentPayload);
+    return fetch(input, {
+      ...init,
+      headers: retryHeaders
+    });
+  };
+}
+
+// src/router/rules.ts
+function classifyByRules(prompt, systemPrompt, estimatedTokens, config, ambiguousZone) {
+  const text = `${systemPrompt ?? ""} ${prompt}`.toLowerCase();
+  let score = 0;
+  const signals = [];
+  if (estimatedTokens < config.tokenCountThresholds.simple) {
+    score -= 2;
+    signals.push(`short (${estimatedTokens} tokens)`);
+  } else if (estimatedTokens > config.tokenCountThresholds.complex) {
+    score += 2;
+    signals.push(`long (${estimatedTokens} tokens)`);
+  }
+  const codeMatches = config.codeKeywords.filter((kw) => text.includes(kw.toLowerCase()));
+  if (codeMatches.length >= 2) {
+    score += 2;
+    signals.push(`code (${codeMatches.slice(0, 3).join(", ")})`);
+  } else if (codeMatches.length === 1) {
+    score += 1;
+    signals.push(`possible code (${codeMatches[0]})`);
+  }
+  const reasoningMatches = config.reasoningKeywords.filter((kw) => text.includes(kw.toLowerCase()));
+  if (reasoningMatches.length > 0) {
+    score += 3;
+    signals.push(`reasoning (${reasoningMatches.slice(0, 3).join(", ")})`);
+  }
+  const techMatches = config.technicalKeywords.filter((kw) => text.includes(kw.toLowerCase()));
+  if (techMatches.length >= 2) {
+    score += Math.floor(techMatches.length / 2);
+    signals.push(`technical (${techMatches.slice(0, 3).join(", ")})`);
+  }
+  const creativeMatches = config.creativeKeywords.filter((kw) => text.includes(kw.toLowerCase()));
+  if (creativeMatches.length > 0) {
+    score += 1;
+    signals.push(`creative (${creativeMatches[0]})`);
+  }
+  const simpleMatches = config.simpleKeywords.filter((kw) => text.includes(kw.toLowerCase()));
+  if (simpleMatches.length > 0) {
+    score -= 2;
+    signals.push(`simple (${simpleMatches.slice(0, 2).join(", ")})`);
+  }
+  const multiStepPatterns = [/first.*then/i, /step \d/i, /\d\.\s/];
+  const multiStepHits = multiStepPatterns.filter((p) => p.test(text));
+  if (multiStepHits.length > 0) {
+    score += 1;
+    signals.push("multi-step");
+  }
+  const questionCount = (prompt.match(/\?/g) || []).length;
+  if (questionCount > 3) {
+    score += 1;
+    signals.push(`${questionCount} questions`);
+  }
+  let tier;
+  let confidence;
+  if (reasoningMatches.length >= 2) {
+    tier = "REASONING";
+    confidence = 0.9;
+  } else if (score <= 0) {
+    tier = "SIMPLE";
+    confidence = Math.min(0.95, 0.85 + Math.abs(score) * 0.02);
+  } else if (score >= ambiguousZone[0] && score <= ambiguousZone[1]) {
+    tier = null;
+    confidence = 0.5;
+  } else if (score >= 3 && score <= 4) {
+    tier = "MEDIUM";
+    confidence = 0.75 + (score - 3) * 0.05;
+  } else if (score >= 5 && score <= 6) {
+    tier = "COMPLEX";
+    confidence = 0.7 + (score - 5) * 0.075;
+  } else if (score >= 7) {
+    tier = "REASONING";
+    confidence = 0.7 + Math.min(0.1, (score - 7) * 0.05);
+  } else {
+    tier = null;
+    confidence = 0.5;
+  }
+  return { score, tier, confidence, signals };
+}
+
+// src/router/llm-classifier.ts
+var CLASSIFIER_PROMPT = `You are a query complexity classifier. Classify the user's query into exactly one category.
+
+Categories:
+- SIMPLE: Factual Q&A, definitions, translations, short answers
+- MEDIUM: Summaries, explanations, moderate code generation
+- COMPLEX: Multi-step code, system design, creative writing, analysis
+- REASONING: Mathematical proofs, formal logic, step-by-step problem solving
+
+Respond with ONLY one word: SIMPLE, MEDIUM, COMPLEX, or REASONING.`;
+var cache = /* @__PURE__ */ new Map();
+async function classifyByLLM(prompt, config, payFetch, apiBase) {
+  const truncated = prompt.slice(0, config.truncationChars);
+  const cacheKey = simpleHash(truncated);
+  const cached = cache.get(cacheKey);
+  if (cached && cached.expires > Date.now()) {
+    return { tier: cached.tier, confidence: 0.75 };
+  }
+  try {
+    const response = await payFetch(`${apiBase}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: config.model,
+        messages: [
+          { role: "system", content: CLASSIFIER_PROMPT },
+          { role: "user", content: truncated }
+        ],
+        max_tokens: config.maxTokens,
+        temperature: config.temperature,
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      return { tier: "MEDIUM", confidence: 0.5 };
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content?.trim().toUpperCase() ?? "";
+    const tier = parseTier(content);
+    cache.set(cacheKey, { tier, expires: Date.now() + config.cacheTtlMs });
+    if (cache.size > 1e3) {
+      pruneCache();
+    }
+    return { tier, confidence: 0.75 };
+  } catch {
+    return { tier: "MEDIUM", confidence: 0.5 };
+  }
+}
+function parseTier(text) {
+  if (/\bREASONING\b/.test(text)) return "REASONING";
+  if (/\bCOMPLEX\b/.test(text)) return "COMPLEX";
+  if (/\bMEDIUM\b/.test(text)) return "MEDIUM";
+  if (/\bSIMPLE\b/.test(text)) return "SIMPLE";
+  return "MEDIUM";
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return hash.toString(36);
+}
+function pruneCache() {
+  const now = Date.now();
+  for (const [key, value] of cache) {
+    if (value.expires <= now) {
+      cache.delete(key);
+    }
+  }
+}
+
+// src/router/selector.ts
+function selectModel(tier, confidence, method, reasoning, tierConfigs, modelPricing, estimatedInputTokens, maxOutputTokens) {
+  const tierConfig = tierConfigs[tier];
+  const model = tierConfig.primary;
+  const pricing = modelPricing.get(model);
+  const inputCost = pricing ? estimatedInputTokens / 1e6 * pricing.inputPrice : 0;
+  const outputCost = pricing ? maxOutputTokens / 1e6 * pricing.outputPrice : 0;
+  const costEstimate = inputCost + outputCost;
+  const gpt4oPricing = modelPricing.get("openai/gpt-4o");
+  const baselineInput = gpt4oPricing ? estimatedInputTokens / 1e6 * gpt4oPricing.inputPrice : 0;
+  const baselineOutput = gpt4oPricing ? maxOutputTokens / 1e6 * gpt4oPricing.outputPrice : 0;
+  const baselineCost = baselineInput + baselineOutput;
+  const savings = baselineCost > 0 ? Math.max(0, (baselineCost - costEstimate) / baselineCost) : 0;
+  return {
+    model,
+    tier,
+    confidence,
+    method,
+    reasoning,
+    costEstimate,
+    baselineCost,
+    savings
+  };
+}
+
+// src/router/config.ts
+var DEFAULT_ROUTING_CONFIG = {
+  version: "1.0",
+  classifier: {
+    ambiguousZone: [1, 2],
+    llmModel: "google/gemini-2.5-flash",
+    llmMaxTokens: 10,
+    llmTemperature: 0,
+    promptTruncationChars: 500,
+    cacheTtlMs: 36e5
+    // 1 hour
+  },
+  scoring: {
+    tokenCountThresholds: { simple: 50, complex: 500 },
+    codeKeywords: [
+      "function",
+      "class",
+      "import",
+      "def",
+      "SELECT",
+      "async",
+      "await",
+      "const",
+      "let",
+      "var",
+      "return",
+      "```"
+    ],
+    reasoningKeywords: [
+      "prove",
+      "theorem",
+      "derive",
+      "step by step",
+      "chain of thought",
+      "formally",
+      "mathematical",
+      "proof",
+      "logically"
+    ],
+    simpleKeywords: [
+      "what is",
+      "define",
+      "translate",
+      "hello",
+      "yes or no",
+      "capital of",
+      "how old",
+      "who is",
+      "when was"
+    ],
+    technicalKeywords: [
+      "algorithm",
+      "optimize",
+      "architecture",
+      "distributed",
+      "kubernetes",
+      "microservice",
+      "database",
+      "infrastructure"
+    ],
+    creativeKeywords: [
+      "story",
+      "poem",
+      "compose",
+      "brainstorm",
+      "creative",
+      "imagine",
+      "write a"
+    ]
+  },
+  tiers: {
+    SIMPLE: {
+      primary: "google/gemini-2.5-flash",
+      fallback: ["deepseek/deepseek-chat", "openai/gpt-4o-mini"]
+    },
+    MEDIUM: {
+      primary: "deepseek/deepseek-chat",
+      fallback: ["google/gemini-2.5-flash", "openai/gpt-4o-mini"]
+    },
+    COMPLEX: {
+      primary: "anthropic/claude-sonnet-4",
+      fallback: ["openai/gpt-4o", "google/gemini-2.5-pro"]
+    },
+    REASONING: {
+      primary: "openai/o3",
+      fallback: ["google/gemini-2.5-pro", "anthropic/claude-sonnet-4"]
+    }
+  },
+  overrides: {
+    maxTokensForceComplex: 1e5,
+    structuredOutputMinTier: "MEDIUM"
+  }
+};
+
+// src/router/index.ts
+async function route(prompt, systemPrompt, maxOutputTokens, options) {
+  const { config, modelPricing, payFetch, apiBase } = options;
+  const fullText = `${systemPrompt ?? ""} ${prompt}`;
+  const estimatedTokens = Math.ceil(fullText.length / 4);
+  if (estimatedTokens > config.overrides.maxTokensForceComplex) {
+    return selectModel(
+      "COMPLEX",
+      0.95,
+      "rules",
+      `Input exceeds ${config.overrides.maxTokensForceComplex} tokens`,
+      config.tiers,
+      modelPricing,
+      estimatedTokens,
+      maxOutputTokens
+    );
+  }
+  const hasStructuredOutput = systemPrompt ? /json|structured|schema/i.test(systemPrompt) : false;
+  const ruleResult = classifyByRules(
+    prompt,
+    systemPrompt,
+    estimatedTokens,
+    config.scoring,
+    config.classifier.ambiguousZone
+  );
+  let tier;
+  let confidence;
+  let method = "rules";
+  let reasoning = `score=${ruleResult.score} | ${ruleResult.signals.join(", ")}`;
+  if (ruleResult.tier !== null) {
+    tier = ruleResult.tier;
+    confidence = ruleResult.confidence;
+  } else {
+    const llmResult = await classifyByLLM(
+      prompt,
+      {
+        model: config.classifier.llmModel,
+        maxTokens: config.classifier.llmMaxTokens,
+        temperature: config.classifier.llmTemperature,
+        truncationChars: config.classifier.promptTruncationChars,
+        cacheTtlMs: config.classifier.cacheTtlMs
+      },
+      payFetch,
+      apiBase
+    );
+    tier = llmResult.tier;
+    confidence = llmResult.confidence;
+    method = "llm";
+    reasoning += ` | ambiguous -> LLM: ${tier}`;
+  }
+  if (hasStructuredOutput) {
+    const tierRank = { SIMPLE: 0, MEDIUM: 1, COMPLEX: 2, REASONING: 3 };
+    const minTier = config.overrides.structuredOutputMinTier;
+    if (tierRank[tier] < tierRank[minTier]) {
+      reasoning += ` | upgraded to ${minTier} (structured output)`;
+      tier = minTier;
+    }
+  }
+  return selectModel(
+    tier,
+    confidence,
+    method,
+    reasoning,
+    config.tiers,
+    modelPricing,
+    estimatedTokens,
+    maxOutputTokens
+  );
+}
+
+// src/logger.ts
+import { appendFile, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var LOG_DIR = join2(homedir2(), ".openclaw", "blockrun", "logs");
+var dirReady = false;
+async function ensureDir() {
+  if (dirReady) return;
+  await mkdir2(LOG_DIR, { recursive: true });
+  dirReady = true;
+}
+async function logUsage(entry) {
+  try {
+    await ensureDir();
+    const date = entry.timestamp.slice(0, 10);
+    const file = join2(LOG_DIR, `usage-${date}.jsonl`);
+    await appendFile(file, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+
+// src/proxy.ts
+var BLOCKRUN_API = "https://blockrun.ai/api";
+var AUTO_MODEL = "blockrun/auto";
+var USER_AGENT = "claw-router/0.1.0";
+function buildModelPricing() {
+  const map = /* @__PURE__ */ new Map();
+  for (const m of BLOCKRUN_MODELS) {
+    if (m.id === AUTO_MODEL) continue;
+    map.set(m.id, { inputPrice: m.inputPrice, outputPrice: m.outputPrice });
+  }
+  return map;
+}
+function mergeRoutingConfig(overrides) {
+  if (!overrides) return DEFAULT_ROUTING_CONFIG;
+  return {
+    ...DEFAULT_ROUTING_CONFIG,
+    ...overrides,
+    classifier: { ...DEFAULT_ROUTING_CONFIG.classifier, ...overrides.classifier },
+    scoring: { ...DEFAULT_ROUTING_CONFIG.scoring, ...overrides.scoring },
+    tiers: { ...DEFAULT_ROUTING_CONFIG.tiers, ...overrides.tiers },
+    overrides: { ...DEFAULT_ROUTING_CONFIG.overrides, ...overrides.overrides }
+  };
+}
+async function startProxy(options) {
+  const apiBase = options.apiBase ?? BLOCKRUN_API;
+  const account = privateKeyToAccount3(options.walletKey);
+  const payFetch = createPaymentFetch(options.walletKey);
+  const routingConfig = mergeRoutingConfig(options.routingConfig);
+  const modelPricing = buildModelPricing();
+  const routerOpts = {
+    config: routingConfig,
+    modelPricing,
+    payFetch,
+    apiBase
+  };
+  const server = createServer(async (req, res) => {
+    if (req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", wallet: account.address }));
+      return;
+    }
+    if (!req.url?.startsWith("/v1")) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    try {
+      await proxyRequest(req, res, apiBase, payFetch, options, routerOpts);
+    } 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: `Proxy error: ${error.message}`, type: "proxy_error" }
+        }));
+      }
+    }
+  });
+  const listenPort = options.port ?? 0;
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(listenPort, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = addr.port;
+      const baseUrl = `http://127.0.0.1:${port}`;
+      options.onReady?.(port);
+      resolve({
+        port,
+        baseUrl,
+        close: () => new Promise((res, rej) => {
+          server.close((err) => err ? rej(err) : res());
+        })
+      });
+    });
+  });
+}
+async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts) {
+  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));
+  }
+  let body = Buffer.concat(bodyChunks);
+  let routingDecision;
+  const isChatCompletion = req.url?.includes("/chat/completions");
+  if (isChatCompletion && body.length > 0) {
+    try {
+      const parsed = JSON.parse(body.toString());
+      if (parsed.model === AUTO_MODEL) {
+        const messages = parsed.messages;
+        let lastUserMsg;
+        if (messages) {
+          for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === "user") {
+              lastUserMsg = messages[i];
+              break;
+            }
+          }
+        }
+        const systemMsg = messages?.find((m) => m.role === "system");
+        const prompt = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : "";
+        const systemPrompt = typeof systemMsg?.content === "string" ? systemMsg.content : void 0;
+        const maxTokens = parsed.max_tokens || 4096;
+        routingDecision = await route(prompt, systemPrompt, maxTokens, routerOpts);
+        parsed.model = routingDecision.model;
+        body = Buffer.from(JSON.stringify(parsed));
+        options.onRouted?.(routingDecision);
+      }
+    } catch {
+    }
+  }
+  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;
+  const upstream = await payFetch(upstreamUrl, {
+    method: req.method ?? "POST",
+    headers,
+    body: body.length > 0 ? body : void 0
+  });
+  const responseHeaders = {};
+  upstream.headers.forEach((value, key) => {
+    if (key === "transfer-encoding" || key === "connection") 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;
+        res.write(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  res.end();
+  if (routingDecision) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: routingDecision.model,
+      cost: routingDecision.costEstimate,
+      latencyMs: Date.now() - startTime
+    };
+    logUsage(entry).catch(() => {
+    });
+  }
+}
+
+// src/index.ts
+var plugin = {
+  id: "claw-router",
+  name: "ClawRouter",
+  description: "Smart LLM router \u2014 30+ models, x402 micropayments, 63% cost savings",
+  version: "0.1.0",
+  register(api) {
+    api.registerProvider(blockrunProvider);
+    api.logger.info("BlockRun provider registered (30+ models via x402)");
+  },
+  async activate(api) {
+    const { key: walletKey, address, source } = await resolveOrGenerateWalletKey();
+    if (source === "generated") {
+      api.logger.info(`Generated new wallet: ${address}`);
+      api.logger.info(`Fund with USDC on Base to start using ClawRouter.`);
+    } else if (source === "saved") {
+      api.logger.info(`Using saved wallet: ${address}`);
+    } else {
+      api.logger.info(`Using wallet from BLOCKRUN_WALLET_KEY: ${address}`);
+    }
+    const routingConfig = api.pluginConfig?.routing;
+    try {
+      const proxy = await startProxy({
+        walletKey,
+        routingConfig,
+        onReady: (port) => {
+          api.logger.info(`BlockRun x402 proxy listening on port ${port}`);
+        },
+        onError: (error) => {
+          api.logger.error(`BlockRun proxy error: ${error.message}`);
+        },
+        onRouted: (decision) => {
+          const cost = decision.costEstimate.toFixed(4);
+          const saved = (decision.savings * 100).toFixed(0);
+          api.logger.info(`${decision.model} $${cost} (saved ${saved}%)`);
+        }
+      });
+      setActiveProxy(proxy);
+      api.logger.info(`BlockRun provider active \u2014 ${proxy.baseUrl}/v1 (smart routing enabled)`);
+    } catch (err) {
+      api.logger.error(
+        `Failed to start BlockRun proxy: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+var index_default = plugin;
+export {
+  BLOCKRUN_MODELS,
+  DEFAULT_ROUTING_CONFIG,
+  OPENCLAW_MODELS,
+  blockrunProvider,
+  buildProviderModels,
+  index_default as default,
+  logUsage,
+  route,
+  startProxy
+};
+//# sourceMappingURL=index.js.map