@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/cloudflare.js

@@ -0,0 +1,531 @@
+import { DurableObject } from "cloudflare:workers";
+import { fromTypedSandbox } from "@fungi.computer/mycelium/effect";
+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";
+/**
+ * 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
+ * reads it. A plain function, not a Durable Object method, so no other
+ * Durable Object can call it over RPC: only code running inside the owner,
+ * holding its storage, delivers grants.
+ */
+export function deliverSessionGrantsToStorage(storage, sessionId, delivery) {
+    return storage.transactionSync(() => {
+        prepareSessionGrants(storage);
+        return deliverSessionGrants(storage, decodeClientSessionId(sessionId), delivery);
+    });
+}
+function runtimeFailure(cause, message) {
+    return new ShiitakeError("runtime", cause, message);
+}
+function earliest(a, b) {
+    if (a === null)
+        return b;
+    return b === null ? a : Math.min(a, b);
+}
+/** Bounded backoff for a native alarm that failed outside any reconciliation. */
+const ALARM_RETRY_BASE_MS = 1_000;
+const ALARM_RETRY_CAP_MS = 30_000;
+/** Exponential growth from one failed alarm attempt, never past the cap. */
+function alarmRetryDelayMs(consecutiveFailures) {
+    return Math.min(ALARM_RETRY_BASE_MS * 2 ** (consecutiveFailures - 1), ALARM_RETRY_CAP_MS);
+}
+/** One native alarm protects queued and executing owner-local work. */
+function runtimeHost(state, hostWork = [], startup) {
+    let alarm;
+    const runtime = {
+        bind: ({ reconcile, pendingWork }) => Effect.sync(() => {
+            let closed = false;
+            const isClosed = () => closed;
+            let mutationVersion = Symbol();
+            const arm = async () => {
+                const existing = await state.storage.getAlarm();
+                const recoveryAt = Date.now() + 5_000;
+                await state.storage.setAlarm(existing === null ? recoveryAt : Math.min(existing, recoveryAt));
+            };
+            /** Arm at the earliest due time (host work included), or disarm. */
+            const armAt = async (due) => {
+                if (due === null)
+                    await state.storage.deleteAlarm();
+                else
+                    await state.storage.setAlarm(due);
+            };
+            const unavailable = () => runtimeFailure("unavailable", "Shiitake durable wake is unavailable");
+            const persistWake = Effect.tryPromise({ try: arm, catch: unavailable });
+            const hostPass = async () => {
+                const failures = [];
+                for (const [moduleIndex, work] of hostWork.entries()) {
+                    try {
+                        await work.run();
+                    }
+                    catch (error) {
+                        await runShiitakePromise(Effect.logError("shiitake_reconciliation_failed", Redacted.make(error)).pipe(Effect.annotateLogs({
+                            operation: "host-work.run",
+                            moduleIndex,
+                            failureKind: error instanceof Error ? "Error" : "NonErrorThrown",
+                        })));
+                        failures.push(error);
+                    }
+                }
+                if (failures.length > 0)
+                    throw new AggregateError(failures, "Host work failed");
+            };
+            function pass(run) {
+                let active;
+                let rerun = false;
+                let retry = false;
+                const slot = {
+                    get active() {
+                        return active;
+                    },
+                    get rerun() {
+                        return rerun;
+                    },
+                    get retry() {
+                        return retry;
+                    },
+                    stop() {
+                        rerun = false;
+                    },
+                    schedule,
+                };
+                function schedule() {
+                    if (closed)
+                        return;
+                    if (active !== undefined) {
+                        rerun = true;
+                        return;
+                    }
+                    const task = Promise.resolve().then(async () => {
+                        const reconciledVersion = mutationVersion;
+                        try {
+                            // Recover only after owner startup commands have committed.
+                            if (!(await runShiitakePromise(startup)) || isClosed())
+                                return;
+                            await run();
+                            if (closed)
+                                return;
+                            retry = false;
+                            // Native transactions serialize this read/disarm with acceptance.
+                            await state.storage.transaction(async () => {
+                                if (closed)
+                                    return;
+                                const owned = await runShiitakePromise(pendingWork);
+                                const host = hostWork.reduce((pending, work) => {
+                                    const next = work.pending();
+                                    return {
+                                        due: pending.due || next.due,
+                                        nextWakeAt: earliest(pending.nextWakeAt, next.nextWakeAt),
+                                    };
+                                }, { due: false, nextWakeAt: null });
+                                const pending = {
+                                    pending: owned.pending || host.due,
+                                    nextWakeAt: earliest(owned.nextWakeAt, host.nextWakeAt),
+                                };
+                                // A mutation can need reconciliation before it creates a job
+                                // (for example an extension command that sets a timer). An older
+                                // run cannot disarm it.
+                                if (reconciledVersion !== mutationVersion ||
+                                    passes.some((other) => other.retry ||
+                                        other.rerun ||
+                                        (other !== slot && other.active !== undefined)) ||
+                                    pending.pending)
+                                    await arm();
+                                else
+                                    await armAt(pending.nextWakeAt);
+                            });
+                        }
+                        catch (error) {
+                            retry = true;
+                            // Not an Effect here: this is a plain async callback driven by
+                            // waitUntil. runShiitakePromise is the same bridge the rest of
+                            // this file uses to reach the host's configured Logger.
+                            // Retain the original failure without printing provider or Session
+                            // data: Effect's default Logger does not redact raw Error objects.
+                            await runShiitakePromise(Effect.logError("shiitake_reconciliation_failed", Redacted.make(error)).pipe(Effect.annotateLogs({
+                                operation: "durable-wake.reconcile",
+                                failureKind: error instanceof Error ? "Error" : "NonErrorThrown",
+                            })));
+                            // Keep recovery independent of another request, including failure
+                            // after job settlement but before Session reconciliation finishes.
+                            if (!closed)
+                                await arm();
+                        }
+                        finally {
+                            if (active === task)
+                                active = undefined;
+                            if (rerun) {
+                                rerun = false;
+                                schedule();
+                            }
+                        }
+                    });
+                    active = task;
+                    state.waitUntil(task);
+                }
+                return slot;
+            }
+            const passes = [
+                pass(() => runShiitakePromise(reconcile)),
+                pass(hostPass),
+            ];
+            function schedule() {
+                for (const slot of passes)
+                    slot.schedule();
+            }
+            const requestWake = Effect.suspend(() => closed
+                ? Effect.fail(runtimeFailure("closed", "Shiitake runtime is closed"))
+                : persistWake.pipe(Effect.tap(() => Effect.sync(schedule))));
+            alarm = () => runShiitakePromise(requestWake);
+            return Object.freeze({
+                commit: (mutation) => Effect.tryPromise({
+                    try: () => state.storage.transaction(async () => {
+                        const result = await runShiitakePromise(mutation);
+                        // Invalidate before the transaction returns, including a lost
+                        // commit acknowledgement. Rollback may cause one extra wake.
+                        mutationVersion = Symbol();
+                        await arm();
+                        return result;
+                    }),
+                    catch: (error) => error instanceof ShiitakeError ? error : unavailable(),
+                }),
+                requestWake,
+                close: Effect.suspend(() => {
+                    closed = true;
+                    for (const slot of passes)
+                        slot.stop();
+                    return Effect.tryPromise({
+                        try: async () => {
+                            const active = passes.flatMap((slot) => slot.active === undefined ? [] : [slot.active]);
+                            const outcomes = await Promise.allSettled(active);
+                            const failures = [];
+                            for (const outcome of outcomes) {
+                                if (outcome.status === "rejected")
+                                    failures.push(outcome.reason);
+                            }
+                            if (failures.length > 0)
+                                throw new AggregateError(failures, "Runtime close failed");
+                        },
+                        catch: unavailable,
+                    });
+                }),
+            });
+        }),
+    };
+    return {
+        runtime,
+        alarm: () => alarm === undefined
+            ? Promise.reject(runtimeFailure("unavailable", "Shiitake runtime is not bound"))
+            : alarm(),
+    };
+}
+function configuredTools(tools) {
+    if (tools === undefined || !("sandbox" in tools))
+        return undefined;
+    return {
+        modules: tools.modules ?? [],
+        sources: tools.sources ?? [],
+        sandbox: fromTypedSandbox(tools.sandbox),
+        access: tools.access ?? {},
+    };
+}
+function effectOptions(state, options, runtime, browser) {
+    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],
+                    };
+            }),
+        },
+        model: adaptModelSource(options.model),
+    };
+    if (options.hostJobs !== undefined) {
+        const hostJobs = options.hostJobs;
+        Object.assign(base, {
+            hostJobs: {
+                lane: hostJobs.lane,
+                open: (watchdog) => {
+                    const host = hostJobs.open({
+                        transactional: watchdog.transactional,
+                        readJob: (jobId) => runShiitakePromise(watchdog.read(jobId)),
+                        tickConcurrent: () => runShiitakePromise(watchdog.tickConcurrent()),
+                    });
+                    return {
+                        execute: (job) => Effect.tryPromise({
+                            try: () => host.execute(job),
+                            catch: (error) => new WatchdogError("execution_failed", error),
+                        }),
+                    };
+                },
+            },
+        });
+    }
+    if (options.meta !== undefined)
+        Object.assign(base, { meta: options.meta });
+    if (options.storageBudget !== undefined)
+        Object.assign(base, { storageBudget: options.storageBudget });
+    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) {
+    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);
+    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);
+            throw cause;
+        }
+        await runShiitakePromise(Deferred.succeed(startup, true));
+        return Object.freeze({
+            ...handle,
+            readSettlement: (sessionId, commandId) => runShiitakePromise(readSettlement(sessionId, commandId)),
+            acceptMail: (mail, meta, reply) => {
+                if (options.mailRoom === undefined)
+                    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));
+        throw cause;
+    });
+}
+/** Owns runtime opening, HTTP/ACP transport, inbox observation and alarm recovery. */
+export class ShiitakeOwner {
+    ctx;
+    env;
+    constructor(ctx, env) {
+        this.ctx = ctx;
+        this.env = env;
+    }
+    agentPromise;
+    openAcp;
+    acpServer;
+    /** Consecutive native alarm failures; reset on the next successful alarm. */
+    alarmFailures = 0;
+    routes = createShiitakeHttpRoutes(async (sessionId, meta) => {
+        const agent = await this.shiitake();
+        return (meta === undefined ? agent : agent.withMeta(meta)).session(sessionId);
+    }, 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();
+            this.openAcp = options.acp;
+            this.agentPromise = makeCloudflareShiitake(this.ctx, options);
+        }
+        try {
+            return await this.agentPromise;
+        }
+        catch (error) {
+            this.agentPromise = undefined;
+            throw error;
+        }
+    }
+    /** Stop live execution without constructing a cold owner's runtime. */
+    async abortActiveSessions() {
+        await (await this.agentPromise)?.abortActive();
+    }
+    /** Close owned resources before storage erasure; a cold owner has none. */
+    async closeShiitake() {
+        await (await this.agentPromise)?.close();
+    }
+    /** Indexed owner-local existence check; corrupt stored Sessions remain unavailable. */
+    async hasStoredSession(sessionId) {
+        await this.shiitake();
+        const inbox = readSessionInboxSummary(this.ctx.storage, sessionId);
+        if (inbox === undefined || inbox.state === "unavailable")
+            return false;
+        return ((await runShiitakePromise(readSessionSummary(this.ctx.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);
+    }
+    /** Latest inbox revision; read only after the owner has opened. */
+    readInboxRevision() {
+        return readSessionInboxChanges(this.ctx.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);
+    }
+    /** Persist a wake and run one reconciliation pass, including host work. */
+    async wakeRuntime() {
+        await (await this.shiitake()).alarm();
+    }
+    /**
+     * Native alarms reconstruct the owner without an incoming user request.
+     * A construction or wake failure must not strand the claimed work on
+     * platform alarm retries: it is caught, logged, and explicitly re-armed
+     * with bounded backoff instead.
+     */
+    async alarm() {
+        try {
+            await (await this.shiitake()).alarm();
+            this.alarmFailures = 0;
+        }
+        catch (error) {
+            this.alarmFailures += 1;
+            const attempt = this.alarmFailures;
+            const retryInMs = alarmRetryDelayMs(attempt);
+            await runShiitakePromise(Effect.logError("shiitake_alarm_failed").pipe(Effect.annotateLogs({
+                cause: error instanceof Error ? error.message : String(error),
+                attempt,
+                retryInMs,
+            })));
+            try {
+                await this.ctx.storage.setAlarm(Date.now() + retryInMs);
+            }
+            catch (rearmError) {
+                // The platform's own alarm retry is the last resort if even this
+                // explicit re-arm fails; surface it rather than fail silently.
+                await runShiitakePromise(Effect.logError("shiitake_alarm_rearm_failed").pipe(Effect.annotateLogs({
+                    cause: rearmError instanceof Error
+                        ? rearmError.message
+                        : String(rearmError),
+                    attempt,
+                })));
+                throw error;
+            }
+        }
+    }
+    /** Serve Shiitake's complete transport without subclass routing. */
+    app;
+    /**
+     * Shiitake's whole HTTP surface (Session routes, browser 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)
+                return new Response(null, { status: 404 });
+            const opening = (this.acpServer ??= this.openAcp(agent));
+            let server;
+            try {
+                server = await opening;
+            }
+            catch (error) {
+                if (this.acpServer === opening)
+                    this.acpServer = undefined;
+                throw error;
+            }
+            return server.handleRequest(context.req.raw, context.get("shiitakeMeta"));
+        })
+            .route("/", this.routes)
+            // Browser and ACP failures reach the Durable Object caller unchanged,
+            // as they did before the routes shared one app.
+            .onError((error) => {
+            throw error;
+        }));
+    }
+    /** Serve one request through Shiitake's whole HTTP surface. */
+    async fetch(request) {
+        return await this.shiitakeApp().fetch(request);
+    }
+}
+/** Native Cloudflare entry points; all runtime lifetime belongs to the owner. */
+export class ShiitakeDO extends DurableObject {
+    #owner;
+    runtimeOwner() {
+        const options = () => this.shiitakeOptions();
+        return (this.#owner ??= new (class extends ShiitakeOwner {
+            shiitakeOptions() {
+                return options();
+            }
+        })(this.ctx, this.env));
+    }
+    shiitake() {
+        return this.runtimeOwner().shiitake();
+    }
+    abortActiveSessions() {
+        return this.runtimeOwner().abortActiveSessions();
+    }
+    closeShiitake() {
+        return this.runtimeOwner().closeShiitake();
+    }
+    readInboxChanges(after, limit) {
+        return this.runtimeOwner().readInboxChanges(after, limit);
+    }
+    readInboxRevision() {
+        return this.runtimeOwner().readInboxRevision();
+    }
+    pruneInboxTombstones(through) {
+        this.runtimeOwner().pruneInboxTombstones(through);
+    }
+    wakeRuntime() {
+        return this.runtimeOwner().wakeRuntime();
+    }
+    /** Reconcile due runtime and host work through the owner. */
+    alarm() {
+        return this.runtimeOwner().alarm();
+    }
+    /** Route an authenticated client request through the owner. */
+    fetch(request) {
+        return this.runtimeOwner().fetch(request);
+    }
+}

