ankka 0.12.0 → 0.14.0

package/dist/autonomous.js

@@ -16,6 +16,7 @@
 // request's tools run again — so a tool with a side effect should tolerate a repeat.
 import { requestFromJson } from "./approvals.js";
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { decodeJsonValue, reviver } from "./json.js";
 import { toJsonSchema } from "./schema.js";
 import { servicesFor } from "./services.js";
@@ -68,6 +69,15 @@ export class AutonomousAgent {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {

package/dist/client-keys.d.ts

@@ -0,0 +1,89 @@
+import { type ComponentClient } from "./client.ts";
+import { Duration, Instant } from "./time.ts";
+/** The first protocol whose runtime keeps client keys; an older one answers `UNIMPLEMENTED`. */
+export declare const CLIENT_KEYS_SINCE = "1.20";
+/** When a client key stops being admitted. There is no default: the issuer says, every time. */
+export type Expiry = {
+    readonly kind: "after";
+    readonly millis: number;
+} | {
+    readonly kind: "at";
+    readonly epochMillis: number;
+} | {
+    readonly kind: "never";
+};
+export declare const Expiry: Readonly<{
+    /** After a while from now: `Expiry.after({ days: 365 })`, or a `Duration`. */
+    after(by: Duration | {
+        readonly days?: number;
+        readonly hours?: number;
+        readonly minutes?: number;
+        readonly seconds?: number;
+        readonly millis?: number;
+    }): Expiry;
+    /** At an instant. */
+    at(when: Instant | Date): Expiry;
+    /** Never: admitted until it is revoked. */
+    never: Expiry;
+}>;
+/** What to issue: the subject a tool is told, how long, and what for. */
+export interface IssueClientKey {
+    readonly subject: string;
+    readonly expiry: Expiry;
+    /** The MCP endpoint's path; needed only when the service has several. */
+    readonly endpoint?: string;
+    /** The tools the key may call; every tool when empty. */
+    readonly scope?: Iterable<string>;
+    /** What a tool reads as the principal's claims: at most 16, each name and value at most 256 characters. */
+    readonly attributes?: Readonly<Record<string, string>>;
+    readonly label?: string;
+}
+/** An issued key: its id, which lists and revokes it, and the key, shown here once. */
+export interface IssuedClientKey {
+    readonly id: string;
+    readonly clientKey: string;
+}
+/** One client key as a listing shows it: never the key, nor anything it could be derived from. */
+export interface ClientKeySummary {
+    readonly id: string;
+    readonly subject: string;
+    readonly attributes: Readonly<Record<string, string>>;
+    readonly label: string | null;
+    readonly endpoint: string;
+    readonly scope: readonly string[];
+    readonly issuedAt: Instant;
+    readonly expiresAt: Instant | null;
+    readonly lastUsed: Instant | null;
+    readonly revokedAt: Instant | null;
+}
+/**
+ * The service's client keys, kept by the runtime. A refusal is a `CommandError` with the runtime's
+ * code: `BAD_REQUEST` for a request that breaks a rule, `UNAVAILABLE` when the service's MCP
+ * endpoints admit no client key (there is then nothing to keep them), `NOT_FOUND` for an unknown id.
+ */
+export declare class ClientKeys {
+    #private;
+    /** The keys reached through `client`'s sidecar; with none, every call throws. */
+    constructor(client?: ComponentClient);
+    /** Issues a key; the answer is the one place the key is ever shown. */
+    issue(request: IssueClientKey): Promise<IssuedClientKey>;
+    /** Every client key of the service, revoked ones included; never a key itself. */
+    list(): Promise<ClientKeySummary[]>;
+    /** Revokes a key: refused on its next request on every instance. Revoking twice is not an error. */
+    revoke(id: string): Promise<void>;
+}
+/** Client keys for unit tests: a map, issuing keys that look like the runtime's and applying its rules. */
+export declare class InMemoryClientKeys extends ClientKeys {
+    #private;
+    constructor();
+    /** The key issued under `id`, which a test may present; the runtime shows it only once. */
+    keyOf(id: string): string | undefined;
+    issue(request: IssueClientKey): Promise<IssuedClientKey>;
+    list(): Promise<ClientKeySummary[]>;
+    revoke(id: string): Promise<void>;
+}
+/**
+ * @internal The client keys reached through `client`'s sidecar. Not a member of the client, which an
+ * entity holds too: only the component kinds that may issue keys call this.
+ */
+export declare function clientKeysFor(client: ComponentClient): ClientKeys;

package/dist/client-keys.js

@@ -0,0 +1,182 @@
+// A service's client keys (protocol 1.20): credentials it issues for its MCP endpoint, each for one
+// subject, with an expiry, an optional scope of tools and attributes a tool reads as the principal's
+// claims. The runtime keeps them; this process sees a key once, in the answer to `issue`, and never
+// again. Offered to endpoints, MCP endpoints, timed actions and agents, as the secret store is.
+//
+//   const issued = await this.clientKeys.issue({ subject: "acme", expiry: Expiry.after({ days: 365 }), scope: ["list_jobs"] })
+//   issued.clientKey   // shown here, and nowhere again
+import { Code, ConnectError } from "@connectrpc/connect";
+import { channelOf } from "./client.js";
+import { metadataToProto } from "./context.js";
+import { CommandError, ErrorCode } from "./effects/common.js";
+import { errorCodeFromProto } from "./kinds.js";
+import { PROTOCOL_VERSION } from "./spec.js";
+import { Duration, Instant } from "./time.js";
+/** The first protocol whose runtime keeps client keys; an older one answers `UNIMPLEMENTED`. */
+export const CLIENT_KEYS_SINCE = "1.20";
+export const Expiry = Object.freeze({
+    /** After a while from now: `Expiry.after({ days: 365 })`, or a `Duration`. */
+    after(by) {
+        const millis = by instanceof Duration
+            ? by.toMillis()
+            : (by.days ?? 0) * 86_400_000 + (by.hours ?? 0) * 3_600_000 + (by.minutes ?? 0) * 60_000 + (by.seconds ?? 0) * 1_000 + (by.millis ?? 0);
+        if (!Number.isFinite(millis) || millis <= 0)
+            throw new TypeError(`a client key's expiry is a positive while, not ${millis}ms`);
+        return Object.freeze({ kind: "after", millis });
+    },
+    /** At an instant. */
+    at(when) {
+        const epochMillis = when instanceof Instant ? when.toEpochMilli() : when.getTime();
+        return Object.freeze({ kind: "at", epochMillis });
+    },
+    /** Never: admitted until it is revoked. */
+    never: Object.freeze({ kind: "never" }),
+});
+function refusalOf(error) {
+    return new CommandError({ message: error.message, code: errorCodeFromProto(error.code), details: { ...(error.details ?? {}) } });
+}
+function tooOld(failure) {
+    if (failure instanceof ConnectError && failure.code === Code.Unimplemented) {
+        throw new CommandError({
+            message: `the runtime beside this process is too old for client keys, which needs protocol ${CLIENT_KEYS_SINCE}; this process speaks ${PROTOCOL_VERSION}: ${failure.rawMessage}`,
+            code: ErrorCode.Internal,
+        });
+    }
+    throw failure;
+}
+function instant(millis) {
+    return millis === undefined ? null : Instant.ofEpochMilli(Number(millis));
+}
+/**
+ * The service's client keys, kept by the runtime. A refusal is a `CommandError` with the runtime's
+ * code: `BAD_REQUEST` for a request that breaks a rule, `UNAVAILABLE` when the service's MCP
+ * endpoints admit no client key (there is then nothing to keep them), `NOT_FOUND` for an unknown id.
+ */
+export class ClientKeys {
+    #client;
+    /** The keys reached through `client`'s sidecar; with none, every call throws. */
+    constructor(client) {
+        this.#client = client;
+    }
+    #channel() {
+        const channel = this.#client ? channelOf(this.#client) : undefined;
+        if (!channel)
+            throw new Error("these client keys are not connected to a runtime; a unit test passes an InMemoryClientKeys");
+        return channel;
+    }
+    /** Issues a key; the answer is the one place the key is ever shown. */
+    async issue(request) {
+        const { stub, metadata } = this.#channel();
+        const expiry = request.expiry;
+        const reply = await stub()
+            .issueClientKey({
+            subject: request.subject,
+            expiry: expiry.kind === "after"
+                ? { case: "afterMillis", value: BigInt(expiry.millis) }
+                : expiry.kind === "at"
+                    ? { case: "atEpochMillis", value: BigInt(expiry.epochMillis) }
+                    : { case: "never", value: true },
+            ...(request.endpoint !== undefined ? { endpoint: request.endpoint } : {}),
+            scope: [...(request.scope ?? [])],
+            attributes: { ...(request.attributes ?? {}) },
+            ...(request.label !== undefined ? { label: request.label } : {}),
+            metadata: metadataToProto(metadata),
+        })
+            .catch(tooOld);
+        switch (reply.reply.case) {
+            case "issued":
+                return Object.freeze({ id: reply.reply.value.id, clientKey: reply.reply.value.clientKey });
+            case "error":
+                throw refusalOf(reply.reply.value);
+            default:
+                throw new CommandError({ message: "the runtime answered an issue with nothing", code: ErrorCode.Internal });
+        }
+    }
+    /** Every client key of the service, revoked ones included; never a key itself. */
+    async list() {
+        const { stub, metadata } = this.#channel();
+        const reply = await stub().listClientKeys({ metadata: metadataToProto(metadata) }).catch(tooOld);
+        if (reply.error)
+            throw refusalOf(reply.error);
+        return reply.keys.map((k) => Object.freeze({
+            id: k.id,
+            subject: k.subject,
+            attributes: Object.freeze({ ...k.attributes }),
+            label: k.label ?? null,
+            endpoint: k.endpoint,
+            scope: Object.freeze([...k.scope]),
+            issuedAt: Instant.ofEpochMilli(Number(k.issuedAtMillis)),
+            expiresAt: instant(k.expiresAtMillis),
+            lastUsed: instant(k.lastUsedMillis),
+            revokedAt: instant(k.revokedAtMillis),
+        }));
+    }
+    /** Revokes a key: refused on its next request on every instance. Revoking twice is not an error. */
+    async revoke(id) {
+        const { stub, metadata } = this.#channel();
+        const reply = await stub().revokeClientKey({ id, metadata: metadataToProto(metadata) }).catch(tooOld);
+        if (reply.error)
+            throw refusalOf(reply.error);
+    }
+}
+/** Client keys for unit tests: a map, issuing keys that look like the runtime's and applying its rules. */
+export class InMemoryClientKeys extends ClientKeys {
+    #keys = new Map();
+    #next = 0;
+    constructor() {
+        super(undefined);
+    }
+    /** The key issued under `id`, which a test may present; the runtime shows it only once. */
+    keyOf(id) {
+        return this.#keys.get(id)?.clientKey;
+    }
+    async issue(request) {
+        if (typeof request.subject !== "string" || request.subject.trim() === "") {
+            throw new CommandError({ message: "a client key needs a subject", code: ErrorCode.BadRequest });
+        }
+        const attributes = request.attributes ?? {};
+        if (Object.keys(attributes).length > 16)
+            throw new CommandError({ message: "a client key carries at most 16 attributes", code: ErrorCode.BadRequest });
+        for (const [name, value] of Object.entries(attributes)) {
+            if (name.length > 256 || value.length > 256)
+                throw new CommandError({ message: `attribute '${name.slice(0, 40)}' is longer than 256 characters`, code: ErrorCode.BadRequest });
+        }
+        this.#next += 1;
+        const id = `ck_${this.#next}`;
+        const clientKey = `ak_test_${id}_${Math.random().toString(36).slice(2)}`;
+        const now = Instant.now();
+        const expiry = request.expiry;
+        const expiresAt = expiry.kind === "after" ? Instant.ofEpochMilli(now.toEpochMilli() + expiry.millis) : expiry.kind === "at" ? Instant.ofEpochMilli(expiry.epochMillis) : null;
+        const summary = Object.freeze({
+            id,
+            subject: request.subject,
+            attributes: Object.freeze({ ...attributes }),
+            label: request.label ?? null,
+            endpoint: request.endpoint ?? "",
+            scope: Object.freeze([...(request.scope ?? [])]),
+            issuedAt: now,
+            expiresAt,
+            lastUsed: null,
+            revokedAt: null,
+        });
+        this.#keys.set(id, { summary, clientKey });
+        return Object.freeze({ id, clientKey });
+    }
+    async list() {
+        return [...this.#keys.values()].map((k) => k.summary);
+    }
+    async revoke(id) {
+        const held = this.#keys.get(id);
+        if (!held)
+            throw new CommandError({ message: `no client key '${id}'`, code: ErrorCode.NotFound });
+        if (held.summary.revokedAt === null)
+            this.#keys.set(id, { ...held, summary: Object.freeze({ ...held.summary, revokedAt: Instant.now() }) });
+    }
+}
+/**
+ * @internal The client keys reached through `client`'s sidecar. Not a member of the client, which an
+ * entity holds too: only the component kinds that may issue keys call this.
+ */
+export function clientKeysFor(client) {
+    return new ClientKeys(client);
+}

package/dist/consumer.d.ts

@@ -3,6 +3,7 @@ import type { Contract, Publication } from "./contract.ts";
 import type { Shape } from "./codec.ts";
 import type { Metadata } from "./effects/common.ts";
 import { type ComponentClient, type ComponentRef, type Secrets } from "./client.ts";
+import { type Buckets } from "./storage.ts";
 import { ConsumerEffects, type ConsumerEffect } from "./effects/stateless.ts";
 import { type Services } from "./services.ts";
 import type { Standing } from "./standing.ts";
@@ -40,6 +41,10 @@ export declare abstract class Consumer<M, Out = never> {
     get secrets(): Secrets;
     /** A unit test's store in place of the runtime's: `component.secrets = new InMemorySecrets()`. */
     set secrets(store: Secrets);
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage(): Buckets;
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets: Buckets);
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services(): Services;
     /** A unit test's in place of the runtime's: `component.services = new ScriptedServices()`. */

package/dist/consumer.js

@@ -1,5 +1,6 @@
 // A consumer: reacts to a source's changes, optionally producing onward to a topic.
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { ConsumerEffects } from "./effects/stateless.js";
 import { servicesFor } from "./services.js";
 /** The metadata entry a runtime sets on a consumer's request to say what it speaks: its protocol version. */
@@ -70,6 +71,15 @@ export class Consumer {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {

package/dist/context.d.ts

@@ -17,19 +17,27 @@ export interface CommandContext {
      * the home, so this is `false` only for a query a follower answers; `true` for an entity not replicated.
      */
     readonly isHome: boolean;
+    /** The subject of the principal who made the original call (1.22); absent when none named one. */
+    readonly attribution?: string;
+    /** The installation this command was forwarded from to its home (1.22); absent when it was not. */
+    readonly forwardedFrom?: string;
 }
-export declare function commandContext(componentId: string, entityId: string, sequenceNumber: bigint, metadata: Metadata, now?: () => Instant, installation?: string | null, isHome?: boolean): CommandContext;
+export declare function commandContext(componentId: string, entityId: string, sequenceNumber: bigint, metadata: Metadata, now?: () => Instant, installation?: string | null, isHome?: boolean, attribution?: string, forwardedFrom?: string): CommandContext;
 /**
  * Where the event `applyEvent` is applying was written (1.19): the installation (`null` when none is
  * named; an event from before replication reads as written at the home), whether that was this
- * installation, and its sequence number. The third argument of `applyEvent`.
+ * installation, and its sequence number; who acted on the command that wrote it and where that
+ * command was forwarded from, as recorded (1.22; absent when nothing was). The third argument of
+ * `applyEvent`.
  */
 export interface EventContext {
     readonly installation: string | null;
     readonly isLocal: boolean;
     readonly sequence: bigint;
+    readonly attribution?: string;
+    readonly forwardedFrom?: string;
 }
-export declare function eventContext(installation: string | null, isLocal: boolean, sequence: bigint): EventContext;
+export declare function eventContext(installation: string | null, isLocal: boolean, sequence: bigint, attribution?: string, forwardedFrom?: string): EventContext;
 export declare function metadataFromProto(proto: ProtoMetadata | undefined): Metadata;
 export declare function metadataToProto(metadata: Metadata | undefined): {
     entries: {

package/dist/context.js

@@ -4,11 +4,27 @@
 // request per asynchronous context, and work handed to another context cannot see it.
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Instant } from "./time.js";
-export function commandContext(componentId, entityId, sequenceNumber, metadata, now = Instant.now, installation = null, isHome = true) {
-    return Object.freeze({ componentId, entityId, sequenceNumber, metadata, now, installation, isHome });
+export function commandContext(componentId, entityId, sequenceNumber, metadata, now = Instant.now, installation = null, isHome = true, attribution, forwardedFrom) {
+    return Object.freeze({
+        componentId,
+        entityId,
+        sequenceNumber,
+        metadata,
+        now,
+        installation,
+        isHome,
+        ...(attribution ? { attribution } : {}),
+        ...(forwardedFrom ? { forwardedFrom } : {}),
+    });
 }
-export function eventContext(installation, isLocal, sequence) {
-    return Object.freeze({ installation, isLocal, sequence });
+export function eventContext(installation, isLocal, sequence, attribution, forwardedFrom) {
+    return Object.freeze({
+        installation,
+        isLocal,
+        sequence,
+        ...(attribution ? { attribution } : {}),
+        ...(forwardedFrom ? { forwardedFrom } : {}),
+    });
 }
 export function metadataFromProto(proto) {
     const out = {};

package/dist/endpoint.d.ts

@@ -1,4 +1,6 @@
+import { type ClientKeys } from "./client-keys.ts";
 import { type ComponentClient, type Secrets } from "./client.ts";
+import { type Buckets } from "./storage.ts";
 import { type RequestContext } from "./context.ts";
 import type { Acl, RouteTable } from "./routes.ts";
 import { type Services } from "./services.ts";
@@ -12,10 +14,18 @@ export declare abstract class Endpoint {
     get secrets(): Secrets;
     /** A unit test's store in place of the runtime's: `component.secrets = new InMemorySecrets()`. */
     set secrets(store: Secrets);
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage(): Buckets;
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets: Buckets);
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services(): Services;
     /** A unit test's in place of the runtime's: `component.services = new ScriptedServices()`. */
     set services(services: Services);
+    /** The service's client keys (1.20): issued for its MCP endpoint, kept by the runtime, each shown once. */
+    get clientKeys(): ClientKeys;
+    /** A unit test's in place of the runtime's: `component.clientKeys = new InMemoryClientKeys()`. */
+    set clientKeys(keys: ClientKeys);
     /** @internal */
     _bindClient(client: ComponentClient | undefined): void;
 }

package/dist/endpoint.js

@@ -8,7 +8,9 @@
 //     static readonly routes = { getCart: get("/{cartId}", ShoppingCart, (ep: ShoppingCartEndpoint, req) => ep.getCart(req.params.cartId)) }
 //     getCart(cartId: string) { return this.client.of(ShoppingCartEntity, cartId).call(ShoppingCartEntity.handlers.getCart).invoke() }
 //   }
+import { clientKeysFor } from "./client-keys.js";
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { currentRequest, requestIfAny } from "./context.js";
 import { servicesFor } from "./services.js";
 export class Endpoint {
@@ -33,6 +35,15 @@ export class Endpoint {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {
@@ -42,6 +53,15 @@ export class Endpoint {
     set services(services) {
         this.#services = services;
     }
+    #clientKeys;
+    /** The service's client keys (1.20): issued for its MCP endpoint, kept by the runtime, each shown once. */
+    get clientKeys() {
+        return this.#clientKeys ?? clientKeysFor(this.client);
+    }
+    /** A unit test's in place of the runtime's: `component.clientKeys = new InMemoryClientKeys()`. */
+    set clientKeys(keys) {
+        this.#clientKeys = keys;
+    }
     /** @internal */
     _bindClient(client) {
         this.#client = client;

package/dist/graph.d.ts

@@ -2,6 +2,7 @@ import type { StartFrom } from "./startFrom.ts";
 import { type Codec, type Shape } from "./codec.ts";
 import type { EffectLike, Metadata } from "./effects/common.ts";
 import { type ComponentClient, type ComponentRef, type Secrets } from "./client.ts";
+import { type Buckets } from "./storage.ts";
 import { type Services } from "./services.ts";
 import type { Standing } from "./standing.ts";
 type MaybePromise<T> = T | Promise<T>;
@@ -146,6 +147,10 @@ export declare abstract class GraphConsumer<M> {
     get secrets(): Secrets;
     /** A unit test's store in place of the runtime's: `component.secrets = new InMemorySecrets()`. */
     set secrets(store: Secrets);
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage(): Buckets;
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets: Buckets);
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services(): Services;
     /** A unit test's in place of the runtime's: `component.services = new ScriptedServices()`. */

package/dist/graph.js

@@ -16,6 +16,7 @@
 //   }
 import { JSON_CONTENT } from "./codec.js";
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { sequenceNumberOf } from "./consumer.js";
 import { renderDouble, reviver } from "./json.js";
 import { servicesFor } from "./services.js";
@@ -426,6 +427,15 @@ export class GraphConsumer {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {

package/dist/index.d.ts

@@ -25,14 +25,19 @@ export { ApprovalAwaited, APPROVALS_SINCE, type AgentOutcome, type Approval, typ
 export { mcpServer, resultGuardrail, toolName, type McpServerOptions, type McpServerRef, type ResultGuardrailRef } from "./mcp.ts";
 export { AutonomousAgent, AutonomousAgentCalls, TaskCalls, Tasks, accepted, rejected, taskAcceptance, taskRule, taskType, type Accepted, type AgentState, type Attachment, type AutonomousAgentClass, type AutonomousSettings, type Notification, type Rejected, type TaskAcceptance, type TaskRule, type TaskSnapshot, type TaskType, } from "./autonomous.ts";
 export { Endpoint, type EndpointClass } from "./endpoint.ts";
+export { McpEndpoint, ToolTable, tools, MCP_ENDPOINTS_SINCE, type McpEndpointClass, type DeclaredTool, type ToolOptions, type ReferenceOptions, type RegisteredMcpEndpoint, type RegisteredMcpTool, type ToolRun, } from "./mcp-endpoint.ts";
+export { ClientKeys, InMemoryClientKeys, Expiry, CLIENT_KEYS_SINCE, type IssueClientKey, type IssuedClientKey, type ClientKeySummary, } from "./client-keys.ts";
 export { type Socket, SocketClosed } from "./socket.ts";
-export { Acl, Callers, type CallerMatcher, type CallersAcl, HttpProblem, get, post, put, patch, del, sse, sseEvent, sseEvents, type SseEvent, socket, type RouteRef, type RouteOptions, type RouteTable, type Params, type ParamNames, type HttpMethod } from "./routes.ts";
+export { Acl, Callers, type CallerMatcher, type CallersAcl, type AnyOfAcl, HttpProblem, get, post, put, patch, del, sse, sseEvent, sseEvents, type SseEvent, socket, type RouteRef, type RouteOptions, type RouteTable, type Params, type ParamNames, type HttpMethod } from "./routes.ts";
 export { type CommandContext, type EventContext, type RequestContext, type Principal, type Caller, Query, Headers } from "./context.ts";
 export { ComponentClient, Calls, TypedCalls, Invocation, AwaitingInvocation, AWAIT_SINCE, awaitPartJson, Views, Timers, Secrets, InMemorySecrets, noSecrets, WatchEnded, VIEW_STREAMS_SINCE, type AwaitPart, type WatchEvent, type WatchOptions, type Overflow, type TimerTarget, type TimedActionTarget, type ComponentRef } from "./client.ts";
+export { ObjectRules, StorageRefusals, InMemoryBuckets, DirectoryBuckets, S3Buckets, S3Bucket, noStorage, chooseStorage, declaredBuckets, processStorage, s3Settings, bucketNameOf, bucketVariableSuffix, localAddress, STORAGE_PATH, type Buckets, type Bucket, type BucketExposure, type SignedAccess, type StoredObject, type ObjectInfo, type ObjectEntry, type PutOptions, type InMemoryBucketsOptions, type DirectoryBucketsOptions, type DeclaredBuckets, type S3Settings, type S3Target, type NamedTarget, type StorageBackend, type ChosenStorage, type StorageChoiceOptions, } from "./storage.ts";
+export { Credentials, SignedRequest, sign as signRequest, presign as presignUrl } from "./sigv4.ts";
 export { Services, ServiceClient, ScriptedServices, noServices, ServiceError, ServiceUnresolvable, ServiceIdentityMismatch, ServiceUnanswered, ServiceCallFailed, type ServiceResponse, type ServiceRequest, type ServiceHeaders, } from "./services.ts";
 export { Ankka, ServiceBuilder, Registry, RegistrationError, type ServiceOptions, type RegisteredComponent, type RegisteredEndpoint, type Source, type RegisteredEventSourced, type RegisteredKeyValue, type RegisteredWorkflow, type RegisteredView, type RegisteredKeyedView, type RegisteredKeyedSource, type RegisteredConsumer, type RegisteredTimedAction, type RegisteredAgent, } from "./service.ts";
 export { Server, type ServerOptions } from "./server/server.ts";
 export { problems as sidecarProblems } from "./server/discovery.ts";
+export { createMcpDispatcher, type McpDispatcher, type ToolAnswer } from "./server/mcp.ts";
 export { PROTOCOL_VERSION, SDK_NAME } from "./spec.ts";
 export { StartFrom } from "./startFrom.ts";
 export { isTerminal, isUnknown, type Standing, type StandingStatus } from "./standing.ts";

package/dist/index.js

@@ -36,14 +36,19 @@ export { ApprovalAwaited, APPROVALS_SINCE } from "./approvals.js";
 export { mcpServer, resultGuardrail, toolName } from "./mcp.js";
 export { AutonomousAgent, AutonomousAgentCalls, TaskCalls, Tasks, accepted, rejected, taskAcceptance, taskRule, taskType, } from "./autonomous.js";
 export { Endpoint } from "./endpoint.js";
+export { McpEndpoint, ToolTable, tools, MCP_ENDPOINTS_SINCE, } from "./mcp-endpoint.js";
+export { ClientKeys, InMemoryClientKeys, Expiry, CLIENT_KEYS_SINCE, } from "./client-keys.js";
 export { SocketClosed } from "./socket.js";
 export { Acl, Callers, HttpProblem, get, post, put, patch, del, sse, sseEvent, sseEvents, socket } from "./routes.js";
 export { Query, Headers } from "./context.js";
 export { ComponentClient, Calls, TypedCalls, Invocation, AwaitingInvocation, AWAIT_SINCE, awaitPartJson, Views, Timers, Secrets, InMemorySecrets, noSecrets, WatchEnded, VIEW_STREAMS_SINCE } from "./client.js";
+export { ObjectRules, StorageRefusals, InMemoryBuckets, DirectoryBuckets, S3Buckets, S3Bucket, noStorage, chooseStorage, declaredBuckets, processStorage, s3Settings, bucketNameOf, bucketVariableSuffix, localAddress, STORAGE_PATH, } from "./storage.js";
+export { Credentials, SignedRequest, sign as signRequest, presign as presignUrl } from "./sigv4.js";
 export { Services, ServiceClient, ScriptedServices, noServices, ServiceError, ServiceUnresolvable, ServiceIdentityMismatch, ServiceUnanswered, ServiceCallFailed, } from "./services.js";
 export { Ankka, ServiceBuilder, Registry, RegistrationError, } from "./service.js";
 export { Server } from "./server/server.js";
 export { problems as sidecarProblems } from "./server/discovery.js";
+export { createMcpDispatcher } from "./server/mcp.js";
 export { PROTOCOL_VERSION, SDK_NAME } from "./spec.js";
 export { StartFrom } from "./startFrom.js";
 export { isTerminal, isUnknown } from "./standing.js";