akanjs 3.0.0-alpha.10 → 3.0.0-alpha.11

package/common/index.ts

@@ -27,6 +27,16 @@ export {
   resolveAkanI18nConfig,
 } from "./localeConfig";
 export { lowerlize } from "./lowerlize";
+export {
+  isMcpDescribableArg,
+  type McpExposureEndpoint,
+  type McpExposureHints,
+  type McpExposureOption,
+  mcpBaseVerbOf,
+  mcpHintsOf,
+  mcpPromptRefusalOf,
+  mcpRefusalOf,
+} from "./mcpExposure";
 export { mergeVersion } from "./mergeVersion";
 export { objectify } from "./objectify";
 export { pathGet } from "./pathGet";

package/common/mcpExposure.ts

@@ -0,0 +1,106 @@
+import { capitalize } from "./capitalize";
+
+/**
+ * What MCP says about one endpoint: whether it is published, why it is not, and the hints it carries.
+ *
+ * Structurally typed like the rest of `common/` so the same rules answer on both sides — the server builds its
+ * catalogue from them and the browser API explorer badges an endpoint from them. A second implementation would
+ * eventually disagree, and an audit surface that disagrees with the catalogue is worse than none.
+ *
+ * Every rejection returns the sentence an author reads, at boot in the server log and in the explorer. Fail-closed
+ * with no reason is what left a deliberate `mcp: { expose: true }` vanishing with nowhere to look but the source.
+ */
+export interface McpExposureEndpoint {
+  type: string;
+  returns: { refName: string };
+  args: { name: string; refName: string; type: string; arrDepth?: number; nullable?: boolean }[];
+  guards?: string[];
+  fileUpload?: boolean;
+}
+
+export interface McpExposureOption {
+  /**
+   * The read-only deployment valve, which is server configuration. The browser explorer cannot know it and so
+   * badges what the code decided; the boot log is where a read-only deployment says what it dropped.
+   */
+  readOnly?: boolean;
+}
+
+/** The author's overrides for the hints derived below. */
+export interface McpExposureHints {
+  readOnly?: boolean;
+  destructive?: boolean;
+  idempotent?: boolean;
+}
+
+/** `Any` publishes as the empty schema, which tells a model nothing — so it is left out rather than described. */
+export const isMcpDescribableArg = (arg: { refName: string }) => arg.refName !== "Any";
+
+/**
+ * Which slice-level verb opts in each CRUD endpoint a model generates. They carry no signal option of their own,
+ * so `mcp: { get: true }` on the slice is the only place their exposure can be written.
+ */
+export const mcpBaseVerbOf = (refName: string, key: string) => {
+  const cap = capitalize(refName);
+  if (key === refName || key === `light${cap}`) return "get" as const;
+  if (key === `create${cap}`) return "create" as const;
+  if (key === `update${cap}`) return "update" as const;
+  if (key === `remove${cap}`) return "remove" as const;
+  return null;
+};
+
+/**
+ * The hints a client renders beside a tool. Hints only — clients are told to distrust them, so they inform a UI
+ * and never stand in for a guard. `openWorldHint` is always false: every endpoint reaches this app's own
+ * database, not the wider internet.
+ */
+export const mcpHintsOf = (key: string, endpoint: { type: string }, mcp: McpExposureHints = {}) => {
+  const readOnly = mcp.readOnly ?? endpoint.type === "query";
+  const destructive = mcp.destructive ?? (!readOnly && /^(remove|delete)/.test(key));
+  return {
+    readOnlyHint: readOnly,
+    destructiveHint: destructive,
+    idempotentHint: mcp.idempotent ?? (readOnly || /^(set|update)/.test(key)),
+    openWorldHint: false,
+  };
+};
+
+/** The sentence explaining why this endpoint is not in the catalogue, or `null` when it is. */
+export const mcpRefusalOf = (endpoint: McpExposureEndpoint, { readOnly }: McpExposureOption = {}): string | null => {
+  if (endpoint.type === "prompt") return mcpPromptRefusalOf(endpoint);
+  if (endpoint.type === "pubsub" || endpoint.type === "message")
+    return `\`${endpoint.type}\` rides the websocket, and its internal arguments read a socket an MCP request does not have.`;
+  if (readOnly && endpoint.type !== "query")
+    return "this deployment is read-only, which drops every endpoint that is not a query.";
+  if (endpoint.returns.refName === "Any" || endpoint.returns.refName === "Upload")
+    return `a return typed \`${endpoint.returns.refName}\` cannot be described to a model.`;
+  if (endpoint.fileUpload || endpoint.args.some((arg) => arg.refName === "Upload"))
+    return "a file upload has no MCP representation.";
+  if (endpoint.type === "mutation" && !endpoint.guards?.some((name) => name !== "Public"))
+    return "a mutation needs a real guard — `[Public]` is having none, spelled out.";
+  const opaque = endpoint.args.find((arg) => !isMcpDescribableArg(arg) && arg.type !== "search" && !arg.nullable);
+  if (opaque)
+    return `its required argument \`${opaque.name}\` is typed \`Any\`, which is left out of the published schema — expose a named filter slice instead.`;
+  return null;
+};
+
+/**
+ * A prompt is a read exposed on the same terms as a query, so every rejection here is one thing: an argument
+ * `prompts/get` cannot carry. Its `arguments` is a flat string map — one string per name, and no schema beside it
+ * — which rules out the argument *kinds* the builder already refuses and, just as surely, two argument *types* it
+ * accepts. A tool escapes both because it publishes a real JSON Schema.
+ */
+export const mcpPromptRefusalOf = (endpoint: McpExposureEndpoint): string | null => {
+  const carried = endpoint.args.find((arg) => arg.type === "body" || arg.type === "msg" || arg.type === "room");
+  if (carried)
+    return `a prompt's arguments travel as a flat string map, so its \`${carried.type}\` argument \`${carried.name}\` cannot be carried.`;
+
+  const list = endpoint.args.find((arg) => arg.arrDepth);
+  if (list)
+    return `a prompt argument is one string, so its list argument \`${list.name}\` could never carry more than one value.`;
+
+  const opaque = endpoint.args.find((arg) => !isMcpDescribableArg(arg));
+  if (opaque)
+    return `its argument \`${opaque.name}\` is typed \`Any\`, and a prompt has no schema in which to describe one.`;
+  return null;
+};

