@fungi.computer/shiitake 0.0.0-stage → 0.0.1

package/dist/internal/agent-close.js

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import * as Latch from "effect/Latch";
+import * as Exit from "effect/Exit";
+function replayCloseResult(result) {
+    return Exit.match(result, {
+        onFailure: Effect.failCause,
+        onSuccess: () => Effect.void,
+    });
+}
+function closeCoordinatorThenExtensions(coordinatorClose, extensionClose) {
+    return Effect.matchCauseEffect(coordinatorClose, {
+        onFailure: (coordinatorCause) => Effect.exit(extensionClose).pipe(Effect.andThen(Effect.failCause(coordinatorCause))),
+        onSuccess: () => extensionClose,
+    });
+}
+/** Compose one idempotent close action for the constructed agent. */
+export function composeAgentClose(coordinatorClose, extensionClose) {
+    let state = { _tag: "open" };
+    const runClose = (running) => closeCoordinatorThenExtensions(coordinatorClose, extensionClose).pipe(Effect.exit, Effect.flatMap((result) => Effect.sync(() => {
+        running.result = result;
+        state = { _tag: "closed" };
+    }).pipe(Effect.andThen(running.settled.open), Effect.andThen(replayCloseResult(result)))), Effect.uninterruptible);
+    return Effect.suspend(() => {
+        if (state._tag === "closed")
+            return Effect.void;
+        if (state._tag !== "open") {
+            const running = state;
+            return running.settled.await.pipe(Effect.andThen(Effect.suspend(() => {
+                const result = running.result;
+                return result === undefined
+                    ? Effect.die(new Error("Agent close settlement was not recorded"))
+                    : replayCloseResult(result);
+            })));
+        }
+        const running = {
+            _tag: "running",
+            settled: Latch.makeUnsafe(false),
+        };
+        state = running;
+        return runClose(running);
+    });
+}

package/dist/internal/browser-sessions.d.ts

@@ -0,0 +1,31 @@
+import type { ModuleRegistration } from "@fungi.computer/mycelium";
+/** The maintained browser transport and its Session-bound tool descriptors. */
+export type BrowserHost = Readonly<{
+    /** Mycelium tools bound to this host's Session and call-time gates. */
+    modules: readonly ModuleRegistration[];
+    /** Forward one browser events, claims or results request to the maintained host. */
+    fetch: (request: Request) => Promise<Response>;
+}>;
+export type BrowserLease = Readonly<{
+    host: BrowserHost;
+    release: () => void;
+}>;
+/** One ephemeral browser host per Session, borrowed by run and SSE scopes. */
+export declare class BrowserSessions {
+    private readonly open;
+    private readonly hasSession;
+    private generation;
+    private closed;
+    private readonly hosts;
+    constructor(open: (sessionId: string) => BrowserHost, hasSession: (sessionId: string) => Promise<boolean>);
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    fetch(request: Request): Promise<Response>;
+    /** Own the async transport opening until its stream joins the connection scope. */
+    private openEvents;
+    private createHost;
+    acquire(sessionId: string): BrowserLease;
+    private releaseBrowserConnection;
+    private releaseIdleHost;
+    private trackBrowserConnection;
+}

package/dist/internal/browser-sessions.js

