caddie-mcp 0.1.0

package/dist/tools/lookups.js

@@ -0,0 +1,282 @@
+import { z } from "zod";
+import { request, truncateResponse } from "../client.js";
+/**
+ * Named lookup tools — convenience wrappers over the action proxy.
+ * Each calls POST /v1/action-proxy/{type}/query — no CU cost, read-only.
+ *
+ * ## Adding a new lookup tool
+ * 1. Identify the B3OS action type (e.g. "coingecko-get-token-data")
+ * 2. Add a registerTool call below
+ * 3. Use queryAction(actionType, payload) helper
+ */
+async function queryAction(actionType, payload) {
+    const result = await request(`/v1/action-proxy/${actionType}/query`, {
+        method: "POST",
+        body: { payload },
+    });
+    return truncateResponse(JSON.stringify(result, null, 2));
+}
+export function registerLookupTools(s) {
+    // ── 1. Token Lookup ─────────────────────────────────────────────────
+    s.registerTool("b3os_token_lookup", {
+        description: `Look up token information by on-chain address or CoinGecko ID. Read-only, no CU cost.
+
+USE CASES:
+- Get token metadata (name, symbol, market cap, image) by contract address on a chain
+- Get current USD price by CoinGecko coin ID (e.g. "bitcoin", "ethereum")
+
+INPUTS (provide ONE of these combinations):
+- coinId → fetches price via CoinGecko ID (e.g. "bitcoin", "uniswap", "aave")
+- network + address → fetches full token data by on-chain contract address
+  network values: "ethereum", "base", "arbitrum-one", "polygon-pos", "optimistic-ethereum", "avalanche", "bsc"
+
+EXAMPLES:
+- { coinId: "bitcoin" } → current BTC/USD price
+- { network: "base", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" } → USDC on Base`,
+        inputSchema: {
+            network: z.string().optional().describe('Chain network slug (e.g. "ethereum", "base", "arbitrum-one")'),
+            address: z.string().optional().describe("Token contract address (hex, checksummed or lowercase)"),
+            coinId: z.string().optional().describe('CoinGecko coin ID (e.g. "bitcoin", "ethereum", "uniswap")'),
+        },
+    }, async ({ network, address, coinId }) => {
+        try {
+            if (coinId) {
+                const text = await queryAction("coingecko-get-token-price", {
+                    coinIds: [coinId],
+                    vsCurrencies: ["usd"],
+                });
+                return { content: [{ type: "text", text }] };
+            }
+            if (network && address) {
+                const text = await queryAction("coingecko-get-token-data", { network, address });
+                return { content: [{ type: "text", text }] };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Provide either `coinId` for a price lookup, or both `network` and `address` for full token data.",
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Token lookup failed: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+    // ── 2. Price Lookup ─────────────────────────────────────────────────
+    s.registerTool("b3os_price_lookup", {
+        description: `Get current prices for one or more tokens by CoinGecko ID. Read-only, no CU cost.
+
+Batch-friendly: pass multiple coin IDs in a single call.
+
+EXAMPLES:
+- { coinIds: ["bitcoin", "ethereum"] } → BTC and ETH prices in USD
+- { coinIds: ["aave"], vsCurrencies: ["usd", "eur"] } → AAVE in USD and EUR`,
+        inputSchema: {
+            coinIds: z.array(z.string()).describe('Array of CoinGecko coin IDs (e.g. ["bitcoin", "ethereum"])'),
+            vsCurrencies: z
+                .array(z.string())
+                .optional()
+                .describe('Quote currencies (default: ["usd"]). e.g. ["usd", "eur", "btc"]'),
+        },
+    }, async ({ coinIds, vsCurrencies }) => {
+        try {
+            const text = await queryAction("coingecko-get-token-price", {
+                coinIds,
+                vsCurrencies: vsCurrencies ?? ["usd"],
+            });
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Price lookup failed: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+    // ── 3. Balance Lookup ───────────────────────────────────────────────
+    s.registerTool("b3os_balance_lookup", {
+        description: `Get wallet token balances across all supported chains. Read-only, no CU cost.
+
+Returns token holdings with USD values, sorted by value descending.
+
+INPUTS:
+- address (required) — wallet address to check
+- chainIds (optional) — filter to specific chain IDs (e.g. [1, 8453] for Ethereum + Base)
+- limit (optional, default 20) — max tokens to return
+- offset (optional) — pagination offset
+
+CHAIN IDs: 1=Ethereum, 8453=Base, 42161=Arbitrum, 137=Polygon, 10=Optimism, 43114=Avalanche, 56=BSC
+
+EXAMPLES:
+- { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" } → vitalik.eth balances
+- { address: "0x...", chainIds: [8453], limit: 50 } → top 50 tokens on Base`,
+        inputSchema: {
+            address: z.string().describe("Wallet address (0x...)"),
+            chainIds: z.array(z.number()).optional().describe("Filter by chain IDs (e.g. [1, 8453])"),
+            limit: z.number().optional().describe("Max tokens to return (default: 20)"),
+            offset: z.number().optional().describe("Pagination offset"),
+        },
+    }, async ({ address, chainIds, limit, offset, }) => {
+        try {
+            const payload = { address, limit: limit ?? 20 };
+            if (chainIds)
+                payload.chainIds = chainIds;
+            if (offset !== undefined)
+                payload.offset = offset;
+            const text = await queryAction("sim-dune-get-wallet-balances", payload);
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Balance lookup failed: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+    // ── 4. DeFi Lookup ──────────────────────────────────────────────────
+    s.registerTool("b3os_defi_lookup", {
+        description: `Get DeFi positions (lending, staking, LPs, vaults) for a wallet. Read-only, no CU cost.
+
+Returns protocol positions with USD values across supported chains.
+
+INPUTS:
+- address (required) — wallet address to check
+- chainId (optional) — filter to a single chain ID
+
+EXAMPLES:
+- { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" } → all DeFi positions
+- { address: "0x...", chainId: 1 } → Ethereum-only DeFi positions`,
+        inputSchema: {
+            address: z.string().describe("Wallet address (0x...)"),
+            chainId: z.number().optional().describe("Filter to a single chain ID (e.g. 1 for Ethereum)"),
+        },
+    }, async ({ address, chainId }) => {
+        try {
+            const payload = { address };
+            if (chainId !== undefined)
+                payload.chainId = chainId;
+            const text = await queryAction("sim-dune-get-defi-positions", payload);
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `DeFi lookup failed: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+    // ── 5. Debug Transaction ────────────────────────────────────────────
+    s.registerTool("b3os_debug_transaction", {
+        description: `Trace and debug an EVM transaction. Read-only, no CU cost.
+
+Returns decoded call trace, logs, balance changes, and revert reasons (if failed).
+Much richer than a block explorer — shows internal calls, state diffs, and decoded parameters.
+
+INPUTS:
+- txHash (required) — the transaction hash
+- chainId (required) — numeric chain ID
+
+CHAIN IDs: 1=Ethereum, 8453=Base, 42161=Arbitrum, 137=Polygon, 10=Optimism, 43114=Avalanche, 56=BSC
+
+EXAMPLES:
+- { txHash: "0xabc...123", chainId: 8453 } → debug a Base transaction
+- { txHash: "0xdef...456", chainId: 1 } → debug an Ethereum transaction`,
+        inputSchema: {
+            txHash: z.string().describe("Transaction hash (0x...)"),
+            chainId: z.number().describe("Numeric chain ID (e.g. 1, 8453, 42161)"),
+        },
+    }, async ({ txHash, chainId }) => {
+        try {
+            const text = await queryAction("debug-transaction", { txHash, chainId });
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Debug transaction failed: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+    // ── 6. Polymarket Lookup ────────────────────────────────────────────
+    s.registerTool("b3os_polymarket_lookup", {
+        description: `Search or fetch Polymarket prediction markets. Read-only, no CU cost.
+
+USE CASES:
+- Search markets by keyword (e.g. "bitcoin", "election", "fed rate")
+- Fetch a specific market by slug or URL
+
+INPUTS (provide ONE):
+- query → search markets by keyword
+- slug → fetch a specific market by its slug (the URL path segment)
+- marketUrl → fetch a specific market by its full Polymarket URL
+
+EXAMPLES:
+- { query: "bitcoin 100k" } → search for Bitcoin prediction markets
+- { slug: "will-bitcoin-hit-100k-2025" } → get specific market details
+- { marketUrl: "https://polymarket.com/event/will-bitcoin-hit-100k-2025" } → same, by URL`,
+        inputSchema: {
+            query: z.string().optional().describe("Search keyword(s) for finding markets"),
+            slug: z.string().optional().describe("Market slug (URL path segment)"),
+            marketUrl: z.string().optional().describe("Full Polymarket URL"),
+        },
+    }, async ({ query, slug, marketUrl }) => {
+        try {
+            if (slug || marketUrl) {
+                const payload = {};
+                if (slug)
+                    payload.slug = slug;
+                if (marketUrl)
+                    payload.marketUrl = marketUrl;
+                const text = await queryAction("polymarket-get-market", payload);
+                return { content: [{ type: "text", text }] };
+            }
+            if (query) {
+                const text = await queryAction("polymarket-search-markets", { query });
+                return { content: [{ type: "text", text }] };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Provide `query` to search markets, or `slug`/`marketUrl` to fetch a specific market.",
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Polymarket lookup failed: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/org.d.ts

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

package/dist/tools/org.js

@@ -0,0 +1,29 @@
+import { request } from "../client.js";
+export function registerOrgTools(s) {
+    s.registerTool("b3os_whoami", {
+        description: `Show the organization associated with your B3OS API key. Use this to:
+- Verify the API key is valid and see which org it belongs to
+- Get the orgId needed for b3os_list_wallets
+- Confirm identity before performing operations`,
+    }, async () => {
+        const data = await request("/v1/organizations");
+        const orgs = data?.items || [];
+        if (orgs.length === 0) {
+            return { content: [{ type: "text", text: "No organization found for this API key." }] };
+        }
+        const org = orgs[0];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        id: org.id,
+                        name: org.name,
+                        slug: org.slug,
+                        description: org.description,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/parse-caddie-blocks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse [[ASK]] and [[PLAN]] blocks from Caddie messages and format them
+ * as CLI-friendly instructions.
+ *
+ * [[ASK]] blocks become tool instructions (which MCP tools to call).
+ * [[PLAN]] blocks become reviewable proposals (present to user before approving).
+ */
+/**
+ * Parse [[ASK]] and [[PLAN]] blocks from a Caddie message and format them
+ * as CLI-friendly instructions.
+ *
+ * `callerTool` is the MCP tool name the agent should call when re-submitting
+ * answers or approving the plan (e.g. "b3os_build_workflow" or "b3os_debug_run").
+ *
+ * If no blocks are found, returns the message unchanged.
+ *
+ * ASK and PLAN are mutually exclusive in Caddie's output (the agent must
+ * choose one per response), so ASK takes precedence if both are present.
+ */
+export declare function formatCaddieBlocksForCLI(message: string, callerTool?: string): string;

package/dist/tools/parse-caddie-blocks.js

@@ -0,0 +1,305 @@
+/**
+ * Parse [[ASK]] and [[PLAN]] blocks from Caddie messages and format them
+ * as CLI-friendly instructions.
+ *
+ * [[ASK]] blocks become tool instructions (which MCP tools to call).
+ * [[PLAN]] blocks become reviewable proposals (present to user before approving).
+ */
+const CHAIN_IDS_HINT = "Common chain IDs: 1=Ethereum, 8453=Base, 42161=Arbitrum, 137=Polygon, 10=Optimism, 56=BSC, 7565164=Solana";
+/**
+ * Maps widget types to CLI-friendly tool instructions.
+ * Types not in this map get no tool suggestion (ask user directly).
+ * Update here when adding new widget types that have associated MCP tools.
+ */
+const TOOL_INSTRUCTIONS = {
+    "slack-channel": 'Use `b3os_list_connectors` to find your Slack connector ID (type: "slack"), then `b3os_list_slack_channels` with that connectorId to see available channels.',
+    "telegram-chat": 'Use `b3os_list_connectors` to find your Telegram bot connector ID (type: "telegram-bot"), then `b3os_list_telegram_chats` with that connectorId to see available chats.',
+    "turnkey-wallet": "Use `b3os_whoami` to get your orgId, then `b3os_list_wallets` with that orgId to see available wallets.",
+    "connector-account": (q) => {
+        const connType = q.properties?.connector_type;
+        if (connType) {
+            return `Use \`b3os_list_connectors\` and find a connector with type: "${connType}".`;
+        }
+        return "Use `b3os_list_connectors` to see available connectors.";
+    },
+    "quickbooks-account": 'Use `b3os_list_connectors` to find your QuickBooks connector (type: "quickbooks").',
+    "token-address": "Use `b3os_token_lookup` to resolve a token by name/symbol, or provide the contract address directly.",
+    "token-addresses": "Use `b3os_token_lookup` to resolve tokens by name/symbol, or provide contract addresses directly.",
+    "asset-selector": "Use `b3os_token_lookup` to find the token, or provide the CoinGecko coin ID directly.",
+    "chain-id": CHAIN_IDS_HINT,
+    "chain-ids": CHAIN_IDS_HINT,
+    network: CHAIN_IDS_HINT,
+    networks: CHAIN_IDS_HINT,
+    "polymarket-outcome": 'Use `b3os_polymarket_lookup` to find the market, then provide the answer as JSON: { "market": "<url>", "outcome": "Yes" }',
+    "database-table": (q) => {
+        const tableName = q.properties?.tableName;
+        const columns = q.properties?.columns;
+        const schemaInfo = tableName ? ` Proposed table name: "${tableName}".` : "";
+        const columnInfo = Array.isArray(columns) ? ` Proposed columns: ${JSON.stringify(columns)}.` : "";
+        return (`The table must be created BEFORE the workflow runs — workflow nodes cannot CREATE/ALTER tables.${schemaInfo}${columnInfo} ` +
+            `REVIEW THE SCHEMA: tables should be named by FUNCTION (e.g. "price_alerts", "budgets", "positions"), NOT by workflow (e.g. "eth_price_alert_state"). ` +
+            `Always include a workflow_id TEXT column so multiple workflows can share the table. ` +
+            `If Caddie's proposed name/schema is workflow-specific, suggest a more reusable design to the user before proceeding. ` +
+            `Once the user approves a schema, create the table via \`b3os_query_database\` with CREATE TABLE IF NOT EXISTS, then provide the table name as the answer.`);
+    },
+};
+// JSON repair logic (replicated from apps/b3os-web/utils/parseLLMBlock.ts)
+function repairLLMJSON(json) {
+    let repaired = json.replace(/\r?\n/g, " ");
+    repaired = repaired.replace(/,\s*([}\]])/g, "$1");
+    return repaired;
+}
+function findBracePositions(json, brace) {
+    const positions = [];
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < json.length; i++) {
+        const ch = json[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (!inString && ch === brace)
+            positions.push(i);
+    }
+    return positions;
+}
+function rebalanceBraces(json) {
+    const openPositions = findBracePositions(json, "{");
+    const closePositions = findBracePositions(json, "}");
+    let targets;
+    if (closePositions.length > openPositions.length) {
+        targets = closePositions.slice(0, -1).reverse();
+    }
+    else if (openPositions.length > closePositions.length) {
+        targets = openPositions.slice(1);
+    }
+    else {
+        return null;
+    }
+    for (const pos of targets) {
+        const candidate = json.slice(0, pos) + json.slice(pos + 1);
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // Try next position
+        }
+    }
+    return null;
+}
+// Matches only the first [[ASK]] block — multiple blocks per message are not expected.
+const ASK_BLOCK_REGEX = /\[\[ASK\]\]\s*([\s\S]*?)\s*\[\[\/ASK\]\]/;
+function parseAskBlock(message) {
+    const match = message.match(ASK_BLOCK_REGEX);
+    if (!match) {
+        return { before: message, askBlock: null, after: "" };
+    }
+    const [fullMatch, jsonContent] = match;
+    const matchIndex = match.index;
+    const before = message.slice(0, matchIndex).trim();
+    const after = message.slice(matchIndex + fullMatch.length).trim();
+    let parsed = null;
+    try {
+        parsed = JSON.parse(jsonContent);
+    }
+    catch {
+        const repaired = repairLLMJSON(jsonContent);
+        try {
+            parsed = JSON.parse(repaired);
+        }
+        catch {
+            parsed = rebalanceBraces(repaired);
+        }
+    }
+    return { before, askBlock: parsed, after };
+}
+function getToolInstruction(question) {
+    const entry = TOOL_INSTRUCTIONS[question.type];
+    if (!entry)
+        return null;
+    if (typeof entry === "function")
+        return entry(question);
+    return entry;
+}
+function formatDefault(value) {
+    if (Array.isArray(value))
+        return value.map(String).join(", ");
+    if (typeof value === "object" && value !== null)
+        return JSON.stringify(value);
+    return String(value);
+}
+function formatQuestionBlock(question, index) {
+    const lines = [];
+    const reqMarker = question.required ? " (required)" : "";
+    lines.push(`${index + 1}. **${question.label}**${reqMarker}`);
+    if (question.description) {
+        lines.push(`   ${question.description}`);
+    }
+    const formattedDefault = question.default != null ? formatDefault(question.default) : "";
+    if (formattedDefault) {
+        lines.push(`   Default: ${formattedDefault}`);
+    }
+    if (question.options?.length) {
+        const optLabels = question.options.map(o => o.label || o.value);
+        lines.push(`   Options: ${optLabels.join(", ")}`);
+    }
+    const instruction = getToolInstruction(question);
+    if (instruction) {
+        lines.push(`   -> ${instruction}`);
+    }
+    return lines.join("\n");
+}
+function getAnswerPlaceholder(type) {
+    switch (type) {
+        case "chain-id":
+        case "network":
+            return "<chain ID>";
+        case "chain-ids":
+        case "networks":
+            return "<chain ID>, <chain ID>";
+        case "token-address":
+        case "contract-address":
+        case "address":
+        case "recipient-address":
+            return "<0x...>";
+        case "token-addresses":
+            return "<0x...>, <0x...>";
+        case "turnkey-wallet":
+            return "<wallet address or ID>";
+        case "slack-channel":
+            return "<channel ID>";
+        case "telegram-chat":
+            return "<chat ID>";
+        case "polymarket-outcome":
+            return '<{ "market": "...", "outcome": "Yes" }>';
+        case "boolean":
+            return "<Yes/No>";
+        case "date-time":
+        case "date":
+            return "<ISO 8601>";
+        default:
+            return "<value>";
+    }
+}
+function formatAskBlockForCLI(message, callerTool) {
+    const { before, askBlock, after } = parseAskBlock(message);
+    if (!askBlock?.questions?.length) {
+        return message;
+    }
+    const parts = [];
+    if (before) {
+        parts.push(before);
+        parts.push("");
+    }
+    parts.push("Caddie needs the following information to continue:");
+    parts.push("");
+    const answerLines = [];
+    for (const [i, q] of askBlock.questions.entries()) {
+        if (i > 0)
+            parts.push("");
+        parts.push(formatQuestionBlock(q, i));
+        answerLines.push(`  ${q.label}: ${getAnswerPlaceholder(q.type)}`);
+    }
+    parts.push("");
+    parts.push("IMPORTANT: Present these questions to the user. Do NOT auto-answer them.");
+    parts.push("Only fill in values the user has already provided in this conversation. For any missing value, ask the user directly.");
+    parts.push("If a question has an MCP tool suggestion (-> line), you may run that tool to gather options to present, but still let the user pick.");
+    parts.push("");
+    parts.push(`Once you have the user's answers, call \`${callerTool}\` again with them formatted as:`);
+    parts.push(...answerLines);
+    if (after) {
+        parts.push("");
+        parts.push(after);
+    }
+    return parts.join("\n");
+}
+// Matches only the first [[PLAN]] block.
+const PLAN_BLOCK_REGEX = /\[\[PLAN\]\]\s*([\s\S]*?)\s*\[\[\/PLAN\]\]/;
+function parsePlanBlock(message) {
+    const match = message.match(PLAN_BLOCK_REGEX);
+    if (!match) {
+        return { before: message, planBlock: null, after: "" };
+    }
+    const [fullMatch, jsonContent] = match;
+    const matchIndex = match.index;
+    const before = message.slice(0, matchIndex).trim();
+    const after = message.slice(matchIndex + fullMatch.length).trim();
+    let parsed = null;
+    try {
+        parsed = JSON.parse(jsonContent);
+    }
+    catch {
+        const repaired = repairLLMJSON(jsonContent);
+        try {
+            parsed = JSON.parse(repaired);
+        }
+        catch {
+            parsed = rebalanceBraces(repaired);
+        }
+    }
+    return { before, planBlock: parsed, after };
+}
+function formatPlanBlockForCLI(message, callerTool) {
+    const { before, planBlock, after } = parsePlanBlock(message);
+    if (!planBlock?.changes?.length) {
+        return message;
+    }
+    const parts = [];
+    if (before) {
+        parts.push(before);
+        parts.push("");
+    }
+    parts.push("Caddie proposes the following workflow plan:");
+    parts.push("");
+    if (planBlock.note) {
+        parts.push(planBlock.note);
+        parts.push("");
+    }
+    for (const [i, change] of planBlock.changes.entries()) {
+        const action = change.action.toUpperCase();
+        const nodeType = change.type ? ` (${change.type})` : "";
+        parts.push(`${i + 1}. [${action}] ${change.description}${nodeType}`);
+    }
+    parts.push("");
+    parts.push("IMPORTANT: Present this plan to the user for review. Do NOT auto-approve it.");
+    parts.push(`If the user approves, call \`${callerTool}\` again with "Looks good, build it." to generate the full workflow definition.`);
+    parts.push(`If the user wants changes, call \`${callerTool}\` with their feedback.`);
+    if (after) {
+        parts.push("");
+        parts.push(after);
+    }
+    return parts.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Unified formatter — handles both [[ASK]] and [[PLAN]] blocks
+// ---------------------------------------------------------------------------
+/**
+ * Parse [[ASK]] and [[PLAN]] blocks from a Caddie message and format them
+ * as CLI-friendly instructions.
+ *
+ * `callerTool` is the MCP tool name the agent should call when re-submitting
+ * answers or approving the plan (e.g. "b3os_build_workflow" or "b3os_debug_run").
+ *
+ * If no blocks are found, returns the message unchanged.
+ *
+ * ASK and PLAN are mutually exclusive in Caddie's output (the agent must
+ * choose one per response), so ASK takes precedence if both are present.
+ */
+export function formatCaddieBlocksForCLI(message, callerTool = "b3os_build_workflow") {
+    if (message.includes("[[ASK]]")) {
+        return formatAskBlockForCLI(message, callerTool);
+    }
+    if (message.includes("[[PLAN]]")) {
+        return formatPlanBlockForCLI(message, callerTool);
+    }
+    return message;
+}

package/dist/tools/runs.d.ts

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