package/constant/immerify.ts

@@ -9,7 +9,7 @@ export const immerify = <T extends object>(modelRef: ConstantModelRef, objOrArr:
   }) as Record<string, unknown>;
   const objRecord = objOrArr as Record<string, unknown>;
   Object.entries(modelRef[FIELD_META]).forEach(([key, field]) => {
-    if (field.isScalar && field.isClass && !!objRecord[key])
+    if (field.isScalar && field.isClass && objRecord[key])
       immeredObj[key] = immerify(field.modelRef, objRecord[key] as object);
   });
   return immeredObj as T;

package/dictionary/DictionaryLookup.ts

@@ -0,0 +1,30 @@
+import { pathGet } from "akanjs/common";
+import { DictionaryRegistry } from "./dictionaryRegistry";
+import type { DictionaryNode } from "./trans";
+
+/**
+ * Reads translated text out of the merged dictionary tree by dotted key (`user.signal.createUser.arg.data.desc`).
+ *
+ * Unlike `translate`, a missing key resolves to `undefined` rather than echoing the key back: callers here are
+ * document generators (OpenAPI, MCP) that must omit an absent description instead of emitting `"user.signal.…"`
+ * as if it were prose. The merged root is snapshotted once per instance, so build a fresh one per document.
+ */
+export class DictionaryLookup {
+  readonly language: string;
+  readonly #models: Record<string, DictionaryNode>;
+  constructor(language?: string) {
+    const root = DictionaryRegistry.getRoot();
+    this.language = language && root[language] ? language : (Object.keys(root).at(0) ?? "en");
+    this.#models = root[this.language] ?? {};
+  }
+
+  /** A bare refName names the model node itself, which holds no text of its own — its label is `<refName>.modelName`. */
+  text(key: string): string | undefined {
+    const [refName, ...rest] = key.split(".");
+    if (!refName) return undefined;
+    const model = this.#models[refName];
+    const node = (rest.length ? pathGet(rest.join("."), model) : model) as { t?: unknown } | null;
+    const text = node?.t;
+    return typeof text === "string" && text.length ? text : undefined;
+  }
+}

