caddie-mcp 0.1.0

package/dist/setup.js

@@ -0,0 +1,429 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { readFileSync, writeFileSync, existsSync, chmodSync, realpathSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const B3OS_SERVER_URL = "https://api.b3os.org";
+const API_KEY_URL = "https://b3os.org/organizations/settings?tab=api-keys";
+/**
+ * Read-only / non-destructive b3os-mcp tools that are safe to pre-approve.
+ * Write tools (create_workflow, run_action, query_database, etc.) stay
+ * behind permission prompts — users must approve each mutation explicitly.
+ */
+const SAFE_AUTO_APPROVE_TOOLS = [
+    // Identity
+    "mcp__b3os-mcp__b3os_whoami",
+    // Read-only lists
+    "mcp__b3os-mcp__b3os_list_wallets",
+    "mcp__b3os-mcp__b3os_list_connectors",
+    "mcp__b3os-mcp__b3os_list_telegram_chats",
+    "mcp__b3os-mcp__b3os_list_slack_channels",
+    "mcp__b3os-mcp__b3os_list_actions",
+    "mcp__b3os-mcp__b3os_search_actions",
+    "mcp__b3os-mcp__b3os_get_action",
+    "mcp__b3os-mcp__b3os_list_triggers",
+    "mcp__b3os-mcp__b3os_get_trigger",
+    "mcp__b3os-mcp__b3os_list_workflows",
+    "mcp__b3os-mcp__b3os_get_workflow",
+    "mcp__b3os-mcp__b3os_validate_workflow",
+    "mcp__b3os-mcp__b3os_list_runs",
+    "mcp__b3os-mcp__b3os_get_run",
+    "mcp__b3os-mcp__b3os_list_tables",
+    "mcp__b3os-mcp__b3os_get_table_schema",
+    // Read-only lookups
+    "mcp__b3os-mcp__b3os_query_action",
+    "mcp__b3os-mcp__b3os_token_lookup",
+    "mcp__b3os-mcp__b3os_price_lookup",
+    "mcp__b3os-mcp__b3os_balance_lookup",
+    "mcp__b3os-mcp__b3os_defi_lookup",
+    "mcp__b3os-mcp__b3os_debug_transaction",
+    "mcp__b3os-mcp__b3os_polymarket_lookup",
+    // Caddie (analysis-only — doesn't mutate user workflows)
+    "mcp__b3os-mcp__b3os_build_workflow",
+    "mcp__b3os-mcp__b3os_debug_run",
+];
+// ── Helpers ──
+function print(msg) {
+    process.stdout.write(msg + "\n");
+}
+function prompt(rl, question) {
+    return new Promise(resolve => rl.question(question, resolve));
+}
+async function validateApiKey(apiKey) {
+    try {
+        const response = await fetch(`${B3OS_SERVER_URL}/v1/organizations`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok)
+            return { valid: false };
+        const body = (await response.json());
+        const orgName = body?.data?.items?.[0]?.name;
+        return { valid: true, orgName };
+    }
+    catch {
+        return { valid: false };
+    }
+}
+function getPackageDir() {
+    // setup.js lives in dist/, package.json is one level up
+    return join(__dirname, "..");
+}
+function getServerEntryPath() {
+    // setup.js and index.js are always co-located in dist/ after tsc build
+    return join(__dirname, "index.js");
+}
+/**
+ * Ensure dist/index.js exists. If missing, attempt to build.
+ */
+function ensureBuild() {
+    const entryPath = getServerEntryPath();
+    if (existsSync(entryPath))
+        return;
+    print("  ⚠ Build not found. Running pnpm build...");
+    try {
+        execSync("pnpm build", { cwd: getPackageDir(), stdio: "inherit" });
+    }
+    catch {
+        print("\n  ✗ Build failed. Run 'pnpm build' manually in packages/b3os-mcp/");
+        process.exit(1);
+    }
+    if (!existsSync(entryPath)) {
+        print("\n  ✗ Build completed but dist/index.js not found.");
+        process.exit(1);
+    }
+}
+/**
+ * Run `npm link` to create a global `b3os-mcp` command, then verify it resolves.
+ * Returns true if the global command is available, false otherwise.
+ */
+function linkGlobally() {
+    const pkgDir = getPackageDir();
+    try {
+        execSync("npm link --force", { cwd: pkgDir, stdio: "pipe" });
+    }
+    catch (err) {
+        const stderr = err?.stderr?.toString().trim();
+        print(`  ⚠ npm link failed: ${stderr || (err instanceof Error ? err.message : String(err))}`);
+        return false;
+    }
+    // Verify the symlink is resolvable
+    try {
+        execSync("which b3os-mcp", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        print("  ⚠ b3os-mcp command not found after linking");
+        return false;
+    }
+}
+/**
+ * Build the MCP server entry for config files.
+ * Uses the global command name if available, falls back to absolute node path.
+ *
+ * NOTE: We use process.execPath (absolute path to the node binary) instead of
+ * "node" because nvm/fnm paths are not available in subprocess environments
+ * (e.g. when Claude Code spawns the MCP server process).
+ */
+function buildServerEntry(apiKey, useGlobalCommand, opts) {
+    const entry = useGlobalCommand
+        ? { command: "b3os-mcp" }
+        : { command: process.execPath, args: [getServerEntryPath()] };
+    if (opts?.type)
+        entry.type = opts.type;
+    entry.env = { B3OS_API_KEY: apiKey, B3OS_SERVER_URL };
+    return entry;
+}
+/**
+ * Check if an existing b3os config entry uses the old absolute-path format
+ * (command: "node" with args pointing to a file path).
+ */
+function isStaleAbsolutePathEntry(entry) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    const e = entry;
+    if (e.command !== "node" || !Array.isArray(e.args) || e.args.length === 0)
+        return false;
+    const firstArg = String(e.args[0]);
+    // Only match absolute paths to our index.js, not custom node setups
+    return firstArg.startsWith("/") && firstArg.endsWith("/index.js");
+}
+// ── JSON config helpers ──
+function readJsonConfig(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            print(`  ⚠ Could not parse existing config at ${filePath} — creating fresh`);
+        }
+        return {};
+    }
+}
+function writeJsonConfig(path, config) {
+    writeFileSync(path, JSON.stringify(config, null, 2) + "\n");
+    // Restrict file permissions to owner-only (rw-------) since config contains API keys
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // chmod may fail on Windows — non-fatal
+    }
+}
+// ── Permission pre-approval helpers ──
+function getClaudeDir() {
+    return join(homedir(), ".claude");
+}
+function getClaudeCodeSettingsPath() {
+    return join(getClaudeDir(), "settings.json");
+}
+/**
+ * Merge new tool entries into permissions.allow idempotently.
+ * Does not touch disk. Mutates the input config in place and returns it.
+ */
+export function mergeAllowedTools(config, tools) {
+    const perms = (config.permissions && typeof config.permissions === "object" ? config.permissions : {});
+    const allow = Array.isArray(perms.allow) ? perms.allow : [];
+    const existing = new Set(allow);
+    let added = 0;
+    for (const tool of tools) {
+        if (!existing.has(tool)) {
+            allow.push(tool);
+            existing.add(tool);
+            added++;
+        }
+    }
+    perms.allow = allow;
+    config.permissions = perms;
+    return { config, added };
+}
+// ── Claude Desktop config ──
+function getClaudeDesktopConfigPath() {
+    const platform = process.platform;
+    if (platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    else if (platform === "win32") {
+        return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    }
+    // Linux
+    return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+function isClaudeDesktopInstalled() {
+    const configPath = getClaudeDesktopConfigPath();
+    return existsSync(dirname(configPath));
+}
+function setupClaudeDesktop(apiKey, useGlobalCommand) {
+    const configPath = getClaudeDesktopConfigPath();
+    const config = readJsonConfig(configPath);
+    const raw = config.mcpServers;
+    const mcpServers = (typeof raw === "object" && raw && !Array.isArray(raw) ? raw : {});
+    const migrated = isStaleAbsolutePathEntry(mcpServers["b3os-mcp"]);
+    mcpServers["b3os-mcp"] = buildServerEntry(apiKey, useGlobalCommand);
+    config.mcpServers = mcpServers;
+    writeJsonConfig(configPath, config);
+    return { migrated };
+}
+// ── Claude Code config ──
+/**
+ * Get the user-scoped MCP config path (~/.claude/mcp.json).
+ * This config applies to ALL projects — ideal for global installs.
+ */
+function getUserMcpJsonPath() {
+    return join(getClaudeDir(), "mcp.json");
+}
+/**
+ * Find the git root directory for the current working directory.
+ * Returns null if not in a git repo.
+ */
+function findGitRoot() {
+    try {
+        return execSync("git rev-parse --show-toplevel", { stdio: "pipe" }).toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the project-scoped .mcp.json path if inside a git repo.
+ * This config applies only to this project.
+ */
+function getProjectMcpJsonPath() {
+    const root = findGitRoot();
+    return root ? join(root, ".mcp.json") : null;
+}
+/**
+ * Check if .mcp.json is listed in the repo's .gitignore.
+ */
+function isMcpJsonGitignored() {
+    try {
+        // git check-ignore exits 0 if the path is ignored, 1 if not
+        execSync("git check-ignore -q .mcp.json", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write the b3os MCP server entry into an mcp.json config file.
+ * Creates the file if it doesn't exist, merges if it does.
+ */
+function writeMcpJsonEntry(filePath, apiKey, useGlobalCommand, opts) {
+    const config = readJsonConfig(filePath);
+    const mcpServers = (typeof config.mcpServers === "object" && config.mcpServers && !Array.isArray(config.mcpServers)
+        ? config.mcpServers
+        : {});
+    const migrated = isStaleAbsolutePathEntry(mcpServers["b3os-mcp"]);
+    mcpServers["b3os-mcp"] = buildServerEntry(apiKey, useGlobalCommand, opts);
+    config.mcpServers = mcpServers;
+    writeJsonConfig(filePath, config);
+    return { migrated };
+}
+// ── Main ──
+async function main() {
+    print("");
+    print("  B3OS MCP Server Setup");
+    print("  ─────────────────────");
+    print("");
+    print("  Connect Claude to the B3OS workflow automation platform.");
+    print("");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        // Step 1: API Key
+        print("  1. Get your API key from:");
+        print(`     → ${API_KEY_URL}`);
+        print('     (Create a key with "read-write" scope)');
+        print("");
+        const apiKey = (await prompt(rl, "  ? Paste your B3OS API key: ")).trim();
+        if (!apiKey) {
+            print("\n  ✗ No API key provided. Exiting.");
+            process.exit(1);
+        }
+        if (!apiKey.startsWith("b3sk_")) {
+            print('\n  ✗ Invalid key format. B3OS API keys start with "b3sk_".');
+            process.exit(1);
+        }
+        // Step 2: Validate
+        print("    Validating...");
+        const { valid, orgName } = await validateApiKey(apiKey);
+        if (!valid) {
+            print("\n  ✗ API key is invalid or expired.");
+            print(`    Create a new key at: ${API_KEY_URL}`);
+            process.exit(1);
+        }
+        print(`  ✓ Key valid — Organization: "${orgName}"`);
+        print("");
+        // Step 3: Build validation & global link
+        ensureBuild();
+        print("  Linking b3os-mcp globally...");
+        const useGlobalCommand = linkGlobally();
+        if (useGlobalCommand) {
+            print("  ✓ Global command linked: b3os-mcp");
+        }
+        else {
+            print("  ⚠ Falling back to absolute path (global link unavailable)");
+        }
+        print("");
+        // Step 4: Configure targets
+        print("  4. Configuring Claude clients...");
+        // 4a: Claude Code — user-scoped (~/.claude/mcp.json, works in all projects)
+        const userMcpPath = getUserMcpJsonPath();
+        {
+            const { migrated } = writeMcpJsonEntry(userMcpPath, apiKey, useGlobalCommand, { type: "stdio" });
+            print(`  ✓ Claude Code (global) — ${userMcpPath}`);
+            if (migrated)
+                print("    ✓ Migrated from absolute path to global command");
+        }
+        // 4b: Claude Code — project-scoped (.mcp.json in git root, if in a repo and gitignored)
+        const projectMcpPath = getProjectMcpJsonPath();
+        if (projectMcpPath) {
+            if (isMcpJsonGitignored()) {
+                const { migrated } = writeMcpJsonEntry(projectMcpPath, apiKey, useGlobalCommand, { type: "stdio" });
+                print(`  ✓ Claude Code (project) — ${projectMcpPath}`);
+                if (migrated)
+                    print("    ✓ Migrated from absolute path to global command");
+            }
+            else {
+                print("  – Skipped project .mcp.json (not in .gitignore — would leak API key)");
+                print("    Add '.mcp.json' to your .gitignore to enable project-scoped config");
+            }
+        }
+        // 4c: Claude Desktop
+        let claudeDesktopConfigured = false;
+        if (isClaudeDesktopInstalled()) {
+            const { migrated } = setupClaudeDesktop(apiKey, useGlobalCommand);
+            print("  ✓ Claude Desktop — configured");
+            if (migrated)
+                print("    ✓ Migrated from absolute path to global command");
+            claudeDesktopConfigured = true;
+        }
+        else {
+            print("  – Claude Desktop not detected (skipped)");
+        }
+        if (!claudeDesktopConfigured) {
+            print("");
+            print("  ℹ Claude Desktop was not detected. Install it from https://claude.ai/download to use B3OS there too.");
+        }
+        // Step 5: Offer to pre-approve safe tools (opt-in)
+        print("");
+        print("  5. Reduce permission prompts?");
+        print(`     Pre-approve ${SAFE_AUTO_APPROVE_TOOLS.length} read-only b3os-mcp tools`);
+        print("     (list/get/lookup/debug — NO create, update, delete, or run).");
+        print("");
+        const approve = (await prompt(rl, "  ? Pre-approve safe tools? [Y/n]: ")).trim().toLowerCase();
+        if (approve === "" || approve === "y" || approve === "yes") {
+            const settingsPath = getClaudeCodeSettingsPath();
+            const config = readJsonConfig(settingsPath);
+            const { config: merged, added } = mergeAllowedTools(config, SAFE_AUTO_APPROVE_TOOLS);
+            writeJsonConfig(settingsPath, merged);
+            if (added > 0) {
+                print(`  ✓ Added ${added} tools to ${settingsPath}`);
+            }
+            else {
+                print(`  ✓ All ${SAFE_AUTO_APPROVE_TOOLS.length} tools already pre-approved`);
+            }
+            print("    Write tools (create/update/delete/run) still require approval per call.");
+            print("    To revert: remove the mcp__b3os-mcp__* entries from permissions.allow");
+        }
+        else {
+            print("  – Skipped (you can pre-approve tools later by re-running setup)");
+        }
+        print("");
+        print("  ─────────────────────");
+        print("  Restart Claude Code and/or Claude Desktop, then try:");
+        print("");
+        print('    "Build a workflow that monitors ETH price every 5 min"');
+        print('    "What actions are available for DeFi?"');
+        print('    "Why did tx 0xabc... on Base fail?"');
+        print("");
+    }
+    finally {
+        rl.close();
+    }
+}
+// Only run main() when this file is the entry point (not when imported by tests).
+// Resolve symlinks so `npm link` (which points argv[1] at a symlink) still matches.
+function isEntryPoint() {
+    if (!process.argv[1])
+        return false;
+    try {
+        const modulePath = fileURLToPath(import.meta.url);
+        return realpathSync(modulePath) === realpathSync(process.argv[1]);
+    }
+    catch {
+        return false;
+    }
+}
+if (isEntryPoint()) {
+    main().catch(err => {
+        print(`\n  ✗ Setup failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+}

package/dist/sse-client.d.ts

@@ -0,0 +1,65 @@
+/**
+ * SSE Event types emitted by the Caddie chat endpoint.
+ *
+ * ## Adding new event types
+ * When Caddie adds a new SSE event type:
+ * 1. Add the type string to CaddieEventType
+ * 2. Add the typed interface to CaddieEvent union
+ * 3. consumeCaddieStream() already forwards unknown events — no changes needed there
+ */
+export type CaddieEventType = "thinking" | "tool_start" | "tool_result" | "node" | "chunk" | "done" | "error" | "mode_switch" | "sheet_data";
+export interface CaddieDoneData {
+    type: "workflow" | "message";
+    workflow?: Record<string, unknown>;
+    message?: string;
+    incompleteFields?: string[];
+    validationErrors?: Array<{
+        nodeId?: string;
+        message: string;
+    }>;
+}
+export interface CaddieDoneEvent {
+    type: "done";
+    data: CaddieDoneData;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationInputTokens?: number;
+        cacheReadInputTokens?: number;
+    };
+    toolUtilization?: Array<{
+        toolName: string;
+        callCount: number;
+        score: number;
+    }>;
+}
+export interface CaddieErrorEvent {
+    type: "error";
+    error: string;
+}
+export type CaddieEvent = {
+    type: CaddieEventType;
+    [key: string]: any;
+};
+/**
+ * Parse raw SSE text into an array of typed events.
+ * Each SSE message is separated by a blank line (`\n\n`).
+ * Lines starting with `data: ` contain the JSON payload.
+ * Lines starting with `:` are comments (heartbeats) and are skipped.
+ */
+export declare function parseSseEvents(raw: string): CaddieEvent[];
+/**
+ * POST to the Caddie chat endpoint and consume the SSE stream.
+ * Returns the final `done` event, or throws on `error` event or timeout.
+ *
+ * @param apiKey  - B3OS API key for Authorization header
+ * @param serverUrl - B3OS server base URL
+ * @param params  - Chat request parameters (message, workflowId, definition, etc.)
+ * @param timeoutMs - Max time to wait for the stream to complete (default: 120s)
+ */
+export declare function consumeCaddieStream(apiKey: string, serverUrl: string, params: {
+    message: string;
+    workflowId?: string;
+    definition?: Record<string, unknown>;
+    agentVersion?: string;
+}, timeoutMs?: number): Promise<CaddieDoneEvent>;

package/dist/sse-client.js

@@ -0,0 +1,101 @@
+/**
+ * Parse raw SSE text into an array of typed events.
+ * Each SSE message is separated by a blank line (`\n\n`).
+ * Lines starting with `data: ` contain the JSON payload.
+ * Lines starting with `:` are comments (heartbeats) and are skipped.
+ */
+export function parseSseEvents(raw) {
+    const events = [];
+    const blocks = raw.split("\n\n");
+    for (const block of blocks) {
+        const trimmed = block.trim();
+        if (!trimmed)
+            continue;
+        const dataLines = [];
+        for (const line of trimmed.split("\n")) {
+            if (line.startsWith("data: ")) {
+                dataLines.push(line.slice(6));
+            }
+            else if (line.startsWith("data:")) {
+                dataLines.push(line.slice(5));
+            }
+        }
+        if (dataLines.length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(dataLines.join(""));
+            if (parsed && typeof parsed.type === "string") {
+                events.push(parsed);
+            }
+        }
+        catch {
+            // Skip malformed JSON
+        }
+    }
+    return events;
+}
+/**
+ * POST to the Caddie chat endpoint and consume the SSE stream.
+ * Returns the final `done` event, or throws on `error` event or timeout.
+ *
+ * @param apiKey  - B3OS API key for Authorization header
+ * @param serverUrl - B3OS server base URL
+ * @param params  - Chat request parameters (message, workflowId, definition, etc.)
+ * @param timeoutMs - Max time to wait for the stream to complete (default: 120s)
+ */
+export async function consumeCaddieStream(apiKey, serverUrl, params, timeoutMs = 120_000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(`${serverUrl}/v1/ai/workflow/chat/stream`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            },
+            body: JSON.stringify({
+                message: params.message,
+                workflowId: params.workflowId,
+                definition: params.definition,
+                agentVersion: params.agentVersion ?? "v2",
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            // Sanitize: strip HTML error pages (Cloudflare 502s etc.) and truncate
+            const clean = /^\s*<(!DOCTYPE|html)/i.test(body)
+                ? "(HTML error page — server may be temporarily unavailable)"
+                : body.length > 500
+                    ? body.slice(0, 500) + "…(truncated)"
+                    : body;
+            throw new Error(`Caddie API error ${response.status}: ${clean}`);
+        }
+        const text = await response.text();
+        const events = parseSseEvents(text);
+        const errorEvent = events.find((e) => e.type === "error");
+        if (errorEvent) {
+            throw new Error(`Caddie error: ${errorEvent.error}`);
+        }
+        const doneEvent = events.find((e) => e.type === "done" && e.data != null && typeof e.data.type === "string");
+        if (!doneEvent) {
+            // Check if there's a done event without valid data — distinguishes "no done event" from "malformed done event"
+            const malformedDone = events.find(e => e.type === "done");
+            if (malformedDone) {
+                throw new Error(`Caddie returned a done event without valid data: ${JSON.stringify(malformedDone).slice(0, 500)}`);
+            }
+            throw new Error("Caddie stream ended without a done event");
+        }
+        return doneEvent;
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error(`Caddie request timed out after ${timeoutMs / 1000} seconds`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/tools/ask-widget-types.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const ASK_WIDGET_TYPES: readonly ["select", "multiselect", "text", "number", "chain-id", "chain-ids", "network", "networks", "token-address", "token-addresses", "recipient-address", "address", "asset-selector", "price-condition", "price", "contract-address", "token-amount", "textarea", "date-time", "date", "email", "rrule", "color", "boolean", "turnkey-wallet", "telegram-chat", "polymarket-outcome", "slack-channel", "quickbooks-account", "connector-account", "database-table"];
+export type AskWidgetType = (typeof ASK_WIDGET_TYPES)[number];

package/dist/tools/ask-widget-types.generated.js

@@ -0,0 +1,34 @@
+// Code generated by cmd/tools/generate-ask-capabilities; DO NOT EDIT.
+export const ASK_WIDGET_TYPES = [
+    "select",
+    "multiselect",
+    "text",
+    "number",
+    "chain-id",
+    "chain-ids",
+    "network",
+    "networks",
+    "token-address",
+    "token-addresses",
+    "recipient-address",
+    "address",
+    "asset-selector",
+    "price-condition",
+    "price",
+    "contract-address",
+    "token-amount",
+    "textarea",
+    "date-time",
+    "date",
+    "email",
+    "rrule",
+    "color",
+    "boolean",
+    "turnkey-wallet",
+    "telegram-chat",
+    "polymarket-outcome",
+    "slack-channel",
+    "quickbooks-account",
+    "connector-account",
+    "database-table",
+];

package/dist/tools/blockchain.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerBlockchainTools(s: McpServer): void;

package/dist/tools/blockchain.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { request, parseJsonParam, truncateResponse } from "../client.js";
+import { ACTION_TYPE_RE } from "./shared.js";
+export function registerBlockchainTools(s) {
+    s.registerTool("b3os_query_action", {
+        description: `Execute any B3OS action as a read-only query — no CU cost, no state changes.
+
+WORKFLOW: b3os_search_actions → b3os_get_action (schema) → b3os_query_action (call)
+
+COMMON ACTIONS (no search needed):
+- "coingecko-get-token-data" — token info by address ({network, address})
+- "coingecko-get-token-price" — prices ({coinIds, vsCurrencies: ["usd"]})
+- "sim-dune-get-wallet-balances" — balances ({address, chainIds?})
+- "debug-transaction" — tx trace with decoded calls ({txHash, chainId})
+- "get-transaction-details" — basic tx data ({txHash, chainId})
+- "sim-dune-get-defi-positions" — DeFi positions ({address, chainId?})
+- "polymarket-search-markets" — prediction markets ({query})
+- "polymarket-get-market" — market details ({slug or marketUrl})
+- "evm-read" — smart contract read ({chainId, contractAddress, abi, functionName, args})
+
+For write operations (send tokens, place bets), build a workflow instead.`,
+        inputSchema: {
+            actionType: z.string().describe("Action type (e.g. 'debug-transaction', 'polymarket-search-markets')"),
+            payload: z
+                .any()
+                .describe("Action payload object. Fields depend on the action — use b3os_get_action to see the schema."),
+        },
+    }, async ({ actionType, payload }) => {
+        if (!ACTION_TYPE_RE.test(actionType)) {
+            return { content: [{ type: "text", text: `Invalid actionType format: "${actionType}"` }] };
+        }
+        try {
+            const parsedPayload = parseJsonParam(payload ?? {}, "payload");
+            const result = await request(`/v1/action-proxy/${actionType}/query`, {
+                method: "POST",
+                body: { payload: parsedPayload },
+            });
+            const text = truncateResponse(JSON.stringify(result, null, 2));
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Action query failed (${actionType}): ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+}