@noodleseed/one 0.186.0 → 0.186.1

package/node_modules/@noodle-borg/admission-limits/dist/in-memory-counter-store.d.ts

@@ -2,13 +2,21 @@ import { type AtomicCounterAttemptOutcome, type AtomicDailyCounterStore, type Co
 /**
  * Process-local counters for local development and tests.
  *
- * `durable` is false, and that is load-bearing rather than informational: the public mint route refuses
- * to serve a surface backed by this store, because a ceiling that resets on every restart and is not
- * shared across instances would look like protection while providing none.
+ * `durable` is false by default, and that is load-bearing rather than informational: public surfaces
+ * (the website mint route, anonymous MCP tool calls) refuse to serve on this store, because a ceiling
+ * that resets on every restart and is not shared across instances would look like protection while
+ * providing none.
+ *
+ * `singleProcess: true` is the caller's claim that exactly one process serves and that losing today's
+ * counts on restart is acceptable, which makes the counters truthfully durable for that host. Only the
+ * local author loop (`noodle dev`) and tests may make that claim.
  */
 export declare class InMemoryDailyCounterStore implements DailyCounterStore, AtomicDailyCounterStore {
     #private;
-    readonly durable = false;
+    readonly durable: boolean;
+    constructor(options?: {
+        readonly singleProcess?: true;
+    });
     consume(request: CounterRequest, now: Date): Promise<CounterOutcome>;
     consumeAll(requests: readonly CounterRequest[], now: Date): Promise<boolean>;
     consumeAllOnce(requests: readonly CounterRequest[], attempt: {

package/node_modules/@noodle-borg/admission-limits/dist/in-memory-counter-store.js

@@ -2,14 +2,22 @@ import { counterRow, dayKey, nextReset, retentionCutoff, } from './counter-store
 /**
  * Process-local counters for local development and tests.
  *
- * `durable` is false, and that is load-bearing rather than informational: the public mint route refuses
- * to serve a surface backed by this store, because a ceiling that resets on every restart and is not
- * shared across instances would look like protection while providing none.
+ * `durable` is false by default, and that is load-bearing rather than informational: public surfaces
+ * (the website mint route, anonymous MCP tool calls) refuse to serve on this store, because a ceiling
+ * that resets on every restart and is not shared across instances would look like protection while
+ * providing none.
+ *
+ * `singleProcess: true` is the caller's claim that exactly one process serves and that losing today's
+ * counts on restart is acceptable, which makes the counters truthfully durable for that host. Only the
+ * local author loop (`noodle dev`) and tests may make that claim.
  */
 export class InMemoryDailyCounterStore {
-    durable = false;
+    durable;
     #used = new Map();
     #receipts = new Map();
+    constructor(options = {}) {
+        this.durable = options.singleProcess === true;
+    }
     async consume(request, now) {
         const row = counterRow(request, now);
         const key = `${row.day}:${row.key}`;

package/node_modules/@noodle-borg/admission-limits/dist/portable.d.ts

@@ -4,6 +4,7 @@ export * from './counter-store.js';
 export * from './envelope.js';
 export * from './in-memory-counter-store.js';
 export * from './public-admission-assertion.js';
+export * from './public-mcp-admission.js';
 export * from './public-record-admission.js';
 export * from './request-attribution.js';
 export * from './visitor-bucket.js';

package/node_modules/@noodle-borg/admission-limits/dist/portable.js

@@ -4,6 +4,7 @@ export * from './counter-store.js';
 export * from './envelope.js';
 export * from './in-memory-counter-store.js';
 export * from './public-admission-assertion.js';
+export * from './public-mcp-admission.js';
 export * from './public-record-admission.js';
 export * from './request-attribution.js';
 export * from './visitor-bucket.js';

package/node_modules/@noodle-borg/admission-limits/dist/public-mcp-admission.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Anonymous callers of a public or mixed MCP app (ADR 0201 §7 applied to MCP).
+ *
+ * The daily ceiling is the solvency bound: it caps what anonymous traffic can spend of the business's
+ * monthly allowance without depending on client-address attribution, which host traffic (ChatGPT,
+ * Claude) makes meaningless. 10,000 a day is about a third of the Free plan's monthly pool per day, so
+ * signed-in callers always keep the rest.
+ */
+export declare const PUBLIC_MCP_ADMISSION_DEFAULTS: Readonly<{
+    anonymousToolCallsPerDay: 10000;
+}>;
+/** One budget per app environment, so a redeploy mid-day does not hand anonymous traffic a fresh one. */
+export declare function anonymousMcpCounterKey(tenant: {
+    readonly org: string;
+    readonly app: string;
+    readonly env: string;
+}): string;
+//# sourceMappingURL=public-mcp-admission.d.ts.map

package/node_modules/@noodle-borg/admission-limits/dist/public-mcp-admission.js

@@ -0,0 +1,16 @@
+/**
+ * Anonymous callers of a public or mixed MCP app (ADR 0201 §7 applied to MCP).
+ *
+ * The daily ceiling is the solvency bound: it caps what anonymous traffic can spend of the business's
+ * monthly allowance without depending on client-address attribution, which host traffic (ChatGPT,
+ * Claude) makes meaningless. 10,000 a day is about a third of the Free plan's monthly pool per day, so
+ * signed-in callers always keep the rest.
+ */
+export const PUBLIC_MCP_ADMISSION_DEFAULTS = Object.freeze({
+    anonymousToolCallsPerDay: 10_000,
+});
+/** One budget per app environment, so a redeploy mid-day does not hand anonymous traffic a fresh one. */
+export function anonymousMcpCounterKey(tenant) {
+    return `mcp-anonymous:${tenant.org}/${tenant.app}/${tenant.env}`;
+}
+//# sourceMappingURL=public-mcp-admission.js.map

package/node_modules/@noodle-borg/module/dist/contract.d.ts

@@ -308,7 +308,7 @@ export type AdmissionDecision = {
 } | {
     readonly allow: false;
     readonly reason: string;
-    readonly status?: 403 | 429;
+    readonly status?: 403 | 429 | 503;
     readonly code?: -32001 | -32002 | -32003;
     readonly policyId?: string;
     readonly policyVersion?: number;

package/node_modules/@noodle-borg/service/dist/admission.js

@@ -1,27 +1,64 @@
-import { PUBLIC_RECORD_ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
+import { anonymousMcpCounterKey, PUBLIC_MCP_ADMISSION_DEFAULTS, PUBLIC_RECORD_ADMISSION_DEFAULTS, } from '@noodle-borg/admission-limits/portable';
 const ANONYMOUS_CONSUMER_LIMIT = PUBLIC_RECORD_ADMISSION_DEFAULTS.networkPerHour;
 const ANONYMOUS_CONSUMER_WINDOW_MS = 60 * 60 * 1000;
-export function createAdmissionGate(anonymousLimiter, audit, extraGate) {
+export function createAdmissionGate(options) {
+    const { counters, audit, extraGate } = options;
+    const now = options.now ?? (() => new Date());
+    const anonymousLimiter = options.anonymousLimiter ?? new AnonymousConsumerLimiter(now);
+    const deny = async (context, decision) => {
+        await emitAdmissionDeny(audit, context, decision.reason, decision.status);
+        return decision;
+    };
     return async (context) => {
         if (extraGate !== undefined) {
             const extra = await extraGate(context);
-            if (!extra.allow) {
-                await emitAdmissionDeny(audit, context, extra.reason, extra.status);
-                return extra;
-            }
+            if (!extra.allow)
+                return deny(context, extra);
         }
         if ((context.accessMode === 'public' || context.accessMode === 'mixed') &&
             context.subject === undefined &&
             context.method === 'tools/call') {
+            // A ceiling that resets on restart and is unshared across instances is no ceiling (ADR 0201 §7),
+            // so anonymous tool calls are refused outright rather than served without one.
+            if (!counters.durable)
+                return deny(context, { allow: false, reason: 'admission_store_not_durable', status: 503 });
             const limited = anonymousLimiter.consume(`${context.routeId}:${context.remoteAddress ?? 'unknown'}`);
-            if (!limited.ok) {
-                await emitAdmissionDeny(audit, context, limited.code, 429);
-                return { allow: false, reason: limited.code, status: 429 };
-            }
+            if (!limited.ok)
+                return deny(context, { allow: false, reason: limited.code, status: 429 });
+            const daily = await consumeAnonymousDaily(counters, context, now());
+            if (daily !== undefined)
+                return deny(context, daily);
         }
         return { allow: true };
     };
 }
+async function consumeAnonymousDaily(counters, context, now) {
+    const tenant = context.org !== undefined && context.app !== undefined && context.env !== undefined
+        ? { org: context.org, app: context.app, env: context.env }
+        : undefined;
+    let outcome;
+    try {
+        outcome = await counters.consume({
+            key: tenant === undefined
+                ? `mcp-anonymous:${context.routeId}`
+                : anonymousMcpCounterKey(tenant),
+            limit: PUBLIC_MCP_ADMISSION_DEFAULTS.anonymousToolCallsPerDay,
+            window: 'day',
+        }, now);
+    }
+    catch {
+        return { allow: false, reason: 'admission_unavailable', status: 503 };
+    }
+    if (outcome.allowed)
+        return undefined;
+    return {
+        allow: false,
+        reason: 'anonymous_daily_quota_exceeded',
+        status: 429,
+        retryAfterSeconds: Math.max(1, Math.ceil((outcome.resetAt.getTime() - now.getTime()) / 1000)),
+        resetAt: outcome.resetAt.toISOString(),
+    };
+}
 async function emitAdmissionDeny(audit, context, reasonCode, status = 403) {
     if (context.org === undefined)
         return;

package/node_modules/@noodle-borg/service/dist/service.js

@@ -5,7 +5,7 @@ import { dispatchKnowledgeRequest } from '@noodle-borg/knowledge-operations/port
 import { capabilityOperatorRoute } from '@noodle-borg/managed-capabilities';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
 import { applySecurityHeaders, createMcpRouter, enforceHttps, noopLogger, sendJson, } from '@noodle-borg/transport-http';
-import { AnonymousConsumerLimiter, createAdmissionGate } from './admission.js';
+import { createAdmissionGate } from './admission.js';
 import { createApplicationServingRuntime } from './application-runtime-target.js';
 import { createArchivePreflight } from './archive-preflight.js';
 import { ArchiveSweeper, resolveArchiveRetentionDays } from './archive-sweeper.js';
@@ -74,13 +74,17 @@ export function createServiceHandler(registry, options = {}) {
     const [intentSettings, intentEvents, requestEvents, intentPreviewOrgs] = createObservabilityStores(options);
     const assistantStore = options.assistantStore ?? new InMemoryAssistantStore();
     const assistantAppearance = options.assistantAppearance ?? new InMemoryAssistantAppearanceSettingsStore();
-    const anonymousLimiter = new AnonymousConsumerLimiter();
     const publicCounters = options.admissionCounters ?? new InMemoryDailyCounterStore();
     const { businessInformationStore, businessInformationSourceStore, sourceCoordinator } = createBusinessInformationRuntime(registry, options, publicCounters);
     const moduleProviders = createServiceModuleProviders({
         options,
         auditMirror: new StdoutAuditSink(logger),
-        admissionGate: createAdmissionGate(anonymousLimiter, { emit: (event) => activeAudit.emit(event) }, options.admissionGate),
+        admissionGate: createAdmissionGate({
+            counters: publicCounters,
+            audit: { emit: (event) => activeAudit.emit(event) },
+            ...(options.admissionGate === undefined ? {} : { extraGate: options.admissionGate }),
+            ...(options.clock === undefined ? {} : { now: options.clock }),
+        }),
     });
     const moduleHost = moduleProviders.host;
     businessInformationStore?.configurePrincipalAuthority(moduleHost.platformHumanIdentity);

package/node_modules/@noodle-borg/transport-http/dist/responses.js

@@ -27,11 +27,13 @@ export function admissionRpcError(context, decision) {
         (decision.status === 429
             ? LEGACY_MCP_ERROR.ADMISSION_QUOTA_EXCEEDED
             : LEGACY_MCP_ERROR.ADMISSION_DENIED);
-    const message = code === LEGACY_MCP_ERROR.ADMISSION_QUOTA_EXCEEDED
-        ? 'Quota exceeded'
-        : code === LEGACY_MCP_ERROR.ADMISSION_RATE_LIMITED
-            ? 'Rate limited'
-            : 'Access denied by policy';
+    const message = decision.status === 503
+        ? 'Admission unavailable, try again shortly'
+        : code === LEGACY_MCP_ERROR.ADMISSION_QUOTA_EXCEEDED
+            ? 'Quota exceeded'
+            : code === LEGACY_MCP_ERROR.ADMISSION_RATE_LIMITED
+                ? 'Rate limited'
+                : 'Access denied by policy';
     const data = { reason: decision.reason };
     if (decision.policyId !== undefined)
         data.policyId = decision.policyId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.186.0",
+  "version": "0.186.1",
   "private": false,
   "description": "Noodle CLI by Noodle Seed — author, run, and deploy declarative MCP servers. Embedding the assistant in your own web app is @noodleseed/assistant.",
   "license": "Apache-2.0",