@fungi.computer/shiitake 0.0.0-stage → 0.0.1

package/dist/internal/coordinator.js

@@ -0,0 +1,362 @@
+import { nanoid } from "@fungi.computer/cairn";
+import { parseModelPreference } from "./model-preference.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { ShiitakeError } from "../errors.js";
+import { decodeClientReadOptions, decodeClientSessionCommand, decodeClientSessionId, decodeClientSubscribeOptions, } from "./client-boundary.js";
+import { mergeObservationSignals, openObservationKernel, publishOwnerObservation, } from "./observation-kernel.js";
+import { checkHostMeta } from "./host-meta.js";
+import { readSessionActivity } from "./session-status.js";
+import { readSessionContext } from "./session-context.js";
+import { abortSession, cancelSession, branchSession, recordOperatorLine, forkSession, readSession, readSessionModelPreference, readSessionReplayPage, readSessionInbox, createSession, deleteSession, deliverSessionGrants, readSessionGrants, setSessionModelPreference, setSessionTitle, } from "./woodstock/index.js";
+/** Generic Agent-scope extension controls over the runtime's one call door. */
+function agentExtensions(runtime) {
+    return Object.freeze({
+        list: runtime.assertOpen.pipe(Effect.map(() => runtime.extensions.list())),
+        resume: (extensionId) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.resume(extensionId))),
+        call: (extensionId, command, input) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "agent" }, extensionId, command, input))),
+    });
+}
+function currentSessionActivity(options, runtime, sessionId) {
+    return runtime
+        .readQueueHead(sessionId)
+        .pipe(Effect.flatMap((head) => (head.state === "queued"
+        ? runtime.runningWork(head.jobId)
+        : Effect.succeed(null)).pipe(Effect.map((runningWork) => readSessionActivity(options.store, sessionId, head, runningWork)))));
+}
+/** Carry the Session's context use on a baseline, when it has one. */
+function withContext(snapshot, context) {
+    return context === undefined
+        ? snapshot
+        : Object.freeze({ ...snapshot, context });
+}
+/** Read the baseline and its context use for one Session. */
+function readSessionWithContext(options, runtime, sessionId, input) {
+    return currentSessionActivity(options, runtime, sessionId).pipe(Effect.flatMap((activity) => readSession(options.store, sessionId, activity, input, () => runtime.extensions.project(sessionId))), Effect.flatMap((snapshot) => readSessionContext(options, runtime, sessionId).pipe(Effect.map((context) => withContext(snapshot, context)))));
+}
+function sessionOwnerOperation(runtime, sessionId, operation) {
+    return runtime.assertOpen.pipe(Effect.andThen(Effect.try({
+        try: () => operation(decodeClientSessionId(sessionId)),
+        catch: (error) => error instanceof ShiitakeError
+            ? error
+            : new ShiitakeError("store", "rejected", "Session owner operation failed"),
+    })));
+}
+function decodeSessionCommand(sessionId, input) {
+    return Effect.try({
+        try: () => {
+            const decodedCommand = decodeClientSessionCommand(input);
+            if (decodedCommand._tag === "Failure")
+                throw new ShiitakeError("contract", "invalid", "Session command is invalid");
+            return Object.freeze({
+                sessionId: decodeClientSessionId(sessionId),
+                command: decodedCommand.success,
+            });
+        },
+        catch: (error) => error instanceof ShiitakeError
+            ? error
+            : new ShiitakeError("contract", "invalid", "Session command is invalid"),
+    });
+}
+function decodeSubscriptionInput(sessionId, input) {
+    return Effect.try({
+        try: () => Object.freeze({
+            sessionId: decodeClientSessionId(sessionId),
+            options: decodeClientSubscribeOptions(input),
+        }),
+        catch: (error) => error instanceof ShiitakeError
+            ? error
+            : new ShiitakeError("contract", "invalid", "Subscribe options are invalid"),
+    });
+}
+function resetFrame(options, runtime, sessionId, includeSandboxFailures = false) {
+    return runtime.assertOpen.pipe(Effect.andThen(readSessionWithContext(options, runtime, sessionId, {
+        includeSandboxFailures,
+    })), Effect.map((baseline) => Object.freeze({
+        kind: "reset",
+        reason: "history_unavailable",
+        cursor: baseline.cursor,
+        baseline,
+    })));
+}
+function continueFromReset(frame) {
+    return [
+        [frame],
+        Option.some({
+            after: frame.cursor ?? undefined,
+            delivery: frame.baseline.hasMore ? "replay" : "live",
+            awaitSignal: !frame.baseline.hasMore,
+        }),
+    ];
+}
+function subscriptionFrames(options, runtime, registration, sessionId, after, delivery, includeSandboxFailures = false) {
+    const initial = {
+        after,
+        delivery,
+        awaitSignal: false,
+    };
+    return Stream.paginate(initial, (state) => (state.awaitSignal
+        ? registration.awaitSignal.pipe(Effect.flatMap((signal) => registration.pollSignal.pipe(Effect.map((pending) => pending === undefined
+            ? signal
+            : mergeObservationSignals(signal, pending)))))
+        : registration.pollSignal).pipe(Effect.flatMap((signal) => {
+        if (signal === "closed")
+            return Effect.succeed([[], Option.none()]);
+        if (signal === "reset")
+            return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
+        return runtime.assertOpen.pipe(Effect.andThen(currentSessionActivity(options, runtime, sessionId)), Effect.flatMap((activity) => {
+            if (signal === "progress" &&
+                state.delivery === "live" &&
+                activity.progress !== null) {
+                return Effect.succeed([
+                    [
+                        {
+                            kind: "progress",
+                            progress: activity.progress,
+                            activity: activity.facts,
+                        },
+                    ],
+                    Option.some({ ...state, awaitSignal: true }),
+                ]);
+            }
+            return readSessionReplayPage(options.store, sessionId, state.after, state.delivery, activity, () => runtime.extensions.project(sessionId), includeSandboxFailures).pipe(Effect.flatMap((page) => {
+                if (page.kind === "reset")
+                    return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
+                const latestCursor = page.frames
+                    .flatMap((frame) => frame.kind === "progress" ? [] : [frame.cursor])
+                    .at(-1);
+                const next = {
+                    after: latestCursor ?? state.after,
+                    delivery: page.hasMore ? state.delivery : "live",
+                    awaitSignal: !page.hasMore,
+                };
+                // Every update carries the context use it settles on.
+                return (page.frames.some((frame) => frame.kind === "update")
+                    ? readSessionContext(options, runtime, sessionId)
+                    : Effect.succeed(undefined)).pipe(Effect.map((context) => [
+                    context === undefined
+                        ? page.frames
+                        : page.frames.map((frame) => frame.kind === "update"
+                            ? Object.freeze({ ...frame, context })
+                            : frame),
+                    Option.some(next),
+                ]));
+            }));
+        }));
+    })));
+}
+function subscribeSession(options, runtime, observation, sessionId, input) {
+    return Stream.unwrap(runtime.assertOpen.pipe(Effect.andThen(decodeSubscriptionInput(sessionId, input)), Effect.flatMap((decoded) => Effect.acquireRelease(observation.register(decoded.sessionId), (registration) => Effect.sync(registration.close)).pipe(Effect.map((registration) => subscriptionFrames(options, runtime, registration, decoded.sessionId, decoded.options.after, "replay", decoded.options.includeSandboxFailures === true))))));
+}
+function decodeWatchInput(sessionId, input) {
+    return Effect.try({
+        try: () => Object.freeze({
+            sessionId: decodeClientSessionId(sessionId),
+            options: decodeClientReadOptions(input),
+        }),
+        catch: (error) => error instanceof ShiitakeError
+            ? error
+            : new ShiitakeError("contract", "invalid", "Watch options are invalid"),
+    });
+}
+function watchSession(options, runtime, observation, sessionId, input) {
+    return runtime.assertOpen.pipe(Effect.andThen(decodeWatchInput(sessionId, input)), Effect.flatMap((decoded) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const registration = yield* observation.register(decoded.sessionId);
+        return yield* restore(runtime.assertOpen.pipe(Effect.andThen(readSessionWithContext(options, runtime, decoded.sessionId, decoded.options)), Effect.map((snapshot) => Object.freeze({
+            snapshot,
+            changes: subscriptionFrames(options, runtime, registration, decoded.sessionId, snapshot.cursor ?? undefined, "live", decoded.options.includeSandboxFailures === true).pipe(Stream.ensuring(Effect.sync(registration.close))),
+            close: Effect.sync(registration.close),
+        })))).pipe(Effect.onError(() => Effect.sync(registration.close)));
+    }))));
+}
+/**
+ * Admit one user prompt, mail prompt or compaction request through the
+ * accepted-command door.
+ */
+function admitUserWork(runtime, sessionId, input, meta, mail, reply) {
+    let request = {
+        sessionId,
+        command: input,
+        when: "now",
+        origin: { kind: "user" },
+    };
+    if (meta !== undefined)
+        request = { ...request, meta };
+    if (mail !== undefined)
+        request = { ...request, mail };
+    if (reply !== undefined)
+        request = { ...request, reply };
+    return runtime.assertOpen.pipe(Effect.andThen(runtime.door.admit(request)), Effect.flatMap((admission) => admission.status === "accepted"
+        ? Effect.succeed({
+            status: "accepted",
+            commandId: admission.commandId,
+        })
+        : Effect.fail(new ShiitakeError("runtime", "unavailable", "Session command was not admitted"))));
+}
+function cancelRequestedSession(options, runtime, sessionId, input, meta) {
+    return runtime.assertOpen.pipe(Effect.andThen(cancelSession(options.store, sessionId, input.commandId, input.onlyIfPending, () => runtime.readQueueHeadTransactional(sessionId), runtime.recordAcceptedCancellation, meta)), Effect.flatMap((cancellation) => cancellation === undefined
+        ? Effect.succeed({
+            status: "too_late",
+            commandId: input.commandId,
+        })
+        : (cancellation.active
+            ? runtime.signalCancellation(cancellation.accepted.commandId, cancellation.accepted.entryId)
+            : runtime.requestWake).pipe(Effect.as({
+            status: "accepted",
+            commandId: cancellation.accepted.commandId,
+        }))));
+}
+function abortCurrentSession(options, runtime, sessionId, meta) {
+    return runtime.assertOpen.pipe(Effect.andThen(runtime.commit(abortSession(options.store, sessionId, () => runtime.readQueueHeadTransactional(sessionId), runtime.recordAcceptedCancellation, meta))), Effect.flatMap((cancellation) => cancellation === undefined
+        ? runtime.requestWake
+        : runtime.signalCancellation(cancellation.commandId, cancellation.entryId)));
+}
+function selectBranch(options, runtime, sessionId, input) {
+    return runtime.assertOpen.pipe(Effect.andThen(branchSession(options.store, {
+        sessionId,
+        type: "branch",
+        entryId: input.entryId,
+        assertIdleSession: runtime.assertIdleSession,
+    })), Effect.as(undefined));
+}
+function forkBranch(options, runtime, sessionId, input) {
+    return runtime.assertOpen.pipe(Effect.andThen(forkSession(options.store, {
+        sessionId,
+        type: "fork",
+        entryId: input.entryId,
+        assertIdleSession: runtime.assertIdleSession,
+    })));
+}
+function executeSessionCommand(options, runtime, sessionId, meta, input) {
+    return runtime.assertOpen.pipe(Effect.andThen(decodeSessionCommand(sessionId, input)), 
+    // The one path every command's host metadata takes: checked once against
+    // the host's schema, then stored on whatever entry the command writes.
+    Effect.flatMap((decoded) => checkCommandMeta(options, meta).pipe(Effect.map((checked) => ({ ...decoded, checked })))), Effect.flatMap(({ sessionId: decodedSessionId, command, checked, }) => {
+        switch (command.type) {
+            case "prompt":
+            case "compact":
+                return admitUserWork(runtime, decodedSessionId, command, checked);
+            case "abort":
+                return abortCurrentSession(options, runtime, decodedSessionId, checked).pipe(Effect.as(undefined));
+            case "cancel":
+                return cancelRequestedSession(options, runtime, decodedSessionId, command, checked);
+            case "branch":
+                return selectBranch(options, runtime, decodedSessionId, command);
+            case "fork":
+                return forkBranch(options, runtime, decodedSessionId, command);
+            case "operator":
+                return runtime.assertOpen.pipe(Effect.andThen(recordOperatorLine(options.store, {
+                    sessionId: decodedSessionId,
+                    requestId: command.requestId,
+                    author: command.author,
+                    meta: checked,
+                    text: command.text,
+                    assertIdleSession: runtime.assertIdleSession,
+                })), Effect.as(undefined));
+            case "title":
+                return runtime
+                    .commit(sessionOwnerOperation(runtime, decodedSessionId, (decoded) => {
+                    setSessionTitle(options.store, decoded, command.title);
+                }))
+                    .pipe(Effect.as(undefined));
+        }
+    }));
+}
+/** Check one command's host metadata against the host's schema, once. */
+function checkCommandMeta(options, meta) {
+    return Effect.try({
+        try: () => meta === undefined ? undefined : checkHostMeta(options.meta, meta),
+        catch: (cause) => cause instanceof ShiitakeError
+            ? cause
+            : new ShiitakeError("contract", "invalid", "Host metadata is invalid"),
+    });
+}
+/** Construct the Effect-native coordinator over the private owner modules. */
+export function openCoordinator(options, runtime) {
+    const observation = openObservationKernel(options.store);
+    /** One Session handle; `meta` is the host metadata its prompts carry. */
+    const sessionFor = (sessionId, meta) => {
+        function command(input) {
+            return executeSessionCommand(options, runtime, sessionId, meta, input);
+        }
+        return Object.freeze({
+            command,
+            abort: command({ type: "abort" }),
+            send: (text, input) => Effect.sync(() => input?.requestId ?? nanoid()).pipe(Effect.flatMap((requestId) => {
+                const prompt = {
+                    type: "prompt",
+                    delivery: input?.delivery ?? "steer",
+                    requestId,
+                    text,
+                };
+                return command(input?.images === undefined
+                    ? prompt
+                    : { ...prompt, images: input.images }).pipe(Effect.mapError((error) => error.requestId === requestId
+                    ? error
+                    : new ShiitakeError(error.boundary, error.cause, error.message, requestId)));
+            })),
+            cancel: (input) => command({ type: "cancel", ...input }),
+            modelPreference: Object.freeze({
+                read: sessionOwnerOperation(runtime, sessionId, (decoded) => readSessionModelPreference(options.store, decoded)),
+                set: (preference) => Effect.try({
+                    try: () => parseModelPreference(preference),
+                    catch: () => new ShiitakeError("contract", "invalid", "Model preference is invalid"),
+                }).pipe(Effect.flatMap((parsed) => runtime
+                    .commit(sessionOwnerOperation(runtime, sessionId, (decoded) => {
+                    setSessionModelPreference(options.store, decoded, parsed);
+                    return decoded;
+                }))
+                    .pipe(
+                // Once committed, observers re-read the Session: the
+                // selection's window may have changed.
+                Effect.tap((decoded) => Effect.sync(() => {
+                    publishOwnerObservation(options.store, decoded);
+                })), Effect.asVoid))),
+            }),
+            extension: (extensionId) => Object.freeze({
+                call: (command, input) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "session", sessionId }, extensionId, command, input))),
+            }),
+            read: (input) => runtime.assertOpen.pipe(Effect.andThen(readSessionWithContext(options, runtime, sessionId, input))),
+            subscribe: (input) => subscribeSession(options, runtime, observation, sessionId, input),
+            watch: (input) => watchSession(options, runtime, observation, sessionId, input),
+        });
+    };
+    const agent = Object.freeze({
+        createSession: (requestId) => runtime.assertOpen.pipe(Effect.andThen(createSession(options.store, requestId, runtime.storage.admitNew))),
+        deleteSession: (sessionId) => runtime.assertOpen.pipe(Effect.andThen(deleteSession(options.store, {
+            sessionId,
+            assertIdleSession: runtime.assertIdleSession,
+        }))),
+        listSessions: (after) => runtime.assertOpen.pipe(Effect.andThen(readSessionInbox(options.store, after))),
+        extensions: agentExtensions(runtime),
+        session: (sessionId) => sessionFor(sessionId, undefined),
+        close: runtime.beginClose.pipe(Effect.andThen(observation.close)),
+    });
+    return Object.freeze({
+        ...agent,
+        grants: Object.freeze({
+            // A synchronous owner write: a delivery lands before any other work
+            // can interleave, so the very next tool call reads it.
+            deliver: (sessionId, delivery) => sessionOwnerOperation(runtime, sessionId, (decoded) => options.store.transactionSync(() => deliverSessionGrants(options.store, decoded, delivery))),
+            read: (sessionId) => sessionOwnerOperation(runtime, sessionId, (decoded) => readSessionGrants(options.store, decoded)),
+        }),
+        withMeta: (meta) => Object.freeze({
+            ...agent,
+            session: (sessionId) => sessionFor(sessionId, meta),
+        }),
+    });
+}
+/**
+ * Accept one addressed mail envelope; the door decodes it as a prompt. `reply`
+ * is the host's authentication of a delegated Agent's reply; only then does
+ * the model see the line inside the verified-reply tag.
+ */
+export function acceptAddressedMail(runtime, mail, meta, reply) {
+    return admitUserWork(runtime, mail.to.sessionId, {
+        requestId: mail.key,
+        delivery: "followUp",
+        type: "prompt",
+        text: mail.content,
+    }, meta, mail, reply);
+}

