akanjs 3.0.0-beta.2 → 3.0.0-beta.21

package/types/signal/guards.d.ts

@@ -11,22 +11,14 @@ export declare class None implements Guard {
     canPass(context: SignalContext): boolean;
 }
 /**
- * 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 guard registered it refuses every call — the same
- * answer `None` gives. An app names its own at boot, e.g. `AgentRelayAccess.use(Every)`, usually through
- * `option.setAgentAccess(...)`. Several are ANDed, as an endpoint's own `guards` array is.
+ * Gates the `runAgentTurn` relay, which spends the app's LLM key. Refuses every call until the app registers guards
+ * (`option.setAgentAccess(...)`); several are ANDed.
  */
 export declare class AgentRelayAccess implements Guard {
     #private;
     static name: string;
     static use(guards: GuardCls | GuardCls[] | null): void;
     static get hasPolicy(): boolean;
-    /**
-     * Whatever the registered guards need, since this one only forwards to them. With none registered it reads the
-     * caller and nothing else — the refusal is unconditional — so a listing may still evaluate it argument-free.
-     */
     static get scope(): GuardScope;
     canPass(context: SignalContext): Promise<boolean>;
 }

package/types/signal/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./agent.d.ts";
 export * from "./agent.signal";
+export * from "./agentMeter.d.ts";
 export * from "./agentTurn.d.ts";
 export * from "./agentTurnStream.d.ts";
 export * from "./base.signal";

package/types/signal/internal.d.ts

@@ -11,13 +11,9 @@ export type InternalCls<SrvModule extends ServiceModel = ServiceModel, InternalI
 } = {
     [key: string]: InternalInfo;
 }> = AdaptorCls & {
-    /**
-     * The adaptor name, which `dangerouslyAdapt` suffixes — and which the DI container keys `live.internal` by.
-     * It used to be declared as the bare service name, so every typed read of it disagreed with the value.
-     */
+    /** The suffixed adaptor name the DI container keys `live.internal` by. */
     refName: `${SrvRefName<SrvModule>}Internal`;
     srv: SrvModule;
     [INTERNAL_META]: InternalInfoMap;
 };
-/** Builds an internal adaptor for schedules, queues, processes, and server-only jobs. */
 export declare function internal<SrvModule extends ServiceModel, InternalInfoMap extends ReturnType<InternalBuilder<SrvModule>>, LibInternals extends InternalCls[]>(srv: SrvModule, internalBuilder: (builder: BuildInternal<SrvModule>) => InternalInfoMap, ...libInternals: LibInternals): InternalCls<SrvModule, MergeAllKeyOfObjects<LibInternals, typeof INTERNAL_META> & InternalInfoMap>;

package/types/signal/internalArg.d.ts

@@ -4,11 +4,9 @@ export interface InternalArg<ArgType = unknown> {
     getArg: (context: SignalContext) => PromiseOrObject<ArgType | null>;
 }
 export type InternalArgCls<ArgType = unknown> = Cls<InternalArg<ArgType>>;
-/** Injects the current Bun request into an endpoint/internal handler. */
 export declare class Req implements InternalArg {
     getArg(context: SignalContext): Bun.BunRequest;
 }
