@ultimat3/mcp 15.0.0 → 17.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/mcp",
-  "version": "15.0.0",
+  "version": "17.0.0",
   "description": "MCP server, dev tools, and the action-to-tool projection \u2014 one authz system, two surfaces",
   "license": "MIT",
   "type": "module",
@@ -31,13 +31,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "15.0.0",
-    "@ultimat3/core": "15.0.0",
-    "@ultimat3/entity": "15.0.0",
-    "@ultimat3/http": "15.0.0",
-    "@ultimat3/jobs": "15.0.0",
-    "@ultimat3/policy": "15.0.0",
-    "@ultimat3/query": "15.0.0",
-    "@ultimat3/schema": "15.0.0"
+    "@ultimat3/action": "17.0.0",
+    "@ultimat3/core": "17.0.0",
+    "@ultimat3/entity": "17.0.0",
+    "@ultimat3/http": "17.0.0",
+    "@ultimat3/jobs": "17.0.0",
+    "@ultimat3/policy": "17.0.0",
+    "@ultimat3/query": "17.0.0",
+    "@ultimat3/schema": "17.0.0"
   }
 }

package/src/query-limits.ts

@@ -2,6 +2,8 @@
 // it may come back. A cap the caller cannot raise, applied where the tool cannot forget it —
 // `limit` is an argument, and an argument is a request, never a permission.
 
+import { finiteCount } from '@ultimat3/core';
+
 /** The ceilings. Frozen because a cap a caller can widen is a default, not a cap. */
 export interface QueryLimits {
   /** Hard row ceiling. A larger `limit` argument is clamped, not honoured. */
@@ -84,14 +86,22 @@ function rowBytes(row: readonly unknown[]): number {
  * what to do next: select fewer columns.
  */
 export function capQueryRows(source: QueryRows, limits: QueryLimits): QueryResult {
-  const overRows = source.rows.length > limits.maxRows;
+  // `QueryLimits` is a PUBLIC type and this is the one path `resolveQueryLimits` cannot defend: a
+  // ceilings object built by hand. `slice(0, NaN)` is `[]` and `length > NaN` is false, so the
+  // agent would be handed zero rows with `truncated: false` — an empty table reported as the
+  // complete answer — and `bytes + size > NaN` would switch the 256 KiB context guard off entirely.
+  // `maxRows` floors at 1 because `resolveQueryLimits` already refuses to build anything lower;
+  // `maxBytes` floors at 0, where nothing in this package claims a floor.
+  const maxRows = finiteCount('capQueryRows', 'limits.maxRows', limits.maxRows, 1);
+  const maxBytes = finiteCount('capQueryRows', 'limits.maxBytes', limits.maxBytes, 0);
+  const overRows = source.rows.length > maxRows;
   const kept: (readonly unknown[])[] = [];
   let bytes = 2; // the enclosing `[]`
   let overBytes = false;
 
-  for (const row of source.rows.slice(0, limits.maxRows)) {
+  for (const row of source.rows.slice(0, maxRows)) {
     const size = rowBytes(row);
-    if (bytes + size > limits.maxBytes) {
+    if (bytes + size > maxBytes) {
       overBytes = true;
       break;
     }
@@ -108,6 +118,6 @@ export function capQueryRows(source: QueryRows, limits: QueryLimits): QueryResul
     // ceiling would also have applied further down.
     truncatedBy: overBytes ? 'bytes' : overRows ? 'rows' : null,
     bytes,
-    guards: [...source.guards, `cap:${limits.maxRows} rows`, `cap:${limits.maxBytes} bytes`],
+    guards: [...source.guards, `cap:${maxRows} rows`, `cap:${maxBytes} bytes`],
   };
 }

package/src/transport-http.ts

@@ -20,7 +20,7 @@
 //     refuse what a human would be allowed.
 
 import type { Actor, Clock } from '@ultimat3/core';
-import { readWithinLimit, systemClock } from '@ultimat3/core';
+import { finiteCount, readWithinLimit, systemClock } from '@ultimat3/core';
 import type { RateLimitStore } from '@ultimat3/http';
 import { memoryRateLimitStore, toBucket } from '@ultimat3/http';
 import { McpRateLimitedError } from './errors';
@@ -91,7 +91,17 @@ const JSON_HEADERS = { 'content-type': 'application/json' } as const;
 
 export function mcpHttpRoute(input: McpHttpTransportInput): McpRouteDescriptor {
   const { server } = input;
-  const bodyLimitBytes = input.bodyLimitBytes ?? DEFAULT_MCP_BODY_LIMIT_BYTES;
+  // At CONSTRUCTION, beside the two buckets and for the same reason: `readWithinLimit` refuses a
+  // non-finite cap, but it does so on the first request an agent makes and only after
+  // `resolveToken` has run — a number that cannot be enforced must fail where an author can act on
+  // it. Floor of 0 because `@ultimat3/http`'s `bodyLimitBytes` accepts 0, and these two must not
+  // answer one question two ways.
+  const bodyLimitBytes = finiteCount(
+    'mcpHttpRoute',
+    'bodyLimitBytes',
+    input.bodyLimitBytes ?? DEFAULT_MCP_BODY_LIMIT_BYTES,
+    0,
+  );
   const limits = input.rateLimits ?? MCP_RATE_LIMITS;
   const clock = input.clock ?? systemClock;
   const store = input.rateLimitStore ?? memoryRateLimitStore();

package/src/transport-stdio.ts

@@ -8,6 +8,7 @@
 // stdout is the WIRE. Anything logged there corrupts the protocol, so diagnostics go to
 // stderr and this file never calls `console.log`.
 
+import { finiteCount } from '@ultimat3/core';
 import type { McpCaller } from './registry';
 import type { McpServer } from './server';
 import { errorResponse, INVALID_REQUEST, PARSE_ERROR } from './wire';
@@ -41,7 +42,16 @@ export interface StdioTransportInput {
 export async function serveStdio(config: StdioTransportInput): Promise<void> {
   const stream = config.input ?? Bun.stdin.stream();
   const write = config.write ?? defaultWrite;
-  const limit = config.lineLimitBytes ?? DEFAULT_STDIO_LINE_LIMIT;
+  // Before a byte of stdin is read, because `line.length > NaN` is false for EVERY line: the cap
+  // would not be a large one, it would be absent, and the buffer it bounds grows until the process
+  // dies. `??` cannot screen it — `NaN` is not nullish. Floor of 1: a cap of 0 refuses every
+  // message there is, which is a dead transport rather than a bound.
+  const limit = finiteCount(
+    'serveStdio',
+    'lineLimitBytes',
+    config.lineLimitBytes ?? DEFAULT_STDIO_LINE_LIMIT,
+    1,
+  );
   const decoder = new TextDecoder();
   let buffer = '';
   // The rest of an over-long message is dropped, not parsed: whatever follows it on the same line