@@ -0,0 +1,173 @@
+/** One ephemeral browser host per Session, borrowed by run and SSE scopes. */
+export class BrowserSessions {
+    open;
+    hasSession;
+    generation = 0;
+    closed = false;
+    hosts = new Map();
+    constructor(open, hasSession) {
+        this.open = open;
+        this.hasSession = hasSession;
+    }
+    async clear() {
+        this.generation += 1;
+        const old = [...this.hosts.values()];
+        this.hosts.clear();
+        await Promise.all(old.flatMap((entry) => [...entry.connections].map((close) => close())));
+    }
+    async close() {
+        this.closed = true;
+        await this.clear();
+    }
+    async fetch(request) {
+        if (this.closed)
+            return new Response(null, { status: 410 });
+        const generation = this.generation;
+        const path = new URL(request.url).pathname;
+        const browserRoute = /^\/browser\/sessions\/([^/]+)\/browser\/(events|claims|results)$/u.exec(path);
+        if (browserRoute === null)
+            return new Response("Not found", { status: 404 });
+        let sessionId;
+        try {
+            sessionId = decodeURIComponent(browserRoute[1] ?? "");
+        }
+        catch {
+            return new Response("Not found", { status: 404 });
+        }
+        const route = browserRoute[2];
+        if (!sessionId || !route)
+            return new Response("Not found", { status: 404 });
+        let entry = this.hosts.get(sessionId);
+        if (entry === undefined) {
+            if (route !== "events")
+                return new Response("Not found", { status: 404 });
+            if (!(await this.hasSession(sessionId)))
+                return new Response("Not found", { status: 404 });
+            if (generation !== this.generation)
+                return new Response(null, { status: 404 });
+            entry = this.hosts.get(sessionId) ?? this.createHost(sessionId);
+        }
+        const target = new URL(request.url);
+        target.pathname = `/browser/${route}`;
+        if (route !== "events")
+            return entry.host.fetch(new Request(target, request));
+        return this.openEvents(new Request(target, request), sessionId, entry, generation);
+    }
+    /** Own the async transport opening until its stream joins the connection scope. */
+    async openEvents(request, sessionId, entry, generation) {
+        entry.browserConnections += 1;
+        try {
+            const response = await entry.host.fetch(request);
+            if (generation !== this.generation) {
+                // The maintained transport may finish opening after teardown. Its
+                // late scope belongs to the old generation and must never escape.
+                await response.body?.cancel();
+                this.releaseBrowserConnection(sessionId, entry);
+                return new Response(null, { status: 404 });
+            }
+            if (!response.ok || response.body === null) {
+                this.releaseBrowserConnection(sessionId, entry);
+                return response;
+            }
+            return this.trackBrowserConnection(response, sessionId, entry);
+        }
+        catch (error) {
+            this.releaseBrowserConnection(sessionId, entry);
+            throw error;
+        }
+    }
+    createHost(sessionId) {
+        const entry = {
+            host: this.open(sessionId),
+            activeRuns: 0,
+            browserConnections: 0,
+            connections: new Set(),
+        };
+        this.hosts.set(sessionId, entry);
+        return entry;
+    }
+    acquire(sessionId) {
+        if (this.closed)
+            throw new Error("Browser host is closed");
+        const entry = this.hosts.get(sessionId) ?? this.createHost(sessionId);
+        entry.activeRuns += 1;
+        let released = false;
+        return {
+            host: entry.host,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                entry.activeRuns -= 1;
+                this.releaseIdleHost(sessionId, entry);
+            },
+        };
+    }
+    releaseBrowserConnection(sessionId, entry) {
+        entry.browserConnections -= 1;
+        this.releaseIdleHost(sessionId, entry);
+    }
+    releaseIdleHost(sessionId, entry) {
+        if (entry.activeRuns === 0 &&
+            entry.browserConnections === 0 &&
+            this.hosts.get(sessionId) === entry)
+            this.hosts.delete(sessionId);
+    }
+    trackBrowserConnection(response, sessionId, entry) {
+        const reader = response.body?.getReader();
+        if (reader === undefined) {
+            this.releaseBrowserConnection(sessionId, entry);
+            return response;
+        }
+        let released = false;
+        let controller;
+        const close = async () => {
+            if (released)
+                return;
+            release();
+            controller.close();
+            await reader.cancel();
+        };
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            entry.connections.delete(close);
+            this.releaseBrowserConnection(sessionId, entry);
+        };
+        entry.connections.add(close);
+        const body = new ReadableStream({
+            start: (streamController) => {
+                controller = streamController;
+            },
+            pull: async (controller) => {
+                try {
+                    const next = await reader.read();
+                    if (released)
+                        return;
+                    if (next.done) {
+                        controller.close();
+                        release();
+                    }
+                    else
+                        controller.enqueue(next.value);
+                }
+                catch (error) {
+                    if (released)
+                        return;
+                    controller.error(error);
+                    release();
+                }
+            },
+            cancel: async (reason) => {
+                release();
+                await reader.cancel(reason);
+            },
+        });
+        return new Response(body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+    }
+}

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

