akanjs 3.0.0-alpha.100 → 3.0.0-alpha.102

package/common/TrustedProxy.ts

@@ -51,9 +51,14 @@ export class TrustedProxy {
   /**
    * The caller's address as recorded by a proxy, but only when the peer is one. Falls back to the peer itself,
    * which is the right answer for a process nothing is proxying, and `null` when there is no peer either.
+   *
+   * `null` and `undefined` mean different things here. `null` is what `Server.requestIP` answers for a socket
+   * that has no address — a unix socket, which is how a gateway reaches its children — and only a process on
+   * this machine can open one, so the headers it wrote are a local proxy's and are believed. `undefined` is
+   * "nobody asked": no resolver was registered, and a header from an unknown peer is a header the client wrote.
    */
   static clientAddress(headers: Headers, peerAddress: string | null | undefined): string | null {
-    if (TrustedProxy.isTrusted(peerAddress)) {
+    if (peerAddress === null || TrustedProxy.isTrusted(peerAddress)) {
       const realIp = headers.get("x-real-ip")?.trim();
       if (realIp) return normalizeIpAddress(realIp);
       const forwarded = headers.get("x-forwarded-for")?.split(",")[0]?.trim();
@@ -62,6 +67,23 @@ export class TrustedProxy {
     return peerAddress ? normalizeIpAddress(peerAddress) : null;
   }
 
+  /**
+   * Whether an address is one no public name should resolve to: the local ranges `isTrusted` reads, plus the
+   * unspecified address, the carrier-grade NAT block `100.64/10`, multicast and the reserved top of IPv4. Used
+   * to refuse a fetch whose destination a caller chose by name, so it judges the address alone and never the
+   * configured proxy list — a trusted proxy is still not somewhere to send an outbound request.
+   */
+  static isPrivateAddress(address: string): boolean {
+    const bytes = TrustedProxy.#toBytes(normalizeIpAddress(address));
+    if (!bytes) return true;
+    if (TrustedProxy.#isLocalRange(bytes)) return true;
+    if (bytes.length === 4) {
+      const [a = 0, b = 0] = bytes;
+      return a === 0 || (a === 100 && b >= 64 && b <= 127) || a >= 224;
+    }
+    return bytes.every((byte) => byte === 0) || bytes[0] === 0xff;
+  }
+
   /** `10/8`, `172.16/12`, `192.168/16`, `127/8`, `169.254/16`, and their IPv6 counterparts `::1`, `fc00::/7`, `fe80::/10`. */
   static #isLocalRange(bytes: Uint8Array): boolean {
     if (bytes.length === 4) {

package/common/mcpExposure.ts

@@ -17,6 +17,8 @@ export interface McpExposureEndpoint {
   guards?: string[];
   fileUpload?: boolean;
   mcp?: boolean;
+  /** `false` when a guard declares `static agents = false`: no model may ever pass, whatever else the guards say. */
+  agents?: boolean;
 }
 
 export interface McpExposureOption {
@@ -68,6 +70,9 @@ export const mcpRefusalOf = (
   if (endpoint.mcp === false)
     return "it declares `mcp: false`, so it is deliberately off the agent shelf. HTTP still serves it.";
 
+  if (endpoint.agents === false)
+    return `its guards (${(endpoint.guards ?? []).join(", ")}) admit no agent — an act reserved for a person, so it is off the agent shelf. HTTP still serves it.`;
+
   if (!endpoint.guards?.length)
     return "it declares no guards, and exposure follows them — write `guards: [Public]` if anonymous access is the intent.";
 

package/constant/cascadePaths.ts

@@ -6,8 +6,10 @@ import type { ConstantModelRef } from "./via";
  * Which end of a relation goes away with the other. `removeRef` removes what the field points at when this
  * document is removed; `removeWith` removes this document when what the field points at is removed. The two
  * read identically on a relation field, so the value has to name the direction — a mistake here is a data loss.
+ * `removeWithAny` is `removeWith` over an owner that is unknowable at build time, and it names the whole
+ * decision in one value so the widening cannot be declared apart from the direction it widens.
  */
-export const cascadeActions = ["removeRef", "removeWith"] as const;
+export const cascadeActions = ["removeRef", "removeWith", "removeWithAny"] as const;
 export type CascadeAction = (typeof cascadeActions)[number];
 
 /** How a `removeWith` field names the owner whose removal takes this document with it. */
@@ -21,7 +23,7 @@ export interface CascadeWithPath {
   readonly typeKey: string | null;
   /** The refNames `typeKey` may hold. Empty unless the field is polymorphic over an enum. */
   readonly typeValues: readonly string[];
-  /** Set by `polymorphic: "any"`: `typeKey` is free-form, so the owner is whatever refName the row holds. */
+  /** Set by `cascade: "removeWithAny"`: `typeKey` is free-form, so the owner is whatever refName the row holds. */
   readonly anyOwner: boolean;
 }
 
@@ -35,7 +37,6 @@ export class CascadePaths {
 
   collect(fieldMap: FieldObject) {
     for (const [key, field] of Object.entries(fieldMap)) {
-      this.#assertPolymorphicIsWiredUp(key, field);
       if (!field.cascade) continue;
       this.#assertKnownAction(key, field.cascade);
       if (field.cascade === "removeRef") this.removeRef.set(key, this.#readOwnedRelation(key, field));
@@ -44,16 +45,6 @@ export class CascadePaths {
     return this;
   }
 
-  /** `polymorphic` widens one thing and nothing else, so anywhere else it is a declaration that does nothing. */
-  #assertPolymorphicIsWiredUp(key: string, field: ConstantField) {
-    if (!field.polymorphic) return;
-    if (field.cascade === "removeWith" && field.refPath) return;
-    throw new Error(
-      `Field "${key}" declares polymorphic: "${field.polymorphic}", which only widens a ` +
-        `cascade: "removeWith" field that names its owner type with refPath`,
-    );
-  }
-
   #assertKnownAction(key: string, action: CascadeAction) {
 
     if (!cascadeActions.includes(action)) {
@@ -74,7 +65,15 @@ export class CascadePaths {
 
     if (field.arrDepth > 0) throw new Error(`Cascade field "${key}" is an array and names more than one owner`);
     if (field.isMap) throw new Error(`Cascade field "${key}" is a Map and names no owner`);
-    if (field.refPath) return this.#readPolymorphicOwner(key, field, fieldMap);
+    const anyOwner = field.cascade === "removeWithAny";
+    if (field.refPath) return this.#readPolymorphicOwner(key, field, fieldMap, anyOwner);
+    
+    if (anyOwner) {
+      throw new Error(
+        `Cascade field "${key}" declares cascade: "removeWithAny" and must name the field holding the owner's ` +
+          `refName with refPath: "<typeField>"`,
+      );
+    }
     if (field.ref) {
       this.#assertHoldsId(key, field);
       return { key, modelRef: null, refName: field.ref, typeKey: null, typeValues: [], anyOwner: false };
@@ -88,18 +87,18 @@ export class CascadePaths {
     );
   }
 
-  #readPolymorphicOwner(key: string, field: ConstantField, fieldMap: FieldObject): CascadeWithPath {
+  #readPolymorphicOwner(key: string, field: ConstantField, fieldMap: FieldObject, anyOwner: boolean): CascadeWithPath {
     if (field.ref) throw new Error(`Cascade field "${key}" declares both ref and refPath; keep one`);
     this.#assertHoldsId(key, field);
     const typeKey = field.refPath as string;
     const typeField = fieldMap[typeKey];
     if (!typeField) throw new Error(`Cascade field "${key}" declares refPath: "${typeKey}", which is not a field`);
-    if (field.polymorphic === "any") return this.#readAnyOwner(key, typeKey, typeField);
+    if (anyOwner) return this.#readAnyOwner(key, typeKey, typeField);
 
     if (!typeField.enum) {
       throw new Error(
         `Cascade field "${key}" declares refPath: "${typeKey}", which must be an enumOf(...) naming the owner ` +
-          `refNames it may hold; declare polymorphic: "any" to pay for a sweep on every removal instead`,
+          `refNames it may hold; declare cascade: "removeWithAny" to pay for a sweep on every removal instead`,
       );
     }
     const typeValues = typeField.enum.values.map((value) => String(value));
@@ -110,14 +109,15 @@ export class CascadePaths {
     
     if (typeField.enum) {
       throw new Error(
-        `Cascade field "${key}" declares polymorphic: "any" and a refPath naming an enumOf(...); keep one`,
+        `Cascade field "${key}" declares cascade: "removeWithAny" and a refPath naming an enumOf(...), which ` +
+          `already names its owners; use cascade: "removeWith"`,
       );
     }
 
     if (this.#primitiveNameOf(typeField) !== "String") {
       throw new Error(
-        `Cascade field "${key}" declares polymorphic: "any", so refPath: "${typeKey}" must be a String field ` +
-          `holding the owner's refName`,
+        `Cascade field "${key}" declares cascade: "removeWithAny", so refPath: "${typeKey}" must be a String ` +
+          `field holding the owner's refName`,
       );
     }
     return { key, modelRef: null, refName: null, typeKey, typeValues: [], anyOwner: true };

package/constant/fieldInfo.ts

@@ -106,11 +106,6 @@ export interface ConstantFieldProps<
   validate?: (value: FieldValue, model: any) => boolean;
   text?: TextFieldRole;
   cascade?: CascadeAction;
-  /**
-   * Widens a `cascade: "removeWith"` field whose `refPath` names a free-form `String` instead of an `enumOf`:
-   * the owner is whatever refName the row happens to hold, found by sweeping at removal time.
-   */
-  polymorphic?: "any";
   /**
    * Renders on the page, never reaches an agent. Stripped wherever a value is masked for an AI caller — the
    * in-page agent's reads and every MCP result — and left untouched everywhere else, so a `File`'s blur
@@ -209,7 +204,6 @@ interface ConstantFieldBuildProps<
   validate?: (value: FieldValue, model: any) => boolean;
   text?: TextFieldRole;
   cascade?: CascadeAction;
-  polymorphic?: "any";
   visual: boolean;
   modelRef: ConstantModelRef;
   arrDepth: number;
@@ -335,7 +329,6 @@ export class ConstantField<
   readonly validate?: (value: FieldValue, model: any) => boolean;
   readonly text?: TextFieldRole;
   readonly cascade?: CascadeAction;
-  readonly polymorphic?: "any";
   readonly visual: boolean;
   readonly modelRef: ConstantModelRef;
   readonly arrDepth: number;
@@ -369,7 +362,6 @@ export class ConstantField<
     this.validate = props.validate;
     this.text = props.text;
     this.cascade = props.cascade;
-    this.polymorphic = props.polymorphic;
     this.visual = props.visual;
     this.modelRef = props.modelRef;
     this.arrDepth = props.arrDepth;
@@ -450,7 +442,6 @@ export class ConstantField<
       validate: option.validate,
       text: option.text,
       cascade: option.cascade,
-      polymorphic: option.polymorphic,
       visual: option.visual ?? false,
       modelRef,
       arrDepth: arrDepth,
@@ -498,7 +489,6 @@ export class ConstantField<
       validate: this.validate,
       text: this.text,
       cascade: this.cascade,
-      polymorphic: this.polymorphic,
       visual: this.visual,
       modelRef: this.modelRef,
       arrDepth: this.arrDepth,
@@ -523,19 +513,35 @@ export interface FieldObject {
  */
 type WithoutTextRole<Option> = Option extends unknown ? Omit<Option, "text"> : never;
 
+/**
+ * A wildcard owner is read off the row at removal time, so `removeWithAny` without a `refPath` names nothing to
+ * read it from — and the price of that action (no cascade in the app removes in one query) is one nobody should
+ * pay for a declaration that cascades nothing. Pairing the two in the option type refuses it at the call site;
+ * `CascadePaths` keeps the same refusal for the macro and bundled paths that reach it without a typecheck.
+ */
+type CascadeOption =
+  | { cascade?: "removeRef" | "removeWith"; refPath?: string }
+  | { cascade: "removeWithAny"; refPath: string };
+
+type WithCascadePair<Option> = Omit<Option, "cascade" | "refPath"> & CascadeOption;
+
 type FieldOption<
   Value extends ConstantFieldTypeInput,
   MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
   Metadata extends { [key: string]: any } = { [key: string]: any },
   _FieldToValue = FieldToValue<Value, MapValue> | null | undefined,
 > =
-  | Omit<
-      ConstantFieldProps<ConstantFieldKind, _FieldToValue, MapValue, Metadata>,
-      "enum" | "meta" | "nullable" | "fieldType" | "select"
+  | WithCascadePair<
+      Omit<
+        ConstantFieldProps<ConstantFieldKind, _FieldToValue, MapValue, Metadata>,
+        "enum" | "meta" | "nullable" | "fieldType" | "select"
+      >
     >
-  | Omit<
-      ConstantFieldProps<ConstantFieldKind, SingleValue<_FieldToValue>, MapValue, Metadata>,
-      "enum" | "meta" | "nullable" | "fieldType" | "select"
+  | WithCascadePair<
+      Omit<
+        ConstantFieldProps<ConstantFieldKind, SingleValue<_FieldToValue>, MapValue, Metadata>,
+        "enum" | "meta" | "nullable" | "fieldType" | "select"
+      >
     >[];
 
 export type PlainTypeToFieldType<PlainType> = PlainType extends [infer First, ...infer Rest]

package/fetch/client/fetchClient.ts

@@ -456,8 +456,10 @@ export class FetchClient {
     const updateGuards = signal.updateGuards ?? signal.cruGuards;
     const removeGuards = signal.removeGuards ?? signal.cruGuards;
 
-    const mcp = (verb: keyof NonNullable<SerializedSignal["mcp"]>) =>
-      signal.mcp?.[verb] === false ? { mcp: false as const } : {};
+    const mcp = (verb: keyof NonNullable<SerializedSignal["mcp"]>) => ({
+      ...(signal.mcp?.[verb] === false ? { mcp: false as const } : {}),
+      ...(signal.agents?.[verb] === false ? { agents: false as const } : {}),
+    });
     const endpoint: { [key: string]: SerializedEndpoint } = {};
     if (signal.getGuards) {
       endpoint[names.model] = {
@@ -631,7 +633,10 @@ export class FetchClient {
       live: `${refName}Live${capSuffix}`,
     };
 
-    const mcp = slice.mcp === false ? { mcp: false as const } : {};
+    const mcp = {
+      ...(slice.mcp === false ? { mcp: false as const } : {}),
+      ...(slice.agents === false ? { agents: false as const } : {}),
+    };
     const endpoint: { [key: string]: SerializedEndpoint } = {
       [names.list]: {
         type: "query",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.100",
+  "version": "3.0.0-alpha.102",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanApp.ts

@@ -96,6 +96,17 @@ export interface AkanAppOptions {
    * module. Handed down as `AKAN_MODULES`, since each replica builds its own container.
    */
   modules?: string[];
+  /**
+   * The inverse of `modules`: mount everything except these and whatever reaches them, in every child. Written
+   * for a lib the app depends on but does not serve — `server.ts` is generated from the dependency graph, so a
+   * lib cannot be dropped by editing it. Handed down as `AKAN_DISABLE_MODULES`, and applied after `modules`.
+   */
+  disableModules?: string[];
+  /**
+   * The same, by owning lib: every module the named libs registered stays out of every child, along with
+   * everything that reaches one. Handed down as `AKAN_DISABLE_LIBS`.
+   */
+  disableLibs?: string[];
   /**
    * Run the one replica in this process instead of spawning it — see `#startSolo`. Defaults on for a single
    * traffic replica the environment configured, and off whenever `replica` is passed here, because code that
@@ -141,6 +152,8 @@ export class AkanApp {
   /** The gateway hands `/_akan/client|styles|fonts` straight off disk, so it needs the same answer its children do. */
   readonly #web = getWebConfigFromEnv();
   readonly #modules: string[];
+  readonly #disableModules: string[];
+  readonly #disableLibs: string[];
   readonly #solo: boolean;
   readonly #children = new Map<number, ChildState>();
   readonly #roomChildren = new Map<string, Set<number>>();
@@ -182,6 +195,8 @@ export class AkanApp {
     this.#prefix = normalizeRoutePrefix(resolvedOptions.prefix) ?? getApiPrefix();
     this.#websocketPrefix = normalizeRoutePrefix(resolvedOptions.websocketPrefix) ?? getWsPrefix();
     this.#modules = resolvedOptions.modules ?? [];
+    this.#disableModules = resolvedOptions.disableModules ?? [];
+    this.#disableLibs = resolvedOptions.disableLibs ?? [];
     this.#solo = AkanApp.#resolveSolo(resolvedOptions, this.#replica);
     this.#logHub = LogHub.attach();
   }
@@ -322,6 +337,8 @@ export class AkanApp {
       AKAN_WS_PREFIX: this.#websocketPrefix,
       ...(this.#openapi === undefined ? {} : { AKAN_OPENAPI: this.#openapi ? "true" : "false" }),
       ...(this.#modules.length ? { AKAN_MODULES: this.#modules.join(",") } : {}),
+      ...(this.#disableModules.length ? { AKAN_DISABLE_MODULES: this.#disableModules.join(",") } : {}),
+      ...(this.#disableLibs.length ? { AKAN_DISABLE_LIBS: this.#disableLibs.join(",") } : {}),
     });
 
     resetEnvCache();
@@ -415,6 +432,8 @@ export class AkanApp {
         AKAN_WS_PREFIX: this.#websocketPrefix,
         ...(this.#openapi === undefined ? {} : { AKAN_OPENAPI: this.#openapi ? "true" : "false" }),
         ...(this.#modules.length ? { AKAN_MODULES: this.#modules.join(",") } : {}),
+        ...(this.#disableModules.length ? { AKAN_DISABLE_MODULES: this.#disableModules.join(",") } : {}),
+        ...(this.#disableLibs.length ? { AKAN_DISABLE_LIBS: this.#disableLibs.join(",") } : {}),
       },
       ipc: (message) => this.#handleMessage(idx, message as AkanIpcMessage, proc),
       stdout: "pipe",

package/server/akanAppHeaders.ts

@@ -23,7 +23,7 @@ export function makeAkanChildProxyHeaders(req: Request, childIdx: number, peer?:
   for (const key of HOP_BY_HOP_HEADERS) headers.delete(key);
   const forwardedFor = headers.get("x-forwarded-for");
 
-  const clientAddress = TrustedProxy.clientAddress(headers, peer?.address);
+  const clientAddress = TrustedProxy.clientAddress(headers, peer === null ? null : peer?.address);
   const host = headers.get("host");
 
   if (clientAddress) {

package/server/akanOption.ts

@@ -20,7 +20,7 @@ export class AkanOption<Env extends BackendEnv = BackendEnv> {
   readonly #adaptorOverrides: AdaptorOverride[] = [];
   readonly #webProxies: WebProxyRegistration[] = [];
   readonly #getLlms: ((env: Env) => LlmOption)[] = [];
-  #mcp: boolean | McpServerOption | undefined;
+  #getMcp: ((env: Env) => boolean | McpServerOption) | undefined;
   #agentAccess: GuardCls | GuardCls[] | null | undefined;
   #crossSite: CrossSiteOption | undefined;
   constructor() {
@@ -48,10 +48,11 @@ export class AkanOption<Env extends BackendEnv = BackendEnv> {
   /**
    * MCP server settings for the app mounting this option, merged over the `AKAN_MCP_*` environment and under an
    * option the server is constructed with. The app's own `option.ts` is the last lib the server reads, so it wins
-   * over every library it depends on.
+   * over every library it depends on. The function form receives the server env, for a setting derived from it —
+   * a token verifier built on the app's signing secret, the issuer an authorization server publishes under.
    */
-  setMcp(mcp: boolean | McpServerOption = true) {
-    this.#mcp = mcp;
+  setMcp(mcpOrFn: boolean | McpServerOption | ((env: Env) => boolean | McpServerOption) = true) {
+    this.#getMcp = typeof mcpOrFn === "function" ? mcpOrFn : () => mcpOrFn;
     return this;
   }
   /**
@@ -91,8 +92,8 @@ export class AkanOption<Env extends BackendEnv = BackendEnv> {
   getWebProxies(): WebProxyRegistration[] {
     return this.#webProxies;
   }
-  getMcp(): boolean | McpServerOption | undefined {
-    return this.#mcp;
+  getMcp(env: Env): boolean | McpServerOption | undefined {
+    return this.#getMcp?.(env);
   }
   getAgentAccess(): GuardCls | GuardCls[] | null | undefined {
     return this.#agentAccess;

package/server/akanServer.ts

@@ -33,7 +33,7 @@ import { LogForwarder } from "./logging/logForwarder";
 import { LogHub } from "./logging/logHub";
 import { LogStreamRoute } from "./logging/logStreamRoute";
 import { RotatingLogWriter } from "./logging/rotatingLogWriter";
-import { type McpAuthOption, McpRouter } from "./mcp";
+import { type McpAuthOption, type McpRateLimitOption, McpRouter } from "./mcp";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { WebProxyRunner } from "./proxy";
 import { SignalResolver } from "./resolver";
@@ -65,6 +65,18 @@ export interface AkanServerOptions {
    * services, signals, routes and schedules do not exist. Omitted or empty mounts every enabled module.
    */
   modules?: string[];
+  /**
+   * The inverse of `modules`: mount everything except these and whatever reaches them. Written for a lib the
+   * app depends on but does not serve — `server.ts` is generated from the dependency graph, so a lib cannot be
+   * dropped by editing it. Applied after `modules`, so a module named by both stays out.
+   */
+  disableModules?: string[];
+  /**
+   * The same, by owning lib: every module the named libs registered stays out, along with everything that
+   * reaches one. This is the spelling for a lib the app depends on but does not serve — it does not drift as
+   * the lib gains modules.
+   */
+  disableLibs?: string[];
 }
 
 export interface McpServerOption {
@@ -106,8 +118,20 @@ export interface McpServerOption {
    * half turns this off and halves what each of those calls costs the model. `AKAN_MCP_LEGACY_TEXT=false`.
    */
   legacyTextBlock?: boolean;
+  /**
+   * How much of a result's shape each tool advertises: `shallow` (default) names nested models instead of inlining
+   * them, `full` inlines the whole closure, `none` publishes no `outputSchema` and keeps the text block on. The
+   * listing is re-sent to every agent that connects, and the nested closures were most of it. `AKAN_MCP_OUTPUT_SCHEMA`.
+   */
+  outputSchema?: "full" | "shallow" | "none";
   /** OAuth resource-server identity: which issuers a client may authenticate with, and the scopes to demand. */
   auth?: McpAuthOption;
+  /**
+   * Per-caller budget for `tools/call`, `resources/read` and `prompts/get`: 120 calls a minute and 8 in flight by
+   * default, counted per process. `false` takes it off. `AKAN_MCP_RATE_LIMIT` (`<calls>` or `<calls>/<seconds>`,
+   * `off` to disable) and `AKAN_MCP_CONCURRENT`.
+   */
+  rateLimit?: McpRateLimitOption | false;
 }
 
 interface AkanAppPrepared {
@@ -156,6 +180,8 @@ export class AkanServer {
   /** Resolved at `init`: what this process actually serves, after env and artifact availability. */
   web: AkanWebConfig = getWebConfigFromEnv();
   modules: string[];
+  disableModules: string[];
+  disableLibs: string[];
   shutdownTimeoutMs = AkanServer.#defaultShutdownTimeoutMs();
 
   #di: DiLifecycle;
@@ -195,7 +221,7 @@ export class AkanServer {
     this.openapi = options?.openapi ?? this.openapi;
     
     libs.forEach((lib) => {
-      const mcp = lib.option.getMcp();
+      const mcp = lib.option.getMcp(this.env);
       if (mcp !== undefined) this.setMcp(mcp);
       const agentAccess = lib.option.getAgentAccess();
       if (agentAccess !== undefined) AgentRelayAccess.use(agentAccess);
@@ -206,7 +232,12 @@ export class AkanServer {
     this.serverMode = serverMode;
     
     this.modules = options?.modules ?? AkanServer.#envList("AKAN_MODULES") ?? [];
-    this.#di = new DiLifecycle({ env: this.env, modules: this.modules }, ...libs);
+    this.disableModules = options?.disableModules ?? AkanServer.#envList("AKAN_DISABLE_MODULES") ?? [];
+    this.disableLibs = options?.disableLibs ?? AkanServer.#envList("AKAN_DISABLE_LIBS") ?? [];
+    this.#di = new DiLifecycle(
+      { env: this.env, modules: this.modules, disableModules: this.disableModules, disableLibs: this.disableLibs },
+      ...libs,
+    );
   }
   setPrefix(prefix: string) {
     if (this.status !== "stopped") throw new Error("Route prefix must be set before app initialization.");
@@ -813,7 +844,11 @@ export class AkanServer {
         !("database" in value) &&
         !("service" in value) &&
         !("scalar" in value) &&
-        ("openapi" in value || "mcp" in value || "modules" in value),
+        ("openapi" in value ||
+          "mcp" in value ||
+          "modules" in value ||
+          "disableModules" in value ||
+          "disableLibs" in value),
     );
   }
 
@@ -884,9 +919,31 @@ export class AkanServer {
       ...(Number.isInteger(pageSize) && pageSize > 0 ? { pageSize } : {}),
       ...(process.env.AKAN_MCP_LANGUAGE ? { language: process.env.AKAN_MCP_LANGUAGE } : {}),
       ...(AkanServer.#isEnvOff("AKAN_MCP_LEGACY_TEXT") ? { legacyTextBlock: false } : {}),
+      ...AkanServer.#mcpOutputSchemaFromEnv(),
+      ...AkanServer.#mcpRateLimitFromEnv(),
     };
   }
 
+  /** `AKAN_MCP_RATE_LIMIT=off` disables; `120` is per minute, `120/30` per thirty seconds; `AKAN_MCP_CONCURRENT` caps in-flight calls. */
+  static #mcpRateLimitFromEnv(): Pick<McpServerOption, "rateLimit"> {
+    const raw = process.env.AKAN_MCP_RATE_LIMIT?.trim().toLowerCase();
+    if (raw === "off" || raw === "false" || raw === "0") return { rateLimit: false };
+    const option: McpRateLimitOption = {};
+    if (raw) {
+      const [calls, seconds] = raw.split("/").map((part) => Number(part));
+      if (Number.isInteger(calls) && calls > 0) option.calls = calls;
+      if (Number.isInteger(seconds) && seconds > 0) option.windowMs = seconds * 1000;
+    }
+    const concurrent = Number(process.env.AKAN_MCP_CONCURRENT);
+    if (Number.isInteger(concurrent) && concurrent >= 0) option.concurrent = concurrent;
+    return Object.keys(option).length ? { rateLimit: option } : {};
+  }
+
+  static #mcpOutputSchemaFromEnv(): Pick<McpServerOption, "outputSchema"> {
+    const value = process.env.AKAN_MCP_OUTPUT_SCHEMA;
+    return value === "full" || value === "shallow" || value === "none" ? { outputSchema: value } : {};
+  }
+
   /**
    * Both consumers build their path by concatenation — the route key, and the RFC 9728 metadata path the resource
    * identifier is inserted into — so `AKAN_MCP_PATH=mcp` served a route named `mcp` and published its metadata at