package/dist/internal/document-codec.d.ts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+import type { DocumentsV0, DocumentSpecV0 } from "../session-documents.js";
+/** The declared schema owns typed values; the JSON decoder owns their encoding. */
+export declare function encodeDocument<A, I>(spec: DocumentSpecV0<A, I>, value: A): string;
+/** Validate policy, bound and initial state before admitting any extension. */
+export declare function documentDescriptor(spec: DocumentsV0[string]): {
+    schema: Schema.Json;
+    initial: string;
+    fork: "inherit-at-fork-point" | "current" | "fresh";
+    maxBytes: number;
+};

package/dist/internal/document-codec.js

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+import * as SchemaRepresentation from "effect/SchemaRepresentation";
+import { ExtensionStateError } from "../extensions.js";
+import { JsonValueSchema } from "./json-value.js";
+const Declaration = Schema.Struct({
+    fork: Schema.Literals(["inherit-at-fork-point", "current", "fresh"]),
+    maxBytes: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER))),
+});
+/** The declared schema owns typed values; the JSON decoder owns their encoding. */
+export function encodeDocument(spec, value) {
+    const result = Schema.encodeUnknownResult(spec.schema)(value);
+    if (result._tag === "Failure")
+        throw new ExtensionStateError({
+            reason: "encode",
+            message: "Session document does not match its schema",
+        });
+    const json = Schema.decodeUnknownResult(JsonValueSchema)(result.success);
+    if (json._tag === "Failure")
+        throw new ExtensionStateError({
+            reason: "encode",
+            message: "Session document must encode finite JSON",
+        });
+    const text = JSON.stringify(json.success);
+    if (new TextEncoder().encode(text).byteLength > spec.maxBytes)
+        throw new ExtensionStateError({
+            reason: "bound",
+            message: "Session document exceeds maxBytes",
+        });
+    return text;
+}
+/** Validate policy, bound and initial state before admitting any extension. */
+export function documentDescriptor(spec) {
+    const declaration = Schema.decodeUnknownSync(Declaration)(spec);
+    return {
+        ...declaration,
+        schema: SchemaRepresentation.toJson(Schema.toRepresentation(spec.schema)),
+        initial: encodeDocument(spec, spec.initial),
+    };
+}

