akanjs 3.0.0-alpha.22 → 3.0.0-alpha.24

package/package.json

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

package/server/akanOption.ts

@@ -54,8 +54,8 @@ export class AkanOption<Env extends BackendEnv = BackendEnv> {
     return this;
   }
   /**
-   * Who may spend the LLM key through the `runAgentTurn` relay — the `AgentRelayAccess` policy, which defaults to
-   * allowing everyone because the framework has no account model to gate on. `null` reopens it.
+   * Who may spend the LLM key through the `runAgentTurn` relay. With no policy the call is refused — the same
+   * answer `None` gives — because the framework has no account model to gate on. `null` clears the policy.
    */
   setAgentAccess(policy: AgentRelayPolicy | null) {
     this.#agentAccess = policy;

package/server/lifecycle/shutdownManager.ts

@@ -14,7 +14,7 @@ export class ShutdownManager {
 
     for (const signal of signals) {
       process.on(signal, async () => {
-        logger.info(`Received ${signal}, starting graceful shutdown...`);
+        logger.debug(`Received ${signal}, starting graceful shutdown...`);
         try {
           await onShutdown();
           process.exit(0);

package/server/mcp/McpRouter.ts

@@ -138,13 +138,13 @@ export class McpRouter {
     try {
       const { tools, prompts, resourceTemplates, refusals, undescribed } = this.#getDocument();
       const counts = `tools=${tools.length} prompts=${prompts.length} resourceTemplates=${resourceTemplates.length}`;
-      McpRouter.logger.info(`MCP catalogue: ${counts}${this.#props.readOnly ? " (read-only deployment)" : ""}`);
+      McpRouter.logger.debug(`MCP catalogue: ${counts}${this.#props.readOnly ? " (read-only deployment)" : ""}`);
 
       if (!tools.length && !prompts.length)
         McpRouter.logger.warn(
           "MCP is enabled but published nothing. Every candidate was refused; see the reasons below.",
         );
-      for (const { key, reason } of refusals) McpRouter.logger.warn(`MCP did not expose "${key}": ${reason}`);
+      for (const { key, reason } of refusals) McpRouter.logger.verbose(`MCP did not expose "${key}": ${reason}`);
       for (const { key, reason } of undescribed)
         McpRouter.logger.warn(`MCP exposed "${key}" with no description: ${reason}`);
     } catch (error) {

package/signal/agent.signal.ts

@@ -10,11 +10,7 @@ import { Req } from "./internalArg";
 import { serverSignal } from "./serverSignal";
 import { SignalRegistry } from "./signalRegistry";
 
-export class AgentInternal extends internal(srv.agent, ({ initialize }) => ({
-  warnOpenRelay: initialize().exec(() => {
-    AgentRelayAccess.warnIfOpen();
-  }),
-})) {}
+export class AgentInternal extends internal(srv.agent, () => ({})) {}
 
 export class AgentEndpoint extends endpoint(srv.agent, ({ mutation }) => ({
 

package/signal/guards.ts

@@ -24,8 +24,8 @@ export type AgentRelayPolicy = (context: SignalContext) => boolean | Promise<boo
  * Gate for the `runAgentTurn` relay. Every tool runs in the caller's own browser session, so the LLM key is the
  * one thing this endpoint spends — ungated, any visitor can bill the app's provider through fetch alone.
  *
- * The framework has no account model to gate on, so with no policy registered it allows everyone — what `Public`
- * said before, but with a seam: a product hardens it at boot, e.g.
+ * The framework has no account model to gate on, so with no policy registered it refuses every call — the same
+ * answer `None` gives. An app opens it at boot, e.g.
  * `AgentRelayAccess.use((context) => !!context.get("account"))`. The policy is the app's; the framework cannot know it.
  */
 export class AgentRelayAccess implements Guard {
@@ -44,17 +44,9 @@ export class AgentRelayAccess implements Guard {
     return !!AgentRelayAccess.#policy;
   }
 
-  /** Runs at boot, after the app entry has evaluated — a module-scope check would fire before `use()` could. */
-  static warnIfOpen() {
-    if (AgentRelayAccess.#policy) return;
-    AgentRelayAccess.#logger.warn(
-      'runAgentTurn is open to every caller — anyone can spend the LLM key. Register a policy at boot: AgentRelayAccess.use((context) => !!context.get("account")), or set AKAN_AGENT=false.',
-    );
-  }
-
   async canPass(context: SignalContext): Promise<boolean> {
     const policy = AgentRelayAccess.#policy;
-    if (!policy) return true;
+    if (!policy) return false;
     try {
       return await policy(context);
     } catch (error) {

package/types/server/akanOption.d.ts

@@ -26,8 +26,8 @@ export declare class AkanOption<Env extends BackendEnv = BackendEnv> {
      */
     setMcp(mcp?: boolean | McpServerOption): this;
     /**
-     * Who may spend the LLM key through the `runAgentTurn` relay — the `AgentRelayAccess` policy, which defaults to
-     * allowing everyone because the framework has no account model to gate on. `null` reopens it.
+     * Who may spend the LLM key through the `runAgentTurn` relay. With no policy the call is refused — the same
+     * answer `None` gives — because the framework has no account model to gate on. `null` clears the policy.
      */
     setAgentAccess(policy: AgentRelayPolicy | null): this;
     /** Settings for whichever adaptor fills `LlmAdaptorRole`, injected into it as the `llmOption` use. */

package/types/signal/agent.signal.d.ts

@@ -1,12 +1,7 @@
-import { Any } from "akanjs/base";
 import { AgentTurn } from "./agentTurn.d.ts";
 declare const AgentInternal_base: import("./internal.d.ts").InternalCls<import("akanjs/service").ServiceModel<typeof import("akanjs/service").AgentService, any, any, {
     agentService: import("akanjs/service").AgentService;
-}>, {
-    warnOpenRelay: import("./internalInfo.d.ts").InternalInfo<"init", {
-        agentService: import("akanjs/service").AgentService;
-    }, [], [], [], typeof Any, void, false>;
-}>;
+}>, {}>;
 export declare class AgentInternal extends AgentInternal_base {
 }
 declare const AgentEndpoint_base: import("./endpoint.d.ts").EndpointCls<import("akanjs/service").ServiceModel<typeof import("akanjs/service").AgentService, any, any, {

package/types/signal/guards.d.ts

@@ -15,8 +15,8 @@ export type AgentRelayPolicy = (context: SignalContext) => boolean | Promise<boo
  * Gate for the `runAgentTurn` relay. Every tool runs in the caller's own browser session, so the LLM key is the
  * one thing this endpoint spends — ungated, any visitor can bill the app's provider through fetch alone.
  *
- * The framework has no account model to gate on, so with no policy registered it allows everyone — what `Public`
- * said before, but with a seam: a product hardens it at boot, e.g.
+ * The framework has no account model to gate on, so with no policy registered it refuses every call — the same
+ * answer `None` gives. An app opens it at boot, e.g.
  * `AgentRelayAccess.use((context) => !!context.get("account"))`. The policy is the app's; the framework cannot know it.
  */
 export declare class AgentRelayAccess implements Guard {
@@ -25,7 +25,5 @@ export declare class AgentRelayAccess implements Guard {
     static scope: GuardScope;
     static use(policy: AgentRelayPolicy | null): void;
     static get hasPolicy(): boolean;
-    /** Runs at boot, after the app entry has evaluated — a module-scope check would fire before `use()` could. */
-    static warnIfOpen(): void;
     canPass(context: SignalContext): Promise<boolean>;
 }