@ziggs-ai/ziggs-mcp 0.9.11 → 0.9.12

package/dist/mcpConnectionTools.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ZIG-1362 — call a brokered MCP connection from the ziggs-mcp surface.
+ *
+ * Same door the SDK's `mcp_tool_call` / `mcp_tools_list` use
+ * (`POST /connections/:id/mcp`). `ziggs_connection_proxy` cannot: it resolves
+ * a named REST connector from `connection.provider`, and MCP rows are
+ * `provider: 'mcp'`.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { type Creds } from '@ziggs-ai/api-client';
+export declare function resolveMcpGatewayTarget(opts: {
+    connectionId: string;
+    grantId: string;
+    operatorKey: string;
+    agentId: string;
+    baseUrl?: string;
+}): {
+    url: URL;
+    headers: Record<string, string>;
+};
+export declare function resolveMcpConnectionTarget(creds: Creds, connectionId?: string, grantId?: string): Promise<{
+    connectionId: string;
+    grantId: string;
+}>;
+/** Test seam — production always uses the StreamableHTTP client below. */
+export type McpGatewayRunner = <T>(target: {
+    url: URL;
+    headers: Record<string, string>;
+}, run: (client: Client) => Promise<T>) => Promise<T>;
+/** @internal tests only */
+export declare function setMcpGatewayRunnerForTests(runner: McpGatewayRunner | null): void;
+export declare function withMcpGatewayClient<T>(creds: Creds, connectionId: string, grantId: string, run: (client: Client) => Promise<T>): Promise<T>;

package/dist/mcpConnectionTools.js

@@ -0,0 +1,90 @@
+/**
+ * ZIG-1362 — call a brokered MCP connection from the ziggs-mcp surface.
+ *
+ * Same door the SDK's `mcp_tool_call` / `mcp_tools_list` use
+ * (`POST /connections/:id/mcp`). `ziggs_connection_proxy` cannot: it resolves
+ * a named REST connector from `connection.provider`, and MCP rows are
+ * `provider: 'mcp'`.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { ConnectionsClient, getBackendUrl, } from '@ziggs-ai/api-client';
+export function resolveMcpGatewayTarget(opts) {
+    if (!opts.connectionId)
+        throw new Error('connectionId is required');
+    if (!opts.grantId)
+        throw new Error('grantId is required');
+    if (!opts.operatorKey)
+        throw new Error('operatorKey is required');
+    if (!opts.agentId)
+        throw new Error('agentId is required');
+    const baseUrl = (opts.baseUrl || getBackendUrl()).replace(/\/$/, '');
+    return {
+        url: new URL(`${baseUrl}/connections/${encodeURIComponent(opts.connectionId)}/mcp`),
+        headers: {
+            authorization: `Bearer ${opts.operatorKey}`,
+            'x-agent-id': opts.agentId,
+            'x-grant-id': opts.grantId,
+        },
+    };
+}
+export async function resolveMcpConnectionTarget(creds, connectionId, grantId) {
+    if (connectionId && grantId)
+        return { connectionId, grantId };
+    if (!creds.operatorKey)
+        throw new Error('operatorKey is required');
+    if (!creds.agentId)
+        throw new Error('agentId is required');
+    const groups = await new ConnectionsClient(creds.operatorKey, creds.agentId).listForHolder();
+    const live = groups.filter((g) => (g.grants ?? []).length > 0);
+    if (live.length === 0) {
+        throw new Error('No live connection grant. Ask the connection owner to issue one for this agent, then retry.');
+    }
+    const chosen = connectionId
+        ? live.find((g) => g.connectionId === connectionId)
+        : live.length === 1
+            ? live[0]
+            : undefined;
+    if (!chosen) {
+        throw new Error(`Name the connection to use — grants exist on ${live
+            .map((g) => g.connectionId)
+            .join(', ')}`);
+    }
+    const grant = grantId
+        ? (chosen.grants ?? []).find((g) => g.grantId === grantId)
+        : (chosen.grants ?? [])[0];
+    if (!grant) {
+        throw new Error(`No live grant on ${chosen.connectionId} for this agent`);
+    }
+    return { connectionId: chosen.connectionId, grantId: grant.grantId };
+}
+const defaultRunner = async (target, run) => {
+    const transport = new StreamableHTTPClientTransport(target.url, {
+        requestInit: { headers: target.headers },
+    });
+    const client = new Client({ name: 'ziggs-mcp', version: '1.0.0' });
+    try {
+        await client.connect(transport);
+        return await run(client);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+};
+let gatewayRunner = defaultRunner;
+/** @internal tests only */
+export function setMcpGatewayRunnerForTests(runner) {
+    gatewayRunner = runner ?? defaultRunner;
+}
+export async function withMcpGatewayClient(creds, connectionId, grantId, run) {
+    if (!creds.operatorKey || !creds.agentId) {
+        throw new Error('operatorKey and agentId are required');
+    }
+    const target = resolveMcpGatewayTarget({
+        connectionId,
+        grantId,
+        operatorKey: creds.operatorKey,
+        agentId: creds.agentId,
+    });
+    return gatewayRunner(target, run);
+}

package/dist/tools.js

@@ -7,6 +7,7 @@ import { registerPaymentTools } from './paymentTools.js';
 import { formatInboxToolResult, buildReadContextReadPlan, } from './inboxToolResult.js';
 import { agreementAppUrl, filterTasksForDelegate, formatPendingDecisionsPayload, resolveWebAppOrigin, buildPendingNextActions, } from './pendingDecisions.js';
 import { PROTOCOL } from './protocol/delegateProtocol.js';
