@blocks-network/mcp-server 0.1.55 → 0.1.62

package/README.md

@@ -2,7 +2,13 @@
 
 MCP (Model Context Protocol) server that exposes Blocks Network consumer operations as tools for AI assistants.
 
-Get API Key: https://app.blocks.ai/manage/api-keys
+## Setup
+
+```bash
+cd mcp
+npm install
+npm run build
+```
 
 ## Environment Variables
 
@@ -15,14 +21,10 @@ All other configuration (keys, endpoints) is resolved automatically from CDM.
 
 ## Installation
 
-```bash
-npm i @blocks-network/mcp-server
-```
-
 ### Claude Code (CLI)
 
 ```bash
-claude mcp add blocks-network -- npx @blocks-network/mcp-server
+claude mcp add blocks-network -- node /path/to/blocks-sdk/mcp/dist/index.js
 ```
 
 Or add to your `.claude/settings.json`:
@@ -31,8 +33,8 @@ Or add to your `.claude/settings.json`:
 {
   "mcpServers": {
     "blocks-network": {
-      "command": "npx",
-      "args": ["@blocks-network/mcp-server"],
+      "command": "node",
+      "args": ["/path/to/blocks-sdk/mcp/dist/index.js"],
       "env": {
         "BLOCKS_API_KEY": "your-api-key"
       }
@@ -49,8 +51,8 @@ Add to your `claude_desktop_config.json`:
 {
   "mcpServers": {
     "blocks-network": {
-      "command": "npx",
-      "args": ["@blocks-network/mcp-server"],
+      "command": "node",
+      "args": ["/path/to/blocks-sdk/mcp/dist/index.js"],
       "env": {
         "BLOCKS_API_KEY": "your-api-key"
       }
@@ -71,8 +73,8 @@ Create an `mcp.json` file:
 {
   "mcpServers": {
     "blocks-network": {
-      "command": "npx",
-      "args": ["@blocks-network/mcp-server"],
+      "command": "node",
+      "args": ["/path/to/blocks-sdk/mcp/dist/index.js"],
       "env": {
         "BLOCKS_API_KEY": "your-api-key"
       }
@@ -89,8 +91,8 @@ Add to your `~/.gemini/settings.json`:
 {
   "mcpServers": {
     "blocks-network": {
-      "command": "npx",
-      "args": ["@blocks-network/mcp-server"],
+      "command": "node",
+      "args": ["/path/to/blocks-sdk/mcp/dist/index.js"],
       "env": {
         "BLOCKS_API_KEY": "your-api-key"
       }

package/dist/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import { resolve, relative } from 'node:path';
-import { realpathSync, statSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { TaskClient, textPart, filePartFromPath, fetchCdmConfig, getAgent, BLOCKS_MAX_UPLOAD_BYTES, } from '@blocks-network/sdk';
+import { listAgentsAuthenticated } from './registry-list.js';
+import { sendTask, getTask, listTasks, cancelTask, listAgents, getAgentCard, connectTask, defaultFileSize, } from './tools.js';
 const ALLOWED_ROOT = process.env.BLOCKS_MCP_FILE_ROOT ?? process.cwd();
 if (!process.env.BLOCKS_API_KEY) {
     console.error('Warning: BLOCKS_API_KEY is not set. Private agents and paid tasks will not work.');
@@ -25,12 +27,6 @@ function validateFilePath(filePath) {
     }
     return real;
 }
-function resolveBillingMode(task) {
-    const mode = task.billingMode;
-    if (mode === 'paid')
-        return 'paid';
-    return 'free';
-}
 const taskClients = new Map();
 let resolvedBaseUrl;
 async function getBaseUrl() {
@@ -44,28 +40,6 @@ async function getBaseUrl() {
     resolvedBaseUrl = cdm.api.baseUrl;
     return resolvedBaseUrl;
 }
-async function listAgentsAuthenticated(opts) {
-    const params = new URLSearchParams({ include: 'full' });
-    if (opts.skill)
-        params.set('skill', opts.skill);
-    if (opts.listing) {
-        params.set('listing', opts.listing);
-        if (opts.listing === 'private')
-            params.set('scope', 'owned');
-    }
-    if (opts.limit)
-        params.set('limit', String(opts.limit));
-    const url = `${opts.baseUrl.replace(/\/+$/, '')}/api/v1/registry/agents?${params}`;
-    const headers = {};
-    if (opts.apiKey)
-        headers['Authorization'] = `Bearer ${opts.apiKey}`;
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
-        throw new Error(`Registry list failed: HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    return data;
-}
 async function getTaskClient(billingMode = 'free') {
     let client = taskClients.get(billingMode);
     if (!client) {
@@ -75,301 +49,57 @@ async function getTaskClient(billingMode = 'free') {
     }
     return client;
 }
+const deps = {
+    getBaseUrl,
+    getApiKey: () => process.env.BLOCKS_API_KEY,
+    getTaskClient,
+    getAgentByName: (agentName, options) => getAgent(agentName, options),
+    listAgents: listAgentsAuthenticated,
+    validateFilePath,
+    fileSize: defaultFileSize,
+    maxUploadBytes: BLOCKS_MAX_UPLOAD_BYTES,
+    filePartFromPath,
+    textPart,
+};
 const server = new McpServer({
     name: 'blocks-network',
-    version: '0.1.0',
+    version: '0.1.60',
 });
-// ============================================================================
-// Tool: send_task
-// ============================================================================
 server.tool('send_task', 'Send a task to a Blocks Network agent and wait for the result', {
     agentName: z.string().describe('Name of the target agent'),
     message: z.string().describe('Text message to send to the agent'),
     filePath: z.string().optional().describe('Optional file path to attach'),
-    inputs: z.record(z.string(), z.string()).optional().describe('Additional named inputs as {partId: value} pairs'),
+    inputs: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Additional named inputs as {partId: value} pairs'),
     taskKind: z.enum(['request', 'pipe']).optional().describe('Task kind (default: request)'),
     duration: z.number().optional().describe('Duration in minutes (required for pipe tasks)'),
-    timeoutMs: z.number().optional().describe('Timeout in milliseconds to wait for result (default: 60000)'),
-}, async ({ agentName, message, filePath, inputs, taskKind, duration, timeoutMs }) => {
-    const baseUrl = await getBaseUrl();
-    const apiKey = process.env.BLOCKS_API_KEY;
-    const entry = await getAgent(agentName, { baseUrl, apiKey });
-    const billingMode = entry?.billingMode ?? 'free';
-    const client = await getTaskClient(billingMode);
-    const declaredInputs = entry?.card?.io?.inputs ?? [];
-    const isTextLike = (ct) => ct.startsWith('text/') || ct === 'application/json' || ct.endsWith('+json');
-    const textInput = declaredInputs.find((i) => isTextLike(i.contentType));
-    const fileInput = declaredInputs.find((i) => !isTextLike(i.contentType));
-    const requestParts = [];
-    const textPartId = textInput?.id ?? 'text';
-    if ((textInput || declaredInputs.length === 0) && !inputs?.[textPartId]) {
-        requestParts.push(textPart(message, textPartId));
-    }
-    if (filePath) {
-        const safePath = validateFilePath(filePath);
-        const fileSize = statSync(safePath).size;
-        if (fileSize > BLOCKS_MAX_UPLOAD_BYTES) {
-            return {
-                content: [{ type: 'text', text: `File too large (${fileSize} bytes). Maximum upload size is ${BLOCKS_MAX_UPLOAD_BYTES} bytes (25 MB).` }],
-                isError: true,
-            };
-        }
-        requestParts.push(await filePartFromPath(safePath, {
-            partId: fileInput?.id ?? 'file',
-            contentType: fileInput?.contentType,
-        }));
-    }
-    if (inputs) {
-        for (const [partId, value] of Object.entries(inputs)) {
-            requestParts.push(textPart(value, partId));
-        }
-    }
-    const session = await client.sendMessage({
-        agentName,
-        requestParts,
-        taskKind,
-        duration,
-    });
-    const timeout = timeoutMs ?? 60000;
-    const results = [];
-    session.onProgress((event) => {
-        if (event.message) {
-            results.push(`[progress] ${event.message}`);
-        }
-    });
-    try {
-        const terminal = await session.waitForTerminal(timeout);
-        const allArtifacts = session.listArtifacts();
-        const output = [`Task ${session.taskId} ${terminal.state}`, ...results];
-        for (const ref of allArtifacts) {
-            try {
-                const downloaded = await session.downloadArtifact(ref);
-                const isText = downloaded.mimeType.startsWith('text/') ||
-                    downloaded.mimeType === 'application/json';
-                if (isText) {
-                    const text = new TextDecoder().decode(downloaded.data);
-                    output.push(`[artifact: ${downloaded.fileName ?? 'unnamed'}]\n${text}`);
-                }
-                else {
-                    output.push(`[artifact: ${downloaded.fileName ?? 'unnamed'}] (${downloaded.mimeType}, ${downloaded.data.length} bytes)`);
-                }
-            }
-            catch {
-                output.push(`[artifact: ${ref.fileName ?? 'unnamed'}] (download failed)`);
-            }
-        }
-        if (terminal.state === 'failed') {
-            output.push(`Error: ${terminal.error ?? terminal.reason ?? 'unknown'}`);
-        }
-        session.close();
-        return { content: [{ type: 'text', text: output.join('\n') }] };
-    }
-    catch (err) {
-        session.close();
-        const msg = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: 'text', text: `Task ${session.taskId} error: ${msg}` }], isError: true };
-    }
-});
-// ============================================================================
-// Tool: get_task
-// ============================================================================
-server.tool('get_task', 'Get the current status of a task by ID, including artifact content if completed', {
-    taskId: z.string().describe('The task ID to look up'),
-}, async ({ taskId }) => {
-    const freeClient = await getTaskClient('free');
-    const task = await freeClient.getTask(taskId);
-    const output = [JSON.stringify(task, null, 2)];
-    const terminalStates = new Set(['completed', 'failed', 'canceled']);
-    if (task.state && terminalStates.has(task.state)) {
-        try {
-            const billingMode = resolveBillingMode(task);
-            const client = await getTaskClient(billingMode);
-            const session = await client.connect({ taskId });
-            const allArtifacts = session.listArtifacts();
-            for (const ref of allArtifacts) {
-                try {
-                    const downloaded = await session.downloadArtifact(ref);
-                    const isText = downloaded.mimeType.startsWith('text/') ||
-                        downloaded.mimeType === 'application/json';
-                    if (isText) {
-                        const text = new TextDecoder().decode(downloaded.data);
-                        output.push(`[artifact: ${downloaded.fileName ?? 'unnamed'}]\n${text}`);
-                    }
-                    else {
-                        output.push(`[artifact: ${downloaded.fileName ?? 'unnamed'}] (${downloaded.mimeType}, ${downloaded.data.length} bytes)`);
-                    }
-                }
-                catch {
-                    output.push(`[artifact: ${ref.fileName ?? 'unnamed'}] (download failed)`);
-                }
-            }
-            session.close();
-        }
-        catch {
-            // connect failed — return task info without artifacts
-        }
-    }
-    return { content: [{ type: 'text', text: output.join('\n') }] };
-});
-// ============================================================================
-// Tool: list_tasks
-// ============================================================================
+    timeoutMs: z
+        .number()
+        .optional()
+        .describe('Timeout in milliseconds to wait for result (default: 60000)'),
+}, (params) => sendTask(params, deps));
+server.tool('get_task', 'Get the current status of a task by ID, including artifact content if completed', { taskId: z.string().describe('The task ID to look up') }, (params) => getTask(params, deps));
 server.tool('list_tasks', 'List tasks, optionally filtered by agent or state', {
     agentName: z.string().optional().describe('Filter by agent name'),
     state: z.string().optional().describe('Filter by state (e.g. completed, failed, running)'),
     limit: z.number().optional().describe('Max results to return'),
-}, async ({ agentName, state, limit }) => {
-    const client = await getTaskClient();
-    const result = await client.listTasks({ agentName, state, limit });
-    const lines = result.tasks.map((t) => `${t.taskId} | ${t.agentName ?? '?'} | ${t.state ?? '?'} | ${t.createdTime ?? ''}`);
-    const header = `Tasks (${result.totalCount ?? result.tasks.length} total):`;
-    return { content: [{ type: 'text', text: [header, ...lines].join('\n') }] };
-});
-// ============================================================================
-// Tool: cancel_task
-// ============================================================================
-server.tool('cancel_task', 'Cancel a running task', {
-    taskId: z.string().describe('The task ID to cancel'),
-}, async ({ taskId }) => {
-    const client = await getTaskClient();
-    await client.cancelTask(taskId);
-    return { content: [{ type: 'text', text: `Task ${taskId} cancelled.` }] };
-});
-// ============================================================================
-// Tool: list_agents
-// ============================================================================
+}, (params) => listTasks(params, deps));
+server.tool('cancel_task', 'Cancel a running task', { taskId: z.string().describe('The task ID to cancel') }, (params) => cancelTask(params, deps));
 server.tool('list_agents', 'List available agents in the Blocks Network registry. Use listing="private" with an API key to discover your private agents.', {
     skill: z.string().optional().describe('Filter by skill name'),
-    listing: z.enum(['public', 'private']).optional().describe('Filter by listing visibility (default: public)'),
+    listing: z
+        .enum(['public', 'private'])
+        .optional()
+        .describe('Filter by listing visibility (default: public)'),
     limit: z.number().optional().describe('Max results to return'),
-}, async ({ skill, listing, limit }) => {
-    const baseUrl = await getBaseUrl();
-    const apiKey = process.env.BLOCKS_API_KEY;
-    const result = await listAgentsAuthenticated({ baseUrl, apiKey, skill, listing, limit });
-    const lines = result.agents.map((a) => {
-        const skills = a.skills?.map((s) => s.name).join(', ') ?? '';
-        return `${a.agentName} | ${a.name ?? a.agentName} | ${a.listing ?? 'public'} | ${skills}`;
-    });
-    const header = `Agents (${result.totalCount ?? result.agents.length}):`;
-    return { content: [{ type: 'text', text: [header, ...lines].join('\n') }] };
-});
-// ============================================================================
-// Tool: get_agent_card
-// ============================================================================
-server.tool('get_agent_card', 'Get the full agent card for a specific agent', {
-    agentName: z.string().describe('Agent name to look up'),
-}, async ({ agentName }) => {
-    const baseUrl = await getBaseUrl();
-    const apiKey = process.env.BLOCKS_API_KEY;
-    const entry = await getAgent(agentName, { baseUrl, apiKey });
-    if (!entry) {
-        return { content: [{ type: 'text', text: `Agent "${agentName}" not found.` }], isError: true };
-    }
-    return { content: [{ type: 'text', text: JSON.stringify(entry.card ?? entry, null, 2) }] };
-});
-// ============================================================================
-// Tool: connect_task
-// ============================================================================
+}, (params) => listAgents(params, deps));
+server.tool('get_agent_card', 'Get the full agent card for a specific agent', { agentName: z.string().describe('Agent name to look up') }, (params) => getAgentCard(params, deps));
 server.tool('connect_task', 'Connect to an existing task, stream events and data until completion', {
     taskId: z.string().describe('The task ID to connect to'),
     timeoutMs: z.number().optional().describe('Timeout in milliseconds (default: 60000)'),
-}, async ({ taskId, timeoutMs }) => {
-    const freeClient = await getTaskClient('free');
-    const task = await freeClient.getTask(taskId);
-    const billingMode = resolveBillingMode(task);
-    const client = await getTaskClient(billingMode);
-    const session = await client.connect({ taskId });
-    const timeout = timeoutMs ?? 60000;
-    const results = [];
-    const streamOutputs = [];
-    const streamDrains = [];
-    session.onProgress((event) => {
-        if (event.message) {
-            results.push(`[progress] ${event.message}`);
-        }
-    });
-    const drainStream = (streamRef) => {
-        const dir = streamRef.descriptor.localDirection;
-        if (dir !== 'inbound' && dir !== 'bidirectional')
-            return;
-        const format = streamRef.descriptor.format;
-        const label = streamRef.descriptor.declaredStream ?? streamRef.descriptor.streamId;
-        const entry = { label, chunks: [] };
-        streamOutputs.push(entry);
-        try {
-            const streamClient = streamRef.open();
-            const drain = (async () => {
-                if (format === 'events') {
-                    for await (const event of streamClient.events()) {
-                        entry.chunks.push(JSON.stringify(event) + '\n');
-                    }
-                }
-                else {
-                    const decoder = new TextDecoder();
-                    for await (const chunk of streamClient.bytes()) {
-                        entry.chunks.push(decoder.decode(chunk, { stream: true }));
-                    }
-                }
-            })();
-            streamDrains.push(drain.catch(() => { }));
-        }
-        catch {
-            // stream already ended or terminal
-        }
-    };
-    for (const ref of session.listStreams()) {
-        drainStream(ref);
-    }
-    session.onStream(drainStream);
-    try {
-        const terminal = await session.waitForTerminal(timeout);
-        await Promise.allSettled(streamDrains);
-        const allArtifacts = session.listArtifacts();
-        results.unshift(`Task ${taskId} ${terminal.state}`);
-        for (const s of streamOutputs) {
-            if (s.chunks.length > 0) {
-                results.push(`[stream: ${s.label}]\n${s.chunks.join('')}`);
-            }
-        }
-        for (const ref of allArtifacts) {
-            try {
-                const downloaded = await session.downloadArtifact(ref);
-                const isText = downloaded.mimeType.startsWith('text/') ||
-                    downloaded.mimeType === 'application/json';
-                if (isText) {
-                    const text = new TextDecoder().decode(downloaded.data);
-                    results.push(`[artifact: ${downloaded.fileName ?? 'unnamed'}]\n${text}`);
-                }
-                else {
-                    results.push(`[artifact: ${downloaded.fileName ?? 'unnamed'}] (${downloaded.mimeType}, ${downloaded.data.length} bytes)`);
-                }
-            }
-            catch {
-                results.push(`[artifact: ${ref.fileName ?? 'unnamed'}] (download failed)`);
-            }
-        }
-        if (terminal.state === 'failed') {
-            results.push(`Error: ${terminal.error ?? terminal.reason ?? 'unknown'}`);
-        }
-        await session.asyncClose();
-        return { content: [{ type: 'text', text: results.join('\n') }] };
-    }
-    catch (err) {
-        await session.asyncClose();
-        const msg = err instanceof Error ? err.message : String(err);
-        const partial = [`Task ${taskId} timed out (${msg})`];
-        for (const s of streamOutputs) {
-            if (s.chunks.length > 0) {
-                partial.push(`[stream: ${s.label}]\n${s.chunks.join('')}`);
-            }
-        }
-        partial.push(...results);
-        return { content: [{ type: 'text', text: partial.join('\n') }], isError: true };
-    }
-});
-// ============================================================================
-// Start server
-// ============================================================================
+}, (params) => connectTask(params, deps));
 function shutdown() {
     for (const client of taskClients.values()) {
         client.destroy();

package/dist/registry-list.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Authenticated registry list helper.
+ *
+ * Calls GET /api/v1/registry/agents with the Blocks-Protocol-Version
+ * header (required by the backend protocol-version middleware) and an
+ * optional Bearer API key for private/owned listings.
+ */
+export declare const PROTOCOL_VERSION_HEADER = "Blocks-Protocol-Version";
+export declare const CURRENT_PROTOCOL_VERSION = "2026-05-01";
+export interface AgentListEntry {
+    agentName: string;
+    name?: string;
+    description?: string;
+    listing?: string;
+    billingMode?: string;
+    skills?: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export interface ListAgentsOptions {
+    baseUrl: string;
+    apiKey?: string;
+    skill?: string;
+    listing?: 'public' | 'private';
+    limit?: number;
+    fetchImpl?: typeof fetch;
+}
+export interface ListAgentsResult {
+    agents: AgentListEntry[];
+    totalCount?: number;
+}
+export declare function listAgentsAuthenticated(opts: ListAgentsOptions): Promise<ListAgentsResult>;

package/dist/registry-list.js

@@ -0,0 +1,33 @@
+/**
+ * Authenticated registry list helper.
+ *
+ * Calls GET /api/v1/registry/agents with the Blocks-Protocol-Version
+ * header (required by the backend protocol-version middleware) and an
+ * optional Bearer API key for private/owned listings.
+ */
+export const PROTOCOL_VERSION_HEADER = 'Blocks-Protocol-Version';
+export const CURRENT_PROTOCOL_VERSION = '2026-05-01';
+export async function listAgentsAuthenticated(opts) {
+    const params = new URLSearchParams({ include: 'full' });
+    if (opts.skill)
+        params.set('skill', opts.skill);
+    if (opts.listing) {
+        params.set('listing', opts.listing);
+        if (opts.listing === 'private')
+            params.set('scope', 'owned');
+    }
+    if (opts.limit)
+        params.set('limit', String(opts.limit));
+    const url = `${opts.baseUrl.replace(/\/+$/, '')}/api/v1/registry/agents?${params}`;
+    const headers = {
+        [PROTOCOL_VERSION_HEADER]: CURRENT_PROTOCOL_VERSION,
+    };
+    if (opts.apiKey)
+        headers['Authorization'] = `Bearer ${opts.apiKey}`;
+    const fetchFn = opts.fetchImpl ?? fetch;
+    const response = await fetchFn(url, { headers });
+    if (!response.ok) {
+        throw new Error(`Registry list failed: HTTP ${response.status}`);
+    }
+    return (await response.json());
+}

package/dist/tools.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Tool handlers for the Blocks Network MCP server.
+ *
+ * Each handler is a pure function that takes its dependencies (clients,
+ * registry helpers, fs/path utilities) so it can be unit-tested without
+ * touching the network or the filesystem.
+ */
+import { textPart, filePartFromPath, type TaskInfo, type SendMessageRequestPart } from '@blocks-network/sdk';
+import type { ListAgentsResult } from './registry-list.js';
+export interface ArtifactRef {
+    fileName?: string;
+}
+export interface DownloadedArtifact {
+    fileName?: string;
+    mimeType: string;
+    data: Uint8Array;
+}
+export interface StreamDescriptor {
+    localDirection: string;
+    format: string;
+    declaredStream?: string;
+    streamId: string;
+}
+export interface StreamClient {
+    events(): AsyncIterable<unknown>;
+    bytes(): AsyncIterable<Uint8Array>;
+}
+export interface StreamRef {
+    descriptor: StreamDescriptor;
+    open(): StreamClient;
+}
+export interface ProgressEvent {
+    message?: string;
+}
+export interface TerminalEvent {
+    state: string;
+    error?: string;
+    reason?: string;
+}
+export interface TaskSessionLike {
+    taskId: string;
+    onProgress(cb: (event: ProgressEvent) => void): unknown;
+    onStream(cb: (ref: StreamRef) => void): unknown;
+    listArtifacts(): ArtifactRef[];
+    listStreams(): StreamRef[];
+    downloadArtifact(ref: ArtifactRef): Promise<DownloadedArtifact>;
+    waitForTerminal(timeoutMs?: number): Promise<TerminalEvent>;
+    close(): void;
+    asyncClose(): Promise<void>;
+}
+export interface TaskClientLike {
+    sendMessage(params: {
+        agentName: string;
+        requestParts: SendMessageRequestPart[];
+        taskKind?: 'request' | 'pipe';
+        duration?: number;
+    }): Promise<TaskSessionLike>;
+    getTask(taskId: string): Promise<TaskInfo>;
+    listTasks(params: {
+        agentName?: string;
+        state?: string;
+        limit?: number;
+    }): Promise<{
+        tasks: TaskInfo[];
+        totalCount?: number;
+    }>;
+    cancelTask(taskId: string): Promise<unknown>;
+    connect(params: {
+        taskId: string;
+    }): Promise<TaskSessionLike>;
+}
+export interface AgentEntryLike {
+    agentName: string;
+    card?: {
+        io?: {
+            inputs?: Array<{
+                id: string;
+                contentType: string;
+            }>;
+        };
+    };
+    billingMode?: 'free' | 'paid';
+}
+export interface ToolResult {
+    [k: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface ToolDeps {
+    getBaseUrl(): Promise<string>;
+    getApiKey(): string | undefined;
+    getTaskClient(billingMode?: 'free' | 'paid'): Promise<TaskClientLike>;
+    getAgentByName(agentName: string, options: {
+        baseUrl: string;
+        apiKey?: string;
+    }): Promise<AgentEntryLike | null>;
+    listAgents(options: {
+        baseUrl: string;
+        apiKey?: string;
+        skill?: string;
+        listing?: 'public' | 'private';
+        limit?: number;
+    }): Promise<ListAgentsResult>;
+    validateFilePath(filePath: string): string;
+    fileSize(path: string): number;
+    maxUploadBytes: number;
+    filePartFromPath: typeof filePartFromPath;
+    textPart: typeof textPart;
+}
+export interface SendTaskParams {
+    agentName: string;
+    message: string;
+    filePath?: string;
+    inputs?: Record<string, string>;
+    taskKind?: 'request' | 'pipe';
+    duration?: number;
+    timeoutMs?: number;
+}
+export interface GetTaskParams {
+    taskId: string;
+}
+export interface ListTasksParams {
+    agentName?: string;
+    state?: string;
+    limit?: number;
+}
+export interface CancelTaskParams {
+    taskId: string;
+}
+export interface ListAgentsParams {
+    skill?: string;
+    listing?: 'public' | 'private';
+    limit?: number;
+}
+export interface GetAgentCardParams {
+    agentName: string;
+}
+export interface ConnectTaskParams {
+    taskId: string;
+    timeoutMs?: number;
+}
+export declare function sendTask(params: SendTaskParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function getTask(params: GetTaskParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function listTasks(params: ListTasksParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function cancelTask(params: CancelTaskParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function listAgents(params: ListAgentsParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function getAgentCard(params: GetAgentCardParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function connectTask(params: ConnectTaskParams, deps: ToolDeps): Promise<ToolResult>;
+export declare function defaultFileSize(path: string): number;