package/dist/effect.d.ts

@@ -0,0 +1,42 @@
+import type { CommandSettlement } from "./internal/contracts.js";
+import type { Json as HostJson } from "./extensions.js";
+import * as Effect from "effect/Effect";
+import type { BirdDogMail } from "@fungi.computer/bird-dog";
+import type { VerifiedAgentReply } from "./internal/woodstock/index.js";
+import type { BirdDogEffect } from "@fungi.computer/bird-dog/effect";
+import type { Accepted } from "./client.js";
+import type { ShiitakeError } from "./errors.js";
+import type { ShiitakeEffectOptions, ShiitakeEffectOwner } from "./internal/effect-contracts.js";
+import type { SqliteOwner } from "./internal/contracts.js";
+export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, ForkCommand, ForkedSession, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionCommandHandler, SessionFrame, SessionMessage, SessionProgress, SessionSnapshot, SessionActivity, AgentRunningWork, SubscribeOptions, TooLate, WatchOptions, } from "./client.js";
+export type { InstructionSnapshot, InstructionSource, ModelAcquisition, ModelDescription, ModelSource, RuntimeHost, RuntimePendingWork, SqliteCursor, SqliteOwner, SqliteValue, SqliteRow, GrantsDelivery, GrantsDeliveryResult, ShiitakeOptions, ToolAccess, HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, ToolSource, } from "./internal/contracts.js";
+export type { InstructionSourceEffect, ModelAcquisitionEffect, ModelSourceEffect, RuntimeHostEffect, ShiitakeEffectAgent, ShiitakeEffectAgentExtensions, ShiitakeEffectCommandHandler, ShiitakeEffectOptions, ShiitakeEffectOwner, ShiitakeEffectSession, ShiitakeEffectSessionExtension, ShiitakeEffectSendOptions, ShiitakeEffectWatch, ToolSourceEffect, } from "./internal/effect-contracts.js";
+export type { SessionSummary } from "./client.js";
+export type { BorrowedCompactionViewV0, CompactionHandoffErrorV0, CompactionHandoffResultV0, CompactionHandoffV0, ExtensionCapabilityV0, ExtensionGrantV0, ExtensionRosterV0, ExtensionSlotV0, ExtensionStatusV0, RosteredExtensionV0, } from "./extensions.js";
+export { ShiitakeError } from "./errors.js";
+/** Construct the canonical Effect-native Shiitake scaffold. */
+export declare function make(options: ShiitakeEffectOptions): Effect.Effect<ShiitakeEffectOwner, ShiitakeError>;
+/** Effect-native host composition with addressed mail kept off Session. */
+export type ShiitakeEffectHost = Readonly<{
+    /** Exact settled command facts; available only to the composing host. */
+    readSettlement: (sessionId: string, commandId: string) => Effect.Effect<CommandSettlement | undefined, ShiitakeError>;
+    agent: ShiitakeEffectOwner;
+    /** Durably admit one addressed mail item through the host owner. */
+    acceptMail: (mail: BirdDogMail, meta?: HostJson, reply?: VerifiedAgentReply) => Effect.Effect<Accepted, ShiitakeError>;
+}>;
+/** Open the Effect-native host composition with addressed mail. */
+export declare function openHost(options: ShiitakeEffectOptions, mailRoom: BirdDogEffect): Effect.Effect<ShiitakeEffectHost, ShiitakeError>;
+export type { ModelPreference } from "./internal/model-preference.js";
+export type { SessionSummaryPage, SessionSummaryRow } from "./client.js";
+export type { StoredSessionSummary, StoredSessionSummaryPage, StoredSessionSummaryRow, } from "./internal/woodstock/index.js";
+/**
+ * Enumerate saved conversations' stored facts in bounded pages, for readers
+ * that hold only the store. Run status is not stored; use the Agent's
+ * `listSessions` for it. An unreadable Session is its own `unavailable` row.
+ */
+export declare function readSessionSummaries(owner: SqliteOwner, after?: string): Effect.Effect<Readonly<{
+    sessions: readonly import("./internal/woodstock/session-store.js").StoredSessionSummaryRow[];
+    next: string | undefined;
+}>, ShiitakeError, never>;
+export { sqliteRowSchema } from "./internal/contracts.js";
+export type { CommandSettlement } from "./internal/contracts.js";