+import { resolveMcpConnectionTarget, withMcpGatewayClient, } from './mcpConnectionTools.js';
 const RELAY_COORDINATOR_AGENT_ID = 'relay-coordinator';
 function buildRelayCoordinatorTaskBody(opts) {
     const title = opts.title?.trim() || 'Relay coordinator job';
@@ -188,9 +189,10 @@ function registerMarketplaceTools(server, creds) {
 }
 function registerConnectionTools(server, creds) {
     registerCapability(server, connectionProxyCapability, creds);
-    registerStrictTool(server, 'ziggs_connection_list', 'Discover the third-party connections (credentials like GitHub/Jira, NOT agent-to-agent Links — see ziggs_link_list for that) you hold grants for (e.g. "is GitHub connected?") without the owner sharing connectionId/grantId out of band. ' +
+    registerStrictTool(server, 'ziggs_connection_list', 'Discover the third-party connections (credentials like GitHub/Jira, and remote MCP servers — NOT agent-to-agent Links; see ziggs_link_list for that) you hold grants for, without the owner sharing connectionId/grantId out of band. ' +
         'Returns, per connection: connectionId, provider, and the grant(s) you hold — each as the canonical grant shape (grantId, scope, caveats, and grant health active/expired/revoked). ' +
-        'Read-only — never returns credential material. Feed the connectionId + a grantId with health "active" into ziggs_connection_proxy to actually use it.', {}, READ_ONLY, async () => {
+        'Read-only — never returns credential material. ' +
+        'How to use a row: provider "mcp" → ziggs_mcp_tools_list / ziggs_mcp_tool_call; named connectors (github, jira, …) → ziggs_connection_proxy.', {}, READ_ONLY, async () => {
         try {
             const connections = await new ConnectionsClient(creds.operatorKey, creds.agentId).listForHolder();
             return textResult({ connections });
@@ -199,6 +201,75 @@ function registerConnectionTools(server, creds) {
             return toolError(e);
         }
     });
+    // ZIG-1362 — brokered MCP connections (provider: mcp). Not connection_proxy.
+    registerStrictTool(server, 'ziggs_mcp_tools_list', "List the tools a connected MCP server exposes, through the Ziggs gateway — the owner's credential stays server-side. " +
+        'The grant may allow only some of them; a call outside the grant is refused by the gateway. ' +
+        'Omit connectionId/grantId when you hold a grant on exactly one connection.', {
+        connectionId: z
+            .string()
+            .optional()
+            .describe('Connection to inspect. Omit when you hold a grant on exactly one.'),
+        grantId: z
+            .string()
+            .optional()
+            .describe('Grant to use. Omit to use the live grant on that connection.'),
+    }, READ_ONLY, async ({ connectionId, grantId }) => {
+        try {
+            const t = await resolveMcpConnectionTarget(creds, connectionId, grantId);
+            const tools = await withMcpGatewayClient(creds, t.connectionId, t.grantId, async (c) => {
+                const res = await c.listTools();
+                return (res.tools ?? []).map((tool) => ({
+                    name: tool.name,
+                    description: tool.description ?? null,
+                }));
+            });
+            return textResult({
+                connectionId: t.connectionId,
+                grantId: t.grantId,
+                tools,
+            });
+        }
+        catch (e) {
+            return toolError(e);
+        }
+    });
+    registerStrictTool(server, 'ziggs_mcp_tool_call', 'Call one tool on a connected MCP server through the Ziggs gateway. ' +
+        'Use this when the connection provider is a remote MCP server — ziggs_connection_proxy is for named connectors (github, jira) and refuses MCP with "Unknown provider: mcp". ' +
+        "The gateway injects the owner's token and checks the tool name against your grant. Discover names with ziggs_mcp_tools_list.", {
+        tool: z
+            .string()
+            .describe('Tool name on the connected MCP server, e.g. list_issues.'),
+        args: z
+            .record(z.unknown())
+            .optional()
+            .describe("Arguments for that tool, as the server's schema defines them."),
+        connectionId: z
+            .string()
+            .optional()
+            .describe('Connection to call through. Omit when you hold a grant on exactly one.'),
+        grantId: z
+            .string()
+            .optional()
+            .describe('Grant to use. Omit to use the live grant on that connection.'),
+    }, WRITE, async ({ tool, args, connectionId, grantId }) => {
+        try {
+            if (!tool)
+                throw new Error('tool is required');
+            const t = await resolveMcpConnectionTarget(creds, connectionId, grantId);
+            const result = await withMcpGatewayClient(creds, t.connectionId, t.grantId, (c) => c.callTool({
+                name: tool,
+                arguments: args ?? {},
+            }));
+            return textResult({
+                connectionId: t.connectionId,
+                tool,
+                result,
+            });
+        }
+        catch (e) {
+            return toolError(e);
+        }
+    });
     registerCapability(server, requestConnectionCapability, creds);
 }
 export function registerZiggsTools(server, creds, cfg) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/ziggs-mcp",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "description": "MCP server for Claude Code, Cursor, and other MCP hosts \u2014 act as your Ziggs delegate agent",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.9.11",
+    "@ziggs-ai/api-client": "0.9.12",
     "dotenv": "^16.6.1",
     "zod": "^3.24.2"
   },