package/dictionary/dictInfo.ts

@@ -56,6 +56,17 @@ type DictEndpointShape<Endpoint> =
         : Endpoint extends Record<string, EndpointInfo>
           ? EndpointCompactShape<Endpoint>
           : Record<never, never>;
+/**
+ * The actions of a store, which is every method on it that dispatches.
+ *
+ * Derived from the shape rather than from a marker like `ENDPOINT_DICT_SHAPE`, because a store's custom actions
+ * are declared on the subclass — after `store()` has already returned, so there is nothing for it to stamp. What
+ * makes the shape readable anyway is that `st.do.<action>()` is typed `void`: an action returns nothing, so the
+ * void-returning methods are exactly the actions and `get` / `pick` / `slice` fall out on their own.
+ */
+type DictStoreShape<Store> = {
+  [K in keyof Store as Store[K] extends (...args: never[]) => void | Promise<void> ? K & string : never]: true;
+};
 type DictArgNames<ArgNames> = ArgNames extends readonly string[] ? ArgNames[number] : never;
 type DictFilterQuery<Filter> = DictFilterShape<Filter>["query"];
 type DictFilterSort<Filter> = DictFilterShape<Filter>["sort"];
@@ -140,6 +151,7 @@ export class ModelDictInfo<
   BaseSignalKey extends string = never,
   SliceKey extends string = "",
   EndpointKey extends string = never,
+  StoreKey extends string = never,
   ErrorKey extends string = never,
   EtcKey extends string = never,
 > {
@@ -245,6 +257,9 @@ export class ModelDictInfo<
   endpointDictionary: { [K in EndpointKey]: FunctionTranslation<Languages> } = {} as {
     [K in EndpointKey]: FunctionTranslation<Languages>;
   };
+  storeDictionary: { [K in StoreKey]: FieldTranslation<Languages> } = {} as {
+    [K in StoreKey]: FieldTranslation<Languages>;
+  };
   errorDictionary: { [K in ErrorKey]: Languages } = {} as {
     [K in ErrorKey]: Languages;
   };
@@ -278,6 +293,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -302,6 +318,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -327,6 +344,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -351,6 +369,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -375,6 +394,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -400,6 +420,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       keyof DictSliceShape<Slice> & string,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -425,6 +446,41 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       keyof DictEndpointShape<Endpoint> & string,
+      StoreKey,
+      ErrorKey,
+      EtcKey
+    >;
+  }
+  /**
+   * What a store's custom actions are called, in the words a person would use.
+   *
+   * Optional, and the only stage that is: an action whose name matches the endpoint it wraps already reads as
+   * that endpoint's `.desc()`, which is most of them — the house naming rule (`st.do.X` reads the same as
+   * `fetch.X`) is what makes that true. This stage is for the rest, where inheriting the endpoint's words would
+   * be actively wrong: nine `getSummaryListIn*` actions that all call one endpoint, or `logout` over
+   * `signoutUser`, where the store name is the verb a user would say and the endpoint name is the verb the API
+   * has. `akan quality scan` names those and no others.
+   *
+   * Labels only, no `.arg()`. Parameter names are not in a class's type the way an endpoint builder's are, and an
+   * action mostly takes none anyway — its data comes from the form state the user already filled in.
+   */
+  store<Store>(
+    translate: (t: (trans: Languages) => FieldTranslation<Languages>) => Partial<{
+      [K in keyof DictStoreShape<Store>]: FieldTranslation<Languages>;
+    }>,
+  ) {
+    Object.assign(this.storeDictionary, translate(FieldTranslation.translate));
+    return this as unknown as ModelDictInfo<
+      Languages,
+      ModelKey,
+      InsightKey,
+      QueryKey,
+      SortKey,
+      EnumKey,
+      BaseSignalKey,
+      SliceKey,
+      EndpointKey,
+      StoreKey | (keyof DictStoreShape<Store> & string),
       ErrorKey,
       EtcKey
     >;
@@ -441,6 +497,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey | (keyof ErrorDict & string),
       EtcKey
     >;
@@ -457,6 +514,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey | (keyof EtcDict & string)
     >;
@@ -473,6 +531,7 @@ export class ModelDictInfo<
       GetBaseSignalKey<RefName>,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -496,6 +555,7 @@ export class ModelDictInfo<
     this.#registerBaseSignalToRoot(refName, rootDict);
     this.#registerSliceToRoot(refName, rootDict);
     this.#registerEndpointToRoot(refName, rootDict);
+    this.#registerStoreToRoot(refName, rootDict);
     this.#registerErrorToRoot(refName, rootDict);
     this.#registerModelToRoot(refName, rootDict);
     this.#registerEtcToRoot(refName, rootDict);
@@ -777,6 +837,23 @@ export class ModelDictInfo<
       });
     });
   }
