@fungi.computer/shiitake 0.2.0 → 0.3.1

package/dist/cloudflare.js

@@ -4,15 +4,13 @@ import * as Effect from "effect/Effect";
 import * as Deferred from "effect/Deferred";
 import * as Redacted from "effect/Redacted";
 import { WatchdogError, } from "@fungi.computer/watchdog";
-import { composeAgentClose } from "./internal/agent-close.js";
 import { ShiitakeError } from "./errors.js";
 import { createShiitakeHttpRoutes, } from "./http-routes.js";
 import { Hono } from "hono";
 import { runShiitakePromise, toPromiseOwner, } from "./internal/effect-client.js";
 import { adaptModelSource } from "./internal/model-acquisition.js";
 import { decodeClientSessionId } from "./internal/client-boundary.js";
-import { deliverSessionGrants, prepareSessionGrants, pruneSessionInboxTombstones, readSessionInboxChanges, readSessionSummary, readSessionInboxSummary, } from "./internal/woodstock/index.js";
-import { BrowserSessions, } from "./internal/browser-sessions.js";
+import { deliverSessionGrants, prepareSessionGrants, pruneSessionInboxTombstones, readColdSessionPage, readSessionInboxChanges, readSessionSummary, readSessionInboxSummary, } from "./internal/woodstock/index.js";
 /**
  * Deliver one Session's grants into a Cloudflare owner's own storage,
  * synchronously, whether or not its runtime is open; the very next tool call
@@ -240,30 +238,16 @@ function configuredTools(tools) {
         access: tools.access ?? {},
     };
 }
-function effectOptions(state, options, runtime, browser) {
+function effectOptions(state, options, runtime) {
     const tools = configuredTools(options.tools);
     const base = {
         store: state.storage,
         runtime,
         extensions: options.extensions,
         instructions: {
-            load: ({ sessionId, commandId }) => Effect.gen(function* () {
-                const lease = browser === undefined
-                    ? undefined
-                    : yield* Effect.acquireRelease(Effect.try({
-                        try: () => browser.acquire(sessionId),
-                        catch: () => new ShiitakeError("instructions", "rejected", "Browser acquisition failed"),
-                    }), (acquired) => Effect.sync(acquired.release));
-                const snapshot = yield* Effect.tryPromise({
-                    try: (signal) => options.instructions.load({ sessionId, commandId, signal }),
-                    catch: () => new ShiitakeError("instructions", "rejected", "Instruction acquisition failed"),
-                });
-                return lease === undefined
-                    ? snapshot
-                    : {
-                        ...snapshot,
-                        modules: [...(snapshot.modules ?? []), ...lease.host.modules],
-                    };
+            load: ({ sessionId, commandId }) => Effect.tryPromise({
+                try: (signal) => options.instructions.load({ sessionId, commandId, signal }),
+                catch: () => new ShiitakeError("instructions", "rejected", "Instruction acquisition failed"),
             }),
         },
         model: adaptModelSource(options.model),
@@ -291,34 +275,58 @@ function effectOptions(state, options, runtime, browser) {
     }
     if (options.meta !== undefined)
         Object.assign(base, { meta: options.meta });
-    if (options.storageBudget !== undefined)
-        Object.assign(base, { storageBudget: options.storageBudget });
+    if (options.storagePressure !== undefined)
+        Object.assign(base, { storagePressure: options.storagePressure });
     if (options.compaction !== undefined)
         Object.assign(base, { compaction: options.compaction });
     return tools === undefined ? base : { ...base, tools };
 }
 /** Construct Shiitake over one Durable Object's SQLite and lifetime. */
