@ziggs-ai/ziggs-mcp 0.34.0 → 0.34.1

package/dist/connectionNotices.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Creds } from '@ziggs-ai/api-client';
+export declare function installConnectionNotices(server: McpServer, creds: Creds, version: string): void;
+export declare function readConnectionNotices(server: McpServer, fresh?: boolean): Promise<string[]>;
+export declare function appendConnectionNotices(server: McpServer, name: string, value: unknown, providedNotices?: string[]): Promise<unknown>;

package/dist/connectionNotices.js

@@ -0,0 +1,59 @@
+import { workspaceRouter } from './workspaceRouting.js';
+import { decodeOperatorKeyClaims } from './operatorKey.js';
+import { getBackendUrl } from '@ziggs-ai/api-client';
+const readers = new WeakMap();
+/** A notice changes when the person reconnects or updates; a minute is soon enough. */
+const NOTICE_TTL_MS = 60_000;
+/** The session-start reads always ask the server, so a reconnect shows on the next one. */
+const SESSION_READS = new Set(['ziggs_auth_status', 'ziggs_inbox']);
+export function installConnectionNotices(server, creds, version) {
+    if (!decodeOperatorKeyClaims(creds.operatorKey)?.keyId)
+        return;
+    let cached = null;
+    readers.set(server, async (fresh) => {
+        if (!fresh && cached && Date.now() - cached.readAt < NOTICE_TTL_MS)
+            return cached.notices;
+        try {
+            const response = await fetch(`${getBackendUrl().replace(/\/$/, '')}/oauth/connection-notices`, {
+                headers: { Authorization: `Bearer ${creds.operatorKey}`, 'X-Ziggs-Mcp-Version': version },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok)
+                return cached?.notices ?? [];
+            const body = await response.json();
+            if (body.assistantConnection)
+                workspaceRouter(server)?.activate();
+            const notices = Array.isArray(body.notices) ? body.notices.filter((n) => typeof n === 'string') : [];
+            cached = { readAt: Date.now(), notices };
+            return notices;
+        }
+        catch {
+            return cached?.notices ?? [];
+        } // A notice lookup must never repeat or suppress a tool's write.
+    });
+}
+export async function readConnectionNotices(server, fresh = false) {
+    return await readers.get(server)?.(fresh) ?? [];
+}
+export async function appendConnectionNotices(server, name, value, providedNotices) {
+    const notices = providedNotices ?? await readConnectionNotices(server, SESSION_READS.has(name));
+    if (!notices?.length || !value || typeof value !== 'object')
+        return value;
+    const result = value;
+    const content = (result.content ?? []).map(item => ({ ...item }));
+    if (name === 'ziggs_auth_status' || name === 'ziggs_inbox') {
+        const text = content.find(item => item.type === 'text' && item.text);
+        if (text?.text)
+            try {
+                const payload = JSON.parse(text.text);
+                if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+                    text.text = JSON.stringify({ ...payload, session: { ...payload.session, connectionNotices: notices } });
+                }
+            }
+            catch { /* Non-JSON content still gets the plain sentence below. */ }
+    }
+    for (const notice of notices)
+        if (!content.some(item => item.text === notice))
+            content.push({ type: 'text', text: notice });
+    return { ...value, content };
+}

package/dist/server.js

@@ -1,3 +1,4 @@
+import { installConnectionNotices } from './connectionNotices.js';
 import { installWorkspaceRouting } from './workspaceRouting.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -24,6 +25,7 @@ export function createZiggsMcpServer(creds, cfg) {
         // since both build the server through this factory.
         instructions: renderInstructions(),
     });
+    installConnectionNotices(server, creds, version);
     const routedCreds = installWorkspaceRouting(server, creds);
     registerZiggsTools(server, routedCreds, cfg);
     // Decide what a caller loads natively and what it reaches through

package/dist/strictParams.js

@@ -1,3 +1,4 @@
+import { appendConnectionNotices, readConnectionNotices } from './connectionNotices.js';
 import { workspaceRouter } from './workspaceRouting.js';
 import { z } from 'zod';
 import { recordCatalogEntry } from './toolCatalog.js';
@@ -51,6 +52,11 @@ export function registerStrictTool(server, name, description, shape, annotations
             shape = { ...shape, orgId: shape.orgId?.optional() ?? z.string().optional().describe('Workspace named by your human. Required for new actions when more than one workspace fits.') };
         cb = router.wrap(name, annotations.readOnlyHint === true, cb, nativeOrgId);
     }
