@fungi.computer/agar 0.0.0-stage → 0.0.1

package/dist/inbox.d.ts

@@ -0,0 +1,99 @@
+import { type MemberInboxItem } from "@fungi.computer/puffball/inbox";
+export { memberInboxItemSchema, memberInboxDeltaItemSchema, memberInboxSessionSchema, workflowReviewInboxItemSchema, workflowReviewKeySchema, memberInboxKey, memberInboxItemKey, type MemberInboxItem, type MemberInboxDeltaItem, type MemberInboxSession, type WorkflowReviewInboxItem, type WorkflowReviewKey, } from "@fungi.computer/puffball/inbox";
+import type { AppAgentTransport } from "./agents.js";
+import * as Schema from "effect/Schema";
+import * as z from "zod";
+/** A member Inbox page and its owner-issued continuation and revision. */
+export declare const memberInboxPageSchema: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly agentId: Schema.String;
+        readonly sessionId: Schema.String;
+        readonly title: Schema.String;
+        readonly triggerId: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.Number;
+        readonly lastActivityAt: Schema.Number;
+        readonly settledAt: Schema.optionalKey<Schema.Number>;
+        readonly visitedAt: Schema.optionalKey<Schema.Number>;
+        readonly state: Schema.Literals<readonly ["needs_you", "running", "errored", "done"]>;
+    }>, Schema.Struct<{
+        readonly agentId: Schema.String;
+        readonly sessionId: Schema.String;
+        readonly state: Schema.Literal<"unavailable">;
+    }>]>, Schema.Struct<{
+        readonly kind: Schema.Literal<"workflow-review">;
+        readonly key: Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+            readonly iteration: Schema.String;
+        }>;
+        readonly installationId: Schema.String;
+        readonly workflowId: Schema.NullOr<Schema.String>;
+        readonly workflowTitle: Schema.String;
+        readonly reviewTitle: Schema.String;
+        readonly reviewers: Schema.Literals<readonly ["runner", "owners"]>;
+        readonly show: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly choices: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly openedAt: Schema.Number;
+        readonly expiresAt: Schema.Number;
+        readonly state: Schema.Literals<readonly ["pending", "answered", "delivered", "timed_out", "closed"]>;
+    }>]>>;
+    readonly next: Schema.NullOr<Schema.String>;
+    readonly cursor: Schema.Number;
+}>;
+/** A successful visit to an existing admitted Inbox Session. */
+export declare const inboxVisitResultSchema: z.ZodObject<{
+    visited: z.ZodLiteral<true>;
+}, z.core.$strict>;
+/** Pages the first read loads; later rows arrive as deltas. */
+export declare const memberInboxInitialPages = 5;
+/** Minimal EventSource surface, so a capability fetch can carry the stream. */
+export type InboxEventSource = {
+    addEventListener(type: string, listener: (event: MessageEvent<string>) => void): void;
+    close(): void;
+};
+export type MemberInboxSnapshot = Readonly<{
+    items: readonly MemberInboxItem[];
+    status: "loading" | "live" | "error";
+}>;
+export type MemberInboxFeed = Readonly<{
+    /** Record that the member opened a Session; the owner moves its row. */
+    visit: (agentId: string, sessionId: string) => Promise<void>;
+    /** Re-register the current Agent directory and reload rows after a new Agent. */
+    refresh: () => Promise<void>;
+    close: () => void;
+}>;
+/**
+ * Load the member inbox, then follow its deltas. A delta that does not start
+ * at this client's cursor means one was missed: the stream is reopened from
+ * the cursor, and the owner replays every change after it. `reset` reloads.
+ */
+export declare function watchMemberInbox(options: Readonly<{
+    /** Base that serves `/inbox`, `/inbox/events` and `/inbox/visits`. */
+    baseUrl: string;
+    fetch: typeof globalThis.fetch;
+    openEvents: (url: string) => InboxEventSource;
+    onChange: (snapshot: MemberInboxSnapshot) => void;
+}>): MemberInboxFeed;
+/** Shared Team notices use the same member-admitted inbox transport as Session reads. */
+export declare function readTeamInboxNoticePage(transport: Pick<AppAgentTransport, "baseUrl" | "fetch">, after?: string | null): Promise<{
+    readonly items: readonly ({
+        readonly appId: import("@fungi.computer/puffball").AppId;
+        readonly displayName: string;
+        readonly createdAt: number;
+        readonly dispositionId: string;
+        readonly releaseIds: readonly import("@fungi.computer/puffball").ReleaseId[];
+        readonly reason?: string | undefined;
+    } | {
+        readonly createdAt: number;
+        readonly kind: "seller-closed";
+        readonly dispositionId: string;
+        readonly sellerAccountId: string;
+        readonly buyerAccountId: string;
+        readonly appId: string;
+        readonly releaseIds: readonly [string];
+        readonly displayName: string;
+        readonly sellerName: string;
+        readonly requestId: string;
+    })[];
+    readonly next: string | null;
+}>;