package/dist/effect.js

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import { readSessionFactPage } from "./internal/woodstock/index.js";
+export { ShiitakeError } from "./errors.js";
+/** Construct the canonical Effect-native Shiitake scaffold. */
+export function make(options) {
+    return Effect.promise(() => import("./internal/runtime-core.js")).pipe(Effect.flatMap(({ openRuntimeCore }) => openRuntimeCore(options)), Effect.map(({ agent }) => agent));
+}
+/** Open the Effect-native host composition with addressed mail. */
+export function openHost(options, mailRoom) {
+    return Effect.promise(() => import("./internal/runtime-core.js")).pipe(Effect.flatMap(({ openRuntimeCore }) => openRuntimeCore(options, mailRoom)));
+}
+/**
+ * Enumerate saved conversations' stored facts in bounded pages, for readers
+ * that hold only the store. Run status is not stored; use the Agent's
+ * `listSessions` for it. An unreadable Session is its own `unavailable` row.
+ */
+export function readSessionSummaries(owner, after) {
+    return readSessionFactPage(owner, after);
+}
+export { sqliteRowSchema } from "./internal/contracts.js";

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+import * as Schema from "effect/Schema";
+/** Stable boundary that rejected a Shiitake operation. */
+declare const ShiitakeErrorBoundarySchema: Schema.Literals<readonly ["contract", "extensions", "instructions", "model", "runtime", "store", "tools"]>;
+/** Stable boundary that rejected a Shiitake operation. */
+export type ShiitakeErrorBoundary = Schema.Schema.Type<typeof ShiitakeErrorBoundarySchema>;
+/** Safe failure category exposed by both Shiitake facades. */
+declare const ShiitakeErrorCauseSchema: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "storage_pressure", "context_too_large"]>;
+/** Safe failure category exposed by both Shiitake facades. */
+export type ShiitakeErrorCause = Schema.Schema.Type<typeof ShiitakeErrorCauseSchema>;
+/** Canonical serialized Shiitake failure. */
+export declare const ShiitakeErrorWireSchema: Schema.Struct<{
+    readonly _tag: Schema.Literal<"ShiitakeError">;
+    readonly boundary: Schema.Literals<readonly ["contract", "extensions", "instructions", "model", "runtime", "store", "tools"]>;
+    readonly cause: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "storage_pressure", "context_too_large"]>;
+    readonly message: Schema.String;
+    readonly requestId: Schema.optionalKey<Schema.String>;
+}>;
+/** Canonical serialized Shiitake failure. */
+export type ShiitakeErrorWire = Schema.Schema.Type<typeof ShiitakeErrorWireSchema>;
+/** Sanitized failure from a parsed Shiitake boundary. */
+export declare class ShiitakeError extends Error {
+    /** Boundary that rejected the operation. */
+    readonly boundary: ShiitakeErrorBoundary;
+    /** Request identity recoverable when a send may have reached the owner. */
+    readonly requestId?: string | undefined;
+    /** Stable runtime tag for typed Shiitake failures. */
+    readonly _tag: "ShiitakeError";
+    /** Safe category describing why it was rejected. */
+    readonly cause: ShiitakeErrorCause;
+    /** Original cause retained only for server-side diagnosis. */
+    readonly underlying?: unknown;
+    /** Construct a sanitized boundary failure. */
+    constructor(
+    /** Boundary that rejected the operation. */
+    boundary: ShiitakeErrorBoundary, 
+    /** Safe category describing why it was rejected. */
+    category: ShiitakeErrorCause, 
+    /** Human-readable message safe for callers to display. */
+    message: string, 
+    /** Request identity recoverable when a send may have reached the owner. */
+    requestId?: string | undefined, 
+    /**
+     * The original thrown value, kept for server-side diagnosis only. It is
+     * never serialized: the wire encoder copies named fields only.
+     */
+    cause?: unknown);
+}
+/** Sanitize one caught host failure for Shiitake's public wire. */
+export declare function toShiitakeErrorWire(cause: unknown): ShiitakeErrorWire;
+export {};