@ziggs-ai/agent-sdk 0.17.0 → 0.18.0

package/dist/mcp/createMcpAgent.js

@@ -1,9 +1,10 @@
-import { resolveWebAppOrigin, connectionsSettingsAppUrl } from '@ziggs-ai/api-client';
+import { resolveWebAppOrigin, connectionsSettingsAppUrl, laneHeader } from '@ziggs-ai/api-client';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { ConnectionsClient, getBackendUrl } from '@ziggs-ai/api-client';
 import { createAgent } from '../Agent.js';
+import { laneFromToolContext } from '../tools/toolCreds.js';
 import { thinkingDefaults } from '../runtime/defaults.js';
 /**
  * Typed failure from the Ziggs MCP gateway. `code` is the stable
@@ -75,8 +76,9 @@ export function resolveZiggsGatewayTarget(config, defaults = {}) {
             // The lane, so the broker can tell who this wake acts for. Until it was
             // sent, this door was the unfenced one: the named-connector proxy states
             // its lane, so the same account and the same grant got two different
-            // answers depending on which door the agent used.
-            ...(defaults.laneId ? { 'x-ziggs-lane': defaults.laneId } : {}),
+            // answers depending on which door the agent used. Built by the shared
+            // helper, because a copy of this header going missing is invisible.
+            ...laneHeader(defaults.laneId),
         },
     };
 }
@@ -110,7 +112,7 @@ export function resolvePerUserGatewayTarget(config, agentId, userId, onBehalfOfA
             // uses this agreement to resolve the delegation root's user.
             ...(onBehalfOfAgreementId ? { 'x-on-behalf-of-agreement': onBehalfOfAgreementId } : {}),
             // The lane, for the same reason as the path-id door above.
-            ...(laneId ? { 'x-ziggs-lane': laneId } : {}),
+            ...laneHeader(laneId),
         },
     };
 }
@@ -135,6 +137,15 @@ export function buildTransport(config, defaults = {}) {
         });
     }
     if (config.type === 'ziggs') {
+        /**
+         * No lane, and there cannot be one: this client is built ONCE at boot and
+         * shared by every wake, so any lane baked into its headers would be the
+         * wrong one for all but the first. The `ziggs` transport is the legacy
+         * fleet entry (`scripts/run-mcp-fleet.ts`) — a fixed connection + grant the
+         * operator configured for itself, so the lane-less fence (its own estate)
+         * is the right answer for it. A per-lane client belongs to `ziggs-per-user`,
+         * which builds one per wake and states the lane there.
+         */
         const target = resolveZiggsGatewayTarget(config, defaults);
         return new StreamableHTTPClientTransport(target.url, {
             requestInit: { headers: target.headers },
@@ -341,14 +352,17 @@ export async function createMcpAgent(options) {
         }
         const tools = capTools(toolSchema, agentId, maxTools, extraTools.length, allowedTools);
         const clients = new Map();
-        const clientFor = (userId, onBehalfOfAgreementId) => {
-            // Key by user + agreement: the gateway may resolve a different end-user
-            // per agreement (delegation), so sessions must not be shared across them.
-            const cacheKey = `${userId}|${onBehalfOfAgreementId ?? ''}`;
+        const clientFor = (userId, onBehalfOfAgreementId, laneId) => {
+            // Key by user + agreement + lane: the gateway may resolve a different
+            // end-user per agreement (delegation), and the lane decides which party's
+            // grants this session may spend, so sessions must not be shared across
+            // any of the three. The headers are fixed when the transport is built,
+            // so a session reused across lanes would carry the first lane's fence.
+            const cacheKey = `${userId}|${onBehalfOfAgreementId ?? ''}|${laneId ?? ''}`;
             let p = clients.get(cacheKey);
             if (!p) {
                 p = (async () => {
-                    const target = resolvePerUserGatewayTarget(transportConfig, agentId, userId, onBehalfOfAgreementId);
+                    const target = resolvePerUserGatewayTarget(transportConfig, agentId, userId, onBehalfOfAgreementId, laneId);
                     const transport = new StreamableHTTPClientTransport(target.url, {
                         requestInit: { headers: target.headers },
                         fetch: wrapGatewayFetch(),
@@ -410,6 +424,14 @@ export async function createMcpAgent(options) {
             // connection-owning end-user; pass the agreement so the gateway resolves
             // the delegation root's user.
             const onBehalfOfAgreementId = typeof context.onBehalfOfAgreementId === 'string' ? context.onBehalfOfAgreementId : undefined;
+            /**
+             * The lane this wake runs in, read the same way every tool reads it.
+             * Without it the relay states no lane, the gateway resolves the wake to
+             * the agent's own operator, and any grant the CUSTOMER gave is refused —
+             * on the door built for exactly that case. Omitting a lane can only
+             * narrow reach, never widen it, so the miss never raises.
+             */
+            const laneId = laneFromToolContext(context);
             // (B): per-user resolution is intermittently flaky even when the
             // connection is valid and resolvable — the same on-behalf call fails with
             // NO_USER_CONNECTION on one wake and succeeds on the next. clientFor never
@@ -420,7 +442,7 @@ export async function createMcpAgent(options) {
             let lastErr;
             for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
                 try {
-                    const c = await clientFor(userId, onBehalfOfAgreementId);
+                    const c = await clientFor(userId, onBehalfOfAgreementId, laneId);
                     return (await c.callTool({ name, arguments: args }));
                 }
                 catch (err) {

package/dist/platform/tools/tier2/mcpConnectionTools.js

@@ -2,6 +2,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { ConnectionsClient } from '@ziggs-ai/api-client';
 import { defineTool } from '../../../tools/defineTool.js';
+import { credsFromToolContext } from '../../../tools/toolCreds.js';
 import { resolveZiggsGatewayTarget } from '../../../mcp/createMcpAgent.js';
 /**
  * Calling a tool on a connected MCP server, one shot.
@@ -24,19 +25,20 @@ import { resolveZiggsGatewayTarget } from '../../../mcp/createMcpAgent.js';
  * no argument to guess; several means the caller must name one, because picking
  * for them is how an agent reads the wrong workspace and reports it as fact.
  */
-async function resolveTarget(ctx, connectionId, grantId) {
+async function resolveTarget(ctx, toolName, connectionId, grantId) {
     if (connectionId && grantId)
         return { connectionId, grantId };
-    const operatorKey = ctx['operatorKey'];
-    const agentId = ctx['agentId'];
-    if (!operatorKey)
-        throw new Error('operatorKey missing from tool context');
-    if (!agentId)
-        throw new Error('agentId missing from tool context');
+    const creds = credsFromToolContext(ctx, toolName);
+    // The lane belongs here as much as on the call itself: the grant list answers
+    // for the party the wake acts for, so a lane-less list is the agent's OWN
+    // grants only — and this is the path that PICKS one when the caller named no
+    // connection. Without it a hired agent discovers nothing and reports "no live
+    // connection grant" while holding its customer's.
+    //
     // No explicit baseUrl: ConnectionsClient already resolves it the way the fleet
     // configures it (HTTP_URL). Passing BACKEND_URL here was the same mistake as in
     // the transport — undefined in deployment.
-    const groups = await new ConnectionsClient(operatorKey, agentId).listForHolder();
+    const groups = await new ConnectionsClient(creds.operatorKey, creds.agentId, undefined, creds.laneId).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.');
@@ -59,16 +61,25 @@ async function resolveTarget(ctx, connectionId, grantId) {
     }
     return { connectionId: chosen.connectionId, grantId: grant.grantId };
 }
-async function withClient(ctx, connectionId, grantId, run) {
+async function withClient(ctx, toolName, connectionId, grantId, run) {
+    /**
+     * The lane comes from `credsFromToolContext`, the same reader every other
+     * tool uses. Reading it off a field of its own (`ctx.laneId`) is how this
+     * door came to send no lane at all: the executor states the lane as
+     * `chatId` / `sessionId`, so a key by any other name is always undefined,
+     * and the gateway then resolves the wake to the agent's own operator and
+     * refuses every grant its customer gave it.
+     */
+    const creds = credsFromToolContext(ctx, toolName);
     const target = resolveZiggsGatewayTarget({
         type: 'ziggs',
         connectionId,
         grantId,
-        operatorKey: ctx['operatorKey'],
-        agentId: ctx['agentId'],
+        operatorKey: creds.operatorKey,
+        agentId: creds.agentId,
     }, {
-        agentId: ctx['agentId'],
-        laneId: ctx['laneId'],
+        agentId: creds.agentId,
+        laneId: creds.laneId,
     });
     const transport = new StreamableHTTPClientTransport(target.url, {
         requestInit: { headers: target.headers },
@@ -98,7 +109,7 @@ export const mcpToolsListTool = defineTool('mcp_tools_list', {
         description: 'Tool names to return the FULL parameters (inputSchema) for. Omit to get the names and descriptions only — a whole server of schemas is tens of thousands of characters and gets cut, which is worse than not asking.',
     },
 }, async (args, ctx) => {
-    const t = await resolveTarget(ctx, args['connectionId'], args['grantId']);
+    const t = await resolveTarget(ctx, 'mcp_tools_list', args['connectionId'], args['grantId']);
     /**
      * Names first, schemas on demand — the same two-step this platform's own MCP
      * surface settled on. One Linear server answers 53 tools and 78,000
@@ -107,7 +118,7 @@ export const mcpToolsListTool = defineTool('mcp_tools_list', {
      * that survives still looks complete.
      */
     const wanted = args['names']?.filter((n) => typeof n === 'string' && n);
-    const tools = await withClient(ctx, t.connectionId, t.grantId, async (c) => {
+    const tools = await withClient(ctx, 'mcp_tools_list', t.connectionId, t.grantId, async (c) => {
         const res = await c.listTools();
         const rows = res.tools ?? [];
         const picked = wanted?.length ? rows.filter((tool) => wanted.includes(tool.name)) : rows;
@@ -253,8 +264,8 @@ export const mcpToolCallTool = defineTool('mcp_tool_call', {
     const name = args['tool'];
     if (!name)
         throw new Error('tool is required');
-    const t = await resolveTarget(ctx, args['connectionId'], args['grantId']);
-    const raw = await withClient(ctx, t.connectionId, t.grantId, (c) => c.callTool({
+    const t = await resolveTarget(ctx, 'mcp_tools_list', args['connectionId'], args['grantId']);
+    const raw = await withClient(ctx, 'mcp_tool_call', t.connectionId, t.grantId, (c) => c.callTool({
         name,
         arguments: args['args'] ?? {},
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.16.0",
+    "@ziggs-ai/api-client": "0.17.0",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",