-export function makeCloudflareShiitake(state, options) {
+/**
+ * The state with its storage named for Woodstock's refusals after the
+ * Durable Object's id, when it has one. Its owner and every reader of it
+ * share this one storage object, so the name travels with the owner.
+ */
+function namedState(state) {
+    const { id, storage } = state;
+    if (id === undefined || storage.storeName !== undefined)
+        return state;
+    return {
+        id,
+        waitUntil: (task) => {
+            state.waitUntil(task);
+        },
+        storage: {
+            sql: storage.sql,
+            transactionSync: (operation) => storage.transactionSync(operation),
+            transaction: (body) => storage.transaction(body),
+            getAlarm: (alarmOptions) => storage.getAlarm(alarmOptions),
+            setAlarm: (time, alarmOptions) => storage.setAlarm(time, alarmOptions),
+            deleteAlarm: (alarmOptions) => storage.deleteAlarm(alarmOptions),
+            storeName: `Durable Object ${id.toString()}`,
+        },
+    };
+}
+/**
+ * Open Shiitake over one Durable Object's storage. It resolves once the runtime
+ * is started and `initialize` has run; if `initialize` throws, the runtime is
+ * closed and the error is rethrown.
+ */
+export function makeCloudflareShiitake(unnamed, options) {
+    const state = namedState(unnamed);
     const startup = Deferred.makeUnsafe();
     const host = runtimeHost(state, options.hostWork, Deferred.await(startup));
-    const browser = options.browser === undefined
-        ? undefined
-        : new BrowserSessions(options.browser, async (sessionId) => (await runShiitakePromise(readSessionSummary(state.storage, sessionId))) !== undefined);
-    const coreOptions = effectOptions(state, options, host.runtime, browser);
+    const coreOptions = effectOptions(state, options, host.runtime);
     return import("./internal/runtime-core.js")
         .then(({ openRuntimeCore }) => runShiitakePromise(openRuntimeCore(coreOptions, options.mailRoom)))
         .then(async ({ agent, activeSessions, acceptMail, readSettlement }) => {
-        const close = composeAgentClose(Effect.tryPromise({
-            try: () => browser?.close() ?? Promise.resolve(),
-            catch: () => runtimeFailure("unavailable", "Browser teardown failed"),
-        }), agent.close);
         const handle = toPromiseOwner(agent);
         try {
             await options.initialize?.(handle);
         }
         catch (cause) {
             await runShiitakePromise(Deferred.succeed(startup, false));
-            await runShiitakePromise(close);
+            await runShiitakePromise(agent.close);
             throw cause;
         }
         await runShiitakePromise(Deferred.succeed(startup, true));
@@ -330,18 +338,12 @@ export function makeCloudflareShiitake(state, options) {
                     return Promise.reject(runtimeFailure("unavailable", "Addressed mail is unavailable"));
                 return runShiitakePromise(acceptMail(mail, meta, reply));
             },
-            close: () => runShiitakePromise(close),
             alarm: host.alarm,
             activeSessions: () => runShiitakePromise(activeSessions),
             abortActive: async () => {
                 for (const sessionId of await runShiitakePromise(activeSessions))
                     await runShiitakePromise(agent.session(sessionId).abort);
             },
-            browser: {
-                fetch: (request) => browser?.fetch(request) ??
-                    Promise.resolve(new Response(null, { status: 404 })),
-                clear: () => browser?.clear() ?? Promise.resolve(),
-            },
         });
     }, async (cause) => {
         await runShiitakePromise(Deferred.succeed(startup, false));
@@ -358,6 +360,11 @@ export class ShiitakeOwner {
     }
     agentPromise;
     openAcp;
+    #named;
+    /** This owner's state, its storage named once for Woodstock's refusals. */
+    get named() {
+        return (this.#named ??= namedState(this.ctx));
+    }
     acpServer;
     /** Consecutive native alarm failures; reset on the next successful alarm. */
     alarmFailures = 0;
@@ -367,11 +374,13 @@ export class ShiitakeOwner {
     }, async (after) => (await this.shiitake()).listSessions(after), async (requestId) => (await this.shiitake()).createSession(requestId), async (sessionId) => (await this.shiitake()).deleteSession(sessionId), async () => (await this.shiitake()).extensions);
     /** Borrow this owner's runtime directly; only the host owns its lifetime. */
     async shiitake() {
-        if (this.agentPromise === undefined) {
-            const options = this.shiitakeOptions();
+        // Publish the flight before loading options: concurrent cold requests
+        // share both first-use imports and the runtime they configure.
+        this.agentPromise ??= Promise.resolve().then(async () => {
+            const options = await this.shiitakeOptions();
             this.openAcp = options.acp;
-            this.agentPromise = makeCloudflareShiitake(this.ctx, options);
-        }
+            return makeCloudflareShiitake(this.named, options);
+        });
         try {
             return await this.agentPromise;
         }
@@ -391,24 +400,32 @@ export class ShiitakeOwner {
     /** Indexed owner-local existence check; corrupt stored Sessions remain unavailable. */
     async hasStoredSession(sessionId) {
         await this.shiitake();
-        const inbox = readSessionInboxSummary(this.ctx.storage, sessionId);
+        const inbox = readSessionInboxSummary(this.named.storage, sessionId);
         if (inbox === undefined || inbox.state === "unavailable")
             return false;
-        return ((await runShiitakePromise(readSessionSummary(this.ctx.storage, sessionId))) !== undefined);
+        return ((await runShiitakePromise(readSessionSummary(this.named.storage, sessionId))) !== undefined);
     }
     /** Bounded strict-after read of this Agent's changed inbox rows. */
     async readInboxChanges(after, limit) {
         await this.shiitake();
-        return readSessionInboxChanges(this.ctx.storage, after, limit);
+        return readSessionInboxChanges(this.named.storage, after, limit);
+    }
+    /**
+     * One bounded, read-only page of Sessions with stored bytes, last activity
+     * and an idle flag, coldest first. The store keeper's only view of cold
+     * Sessions; it carries no SQL, transaction or write.
+     */
+    async readColdSessions(request) {
+        await this.shiitake();
+        return await runShiitakePromise(readColdSessionPage(this.named.storage, request));
     }
     /** Latest inbox revision; read only after the owner has opened. */
     readInboxRevision() {
-        return readSessionInboxChanges(this.ctx.storage, Number.MAX_SAFE_INTEGER, 0)
-            .latest;
+        return readSessionInboxChanges(this.named.storage, Number.MAX_SAFE_INTEGER, 0).latest;
     }
     /** Prune deletion deltas after every current member inbox has acknowledged them. */
     pruneInboxTombstones(through) {
-        pruneSessionInboxTombstones(this.ctx.storage, through);
+        pruneSessionInboxTombstones(this.named.storage, through);
     }
     /** Persist a wake and run one reconciliation pass, including host work. */
     async wakeRuntime() {
@@ -453,13 +470,12 @@ export class ShiitakeOwner {
     /** Serve Shiitake's complete transport without subclass routing. */
     app;
     /**
-     * Shiitake's whole HTTP surface (Session routes, browser and ACP) as one
+     * Shiitake's whole HTTP surface (Session routes and ACP) as one
      * Hono app. A host mounts it behind its own middleware, which alone may
      * set the `shiitakeMeta` variable.
      */
     shiitakeApp() {
         return (this.app ??= new Hono()
-            .all("/browser/*", async (context) => (await this.shiitake()).browser.fetch(context.req.raw))
             .all("/acp", async (context) => {
             const agent = await this.shiitake();
             if (this.openAcp === undefined)
@@ -477,7 +493,7 @@ export class ShiitakeOwner {
             return server.handleRequest(context.req.raw, context.get("shiitakeMeta"));
         })
             .route("/", this.routes)
-            // Browser and ACP failures reach the Durable Object caller unchanged,
+            // ACP failures reach the Durable Object caller unchanged,
             // as they did before the routes shared one app.
             .onError((error) => {
             throw error;
@@ -508,12 +524,18 @@ export class ShiitakeDO extends DurableObject {
     closeShiitake() {
         return this.runtimeOwner().closeShiitake();
     }
+    hasStoredSession(sessionId) {
+        return this.runtimeOwner().hasStoredSession(sessionId);
+    }
     readInboxChanges(after, limit) {
         return this.runtimeOwner().readInboxChanges(after, limit);
     }
     readInboxRevision() {
         return this.runtimeOwner().readInboxRevision();
     }
+    readColdSessions(request) {
+        return this.runtimeOwner().readColdSessions(request);
+    }
     pruneInboxTombstones(through) {
         this.runtimeOwner().pruneInboxTombstones(through);
     }
@@ -524,8 +546,8 @@ export class ShiitakeDO extends DurableObject {
     alarm() {
         return this.runtimeOwner().alarm();
     }
-    /** Route an authenticated client request through the owner. */
+    /** Route an authenticated client request through the host's routes, then the owner. */
     fetch(request) {
-        return this.runtimeOwner().fetch(request);
+        return this.hostFetch?.(request) ?? this.runtimeOwner().fetch(request);
     }
 }

package/dist/cold-sessions.d.ts

@@ -0,0 +1,28 @@
+/** One Session as the store keeper sees it: what it holds and how cold it is. */
+export type ColdSessionRow = Readonly<{
+    sessionId: string;
+    /**
+     * Bytes of the Session's stored payloads: conversation entries, accepted
+     * commands, open attention and tool grants. Measured from the stored rows
+     * on every read, never from a counter.
+     */
+    bytes: number;
+    /** Milliseconds since the epoch of the Session's latest conversation or run activity. */
+    lastActivityAt: number;
+    /**
+     * True only when no run is queued or live and no extension attention waits
+     * on a person: the Session is settled. Anything else is not idle.
+     */
+    idle: boolean;
+}>;
+/** One bounded page of Sessions, coldest first. */
+export type ColdSessionPage = Readonly<{
+    sessions: readonly ColdSessionRow[];
+    /** Pass as `after` to read the next page; absent on the last page. */
+    next?: string;
+}>;
+/** A page request: `limit` is a whole number from 1 to 200 (default 50). */
+export type ColdSessionPageRequest = Readonly<{
+    limit?: number;
+    after?: string;
+}>;

package/dist/cold-sessions.js

@@ -0,0 +1 @@
+export {};

package/dist/delegation.d.ts

@@ -0,0 +1,214 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import * as Schema from "effect/Schema";
+import { type BirdDogEffect } from "@fungi.computer/bird-dog/effect";
+import type { BirdDogMail } from "@fungi.computer/bird-dog";
+import { type PostRoute, type PostRuntime, type PostEnvelope, type PostDeliveryResult } from "@fungi.computer/carrier/post";
+import { type Accepted, type CancelResult } from "./client.js";
+import type { CommandSettlement, ShiitakeHost, VerifiedAgentReply } from "./index.js";
+import type { AgentControlDirectory, AgentDelegationInput, AgentDelegationInvocation, AgentRecallInput } from "./agent-control.js";
+/** Shiitake host-pack identity; core consumes OysterAgents, never this engine. */
+export type DelegationIdentity = Readonly<{
+    scopeId: string;
+    agentId: string;
+}>;
+/** Host-owned identity and admission around BirdDog's ordinary envelope. */
+export declare class AgentDelegation {
+    private readonly deps;
+    constructor(deps: Readonly<{
+        storage: WatchdogSqliteOwner;
+        expiresAt: () => number;
+        identity: () => DelegationIdentity | null | Promise<DelegationIdentity | null>;
+        directory: () => AgentControlDirectory;
+        deliver: (mail: BirdDogMail) => Promise<Accepted>;
+        prepare: (mail: BirdDogMail) => Promise<void>;
+        /** Admit mail; `reply` is present only for an authenticated reply. */
+        accept: (mail: BirdDogMail, reply?: VerifiedAgentReply) => Promise<Accepted>;
+    }>);
+    private fleetOwner;
+    private fleet;
+    private scope;
+    private requestKey;
+    /** Recipient-local disclosure through the public host, never another Agent's RPC. */
+    settlement(sender: DelegationIdentity, sessionId: string, commandId: string, host: Pick<ShiitakeHost, "readSettlement">): Promise<CommandSettlement | undefined>;
+    /** Delegate work to an in-scope Agent: steer its Session, or start fleet correspondence. */
+    send(input: AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: AgentDelegationInvocation): Promise<Accepted>;
+    /** Resolve this sender's exact request, then let the recipient guard pending work. */
+    recall(input: AgentRecallInput, sourceSessionId: string, signal: AbortSignal): Promise<CancelResult>;
+    /**
+     * A reply-less envelope is only ever BirdDog's reply to work this Agent
+     * sent. Admit it only after the fleet authenticates it against that frozen
+     * mail; the line is then authored by the replying Agent, never by whoever
+     * settled or cancelled the work, and its meta carries the verified reply.
+     */
+    private authenticatedReply;
+    /** Admit one addressed Agent mail for this Agent, or refuse it. */
+    receive(raw: PostEnvelope): Promise<PostDeliveryResult>;
+}
+/** A current correspondent no longer has disclosure authority. */
+export declare class AgentDisclosureRefused extends Error {
+    constructor();
+}
+/** Undefined is an explicit disclosure refusal; missing facts and read errors must fail. */
+export type AgentReplySettlement = (mail: BirdDogMail) => Promise<CommandSettlement | undefined>;
+/** Current disclosure admission runs at every transport attempt, including frozen retries. */
+export declare function agentMailRoute(namespace: PostRoute<never, never>["namespace"], replySettlement: AgentReplySettlement): PostRoute<import("@fungi.computer/seam/machine-link-protocol").AgentMailAddress, {
+    readonly key: string;
+    readonly content: string;
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly to: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
+    readonly reply?: {
+        readonly commandId: string;
+        readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
+        readonly diagnostic?: string;
+    };
+}, {
+    readonly key: string;
+    readonly content: string;
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly to: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
+    readonly reply?: {
+        readonly commandId: string;
+        readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
+        readonly diagnostic?: string;
+    };
+}, import("@fungi.computer/seam/machine-link-protocol").AgentMailAddress, {
+    readonly key: string;
+    readonly content: string;
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly to: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
+    readonly reply?: {
+        readonly commandId: string;
+        readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
+        readonly diagnostic?: string;
+    };
+}, {
+    readonly key: string;
+    readonly content: string;
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly to: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
+    readonly reply?: {
+        readonly commandId: string;
+        readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
+        readonly diagnostic?: string;
+    };
+}> & Omit<Readonly<{
+    addressKind: string;
+    address: Schema.Codec<unknown, unknown>;
+    event: Schema.Codec<unknown, unknown>;
+    encodeEnvelope: (envelope: PostEnvelope) => PostEnvelope;
+    parseDelivery: (envelope: PostEnvelope) => PostEnvelope;
+    prepareEnvelope?: ((envelope: PostEnvelope, signal: AbortSignal) => Promise<PostEnvelope>) | undefined;
+    recordDelivered?: ((envelope: PostEnvelope) => void) | undefined;
+    nameOf: (envelope: Pick<PostEnvelope, "address">) => string;
+    namespace: PostRoute<never, never>["namespace"];
+    recordCursor?: ((envelope: PostEnvelope, cursor: number) => void) | undefined;
+    recordRefused?: ((envelope: PostEnvelope) => void) | undefined;
+}>, "event" | "address">;
+/** The host's one Post lane, as Agent mail borrows it. */
+export type AgentMailPost = Pick<PostRuntime<{
+    agentMail: ReturnType<typeof agentMailRoute>;
+}>, "send" | "read" | "nextWake">;
+/** Recipient-owned replies and receipt-bearing submissions over the host's one Post lane. */
+export declare class AgentMail {
+    private readonly deps;
+    constructor(deps: Readonly<{
+        storage: WatchdogSqliteOwner;
+        post: () => AgentMailPost;
+        identity: () => DelegationIdentity | null | Promise<DelegationIdentity | null>;
+        /** Only a typed disclosure refusal becomes undefined; missing settled facts must fail. */
+        replySettlement: AgentReplySettlement;
+        drain: () => Promise<void>;
+        wake: () => Promise<void>;
+    }>);
+    private envelope;
+    /** Submit one mail and return the recipient's Accepted receipt. */
+    send(mail: BirdDogMail): Promise<Accepted>;
+    /** BirdDog's mail room: disclosed settlement replies fan out over Post. */
+    mailRoom(): BirdDogEffect;
+}
+/**
+ * The Agent wire decoders a host lends Oyster's machine-link client, so the
+ * device link routes Agent work without owning Shiitake's grammar.
+ */
+export declare const machineAgentCodecs: {
+    /** The Session-creation intent, or null when the body is not one. */
+    readonly sessionCreation: (body: Schema.Json) => Readonly<{
+        requestId: string;
+    }> | null;
+    /** One serialized settlement from a hosted or machine-homed Agent. */
+    readonly settlement: (encoded: string) => CommandSettlement;
+    /** Throws unless an acknowledgment carries a well-formed Accepted receipt. */
+    readonly accepted: (receipt: Schema.Json) => void;
+};
+/**
+ * Machine-homed Agent identities in the ordinary directory over the
+ * enrollment's own store: one Team identity per enrollment receipt, reserved
+ * without opening a hosted Agent. The enrolling member is the grant actor.
+ */
+export declare function machineAgentReservations(sql: WatchdogSqliteOwner["sql"]): (reservation: Readonly<{
+    memberId: string;
+    requestId: string;
+    name: string;
+}>) => {
+    agentId: import("./fleet.js").AgentId;
+};