-/** Injects the current mutable response context into an endpoint/internal handler. */
 export declare class Res implements InternalArg {
     getArg(context: SignalContext): {
         new (body?: BodyInit | null, init?: ResponseInit): Response;
@@ -18,21 +16,17 @@ export declare class Res implements InternalArg {
         redirect(url: string | URL, status?: number): Response;
     };
 }
-/**
- * Injects the caller's IP, as the nearest proxy recorded it rather than as the socket peer reports it.
- * Behind the federation gateway every peer is the gateway, so an endpoint that reads `remoteAddress` sees
- * `127.0.0.1` for every caller — this reads the forwarded headers first and falls back to the peer only
- * when nothing proxied the call. IPv4 comes back unwrapped from `::ffff:`, so it can address a `udp4`
- * socket. `null` when no proxy recorded one and the transport has no peer.
- */
+/** Whatever the account middleware resolved for this call, or `null` for an anonymous one. */
+export declare class CallerAccount implements InternalArg<unknown> {
+    getArg(context: SignalContext): unknown;
+}
+/** The caller's IP as the nearest proxy recorded it (see `SignalContext.getClientIp`), `null` when unknown. */
 export declare class Ip implements InternalArg<string | null> {
     getArg(context: SignalContext): string | null;
 }
 /**
- * Injects websocket state, this connection's id, and subscription hooks into message/pubsub handlers.
- * `socketId` is the one `AppWsData` minted at the handshake, so a handler never reads `ws.data` to
- * tell two callers apart — and never mints an id of its own, which would not match the room bookkeeping.
- * `on`/`off` register cleanup that runs when the room is unsubscribed or the socket closes.
+ * `socketId` is the one minted at the handshake — never mint your own, it would not match the room bookkeeping.
+ * `on`/`off` register cleanup for unsubscribe or socket close.
  */
 export declare class Ws implements InternalArg {
     getArg(context: SignalContext): {

package/types/signal/mcp/McpDocument.d.ts

@@ -4,18 +4,11 @@ import type { McpResource, McpResourceTemplate, McpTool } from "./mcpProtocol.d.
 export interface McpDocumentOptions {
     resolveDescription?: (key: string) => string | undefined;
     excludeSignals?: string[];
-    /**
-     * Drops every mutation from the catalogue regardless of what it opted into. Off by default: the endpoint's own
-     * an endpoint's guards are the decision, and a second switch that silently unlists a published endpoint gives
-     * its author no way to see why. This is the read-only-deployment valve.
-     */
+    /** Drops every mutation from the catalogue whatever its guards allow. Off by default. */
     readOnly?: boolean;
     /**
-     * How much of a result's shape a tool advertises. `shallow`, the default, publishes the returned model with every
-     * field of its own and names each nested model instead of inlining it: on a fully open catalogue 83% of the bytes
-     * were the same model schemas re-inlined per entry, most of them nested closures. `full` inlines the closure the
-     * way a shared component section would. `none` publishes no `outputSchema` at all — results still ship as
-     * `structuredContent` — for a deployment that would rather spend the bytes per call.
+     * `shallow` (default) names each nested model instead of inlining it, `full` inlines the closure, `none` publishes
+     * no `outputSchema` (results still ship as `structuredContent`).
      */
     outputSchema?: McpOutputSchemaMode;
 }
@@ -25,13 +18,8 @@ export interface McpExposedEndpoint {
     key: string;
     endpoint: SerializedEndpoint;
 }
-/**
- * A candidate this catalogue did not publish. The bookkeeping is audience-independent and lives on
- * `AgentCatalogue`; these are the MCP names for it.
- */
 export type McpRefusal = AgentRefusal;
 export type McpUndescribed = AgentUndescribed;
-/** What one signal contributes to a listing, so a catalogue that grew can say where it grew. */
 export interface McpSignalCost {
     refName: string;
     entries: number;
@@ -41,49 +29,21 @@ export interface McpListingCost {
     bytes: number;
     bySignal: McpSignalCost[];
 }
-/**
- * Turns the serialized signal registry into the three MCP catalogues and answers the lookups `tools/call` and
- * `resources/read` need. Pure: no IO and no DI — the sibling of `createOpenApiDocument`.
- */
 export declare class McpDocument {
     #private;
-    /**
-     * An array cannot be `structuredContent` — the spec types it as an object — so a list result is wrapped under
-     * this key and `outputSchema` is shaped to match. Both halves must agree, which is why they live together.
-     */
+    /** The spec types `structuredContent` as an object, so a list result is wrapped under this key. */
     static readonly listKey = "items";
     readonly tools: McpTool[];
     readonly resourceTemplates: McpResourceTemplate[];
     /** Every readable thing is addressed by a template, so there are no fixed resources to enumerate. */
     readonly resources: McpResource[];
-    /**
-     * Every candidate that was not published, with the sentence saying why — the rejections are fail-closed by
-     * design, and an author whose endpoint is missing otherwise has nowhere to look but the framework source.
-     */
     readonly refusals: McpRefusal[];
-    /** What is published with no description of its own, which is the field a model picks a tool by. */
     readonly undescribed: McpUndescribed[];
     constructor(serializedSignal: Record<string, SerializedSignal>, options?: McpDocumentOptions);
-    /**
-     * Roughly what a `tools/list` costs the caller, and which signals it went to.
-     *
-     * Worth reporting because the number is nobody's intuition: MCP has no shared component section and forbids a
-     * `$ref` across entries, so every entry inlines the schema of every model it mentions — under `outputSchema:
-     * "full"` a plain 21-field model with one named slice ships 12KB across its eight entries, three quarters of it
-     * the same four schemas repeated. A catalogue is re-sent whole to every agent that connects, before its first turn.
-     */
     get listingCost(): McpListingCost;
     findTool(name: string): McpExposedEndpoint | undefined;
-    /**
-     * The uri `resources/read` answers for one call of a tool, or undefined for a tool that has no template. What a
-     * page fetched is attached to a prompt under the address an agent can read it back from.
-     */
     resourceUri(key: string, args: Record<string, unknown>): string | undefined;
-    /**
-     * Resolves a URI only when the endpoint behind it was published as a template. An endpoint that was never
-     * advertised has to fail here rather than fall through to its guards: opting out of MCP means keeping a thing
-     * off the wire entirely, not merely making it refuse.
-     */
+    /** Only a published template resolves: an opted-out endpoint must be unreachable, not merely refused by guards. */
     resolveResource(uri: string): {
         exposed: McpExposedEndpoint;
         args: Record<string, string | string[]>;

package/types/signal/mcp/McpProgress.d.ts

@@ -1,39 +1,26 @@
 export interface McpProgressOption {
-    /** Denominator for the ratio a client renders. Omit when the amount of work is not known up front. */
+    /** Omit when the amount of work is not known up front. */
     total?: number;
-    /** One short line describing the current step. Shown to the user, so keep it prose rather than a status code. */
+    /** Shown to the user, so write prose rather than a status code. */
     message?: string;
 }
 export interface McpProgressReport extends McpProgressOption {
     progress: number;
 }
 /**
- * The progress channel for one streamed MCP call.
- *
- * Reached through `AsyncLocalStorage` rather than a parameter so an endpoint reports progress from wherever the
- * work actually happens — a service, an adapter, a loop several frames down — without every signature between
- * here and there growing a channel argument. Outside a streamed call `report` is a no-op, so the same endpoint
- * code runs unchanged over plain HTTP, a websocket, or a test.
+ * Reached through `AsyncLocalStorage` so any frame of the work can report; outside a streamed call `report` is a
+ * no-op, so the same endpoint runs unchanged over HTTP, a websocket or a test.
  */
 export declare class McpProgress {
     #private;
-    /**
-     * Reports progress for the call running on this stack. Silent when nothing is listening, which is every call
-     * that did not ask for a stream.
-     */
     static report(progress: number, option?: McpProgressOption): void;
-    /** True while the caller is streaming, so an expensive progress message can be skipped when nobody reads it. */
     static get streaming(): boolean;
     static run<T>(channel: McpProgress, exec: () => Promise<T>): Promise<T>;
-    /** Resolves on the first report and never otherwise — a call that reports nothing has nothing to stream. */
+    /** Resolves on the first report, and never for a call that reports nothing. */
     readonly started: Promise<void>;
     constructor();
-    /**
-     * Aborted when the client closes the response stream, which is how cancellation is signalled over this
-     * transport. Long-running work may watch it; the framework cannot force an `exec` already in flight to stop.
-     */
+    /** Aborted when the client closes the response stream; an `exec` already in flight is not forced to stop. */
     get signal(): AbortSignal;
-    /** Yields every report until the call finishes. Buffered ones come out first, so none is lost to a late reader. */
     reports(): AsyncGenerator<McpProgressReport>;
     end(): void;
     abort(): void;

package/types/signal/mcp/McpUriTemplate.d.ts

@@ -2,30 +2,12 @@ export interface McpResourceTarget {
     endpointKey: string;
     args: Record<string, string | string[]>;
 }
-/**
- * Two-way map between an `akan://` resource URI and the endpoint that answers it.
- *
- * Parsing is done by hand rather than through `URL`: `akan:` is a non-special scheme, and how a runtime
- * normalizes the authority of one (case, percent-decoding) is exactly where a camelCase refName like
- * `agentSession` would quietly stop matching its model.
- */
 export declare class McpUriTemplate {
     #private;
     static readonly scheme = "akan";
     static model(refName: string): string;
-    /**
-     * The model's own unfiltered list is the bare `…/list`, never `…/list/<token>`. A named slice occupies the
-     * third segment, and a slice key is an author-chosen identifier — so any token put there for the root list
-     * would be one a slice could also be called, and the two would publish the same uri with only one of them
-     * readable. `list` in the *second* segment is already reserved against a model id, so there is nothing to
-     * collide with here.
-     */
+    /** The root list is the bare `…/list`: any third-segment token could also be an author's slice key. */
     static list(refName: string, sliceKey: string, argNames: string[]): string;
-    /**
-     * The uri a template names for one call's arguments — the inverse of `parse`, so what a page fetched can be
-     * attached under the address an agent may read it back from. A list argument repeats its key; an absent
-     * optional one is left out.
-     */
     static expand(template: string, args: Record<string, unknown>): string;
     static parse(uri: string): McpResourceTarget | null;
 }

package/types/signal/mcp/Msg.d.ts

@@ -1,20 +1,11 @@
 import { type MaskModel } from "akanjs/constant";
 import type { JsonSchema } from "../schema.d.ts";
 export type PromptRole = "user" | "assistant";
-/**
- * What a client may do with a block when it cannot keep all of them.
- *
- * `priority` is the field that matters here: a prompt this server assembles is often mostly context — a document
- * embedded beside the one line asking for something — and a client with a full window drops blocks by this number
- * rather than by position. Leaving it off means every block is equally droppable, so the instruction can go and
- * the attachment stay.
- */
 export interface PromptAnnotations {
-    /** Who the block is for. A note meant only for the model is `["assistant"]`, so a UI need not render it. */
     audience?: PromptRole[];
-    /** 0 is "drop this first", 1 is "this is the point of the prompt". Anything outside the range is refused. */
+    /** 0 = drop first, 1 = the point of the prompt; omitted = as droppable as any block; outside 0..1 throws. */
     priority?: number;
-    /** ISO 8601. Lets a client tell a re-fetched resource from the copy it already holds. */
+    /** ISO 8601. */
     lastModified?: string;
 }
 export interface PromptTextContent {
@@ -51,93 +42,45 @@ export interface PromptMessage {
     role: PromptRole;
     content: PromptContent;
 }
-/** What a `prompt()` exec may return. A bare string is the 80% case and is wrapped into one user message. */
+/** A bare string is wrapped into one user message. */
 export type PromptResult = string | PromptMessage[];
-/** Enough of the `File` model to link or inline it, structural so the framework does not depend on the lib. */
+/** Structural, so the framework does not depend on the lib's `File` model. */
 export interface PromptFileSource {
     url: string;
     filename?: string;
     mimetype?: string;
 }
-/**
- * A model class, named by the caller so an attachment can be masked by what it *is* rather than by what it still
- * carries at runtime. The same model any other audience masks by — see `mask` in `akanjs/constant`.
- */
 export type PromptModel = MaskModel;
 /**
- * Builds the messages a `prompt()` endpoint returns.
- *
- * Named `Msg` rather than `msg` because `akanjs/dictionary` already exports a `msg` for toasts.
- *
- * Every attachment builder carries the `user` role. Content the server assembles is context handed *to* the
- * model, which is what the user role means; an assistant-role attachment would be the server putting words in the
- * model's mouth. That is only meaningful for few-shot text, which `Msg.assistant` covers.
+ * Named `Msg` because `akanjs/dictionary` already exports a `msg`. Attachments carry the `user` role: an
+ * assistant-role attachment would put the server's words in the model's mouth.
  */
 export declare class Msg {
     #private;
-    /**
-     * What every `prompt()` route answers with, as JSON Schema, for the app's OpenAPI document.
-     *
-     * A prompt declares `Any` on the wire, so the generated response schema was `{}` — a documented `GET` whose body
-     * the document could not describe, which is half of the agreement the HTTP route was mounted for. The shape is
-     * fixed by the protocol rather than by the endpoint, so it is written once, here: the block types and the fields
-     * each must carry come off `contentFields`, so a type added to one cannot describe itself out of the other.
-     */
+    /** JSON Schema of a prompt message for the OpenAPI document, since a prompt declares `Any` on the wire. */
     static readonly schema: JsonSchema;
     static user(text: string, annotations?: PromptAnnotations): PromptMessage;
     static assistant(text: string, annotations?: PromptAnnotations): PromptMessage;
     /**
-     * Embeds the value itself. The payload travels in the prompt, so prefer `link` for anything large.
-     *
-     * Name the model it is an instance of and the `hidden`/`secret` fields are stripped before it goes out:
-     * `Msg.resource(uri, order, { model: cnst.Order })`. A payload you assembled yourself needs no model and is
-     * embedded as given — but one that still carries a document's secret fields is refused rather than sent, so
-     * the rule is the same either way: a document travels masked, or it does not travel.
+     * Naming the `model` strips its `hidden`/`secret` fields; an unnamed payload that still carries populated ones
+     * throws rather than being sent.
      */
     static resource(uri: string, value: unknown, { model, ...annotations }?: {
         model?: PromptModel;
     } & PromptAnnotations): PromptMessage;
     /**
-     * Strips what a model marks `hidden` or `secret`, by the model the caller names rather than by the one the
-     * value happens to still carry.
-     *
-     * That distinction is the whole fix. A check that reads the class off the value can only mask what arrives as an
-     * instance, so a `{ ...doc }` spread, a `toJSON()`, or a round-trip through `JSON.stringify` reached the wire
-     * with the metadata already gone and nothing could be done about it. A named model is metadata the value cannot
-     * lose, so a hydrated document and a plain object copied out of one mask identically.
-     *
-     * This is the field half of `resolveReturn` and deliberately not the whole of it. That one also loads every
-     * relation it walks past, which is right for a query's return value and wrong for an attachment, where it would
-     * turn embedding one document into a fan of queries nobody asked for. So a populated relation is masked in
-     * place and one that is still an id is left as an id.
-     *
-     * Public because a payload can be an assembly of several documents — `{ order, customer }` names no single
-     * model, so each piece is masked on its way in.
-     *
-     * Returns `unknown` rather than the argument's type, because what comes back is missing fields that type still
-     * promises. The value's only destination is a JSON payload, so nothing downstream wanted the type anyway.
+     * Masks by the named model rather than the value's class, which a spread or a JSON round-trip loses. Unlike
+     * `resolveReturn` it loads no relation: a populated one is masked in place, an id stays an id.
      */
     static mask(model: PromptModel, value: unknown): unknown;
-    /**
-     * Points at something without paying for it. The client decides whether to fetch, and skips what it already
-     * holds — so a prompt that references twenty documents costs twenty URIs rather than twenty payloads.
-     */
     static link(source: string | PromptFileSource, { name, description, ...annotations }?: {
         name?: string;
         description?: string;
     } & PromptAnnotations): PromptMessage;
     static image(data: string, mimeType: string, annotations?: PromptAnnotations): PromptMessage;
     static audio(data: string, mimeType: string, annotations?: PromptAnnotations): PromptMessage;
-    /**
-     * Inlines a file as base64, costing roughly 1.33× its bytes in the prompt. Worth it only when the client
-     * cannot fetch the URL itself — a public asset is cheaper as `Msg.link`. Fetched as this process, so a file
-     * behind a caller-scoped signed URL needs its bytes passed to `Msg.image` instead.
-     */
+    /** Fetched as this process, so a file behind a caller-scoped signed URL needs its bytes passed to `Msg.image`. */
     static imageOf(file: PromptFileSource, annotations?: PromptAnnotations): Promise<PromptMessage>;
-    /**
-     * The one runtime check on a prompt's return value. `prompt()` carries `Any` on the wire so the signal
-     * pipeline hands the value back untouched — nothing upstream would notice a malformed message, and the client
-     * would receive it as a valid prompt.
-     */
+    /** The only runtime check on a prompt's value: `prompt()` carries `Any`, so nothing upstream inspects it. */
     static normalize(value: unknown): PromptMessage[];
 }

package/types/signal/mcp/mcpProtocol.d.ts

@@ -1,17 +1,3 @@
-/**
- * Wire vocabulary for the MCP revisions this server answers.
- *
- * `2026-07-28` made the protocol stateless — no `initialize`, no session id, no server-opened stream — which is
- * what makes a single `POST /mcp` route sufficient. Everything before it is the *legacy* era, still what shipping
- * clients speak (measured: Claude Code 2.1.226 negotiates `2025-11-25`), and supporting it costs almost nothing
- * here because a legacy server *may* decline to issue `Mcp-Session-Id`: without one the client sends no session
- * header and never asks to resume a stream, so both eras run over the same stateless handler.
- *
- * `2025-06-18` is listed for the same reason. The surface this server actually implements — POST-only Streamable
- * HTTP, no sessions, no server-initiated requests — is wire-identical between the two legacy revisions, and a
- * client that proposes a version the server does not list is told to disconnect. Naming only the one revision that
- * was measured turned "we tested against this" into "we refuse everything else".
- */
 export declare const MCP_MODERN_VERSION = "2026-07-28";
 export declare const MCP_LEGACY_VERSION = "2025-11-25";
 export declare const MCP_LEGACY_PRIOR_VERSION = "2025-06-18";
@@ -24,14 +10,6 @@ export declare const MCP_META_PROTOCOL_VERSION = "io.modelcontextprotocol/protoc
 export declare const MCP_META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
 export declare const MCP_META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
 export declare const MCP_META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
-/**
- * `-32020`..`-32099` is reserved by the spec, so nothing outside this table may be minted in that band.
- * `-32002` (resource not found) is retired in the modern revision; unknown resources are `invalidParams`.
- *
- * The band also defines `-32021 missingRequiredClientCapability`, which is absent because this server requires
- * none: it never samples, elicits, or reads roots. It belongs here the day one of those appears, not before — a
- * constant nothing emits reads as a check someone forgot to write.
- */
 export declare const McpErrorCode: {
     readonly parse: -32700;
     readonly invalidRequest: -32600;
@@ -83,10 +61,7 @@ export interface McpPromptArgument {
     description?: string;
     required?: boolean;
 }
-/**
- * A prompt is user-controlled — the client offers it as a slash command and the model never invokes it — so its
- * `title` and `description` are read by a person, not inferred from a schema the way a tool's are.
- */
+/** User-controlled: a client offers it as a slash command, so a person reads its `title` and `description`. */
 export interface McpPrompt {
     name: string;
     title?: string;

package/types/signal/mcp/pagePrompt.d.ts

@@ -1,13 +1,11 @@
 import type { McpPromptArgument } from "./mcpProtocol.d.ts";
-/** One `page().prompt(name, description)` as the catalogue lists it, with the route it was declared on. */
 export interface PagePromptEntry {
     name: string;
     description: string;
     arguments: McpPromptArgument[];
-    /** The matched route pattern (`/:lang/project/:projectId`), which is also what names the screen to a model. */
+    /** The matched route pattern, e.g. `/:lang/project/:projectId`. */
     pattern: string;
 }
-/** One `fetch.*` query the page made while its body ran, with the answer it received. */
 export interface PagePromptRecord {
     key: string;
     args: Record<string, unknown>;
@@ -35,15 +33,11 @@ export interface PagePromptRunInput {
     name: string;
     /** `prompts/get` sends a flat string map; the page's own declaration types each value. */
     arguments: Record<string, string>;
-    /** The caller's request headers the page run should carry — the bearer token above all. */
     headers: [string, string][];
-    /** The locale segment the synthetic URL starts with; the route needs one whether or not the page reads it. */
+    /** The synthetic URL's locale segment, which the route needs whether or not the page reads it. */
     language?: string;
 }
-/**
- * Where page prompts come from. Pages live in the RSC worker, a process apart from the one that serves `/mcp`,
- * so the MCP router speaks to them through this rather than by importing route modules of its own.
- */
+/** Pages live in the RSC worker, a process apart from the one serving `/mcp`, so the router reaches them through this. */
 export interface PagePromptSource {
     list(): Promise<PagePromptEntry[]>;
     run(input: PagePromptRunInput): Promise<PagePromptRun>;

package/types/signal/middleware.d.ts

@@ -21,15 +21,6 @@ declare const Logging_base: {
 export declare class Logging extends Logging_base {
     use(): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<unknown>>;
 }
-declare const Cache_base: {
-    new (): {
-        use(env: BackendEnv): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<unknown>>;
-    };
-    refName: string;
-};
-export declare class Cache extends Cache_base {
-    use(): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<any>>;
-}
 declare const Timeout_base: {
     new (): {
         use(env: BackendEnv): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<unknown>>;
@@ -39,13 +30,4 @@ declare const Timeout_base: {
 export declare class Timeout extends Timeout_base {
     use(): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<unknown>>;
 }
-declare const Retry_base: {
-    new (): {
-        use(env: BackendEnv): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<unknown>>;
-    };
-    refName: string;
-};
-export declare class Retry extends Retry_base {
-    use(): Promise<(context: SignalContext, next: () => Promise<unknown>) => Promise<unknown>>;
-}
 export {};

package/types/signal/schema/JsonSchemaBuilder.d.ts

@@ -2,71 +2,43 @@ import { type ConstantCls } from "akanjs/constant";
 import type { SerializedArg, SerializedReturns } from "../types.d.ts";
 export type JsonSchema = Record<string, unknown>;
 export interface JsonSchemaBuilderOptions {
-    /**
-     * Where a model `$ref` points. OpenAPI collects every model under `components/schemas`, while MCP requires each
-     * tool schema to resolve on its own and so embeds its models in a per-schema `$defs`.
-     */
+    /** Default `#/components/schemas/` (OpenAPI); MCP embeds each tool's models in a per-schema `$defs`. */
     refPrefix?: string;
-    /**
-     * How a nullable schema is spelled. `anyOf` with a null branch is the OpenAPI habit and the default; `type` merges
-     * `"null"` into a schema that has one plain `type` (and lists `null` in its `enum`, which would otherwise still
-     * refuse it) — the shorter form a listing that is re-sent to every agent is paid for by the byte.
-     */
+    /** `anyOf` (default) adds a null branch; `type` merges `"null"` into a plain `type` (and its `enum`), shorter. */
     nullable?: "anyOf" | "type";
+    /** `wire` (default) is the HTTP body shape; `agent` uses a primitive's `agent.schema` when it declares one. */
+    face?: JsonSchemaFace;
 }
+export type JsonSchemaFace = "wire" | "agent";
 export type JsonSchemaRelations = "inline" | "id" | "named";
 export interface JsonSchemaModelOptions {
     /**
-     * Drops `hidden`, `secret`, and `visual` fields. `SignalContext.resolveReturn` strips the first two from every
-     * response, so naming them describes a value the caller can never read — and on a model like `user` the names
-     * are themselves the leak: `password`, `accountId`, `phone` published as readable properties of the model. This
-     * is the one place a field the framework blocks on every value path is still visible, so it is scoped to schemas
-     * that describe a *response*. A request body is a different shape and legitimately carries all three.
-     *
-     * `visual` is dropped here because it is dropped from the payload an AI caller receives, and a schema that
-     * promises a field the value omits is worse than one that never named it: a non-optional visual field would be
-     * listed `required` and a validating client would refuse the whole result.
+     * Response schemas only: drops `hidden`/`secret` (stripped from every response, and on `user` the names alone
+     * leak) and `visual` (stripped for AI callers, so listing it `required` would make a client refuse the result).
      */
     readable?: boolean;
     /**
-     * How a field holding another database model is described. `inline` follows the `$ref`, which is right where
-     * schemas share a component section. `id` is what a request body carries: `serialize` sends a relation as its id,
-     * so a schema showing the whole related object asks the caller for a shape the server never reads. `named` is for
-     * a response: the nested document becomes `{ type: "object" }` carrying its model name, so the returned model
-     * keeps every field of its own and stops dragging its relations' closures into each copy. An embedded scalar has
-     * no tool of its own and stays inline under either.
+     * A database-model field: `inline` (default) follows the `$ref`, `id` is what a request body carries, `named` is
+     * `{ type: "object" }` with the model name. An embedded scalar always stays inline.
      */
     relations?: JsonSchemaRelations;
-    /**
-     * Whether an id carries the 24-hex `pattern`. Kept on a top-level argument, where it is read once; dropped inside
-     * a per-tool `$defs`, where it would repeat on every id field of every copy.
-     */
+    /** Whether an id carries the 24-hex `pattern` (default `true`). */
     idPattern?: boolean;
 }
-/**
- * Turns serialized signal metadata and Akan constants into JSON Schema (2020-12 by default, which is also what
- * OpenAPI 3.1 uses). One builder per output dialect target — `new` it at the call site, it holds no shared state.
- */
 export declare class JsonSchemaBuilder {
     #private;
-    constructor({ refPrefix, nullable }?: JsonSchemaBuilderOptions);
+    constructor({ refPrefix, nullable, face, }?: JsonSchemaBuilderOptions);
     arg(arg: SerializedArg): JsonSchema;
     upload(arg: SerializedArg): JsonSchema;
     returns(returns: SerializedReturns): JsonSchema;
     model(modelRef: ConstantCls, options?: JsonSchemaModelOptions): JsonSchema;
-    /** Every registered model, keyed by schema name. Callers narrow this with `referencedSchemas`. */
     allModelSchemas(options?: JsonSchemaModelOptions): Record<string, JsonSchema>;
-    /**
-     * The models `seed` references, plus everything those transitively reference, sorted by name.
-     *
-     * `allSchemas` is derived from the registry, so a caller that narrows many seeds against the same registry —
-     * MCP builds one per tool schema and one per output schema — passes its own copy rather than rebuilding every
-     * registered model each time. Holding it here instead would make this builder stateful, and the one in
-     * `openapi.ts` lives at module scope for the life of the process.
-     */
+    /** The transitive closure of the models `seed` references, sorted by name. Pass `allSchemas` when narrowing often. */
     referencedSchemas(seed: unknown, allSchemas?: Record<string, JsonSchema>): {
         [k: string]: JsonSchema;
     };
     collectRefNames(value: unknown): Set<string>;
-    static primitive(refName: string, { idPattern }?: Pick<JsonSchemaModelOptions, "idPattern">): JsonSchema;
+    static primitive(refName: string, { idPattern, face }?: Pick<JsonSchemaModelOptions, "idPattern"> & {
+        face?: JsonSchemaFace;
+    }): JsonSchema;
 }

package/types/signal/serializer/fetch.serializer.d.ts

@@ -6,12 +6,7 @@ export declare class FetchSerializer {
     static logger: Logger;
     static serializeDatabaseSignal(sliceCls: SliceCls, endpointCls: EndpointCls): SerializedSignal;
     static serializeServiceSignal(endpointCls: EndpointCls): SerializedSignal;
-    /**
-     * A container that never finished initializing has empty registries rather than none, so a caller reaching a
-     * devtools or MCP route before boot completed gets an empty catalogue. Destructuring the registry used to
-     * throw before the loop, which surfaced as `Cannot destructure property 'endpointCls' from null` on a route
-     * whose honest answer is "nothing is registered yet".
-     */
+    /** A container that has not finished booting answers an empty catalogue rather than throwing. */
     static serializeRegistry(live: LiveRegistry | null | undefined): {
         signal: {
             [key: string]: SerializedSignal;

package/types/signal/serverSignal.d.ts

@@ -34,6 +34,5 @@ export type ServerSignalClsStatics = {
 export type ServerSignalMethods<EnpCls, IntCls> = EndpointServerSignalMethods<EnpCls> & InternalServerSignalMethods<IntCls>;
 export type TypedServerSignalCls<EnpCls, IntCls> = AdaptorCls<ServerSignalMethods<EnpCls, IntCls> & ServerSignal> & ServerSignalClsStatics;
 export type ServerSignalCls<EnpCls = unknown, IntCls = unknown> = AdaptorCls<ServerSignalMethods<EnpCls, IntCls> & ServerSignal> & ServerSignalClsStatics;
-/** Composes endpoint and internal classes into a server-side signal class. */
 export declare const serverSignal: <EnpCls, IntCls>(endpointRef: EnpCls, internalRef: IntCls) => ServerSignalCls<EnpCls, IntCls>;
 export {};