@@ -0,0 +1,262 @@
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+/** Bounded image payload admitted and persisted by the Session owner. */
+export declare const PromptImageSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"image">;
+    readonly data: Schema.String;
+    readonly mimeType: Schema.String;
+}>;
+/** Delivery policy for input accepted while a Session run is active. */
+export type PromptDelivery = "steer" | "followUp";
+declare const SessionCreationRequestSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+}>;
+declare const PromptCommandSchema: Schema.Struct<{
+    readonly delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"prompt">;
+    readonly text: Schema.String;
+    readonly images: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+    }>>>;
+}>;
+declare const AbortCommandSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"abort">;
+}>;
+declare const CancelCommandSchema: Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly onlyIfPending: Schema.optional<Schema.Boolean>;
+    readonly type: Schema.Literal<"cancel">;
+}>;
+/**
+ * Compact the Session's context now. It is accepted Session work, queued
+ * behind any running work and idempotent by `requestId`; it runs no model
+ * turn beyond the summary and never enters model context or a title.
+ */
+/** Bounded focus text a manual compaction passes to its summary. */
+export declare const CompactionInstructionsSchema: Schema.String;
+/** Work the accepted-command door admits: a prompt or a compaction request. */
+declare const AcceptedCommandSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"prompt">;
+    readonly text: Schema.String;
+    readonly images: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+    }>>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compact">;
+    readonly requestId: Schema.String;
+    /** Focus for the summary, appended as Pi's "Additional focus". */
+    readonly instructions: Schema.optionalKey<Schema.String>;
+}>]>;
+/**
+ * The longest Session title, in Unicode code points; the derived first-prompt
+ * title uses the same bound.
+ */
+export declare const sessionTitleLimit = 120;
+/** One user-set Session title: trimmed, single-line and bounded. */
+export declare const SessionTitleSchema: Schema.String;
+declare const SessionCommandSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly delivery: Schema.Literals<readonly ["steer", "followUp"]>;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"prompt">;
+    readonly text: Schema.String;
+    readonly images: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly data: Schema.String;
+        readonly mimeType: Schema.String;
+    }>>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"abort">;
+}>, Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly onlyIfPending: Schema.optional<Schema.Boolean>;
+    readonly type: Schema.Literal<"cancel">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"branch">;
+    readonly entryId: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"fork">;
+    readonly entryId: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"operator">;
+    readonly requestId: Schema.String;
+    readonly author: Schema.Literals<readonly ["operator", "party"]>;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compact">;
+    readonly requestId: Schema.String;
+    /** Focus for the summary, appended as Pi's "Additional focus". */
+    readonly instructions: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"title">;
+    readonly title: Schema.NullOr<Schema.String>;
+}>]>;
+declare const ReadOptionsSchema: Schema.Struct<{
+    readonly includeSandboxFailures: Schema.optional<Schema.Boolean>;
+    readonly limit: Schema.optional<Schema.Int>;
+    readonly before: Schema.optional<Schema.String>;
+}>;
+export declare const decodeClientSessionCreationRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly requestId: string;
+}, Schema.SchemaError>;
+/** The accepted-command door's one decoder for queued Session work. */
+export declare const decodeClientAcceptedCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly requestId: string;
+    readonly type: "prompt";
+    readonly text: string;
+    readonly delivery: "followUp" | "steer";
+    readonly images?: readonly {
+        readonly type: "image";
+        readonly data: string;
+        readonly mimeType: string;
+    }[];
+} | {
+    readonly requestId: string;
+    readonly type: "compact";
+    readonly instructions?: string;
+}, Schema.SchemaError>;
+/** Decode one owner-issued identity (command, extension or cursor). */
+export declare const decodeClientIdentity: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<string, Schema.SchemaError>;
+export declare const decodeClientSessionCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly requestId: string;
+    readonly type: "prompt";
+    readonly text: string;
+    readonly delivery: "followUp" | "steer";
+    readonly images?: readonly {
+        readonly type: "image";
+        readonly data: string;
+        readonly mimeType: string;
+    }[];
+} | {
+    readonly type: "abort";
+} | {
+    readonly type: "cancel";
+    readonly commandId: string;
+    readonly onlyIfPending?: boolean | undefined;
+} | {
+    readonly type: "branch";
+    readonly entryId: string;
+} | {
+    readonly type: "fork";
+    readonly entryId: string;
+} | {
+    readonly type: "operator";
+    readonly requestId: string;
+    readonly author: "operator" | "party";
+    readonly text: string;
+} | {
+    readonly requestId: string;
+    readonly type: "compact";
+    readonly instructions?: string;
+} | {
+    readonly type: "title";
+    readonly title: string | null;
+}, Schema.SchemaError>;
+export declare const decodeClientSessionCommandRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly command: {
+        readonly requestId: string;
+        readonly type: "prompt";
+        readonly text: string;
+        readonly delivery: "followUp" | "steer";
+        readonly images?: readonly {
+            readonly type: "image";
+            readonly data: string;
+            readonly mimeType: string;
+        }[];
+    } | {
+        readonly type: "abort";
+    } | {
+        readonly type: "cancel";
+        readonly commandId: string;
+        readonly onlyIfPending?: boolean | undefined;
+    } | {
+        readonly type: "branch";
+        readonly entryId: string;
+    } | {
+        readonly type: "fork";
+        readonly entryId: string;
+    } | {
+        readonly type: "operator";
+        readonly requestId: string;
+        readonly author: "operator" | "party";
+        readonly text: string;
+    } | {
+        readonly requestId: string;
+        readonly type: "compact";
+        readonly instructions?: string;
+    } | {
+        readonly type: "title";
+        readonly title: string | null;
+    };
+}, Schema.SchemaError>;
+export declare const decodeClientReadQuery: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly includeSandboxFailures?: "true" | undefined;
+    readonly limit?: number | undefined;
+    readonly before?: string | undefined;
+}, Schema.SchemaError>;
+export declare const decodeClientEventsQuery: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly includeSandboxFailures?: "true" | undefined;
+    readonly limit?: number | undefined;
+    readonly after?: string | undefined;
+    readonly mode?: "subscribe" | undefined;
+}, Schema.SchemaError>;
+/** Normalized C1 read policy after the public option bag is decoded once. */
+export type ClientReadOptions = Readonly<{
+    includeSandboxFailures?: boolean;
+    limit: number;
+    before?: string;
+}>;
+/** Public Session command inferred from its one runtime parser. */
+export type SessionCommand = Schema.Schema.Type<typeof SessionCommandSchema>;
+/** Public prompt command accepted as durable Session work. */
+export type PromptCommand = Schema.Schema.Type<typeof PromptCommandSchema>;
+/** Cancel the running turn and all queued prompts, retaining their text. */
+export type AbortCommand = Schema.Schema.Type<typeof AbortCommandSchema>;
+/** Public command that cancels exactly one accepted request. */
+export type CancelCommand = Schema.Schema.Type<typeof CancelCommandSchema>;
+/** Public command that selects one complete entry as the active lineage leaf. */
+export type BranchCommand = Extract<SessionCommand, Readonly<{
+    type: "branch";
+}>>;
+/** Public command that records one operator or party line without a run. */
+export type OperatorCommand = Extract<SessionCommand, Readonly<{
+    type: "operator";
+}>>;
+/** Public command that compacts the Session's context as queued work. */
+export type CompactCommand = Extract<SessionCommand, Readonly<{
+    type: "compact";
+}>>;
+/** Accepted Session work the door admits and Watchdog queues. */
+export type AcceptedWork = Schema.Schema.Type<typeof AcceptedCommandSchema>;
+/** Public command that sets or clears the user's Session title. */
+export type TitleCommand = Extract<SessionCommand, Readonly<{
+    type: "title";
+}>>;
+/** Public command that creates a new Session from one complete entry lineage. */
+export type ForkCommand = Extract<SessionCommand, Readonly<{
+    type: "fork";
+}>>;
+/** Exact C2 replay position after the public option bag is decoded once. */
+export type ClientSubscribeOptions = Readonly<{
+    after?: string;
+    includeSandboxFailures?: boolean;
+}>;
+/** Decode one ordinary Session-id value without exposing input detail. */
+export declare function decodeClientSessionId(value: string): string;
+/** Decode one opaque session-page cursor; its owner decodes the position. */
+export declare function decodeClientPageCursor(value: string): string;
+/** Decode the exact public Session creation request. */
+export declare function decodeClientSessionCreationRequestId(value: Schema.Schema.Type<typeof SessionCreationRequestSchema>): string;
+/** Decode and normalize the exact public C1 read option bag. */
+export declare function decodeClientReadOptions(value: Schema.Schema.Type<typeof ReadOptionsSchema> | undefined): ClientReadOptions;
+/** Decode the exact public C2 subscribe option bag before cursor classification. */
+export declare function decodeClientSubscribeOptions(value: ClientSubscribeOptions): ClientSubscribeOptions;
+/** Take one decoder result, or reject with a sanitized contract error. */
+export declare function requireDecoded<A, E>(decoded: Result.Result<A, E>, message: string): A;
+export {};