@noodleseed/one 0.185.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/channels/capability-report.js

@@ -3,7 +3,7 @@ const ACCOUNT_SELF_SERVICE = {
     status: 'unavailable',
     code: 'IDENTITY_NOT_ESTABLISHABLE',
     requirement: 'verified_customer',
-    next: 'Account questions are answered as limitations until WhatsApp identity linking ships.',
+    next: 'Account questions are answered as limitations until messaging identity linking ships.',
 };
 export async function capabilityReport(input) {
     const { artifact } = input;

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

@@ -36,11 +36,11 @@ export function createWhatsAppRuntime(options, deps, history) {
             : {}),
     }, deps);
 }
-/** What business routes may do with WhatsApp: read its projection and erase a participant's memory. */
+/** What business routes may do with messaging channels: read each one's projection and erase a participant's memory. */
 export function whatsappBusinessRoutes(whatsapp) {
     return whatsapp
         ? {
-            readWhatsApp: whatsapp.projection.bind(whatsapp),
+            readMessaging: whatsapp.projection.bind(whatsapp),
             forgetWhatsApp: whatsapp.forgetParticipant.bind(whatsapp),
         }
         : {};

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

@@ -172,13 +172,13 @@ export class WhatsAppRuntime {
             throw new ChannelError('pause_before_webhook_change');
         await (await this.provider(binding)).adapter.configureWebhook(this.webhookUrl(req, binding));
     }
-    async projection(tenant) {
-        const binding = await this.channels.get(tenant, 'whatsapp');
+    async projection(tenant, channel) {
+        const binding = await this.channels.get(tenant, channel);
         if (!binding)
             return {
                 status: 'unavailable',
                 capabilities: [],
-                reason: 'WhatsApp is not configured.',
+                reason: `${channel === 'instagram' ? 'Instagram' : 'WhatsApp'} is not configured.`,
             };
         const view = {
             bindingId: binding.id,

package/node_modules/@noodle-borg/service/dist/routes/business-information-channels.js

@@ -59,7 +59,12 @@ export async function projectBusinessChannels(installation, canEdit, base, deps)
     };
     const registered = await deps.registry.getActiveByTenant(tenant);
     const target = registered && (await resolveTargetOrigins(registered));
-    const whatsapp = await deps.readWhatsApp?.(tenant);
+    const [whatsapp, instagram] = await Promise.all([
+        deps.readMessaging?.(tenant, 'whatsapp'),
+        deps.readMessaging?.(tenant, 'instagram'),
+    ]);
+    // Pausing agent channels pauses every messaging channel with them.
+    const intake = (view) => installation.intakeActive ? view : { ...view, status: 'paused' };
     const shared = {
         revision: installation.revision,
         active: installation.intakeActive,
@@ -67,14 +72,8 @@ export async function projectBusinessChannels(installation, canEdit, base, deps)
         ...(deps.pageOrigin
             ? { businessPageUrl: `${deps.pageOrigin}/b/${installation.publicId}` }
             : {}),
-        ...(whatsapp
-            ? {
-                whatsapp: {
-                    ...whatsapp,
-                    ...(!installation.intakeActive ? { status: 'paused' } : {}),
-                },
-            }
-            : {}),
+        ...(whatsapp ? { whatsapp: intake(whatsapp) } : {}),
+        ...(instagram ? { instagram: intake(instagram) } : {}),
     };
     if (!target?.deploymentId)
         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/node_modules/@noodle-borg/wire-contracts/dist/application-channels.d.ts

@@ -49,6 +49,17 @@ export declare const ApplicationChannelsProjectionSchema: z.ZodObject<{
         capabilities: z.ZodArray<z.ZodString>;
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    instagram: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            ready: "ready";
+            paused: "paused";
+        }>;
+        bindingId: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNumber>;
+        capabilities: z.ZodArray<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ApplicationChannelsProjection = z.infer<typeof ApplicationChannelsProjectionSchema>;
 export declare const ApplicationChannelsResponseSchema: z.ZodObject<{
@@ -103,6 +114,17 @@ export declare const ApplicationChannelsResponseSchema: z.ZodObject<{
             capabilities: z.ZodArray<z.ZodString>;
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        instagram: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                ready: "ready";
+                paused: "paused";
+            }>;
+            bindingId: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNumber>;
+            capabilities: z.ZodArray<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export declare const ApplicationChannelsClientResponseSchema: z.ZodObject<{
@@ -133,6 +155,17 @@ export declare const ApplicationChannelsClientResponseSchema: z.ZodObject<{
             capabilities: z.ZodArray<z.ZodString>;
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        instagram: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                ready: "ready";
+                paused: "paused";
+            }>;
+            bindingId: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNumber>;
+            capabilities: z.ZodArray<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         assistant: z.ZodObject<{
             status: z.ZodEnum<{
                 unavailable: "unavailable";

package/node_modules/@noodle-borg/wire-contracts/dist/application-channels.js

@@ -39,7 +39,8 @@ const assistant = z
     usage: usage.optional(),
 })
     .strict();
-const whatsapp = z.strictObject({
+/** One messaging channel (WhatsApp, Instagram) of the application, without provider identifiers. */
+const messaging = z.strictObject({
     status,
     bindingId: z.string().max(256).optional(),
     revision: z.number().int().positive().optional(),
@@ -55,7 +56,8 @@ export const ApplicationChannelsProjectionSchema = z
     deploymentId: z.string().min(1).max(256).optional(),
     mcp,
     assistant,
-    whatsapp: whatsapp.optional(),
+    whatsapp: messaging.optional(),
+    instagram: messaging.optional(),
 })
     .strict();
 export const ApplicationChannelsResponseSchema = z
@@ -66,7 +68,8 @@ export const ApplicationChannelsClientResponseSchema = z
     ok: z.literal(true),
     data: ApplicationChannelsProjectionSchema.extend({
         mcp: mcp.strip(),
-        whatsapp: whatsapp.strip().optional(),
+        whatsapp: messaging.strip().optional(),
+        instagram: messaging.strip().optional(),
         assistant: assistant
             .extend({
             usage: usage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.185.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",