+  /** Under its own `store` node rather than beside `signal`, because the two hold the same key by design. */
+  #registerStoreToRoot(refName: string, rootDict: RootDictionary) {
+    this.languages.forEach((language) => {
+      ensureNode(getRootModelNode(rootDict, language, refName), "store");
+    });
+    Object.entries(this.storeDictionary as { [key: string]: FieldTranslation<Languages> }).forEach(([key, value]) => {
+      value.trans.forEach((t, idx) => {
+        ensureNode(ensureNode(getTranslatedRootModelNode(rootDict, this.languages, idx, refName), "store"), key).t = t;
+      });
+      value.descTrans?.forEach((t, idx) => {
+        ensureNode(
+          ensureNode(ensureNode(getTranslatedRootModelNode(rootDict, this.languages, idx, refName), "store"), key),
+          "desc",
+        ).t = t;
+      });
+    });
+  }
   #registerErrorToRoot(refName: string, rootDict: RootDictionary) {
     this.languages.forEach((language) => {
       ensureNode(getRootModelNode(rootDict, language, refName), "error");

package/dictionary/index.ts

@@ -1,3 +1,4 @@
+export * from "./DictionaryLookup";
 export * from "./dictInfo";
 export {
   __Dict_Key__,

package/dictionary/locale.ts

@@ -168,6 +168,14 @@ export type ModelTrans<
     }>;
   error: { [K in ErrorKey]: Trans };
 } & { [K in EtcKey]: Trans };
+/**
+ * Store action labels, keyed off the resolved `.store()` keys rather than off the store class.
+ *
+ * The endpoint half needs the class because it reads argument names out of it. A store entry is a label and a
+ * description with no arguments to name, so the keys the stage already resolved are the whole of it — which is
+ * also why a generated `dict.ts` passes no store type at all.
+ */
+export type StoreTranslatorKey<T extends string, StoreKey extends string> = `${T}.store.${StoreKey}${"" | ".desc"}`;
 export type ModelTranslatorKey<T extends string, Model, Insight, Filter, Slice, Endpoint, EtcKey extends string> =
   | `${T}.modelName`
   | `${T}.modelDesc`
@@ -234,11 +242,14 @@ export const registerModelTrans = <
   infer _BaseSignalKey,
   infer _SliceKey,
   infer _EndpointKey,
+  infer StoreKey,
   infer ErrorKey,
   infer EtcKey
 >
   ? DictModule<
-      ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
+      | ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey>
+      | EnumTranslatorKey<EnumKey>
+      | StoreTranslatorKey<RefName, StoreKey>,
       `${RefName}.error.${ErrorKey}`
     >
   : never => {
@@ -252,11 +263,14 @@ export const registerModelTrans = <
     infer _BaseSignalKey,
     infer _SliceKey,
     infer _EndpointKey,
+    infer StoreKey,
     infer ErrorKey,
     infer EtcKey
   >
     ? DictModule<
-        ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
+        | ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey>
+        | EnumTranslatorKey<EnumKey>
+        | StoreTranslatorKey<RefName, StoreKey>,
         `${RefName}.error.${ErrorKey}`
       >
     : never;

package/document/index.ts

@@ -7,5 +7,6 @@ export * from "./documentSchema";
 export * from "./filterMeta";
 export * from "./into";
 export * from "./loaderInfo";
+export * from "./noDocumentError";
 export * from "./schema";
 export * from "./types";

package/document/noDocumentError.ts

@@ -0,0 +1,12 @@
+/**
+ * A `pick` or a `get` that matched nothing. Typed so a caller can tell "you asked for something that is not
+ * there" from "we broke" — an agent-facing transport in particular must not log a stack and answer "the server
+ * failed" every time a model guesses an id.
+ *
+ * The message is unchanged from the bare `Error` this replaces, because callers already match on it, and the
+ * `statusCode` does not reach the HTTP layer: `isExceptionLike` wants a `toJSON` too, so a missing document
+ * stays a 500 there until someone decides framework-wide that it should be a 404.
+ */
+export class NoDocumentError extends Error {
+  readonly statusCode = 404;
+}

package/fetch/client/fetchClient.ts

@@ -246,6 +246,8 @@ export class FetchClient {
     const parseReturn = this.#makeReturnParser(endpoint.returns);
     const { bodyArgs, uploadArgs } = FetchClient.classifyHttpArgs(endpoint.args);
     switch (endpoint.type) {
+      
+      case "prompt":
       case "query": {
         const queryFn = async (...argData: unknown[]) => {
           const args = argData.slice(0, argLength);
@@ -286,6 +288,7 @@ export class FetchClient {
   }
   #registerEndpoint(key: string, endpoint: SerializedEndpoint, prefix?: string) {
     switch (endpoint.type) {
+      case "prompt":
       case "query": {
         this.#setHandlerFactory(key, () => this.#makeHttpFn(key, endpoint, prefix));
         return;

package/fetch/fetchType/endpointFetch.type.ts

@@ -7,6 +7,7 @@ import type {
   EndpInfoReqType,
   EndpointCls,
   EndpointInfo,
+  PromptMessage,
   SlceCnstFull,
   SlceCnstInsight,
   SlceCnstLight,
@@ -40,6 +41,9 @@ type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (
   ...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]
 ) => Promise<EndpInfoReturns<E, SlceCls>>;
 
+/** Typed off `PromptResult` rather than the endpoint's return ref, which is the `Any` carrier a prompt rides on. */
+type PromptFetchFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<PromptMessage[]>;
+
 type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => void;
 
 type MessageListenFn<E, SlceCls extends SliceCls | never> = (
@@ -58,12 +62,14 @@ type PubsubSubscribeFn<E, SlceCls extends SliceCls | never> = (
 type PrimaryFetchFn<E, SlceCls extends SliceCls | never> =
   EndpInfoReqType<E> extends "query" | "mutation"
     ? QueryOrMutationFetchFn<E, SlceCls>
-    : EndpInfoReqType<E> extends "message"
-      ? MessageEmitFn<E>
-      : never;
+    : EndpInfoReqType<E> extends "prompt"
+      ? PromptFetchFn<E>
+      : EndpInfoReqType<E> extends "message"
+        ? MessageEmitFn<E>
+        : never;
 
 type PrimaryFetchType<EInfoObj extends { [key: string]: EndpointInfo }, SlceCls extends SliceCls | never> = {
-  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "message"
+  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "prompt" | "message"
     ? K
     : never]: PrimaryFetchFn<EInfoObj[K], SlceCls>;
 };

package/package.json

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

package/server/akanApp.ts

@@ -6,6 +6,7 @@ import { Logger } from "akanjs/common";
 import type { AkanChildRole, AkanChildStatus, AkanIpcMessage, AkanMetricsReport, AkanUpstream } from "akanjs/service";
 import { isTraceEnabled } from "akanjs/signal";
 import { makeAkanChildProxyHeaders } from "./akanAppHeaders";
+import type { McpServerOption } from "./akanServer";
 import type { BuilderCsrReq, BuilderCsrRes, BuilderMessage, BuilderReq, BuilderRes } from "./artifact";
 import { resolveEncodedSidecar } from "./assetEncoding";
 import { isPortInUseError } from "./lifecycle/portInUse";
@@ -54,6 +55,11 @@ export interface AkanAppOptions {
   port?: number;
   wsBasePort?: number;
   openapi?: boolean;
+  /**
+   * MCP server config for the children, which are the processes that actually mount `/mcp`. Declared here
+   * because `server.ts` is generated and takes no options, so `main.ts` is the only app-authored place left.
+   */
+  mcp?: boolean | McpServerOption;
 }
 
 interface AkanReplicaConfig {
@@ -84,6 +90,7 @@ export class AkanApp {
   readonly #port: number;
   readonly #wsBasePort: number;
   readonly #openapi?: boolean;
+  readonly #mcpEnv: Record<string, string>;
   readonly #children = new Map<number, ChildState>();
   readonly #roomChildren = new Map<string, Set<number>>();
   readonly #childRooms = new Map<number, Set<string>>();
@@ -125,6 +132,30 @@ export class AkanApp {
     this.#port = Number(resolvedOptions.port ?? process.env.PORT ?? 8282);
     this.#wsBasePort = Number(resolvedOptions.wsBasePort ?? process.env.AKAN_WS_BASE_PORT ?? this.#port + 10_000);
     this.#openapi = resolvedOptions.openapi;
+    this.#mcpEnv = AkanApp.#toMcpEnv(resolvedOptions.mcp);
+  }
+
+  /**
+   * `McpServerOption`, spelled as the environment a child is spawned with — the only channel the gateway has to
+   * a process it starts, and the same one a deployment configures MCP through when it sets nothing in code.
+   */
+  static #toMcpEnv(mcp: boolean | McpServerOption | undefined): Record<string, string> {
+    if (mcp === undefined) return {};
+    if (typeof mcp === "boolean") return { AKAN_MCP: String(mcp) };
+    const { enabled, readOnly, path: mcpPath, version, instructions, allowedOrigins, pageSize, language, auth } = mcp;
+    return {
+      AKAN_MCP: String(enabled ?? true),
+      ...(readOnly === undefined ? {} : { AKAN_MCP_READONLY: String(readOnly) }),
+      ...(mcpPath ? { AKAN_MCP_PATH: mcpPath } : {}),
+      ...(version ? { AKAN_MCP_VERSION: version } : {}),
+      ...(instructions ? { AKAN_MCP_INSTRUCTIONS: instructions } : {}),
+      ...(allowedOrigins?.length ? { AKAN_MCP_ALLOWED_ORIGINS: allowedOrigins.join(",") } : {}),
+      ...(pageSize === undefined ? {} : { AKAN_MCP_PAGE_SIZE: String(pageSize) }),
+      ...(language ? { AKAN_MCP_LANGUAGE: language } : {}),
+      ...(auth?.authorizationServers?.length ? { AKAN_MCP_AUTH_SERVERS: auth.authorizationServers.join(",") } : {}),
+      ...(auth?.scopes?.length ? { AKAN_MCP_SCOPES: auth.scopes.join(",") } : {}),
+      ...(auth?.resource ? { AKAN_MCP_RESOURCE: auth.resource } : {}),
+    };
   }
 
   static #resolveServerPath(serverPath: string) {
@@ -289,6 +320,7 @@ export class AkanApp {
         AKAN_CHILD_SOCKET: upstream.http.socketPath,
         AKAN_CHILD_WS_PORT: upstream.ws ? String(upstream.ws.port) : "",
         ...(this.#openapi === undefined ? {} : { AKAN_OPENAPI: this.#openapi ? "true" : "false" }),
+        ...this.#mcpEnv,
       },
       ipc: (message) => this.#handleMessage(idx, message as AkanIpcMessage, proc),
       stdout: "pipe",