package/dist/inbox.js

@@ -0,0 +1,184 @@
+import { memberInboxItemSchema, memberInboxDeltaItemSchema, memberInboxItemKey, } from "@fungi.computer/puffball/inbox";
+export { memberInboxItemSchema, memberInboxDeltaItemSchema, memberInboxSessionSchema, workflowReviewInboxItemSchema, workflowReviewKeySchema, memberInboxKey, memberInboxItemKey, } from "@fungi.computer/puffball/inbox";
+import { sellerClosureNoticeSchema } from "@fungi.computer/puffball/seller-closure-notice";
+import { artifactDispositionNoticeSchema } from "@fungi.computer/puffball/artifact-dispositions";
+import * as Schema from "effect/Schema";
+import * as z from "zod";
+import { reportCatchFailure } from "./failure.js";
+/**
+ * Client for one member's inbox feed. The host's member owner decides nothing
+ * here either: this module keeps the rows it is sent, resumes from its member
+ * cursor, and re-reads whenever a delta could have been missed. It never
+ * polls.
+ */
+const time = Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** A member Inbox page and its owner-issued continuation and revision. */
+export const memberInboxPageSchema = Schema.Struct({
+    items: Schema.Array(memberInboxItemSchema),
+    next: Schema.NullOr(Schema.String),
+    cursor: time,
+});
+/** A successful visit to an existing admitted Inbox Session. */
+export const inboxVisitResultSchema = z.strictObject({
+    visited: z.literal(true),
+});
+const decodePage = Schema.decodeUnknownSync(memberInboxPageSchema);
+const decodeRows = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Struct({
+    kind: Schema.Literal("rows"),
+    from: time,
+    to: time,
+    items: Schema.Array(memberInboxDeltaItemSchema),
+    more: Schema.Boolean,
+})));
+/** Pages the first read loads; later rows arrive as deltas. */
+export const memberInboxInitialPages = 5;
+/**
+ * Load the member inbox, then follow its deltas. A delta that does not start
+ * at this client's cursor means one was missed: the stream is reopened from
+ * the cursor, and the owner replays every change after it. `reset` reloads.
+ */
+export function watchMemberInbox(options) {
+    const items = new Map();
+    let cursor = 0;
+    let closed = false;
+    let events;
+    let generation = 0;
+    const emit = (status) => {
+        if (!closed)
+            options.onChange({ items: [...items.values()], status });
+    };
+    const upsert = (list) => {
+        for (const item of list) {
+            const key = memberInboxItemKey(item);
+            if ("deleted" in item)
+                items.delete(key);
+            else
+                items.set(key, item);
+        }
+    };
+    const follow = () => {
+        events?.close();
+        const current = ++generation;
+        const source = options.openEvents(`${options.baseUrl}/inbox/events?after=${String(cursor)}`);
+        events = source;
+        let disconnected = false;
+        source.addEventListener("error", () => {
+            if (closed || current !== generation)
+                return;
+            disconnected = true;
+            reportCatchFailure("inbox.observe", new Error("Member inbox stream disconnected"));
+            emit("error");
+        });
+        source.addEventListener("open", () => {
+            if (closed || current !== generation || !disconnected)
+                return;
+            // A transport reconnect is not an owner refresh. Read before claiming live.
+            void load();
+        });
+        source.addEventListener("rows", (event) => {
+            if (closed || current !== generation)
+                return;
+            let delta;
+            try {
+                delta = decodeRows(event.data);
+            }
+            catch (cause) {
+                reportCatchFailure("inbox.decode-event", cause);
+                emit("loading");
+                follow();
+                return;
+            }
+            if (delta.from !== cursor) {
+                // A missed delta: resume from what this client actually holds.
+                emit("loading");
+                follow();
+                return;
+            }
+            upsert(delta.items);
+            cursor = delta.to;
+            emit("live");
+        });
+        source.addEventListener("reset", () => {
+            if (closed || current !== generation)
+                return;
+            void load();
+        });
+    };
+    const load = async () => {
+        const current = ++generation;
+        events?.close();
+        events = undefined;
+        emit("loading");
+        try {
+            items.clear();
+            let after = null;
+            let first = true;
+            for (let page = 0; page < memberInboxInitialPages; page += 1) {
+                const query = after === null ? "" : `?after=${encodeURIComponent(after)}`;
+                const response = await options.fetch(`${options.baseUrl}/inbox${query}`, {
+                    cache: "no-store",
+                });
+                if (!response.ok)
+                    throw new Error("Inbox unavailable");
+                const read = decodePage(await response.json());
+                if (closed || current !== generation)
+                    return;
+                // Deltas resume after the first page's cursor; later pages only add.
+                if (first)
+                    cursor = read.cursor;
+                first = false;
+                upsert(read.items);
+                after = read.next;
+                if (after === null)
+                    break;
+            }
+            emit("live");
+            follow();
+        }
+        catch (cause) {
+            if (closed || current !== generation)
+                return;
+            reportCatchFailure("inbox.refresh", cause);
+            emit("error");
+        }
+    };
+    void load();
+    return Object.freeze({
+        refresh: () => (closed ? Promise.resolve() : load()),
+        visit: async (agentId, sessionId) => {
+            const response = await options.fetch(`${options.baseUrl}/inbox/visits`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ agentId, sessionId }),
+            });
+            if (!response.ok && response.status !== 404)
+                throw new Error("Visit was not recorded");
+        },
+        close: () => {
+            closed = true;
+            generation += 1;
+            events?.close();
+        },
+    });
+}
+const decodeTeamNotices = Schema.decodeUnknownSync(Schema.Struct({
+    items: Schema.Array(Schema.Union([
+        Schema.Struct({
+            ...artifactDispositionNoticeSchema.fields,
+            reason: Schema.optional(artifactDispositionNoticeSchema.fields.reason),
+            createdAt: time,
+        }),
+        Schema.Struct({ ...sellerClosureNoticeSchema.fields, createdAt: time }),
+    ])).pipe(Schema.check(Schema.isMaxLength(100))),
+    next: Schema.NullOr(Schema.String.pipe(Schema.check(Schema.isMaxLength(1024)))),
+}), { onExcessProperty: "error" });
+/** Shared Team notices use the same member-admitted inbox transport as Session reads. */
+export async function readTeamInboxNoticePage(transport, after = null) {
+    const url = new URL(`${transport.baseUrl}/inbox/notices`);
+    if (after !== null)
+        url.searchParams.set("after", after);
+    const response = await transport.fetch(url);
+    if (!response.ok)
+        throw new Error("Team notices unavailable");
+    return decodeTeamNotices(await response.json());
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export { FungiAuthorSchema, FungiDelegationReplySchema, FungiMessageMetaSchema, messageAuthor, messageDelegationReply, authorMeta, } from "./agent-message-meta.js";
+export type { FungiAuthor, FungiDelegationReply, FungiMessageMeta, MessageMetaValue, AuthorMeta, } from "./agent-message-meta.js";
+export { createCapabilityRegistry, defineCapability } from "./capabilities.js";
+export { pending, pendingSchema } from "./pending.js";
+export type { Pending } from "./pending.js";
+export type { CapabilityContract, CapabilityDirectory, CapabilityRegistry, } from "./capabilities.js";
+export { agentList, agentManage, agentRename, agentSessionRead, agentSessionWrite, agentToolPolicy, createAppAgent, renameAppAgent, appAgentCreateInputSchema, appAgentRenameInputSchema, appAgentSchema, appAgentToolPolicyResultSchema, appAgentToolPolicyStatusSchema, listAppAgents, openAppAgent, } from "./agents.js";
+export type { AppAgent, AppAgentCreateHandle, AppAgentCreateInput, AppAgentDirectoryHandle, AppAgentListHandle, AppAgentRenameHandle, AppAgentRenameInput, AppAgentToolPolicyHandle, AppAgentToolPolicyResult, AppAgentToolPolicyStatus, AppAgentTransport, AppAgentTransportHandle, } from "./agents.js";
+export { mediaGeneration, mediaGenerationFailureSchema, mediaGenerationReferenceSchema, mediaGenerationSelectionSchema, mediaModelSchema, openMediaGeneration, } from "./media.js";
+export type { MediaGenerationHandle, MediaGenerationAttempt, MediaGenerationAttemptHandle, MediaGenerationFailure, MediaGenerationInput, MediaGenerationOutcome, MediaGenerationReference, MediaGenerationResult, MediaGenerationSelection, MediaModel, MediaOutputFormat, MediaGenerationSession, } from "./media.js";
+export type { AppCommand, AppCommandHandler, AppCommandInvocation, AppCommands, } from "./commands.js";
+export { registerCatalog } from "./commands.js";
+export { connectApp } from "./connect.js";
+export type { ConnectAppOptions } from "./connect.js";
+/** Data exchanged by iframe and host before the RPC MessagePort takes over. */
+export { APP_CONNECT_TYPE, APP_PROTOCOL_VERSION, APP_READY_TYPE, } from "./internal/protocol.js";
+export type { AppConnectMessage, AppReadyMessage, } from "./internal/protocol.js";
+export { AppError } from "./errors.js";
+export { statusActionAllowed, statusText } from "./status.js";
+export { APP_BROWSER_SAVE_MAX_BYTES, APP_BROWSER_COPY_MAX_BYTES, APP_STATUS_ITEMS_MAX, APP_STATUS_OPTIONS_MAX, APP_STATUS_TEXT_MAX, } from "./ui.js";
+export { parseStatusAction as parseAppStatusAction, parseStatusItems as parseAppStatusItems, } from "./internal/schemas.js";
+export type { AppErrorCode, AppErrorOptions } from "./errors.js";
+export type { AppContext, AppIdentity, AppOpenRequest, AppLifecycle, FocusState, } from "./lifecycle.js";
+export type { AppRoot } from "./root.js";
+export type { AgentSessionSelection } from "./ui.js";
+export type { Disposer, ReadonlyStore } from "./store.js";
+export type { AppBrowserAction, AppBrowserActionOutcome, AppBrowserActionRefusal, AgentAccessOperation, AppPermissionOutcome, AppPermissionRequest, AppStatusAction, AppStatusActionHandler, AppStatusIcon, AppStatusItem, AppStatusOption, AppStatusTone, ComputerAccessOperation, FileNavigationInput, HostUi, ToastInput, } from "./ui.js";
+export { APP_NAVIGATION_CONTRACT_VERSION, APP_NAVIGATION_TITLE_MAX, inertHostNavigation, } from "./window.js";
+export type { AppBackHandler, AppNavigationState, AppWindow, BeforeAppClose, HostNavigation, } from "./window.js";
+export { appStorage, AppStorageError } from "./storage.js";
+export type { AppStorage, AppStorageWatch, AppStorageWrite, AppStorageReset, ResolvedAppStorage, } from "./storage.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+export { FungiAuthorSchema, FungiDelegationReplySchema, FungiMessageMetaSchema, messageAuthor, messageDelegationReply, authorMeta, } from "./agent-message-meta.js";
+export { createCapabilityRegistry, defineCapability } from "./capabilities.js";
+export { pending, pendingSchema } from "./pending.js";
+export { agentList, agentManage, agentRename, agentSessionRead, agentSessionWrite, agentToolPolicy, createAppAgent, renameAppAgent, appAgentCreateInputSchema, appAgentRenameInputSchema, appAgentSchema, appAgentToolPolicyResultSchema, appAgentToolPolicyStatusSchema, listAppAgents, openAppAgent, } from "./agents.js";
+export { mediaGeneration, mediaGenerationFailureSchema, mediaGenerationReferenceSchema, mediaGenerationSelectionSchema, mediaModelSchema, openMediaGeneration, } from "./media.js";
+export { registerCatalog } from "./commands.js";
+export { connectApp } from "./connect.js";
+/** Data exchanged by iframe and host before the RPC MessagePort takes over. */
+export { APP_CONNECT_TYPE, APP_PROTOCOL_VERSION, APP_READY_TYPE, } from "./internal/protocol.js";
+export { AppError } from "./errors.js";
+export { statusActionAllowed, statusText } from "./status.js";
+export { APP_BROWSER_SAVE_MAX_BYTES, APP_BROWSER_COPY_MAX_BYTES, APP_STATUS_ITEMS_MAX, APP_STATUS_OPTIONS_MAX, APP_STATUS_TEXT_MAX, } from "./ui.js";
+export { parseStatusAction as parseAppStatusAction, parseStatusItems as parseAppStatusItems, } from "./internal/schemas.js";
+export { APP_NAVIGATION_CONTRACT_VERSION, APP_NAVIGATION_TITLE_MAX, inertHostNavigation, } from "./window.js";
+export { appStorage, AppStorageError } from "./storage.js";

package/dist/inference.d.ts

@@ -0,0 +1,17 @@
+import type { CapabilityContract, CapabilityDirectory } from "./capabilities.js";
+/** One request lifetime. Closing it cancels only this generation, not other calls. */
+export type AppInferenceRequest = {
+    fetch(request: Request): Promise<Response>;
+    close(): Promise<void>;
+    [Symbol.dispose](): void;
+};
+/** Live generation capability supplied by the host. */
+export type AppInferenceHandle = {
+    open(): Promise<AppInferenceRequest>;
+};
+export declare const llmGeneration: CapabilityContract<AppInferenceHandle>;
+/** OpenAI-compatible transport; no Agent, Session, host URL or credentials are exposed. */
+export declare function createAppInferenceTransport(capabilities: CapabilityDirectory): {
+    baseURL: string;
+    fetch: typeof globalThis.fetch;
+};

package/dist/inference.js

@@ -0,0 +1,115 @@
+import { defineCapability } from "./capabilities.js";
+import { rpcFetchHandleSchema, rpcHandleSchema, rpcMethod, } from "./internal/rpc-contract.js";
+import * as Schema from "effect/Schema";
+import { AppError } from "./errors.js";
+import { reportCatchFailure } from "./failure.js";
+export const llmGeneration = defineCapability("llm.generation", 1, rpcHandleSchema({ open: rpcMethod(rpcFetchHandleSchema) }));
+const baseURL = "https://inference.fungi.invalid/v1";
+const decodeResponse = Schema.decodeUnknownSync(Schema.instanceOf(Response));
+/** OpenAI-compatible transport; no Agent, Session, host URL or credentials are exposed. */
+export function createAppInferenceTransport(capabilities) {
+    const fetch = async (input, init) => {
+        const request = new Request(input, init);
+        const url = new URL(request.url);
+        if (url.origin !== "https://inference.fungi.invalid" ||
+            url.search !== "" ||
+            !((request.method === "GET" && url.pathname === "/v1/models") ||
+                (request.method === "POST" && url.pathname === "/v1/chat/completions")))
+            throw new AppError("The inference request target is invalid", {
+                code: "INVALID_ARGUMENT",
+                retryable: false,
+            });
+        request.signal.throwIfAborted();
+        let handle;
+        let closed = false;
+        let closing;
+        const close = () => {
+            closed = true;
+            if (closing !== undefined)
+                return closing;
+            request.signal.removeEventListener("abort", abort);
+            const opened = handle;
+            if (opened === undefined)
+                return Promise.resolve();
+            closing = (async () => {
+                try {
+                    await opened.close();
+                }
+                finally {
+                    opened[Symbol.dispose]();
+                }
+            })();
+            return closing;
+        };
+        // Cap'n Web carries Request/Response streams but not Request.signal. The
+        // per-request object lifetime supplies cancellation across that boundary.
+        let rejectAbort = () => undefined;
+        const aborted = new Promise((_resolve, reject) => {
+            rejectAbort = reject;
+        });
+        const abort = () => {
+            void close().catch((cause) => {
+                reportCatchFailure("inference.abort-close", cause);
+            });
+            rejectAbort(new DOMException("The operation was aborted", "AbortError"));
+        };
+        request.signal.addEventListener("abort", abort, { once: true });
+        try {
+            if (request.signal.aborted)
+                abort();
+            const opening = capabilities
+                .require(llmGeneration)
+                .open()
+                .then(async (opened) => {
+                handle = opened;
+                if (closed) {
+                    await close();
+                    request.signal.throwIfAborted();
+                    throw new Error("Inference request is closed");
+                }
+                return opened;
+            });
+            const opened = await Promise.race([opening, aborted]);
+            const response = decodeResponse(await Promise.race([opened.fetch(request), aborted]));
+            request.signal.throwIfAborted();
+            if (response.body === null) {
+                await close();
+                return response;
+            }
+            const reader = response.body.getReader();
+            const body = new ReadableStream({
+                async pull(controller) {
+                    try {
+                        const next = await Promise.race([reader.read(), aborted]);
+                        if (next.done) {
+                            controller.close();
+                            await close();
+                        }
+                        else
+                            controller.enqueue(next.value);
+                    }
+                    catch (error) {
+                        controller.error(request.signal.aborted ? request.signal.reason : error);
+                        await close();
+                    }
+                },
+                async cancel(reason) {
+                    await Promise.all([reader.cancel(reason), close()]);
+                },
+            }, { highWaterMark: 0 });
+            return new Response(body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        }
+        catch (error) {
+            await close().catch((cause) => {
+                reportCatchFailure("inference.request-cleanup", cause);
+            });
+            request.signal.throwIfAborted();
+            throw error;
+        }
+    };
+    return { baseURL, fetch };
+}

package/dist/internal/app-error.d.ts

@@ -0,0 +1,8 @@
+import { AppError, type AppErrorCode } from "../errors.js";
+export type AppErrorData = {
+    readonly code: AppErrorCode;
+    readonly message: string;
+    readonly retryable: boolean;
+};
+export declare function appErrorData(cause: unknown): AppErrorData;
+export declare function appErrorFromData(value: AppErrorData): AppError;

package/dist/internal/app-error.js

@@ -0,0 +1,36 @@
+import { AppError } from "../errors.js";
+import { parseErrorData } from "./schemas.js";
+export function appErrorData(cause) {
+    if (cause instanceof AppError) {
+        return {
+            code: cause.code,
+            message: bounded(cause.message),
+            retryable: cause.retryable,
+        };
+    }
+    return {
+        code: "HOST_FAILURE",
+        message: "Host operation failed",
+        retryable: false,
+    };
+}
+export function appErrorFromData(value) {
+    try {
+        const parsed = parseErrorData(value);
+        return new AppError(parsed.message, {
+            code: parsed.code,
+            retryable: parsed.retryable,
+        });
+    }
+    catch (cause) {
+        return new AppError("The host returned a malformed error", {
+            cause,
+            code: "PROTOCOL",
+            retryable: false,
+        });
+    }
+}
+function bounded(message) {
+    const clean = message.trim().slice(0, 512);
+    return clean || "Host operation failed";
+}

package/dist/internal/app-session.d.ts

@@ -0,0 +1,8 @@
+import type { AppRoot } from "../root.js";
+export declare function connectAppPort(options: {
+    readonly epoch: string;
+    readonly isActive: () => boolean;
+    readonly onDisposed: () => void;
+    readonly port: MessagePort;
+    readonly window: Window;
+}): Promise<AppRoot>;