@suveren/gateway 0.7.3 → 0.7.4

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

@@ -865,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",
@@ -892,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.
 
@@ -1062,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}`;
@@ -1079,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)
       });
@@ -1088,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) {

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);
   }