+    const routed = cb;
+    cb = (async (...args) => {
+        const notices = await readConnectionNotices(server, name === 'ziggs_auth_status' || name === 'ziggs_inbox');
+        return appendConnectionNotices(server, name, await routed(...args), notices);
+    });
     const params = strictParams(name, shape);
     const handle = server.registerTool(name, {
         title: annotations.title,

package/dist/workspaceRouting.d.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type AssistantWorkspace, type Creds } from '@ziggs-ai/api-client';
 /**
- * One connection, an assistant per workspace, and every tool call acting as
- * exactly one of them.
+ * One assistant identity across workspace hires, with each tool call choosing
+ * the workspace that owns its work.
  *
  * The connection's roster (`GET /oauth/workspaces`) is read once a minute and
  * on every session-start read, so a workspace joined mid-session shows up
@@ -40,12 +40,14 @@ export declare function workspaceRouter(server: McpServer): WorkspaceRouter | un
  */
 export declare function installWorkspaceRouting(server: McpServer, creds: Creds): Creds;
 export declare class WorkspaceRouter {
+    private enabled;
     private readonly active;
     /** The base credentials with `agentId` answered by the call in progress. */
     readonly creds: Creds;
     private readonly client;
     private roster;
-    constructor(base: Creds);
+    constructor(base: Creds, enabled?: boolean);
+    activate(): void;
     acceptsWorkspace(name: string): boolean;
     /** The connection's workspaces, re-read after {@link WORKSPACES_TTL_MS} or on demand. */
     workspaces(fresh?: boolean): Promise<AssistantWorkspace[]>;
@@ -53,6 +55,7 @@ export declare class WorkspaceRouter {
     /** The existing thing a call is about, from the argument that names it. */
     private target;
     wrap(name: string, readOnly: boolean, handler: Handler, nativeOrgId?: boolean): Handler;
+    private wrapConnected;
     /** The connection's own reads and acks: never routed, always live. */
     private connectionTool;
     /**

package/dist/workspaceRouting.js

@@ -47,26 +47,30 @@ export function workspaceRouter(server) {
  * a fleet key with ZIGGS_AGENT_ID) names its agent itself and is left alone.
  */
 export function installWorkspaceRouting(server, creds) {
-    if (!decodeOperatorKeyClaims(creds.operatorKey)?.connectionClientId)
+    const claims = decodeOperatorKeyClaims(creds.operatorKey);
+    if (!claims?.connectionClientId && !claims?.boundAgentId)
         return creds;
-    const router = new WorkspaceRouter(creds);
+    const router = new WorkspaceRouter(creds, !!claims.connectionClientId);
     routers.set(server, router);
     return router.creds;
 }
 export class WorkspaceRouter {
+    enabled;
     active = new AsyncLocalStorage();
     /** The base credentials with `agentId` answered by the call in progress. */
     creds;
     client;
     roster = null;
-    constructor(base) {
+    constructor(base, enabled = true) {
+        this.enabled = enabled;
         this.client = new AssistantConnectionClient(base);
         this.creds = new Proxy(base, {
-            get: (target, key, receiver) => key === 'agentId'
+            get: (target, key, receiver) => key === 'agentId' && this.enabled
                 ? (this.active.getStore()?.agentId ?? '')
                 : Reflect.get(target, key, receiver),
         });
     }
+    activate() { this.enabled = true; }
     acceptsWorkspace(name) {
         return !GLOBAL.has(name) && !CONNECTION.has(name);
     }
@@ -103,6 +107,10 @@ export class WorkspaceRouter {
         return null;
     }
     wrap(name, readOnly, handler, nativeOrgId = false) {
+        const routed = this.wrapConnected(name, readOnly, handler, nativeOrgId);
+        return (args, ...extra) => this.enabled ? routed(args, ...extra) : handler(args, ...extra);
+    }
+    wrapConnected(name, readOnly, handler, nativeOrgId = false) {
         if (GLOBAL.has(name))
             return handler;
         // The routing argument stays out of business payloads; a tool with its own
@@ -204,7 +212,7 @@ export class WorkspaceRouter {
      * already knows, as a fan-out does.
      */
     async run(workspace, args, extra, handler, label = true) {
-        return this.active.run(workspace, async () => {
+        return withAssistantRequest({ orgId: workspace.orgId }, () => this.active.run(workspace, async () => {
             const response = await handler(args, ...extra);
             if (!label || response.isError)
                 return response;
@@ -225,7 +233,7 @@ export class WorkspaceRouter {
                     };
                 }),
             };
-        });
+        }));
     }
 }
 function parseJson(text) {

package/package.json

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