package/dist/internal/effect-client.d.ts

@@ -0,0 +1,13 @@
+import * as Effect from "effect/Effect";
+import type { ShiitakeAgent } from "../client.js";
+import type { ShiitakeEffectAgent, ShiitakeEffectOwner } from "./effect-contracts.js";
+import type { ShiitakeOwnerAgent } from "./contracts.js";
+/** Run one Shiitake Effect through its sole Promise error adaptation. */
+export declare function runShiitakePromise<A, E>(effect: Effect.Effect<A, E>): Promise<A>;
+/** Adapt one canonical Effect agent to Shiitake's ordinary web interface. */
+export declare function toPromiseAgent(agent: ShiitakeEffectAgent, suppliedAddress?: string): ShiitakeAgent;
+/**
+ * Adapt the in-process owner, keeping its host-only grants and metadata
+ * surfaces; its metadata views share one address.
+ */
+export declare function toPromiseOwner(owner: ShiitakeEffectOwner): ShiitakeOwnerAgent;

package/dist/internal/effect-client.js

@@ -0,0 +1,102 @@
+import { nanoid } from "@fungi.computer/cairn";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { ShiitakeError } from "../errors.js";
+/** Run one Shiitake Effect through its sole Promise error adaptation. */
+export function runShiitakePromise(effect) {
+    return Effect.runPromiseExit(effect).then((exit) => {
+        if (Exit.isSuccess(exit))
+            return exit.value;
+        const failure = Option.getOrUndefined(Cause.findErrorOption(exit.cause));
+        const error = failure ?? Cause.squash(exit.cause);
+        return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    });
+}
+/**
+ * Run one synchronous owner Effect and return or throw its result. Only
+ * store operations that never suspend use it.
+ */
+function runShiitakeSync(effect) {
+    const exit = Effect.runSyncExit(effect);
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    const failure = Option.getOrUndefined(Cause.findErrorOption(exit.cause));
+    const error = failure ?? Cause.squash(exit.cause);
+    throw error instanceof Error ? error : new Error(String(error));
+}
+function observationAsyncIterable(stream) {
+    const iterable = Stream.toAsyncIterable(stream);
+    return Object.freeze({
+        [Symbol.asyncIterator]: () => {
+            const iterator = iterable[Symbol.asyncIterator]();
+            return {
+                next: () => iterator.next(),
+                return: () => iterator.return?.() ??
+                    Promise.resolve({ done: true, value: undefined }),
+            };
+        },
+    });
+}
+function sessionFacade(address, session) {
+    function command(input) {
+        return runShiitakePromise(session.command(input));
+    }
+    return Object.freeze({
+        address,
+        command,
+        abort: () => runShiitakePromise(session.abort),
+        send: (text, options) => runShiitakePromise(session.send(text, options)),
+        cancel: (input) => runShiitakePromise(session.cancel(input)),
+        modelPreference: Object.freeze({
+            read: () => runShiitakePromise(session.modelPreference.read),
+            set: (preference) => runShiitakePromise(session.modelPreference.set(preference)),
+        }),
+        extension: (extensionId) => {
+            const extension = session.extension(extensionId);
+            return Object.freeze({
+                call: (command, input) => runShiitakePromise(extension.call(command, input)),
+            });
+        },
+        read: (input) => runShiitakePromise(session.read(input)),
+        subscribe: (input) => observationAsyncIterable(session.subscribe(input)),
+        watch: (input) => runShiitakePromise(session.watch(input)).then((watch) => Object.freeze({
+            snapshot: watch.snapshot,
+            changes: observationAsyncIterable(watch.changes),
+            close: () => runShiitakePromise(watch.close),
+        })),
+    });
+}
+/** Adapt one canonical Effect agent to Shiitake's ordinary web interface. */
+export function toPromiseAgent(agent, suppliedAddress) {
+    const agentAddress = suppliedAddress ?? `local:${nanoid()}`;
+    return Object.freeze({
+        createSession: (requestId) => runShiitakePromise(agent.createSession(requestId)),
+        deleteSession: (sessionId) => runShiitakePromise(agent.deleteSession(sessionId)),
+        listSessions: (after) => runShiitakePromise(agent.listSessions(after)),
+        extensions: Object.freeze({
+            list: () => runShiitakePromise(agent.extensions.list),
+            resume: (extensionId) => runShiitakePromise(agent.extensions.resume(extensionId)),
+            call: (extensionId, command, input) => runShiitakePromise(agent.extensions.call(extensionId, command, input)),
+        }),
+        session: (sessionId) => sessionFacade(`${agentAddress}/sessions/${encodeURIComponent(sessionId)}`, agent.session(sessionId)),
+        close: () => runShiitakePromise(agent.close),
+    });
+}
+/**
+ * Adapt the in-process owner, keeping its host-only grants and metadata
+ * surfaces; its metadata views share one address.
+ */
+export function toPromiseOwner(owner) {
+    const address = `local:${nanoid()}`;
+    return Object.freeze({
+        ...toPromiseAgent(owner, address),
+        grants: Object.freeze({
+            deliver: (sessionId, delivery) => runShiitakeSync(owner.grants.deliver(sessionId, delivery)),
+            read: (sessionId) => runShiitakeSync(owner.grants.read(sessionId)),
+        }),
+        withMeta: (meta) => toPromiseAgent(owner.withMeta(meta), address),
+    });
+}