@suveren/gateway 0.7.2 → 0.7.4

package/README.md

@@ -119,7 +119,16 @@ suveren-gateway stop               # stop a detached run
 
 Open `http://localhost:3400`. The MCP server is at `http://localhost:3430`.
 
-To upgrade later: `npm install -g @suveren/gateway@latest && suveren-gateway restart`.
+To upgrade later, run these two commands:
+
+```
+npm install -g @suveren/gateway@latest
+suveren-gateway restart
+```
+
+(Written as two lines on purpose: `&&` is not a valid separator in Windows
+PowerShell 5.1, which is what ships with Windows. Use `;` there if you want
+them on one line.)
 
 ### Connecting an MCP client
 

package/content/integrations/gmail.json

@@ -216,8 +216,7 @@
       "bounds": {
         "recipient_max": "0",
         "send_daily_max": "0",
-        "read_max_age_days": "30",
-        "read_daily_max": "100"
+        "read_max_age_days": "30"
       },
       "context": {
         "allowed_recipients": "",
@@ -227,8 +226,7 @@
       "ttl": 2592000,
       "tags": [
         "read-only",
-        "30 days",
-        "100 reads/day"
+        "30 days"
       ]
     },
     {
@@ -239,8 +237,7 @@
       "bounds": {
         "recipient_max": "5",
         "send_daily_max": "20",
-        "read_max_age_days": "90",
-        "read_daily_max": "200"
+        "read_max_age_days": "90"
       },
       "context": {
         "allowed_recipients": "",

package/dist/control-plane/index.mjs

@@ -685,6 +685,64 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2) {
 
 // src/routes/vault.ts
 import { Router as Router2 } from "express";
+
+// src/lib/credential-meta.ts
+var META_KEY = "__updatedAt";
+var MIN_PREVIEW_LENGTH = 12;
+var PREFIX_RE = /^([A-Za-z][A-Za-z0-9]*(?:[-_][A-Za-z0-9]+)*[-_])/;
+var MAX_PREFIX_LENGTH = 12;
+var HIDDEN_FLOOR = 12;
+function previewSecret(value) {
+  if (value.length < MIN_PREVIEW_LENGTH) return { preview: null };
+  const match = PREFIX_RE.exec(value)?.[1] ?? "";
+  const prefix = match && match.length <= MAX_PREFIX_LENGTH && value.length - match.length - 4 >= HIDDEN_FLOOR ? match : "";
+  if (!prefix && value.length - 4 < 8) return { preview: null };
+  return { preview: `${prefix}\u2026${value.slice(-4)}` };
+}
+var AI_CONFIG_TEXT_FIELDS = /* @__PURE__ */ new Set(["provider", "endpoint", "model"]);
+function textFieldsFor(name, manifests) {
+  if (name === "ai-config") return AI_CONFIG_TEXT_FIELDS;
+  const list = Array.isArray(manifests) ? manifests : [];
+  const manifest = list.find((m) => m?.id === name);
+  const out = /* @__PURE__ */ new Set();
+  for (const f of manifest?.credentials?.fields ?? []) {
+    if (typeof f?.key === "string" && f?.type === "text") out.add(f.key);
+  }
+  return out;
+}
+function credentialView(cred, textFields) {
+  const fields = {};
+  const secrets = {};
+  let updatedAt;
+  for (const [key, value] of Object.entries(cred)) {
+    if (key === META_KEY) {
+      updatedAt = value;
+      continue;
+    }
+    if (textFields.has(key)) fields[key] = value;
+    else secrets[key] = previewSecret(value);
+  }
+  return {
+    configured: true,
+    fieldNames: Object.keys(fields).concat(Object.keys(secrets)),
+    fields,
+    secrets,
+    ...updatedAt ? { updatedAt } : {}
+  };
+}
+
+// src/routes/vault.ts
+var manifestCache = null;
+async function cachedManifests() {
+  if (manifestCache && Date.now() - manifestCache.at < 6e4) return manifestCache.value;
+  try {
+    const m = await getManifests();
+    manifestCache = { at: Date.now(), value: m?.manifests ?? m };
+  } catch {
+    manifestCache = { at: Date.now(), value: [] };
+  }
+  return manifestCache.value;
+}
 function createVaultRouter(vault2) {
   const router = Router2();
   router.get("/status", (_req, res) => {
@@ -696,14 +754,14 @@ function createVaultRouter(vault2) {
       serviceCount: services.length
     });
   });
-  router.get("/credentials/:name", (req, res) => {
+  router.get("/credentials/:name", async (req, res) => {
     const { name } = req.params;
     const cred = vault2.getCredential(name);
     if (!cred) {
       res.json({ configured: false });
       return;
     }
-    res.json({ configured: true, fieldNames: Object.keys(cred), fields: cred });
+    res.json(credentialView(cred, textFieldsFor(name, await cachedManifests())));
   });
   router.put("/credentials/:name", async (req, res) => {
     const { name } = req.params;
@@ -714,6 +772,7 @@ function createVaultRouter(vault2) {
       if (existing) fields = { ...existing, ...incoming };
     } catch {
     }
+    fields = { ...fields, [META_KEY]: (/* @__PURE__ */ new Date()).toISOString() };
     vault2.setCredential(name, fields);
     try {
       await pushServiceCredentials(name, fields);
@@ -806,6 +865,7 @@ function createVaultRouter(vault2) {
 import { Router as Router3 } from "express";
 
 // src/lib/ai-client.ts
+var CHAT_TOKEN_BUDGET = 4e3;
 var PROVIDER_PRESETS = {
   ollama: {
     provider: "ollama",
@@ -833,6 +893,30 @@ var PROVIDER_PRESETS = {
     model: "meta-llama/Llama-3-8b-chat-hf"
   }
 };
+function explainEmptyReply(choice, usage, budget) {
+  const reasoningTokens = usage?.completion_tokens_details?.reasoning_tokens ?? 0;
+  const finish = choice?.finish_reason;
+  const hadReasoning = reasoningTokens > 0 || Boolean(choice?.message?.reasoning_content || choice?.message?.reasoning);
+  if (finish === "length" && hadReasoning) {
+    return `The model is a reasoning model and spent its whole ${budget}-token budget` + (reasoningTokens ? ` (${reasoningTokens} tokens)` : "") + " thinking, leaving nothing for the answer. Raise the token limit or choose a non-reasoning model in Settings.";
+  }
+  if (finish === "length") {
+    return `The model hit the ${budget}-token limit before writing any answer.`;
+  }
+  if (hadReasoning) {
+    return "The model returned only internal reasoning and no answer \u2014 it may not be compatible with this endpoint. Try a different model in Settings.";
+  }
+  if (finish === "content_filter") {
+    return "The provider's content filter blocked the response.";
+  }
+  if (choice?.message?.tool_calls?.length) {
+    return "The model tried to call a tool instead of answering. Choose a model without forced tool use.";
+  }
+  if (!choice) {
+    return "The provider returned no choices. Check the model name in Settings.";
+  }
+  return `The model returned an empty answer${finish ? ` (finish_reason: ${finish})` : ""}.`;
+}
 var SYSTEM_PROMPTS = {
   intent: `You are a reviewing assistant helping a human articulate their intent for an AI agent authorization.
 
@@ -1003,13 +1087,20 @@ ${request.currentText}
           model: config.model,
           messages,
           stream: false,
-          options: { temperature: 0.3, num_predict: 600 }
+          options: { temperature: 0.3, num_predict: CHAT_TOKEN_BUDGET }
         }),
         signal: AbortSignal.timeout(6e4)
       });
       if (!response.ok) throw new Error(`Ollama: ${response.status}`);
       const data = await response.json();
-      reply = data.message?.content?.trim() || "No response generated.";
+      const content = data.message?.content?.trim();
+      if (!content) {
+        return {
+          success: false,
+          error: data.message?.thinking ? "The model returned only internal reasoning and no answer. Try a non-thinking model." : `The model returned an empty answer. Check that "${config.model}" is pulled and running in Ollama.`
+        };
+      }
+      reply = content;
     } else {
       const headers = { "Content-Type": "application/json" };
       if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
@@ -1020,7 +1111,10 @@ ${request.currentText}
           model: config.model,
           messages,
           temperature: 0.3,
-          max_tokens: 600
+          // Reasoning models charge their thinking against this same budget,
+          // so a small number here produces an empty answer rather than a
+          // short one. 4000 leaves room to think AND reply.
+          max_tokens: CHAT_TOKEN_BUDGET
         }),
         signal: AbortSignal.timeout(6e4)
       });
@@ -1029,7 +1123,14 @@ ${request.currentText}
         throw new Error(`AI provider: ${response.status} - ${errorText}`);
       }
       const data = await response.json();
-      reply = data.choices?.[0]?.message?.content?.trim() || "No response generated.";
+      const content = data.choices?.[0]?.message?.content?.trim();
+      if (!content) {
+        return {
+          success: false,
+          error: explainEmptyReply(data.choices?.[0], data.usage, CHAT_TOKEN_BUDGET)
+        };
+      }
+      reply = content;
     }
     return { success: true, reply };
   } catch (error) {
@@ -2327,7 +2428,7 @@ function resolveOrigin(req) {
   return `${req.protocol}://${req.get("host")}`;
 }
 var oauthRedirectUris = /* @__PURE__ */ new Map();
-var manifestCache = null;
+var manifestCache2 = null;
 function resolvePath(obj, path) {
   const v = path.split(".").reduce((acc, key) => {
     return acc && typeof acc === "object" ? acc[key] : void 0;
@@ -2347,15 +2448,15 @@ function decodeJwtEmail(idToken) {
   }
 }
 async function getOAuthManifest(integrationId) {
-  if (!manifestCache) {
+  if (!manifestCache2) {
     try {
       const data = await getManifests();
-      manifestCache = data.manifests;
+      manifestCache2 = data.manifests;
     } catch {
       return null;
     }
   }
-  return manifestCache?.find((m) => m.id === integrationId && m.oauth) ?? null;
+  return manifestCache2?.find((m) => m.id === integrationId && m.oauth) ?? null;
 }
 app.get("/auth/oauth/:integrationId/start", async (req, res) => {
   const { integrationId } = req.params;

package/dist/mcp-server/http.mjs

@@ -137,7 +137,7 @@ var SPClient = class {
    */
   async postReceipt(data) {
     const body = JSON.stringify(data);
-    const maxAttempts = data.idempotencyKey ? this.receiptRetry.maxAttempts : 1;
+    const maxAttempts = data.idempotencyKey || data.proposalId ? this.receiptRetry.maxAttempts : 1;
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       const isLast = attempt === maxAttempts;
@@ -2403,6 +2403,7 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       `[Suveren MCP] Warning: proposal ${proposal.id} has no action_type in executionContext. Bounds check may be skipped. Fix the integration manifest for ${proposal.tool}.`
     );
   }
+  const cachedAuth = state2.cache.getAllAuthorizations().find((a) => a.authorizationId === proposal.authorizationId);
   let receiptId;
   try {
     const binding = computeContentBinding(
@@ -2413,6 +2414,9 @@ async function executeCommitted(proposal, state2, integrationManager2) {
     );
     const { receipt } = await state2.spClient.postReceipt({
       authorizationId: proposal.authorizationId,
+      // Optional cross-check — the AS fails closed on a mismatch. Parity
+      // with the automatic path (tool-proxy.ts).
+      boundsHash: cachedAuth?.boundsHash,
       profileId: proposal.profileId,
       action: proposal.tool,
       actionType: proposalActionType,
@@ -2420,6 +2424,13 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       amount: typeof proposal.executionContext.amount === "number" ? proposal.executionContext.amount : void 0,
       proposalId: proposal.id,
       toolArgs: proposal.toolArgs,
+      // Deliberately NO idempotencyKey: the spec has review-mode commits carry
+      // a proposalId INSTEAD of a key — the proposal's committed→executed
+      // transition is their replay protection, and the AS replays the ORIGINAL
+      // receipt to the same caller if a retry arrives after it committed.
+      // SPClient therefore treats proposalId as retry-safe on its own; a
+      // PROPOSAL_ALREADY_EXECUTED answer is still a definitive rejection
+      // (never retried) and means a *different* caller consumed the proposal.
       ...binding ?? {}
     });
     receiptId = typeof receipt?.id === "string" ? receipt.id : void 0;
@@ -2451,7 +2462,7 @@ async function executeCommitted(proposal, state2, integrationManager2) {
     let outgoingArgs = proposal.toolArgs;
     if (discovered && receiptId) {
       if (shouldAttachFooter()) {
-        outgoingArgs = appendVerificationFooter(discovered, outgoingArgs, receiptId);
+        outgoingArgs = appendVerificationFooter(discovered, outgoingArgs, receiptId, cachedAuth?.subjects?.[0]);
       }
       outgoingArgs = attachReceiptId(discovered, outgoingArgs, receiptId);
       outgoingArgs = encodeOutgoingArgs(discovered, outgoingArgs);
@@ -2672,7 +2683,12 @@ function createMcpServer(state2, integrationManager2) {
       }
     }
     for (const tool of allTools) {
-      if (proxiedTools.has(tool.namespacedName)) continue;
+      const existing = proxiedTools.get(tool.namespacedName);
+      if (existing) {
+        if (existing.tool === tool) continue;
+        existing.registered.remove();
+        proxiedTools.delete(tool.namespacedName);
+      }
       const handler = createGatedToolHandler(tool, integrationManager2, state2);
       const zodShape = jsonSchemaToZodShape(tool.inputSchema);
       const description = buildProxiedToolDescription(tool, state2);
@@ -2869,6 +2885,24 @@ var IntegrationManager = class {
   }
   running = /* @__PURE__ */ new Map();
   onToolsChanged = null;
+  /**
+   * Per-integration operation queue. Start/stop for one id are serialized
+   * through here; without it, a second start issued while the first is still
+   * installing/handshaking sees `running.has(id) === false`, skips the stop,
+   * and both children come up — last `running.set` wins, the loser's process
+   * leaks, and the surviving GATING is whichever start happened to finish
+   * last. That last-writer-wins gating is a fail-open: a permissive manifest
+   * config can silently replace a stricter explicit one (observed as the
+   * read-gate value-mismatch flake).
+   */
+  opQueues = /* @__PURE__ */ new Map();
+  /** Run `task` after every previously queued operation for `id` has settled. */
+  runExclusive(id, task) {
+    const prev = this.opQueues.get(id) ?? Promise.resolve();
+    const run = prev.then(task, task);
+    this.opQueues.set(id, run.then(() => void 0, () => void 0));
+    return run;
+  }
   /**
    * Register a callback invoked when the tool set changes
    * (integration started, stopped, or crashed).
@@ -3018,10 +3052,19 @@ var IntegrationManager = class {
    * Start a downstream MCP server integration.
    * Installs npm package on-demand if needed, resolves envKeys,
    * spawns the process, connects as MCP client, and discovers tools.
+   *
+   * Serialized per id: a start issued while another start/stop for the same
+   * id is in flight waits for it, then applies its own semantics (restart, or
+   * keep-if-running with `skipIfRunning`). See `opQueues`.
    */
-  async startIntegration(config) {
-    if (this.running.has(config.id)) {
-      await this.stopIntegration(config.id);
+  async startIntegration(config, opts = {}) {
+    return this.runExclusive(config.id, () => this.startIntegrationLocked(config, opts));
+  }
+  async startIntegrationLocked(config, opts) {
+    const existing = this.running.get(config.id);
+    if (existing) {
+      if (opts.skipIfRunning) return existing.tools;
+      await this.stopIntegrationLocked(config.id);
     }
     if (config.npmPackage) {
       await this.ensureInstalled(config.npmPackage);
@@ -3076,6 +3119,7 @@ var IntegrationManager = class {
     };
     this.running.set(config.id, entry);
     transport.onclose = () => {
+      if (this.running.get(config.id)?.transport !== transport) return;
       console.error(`[IntegrationManager] Transport closed for ${config.id}`);
       this.handleCrash(config.id);
     };
@@ -3084,8 +3128,15 @@ var IntegrationManager = class {
   }
   /**
    * Stop a running integration, closing its transport and removing its tools.
+   *
+   * Serialized per id: a stop issued while a start is in flight waits and
+   * then stops the just-started instance, instead of silently doing nothing
+   * because the entry wasn't in `running` yet.
    */
   async stopIntegration(id) {
+    return this.runExclusive(id, () => this.stopIntegrationLocked(id));
+  }
+  async stopIntegrationLocked(id) {
     const entry = this.running.get(id);
     if (!entry) return;
     entry.transport.onclose = void 0;
@@ -3308,7 +3359,7 @@ var IntegrationManager = class {
     console.error(`[IntegrationManager] ${id} crashed, respawning in ${delay}ms (attempt ${attempts + 1}/${MAX_RESPAWN_ATTEMPTS})`);
     setTimeout(async () => {
       try {
-        await this.startIntegration(entry.config);
+        await this.startIntegration(entry.config, { skipIfRunning: true });
         const newEntry = this.running.get(id);
         if (newEntry) {
           newEntry.respawnAttempts = attempts + 1;
@@ -3833,7 +3884,7 @@ async function startOneIntegration(config) {
   const manifest = getManifest(config.id);
   const effectiveConfig = manifest ? { ...config, toolGating: manifest.toolGating, npmPackage: manifest.npmPackage ?? config.npmPackage } : config;
   try {
-    await integrationManager.startIntegration(effectiveConfig);
+    await integrationManager.startIntegration(effectiveConfig, { skipIfRunning: true });
   } catch (err) {
     console.error(`[Suveren MCP] Failed to start integration ${config.id}:`, err);
   }