@fungi.computer/oyster 0.3.2 → 0.4.1

package/dist/standalone/agent-computers.d.ts

@@ -0,0 +1,29 @@
+import { Hono } from "hono";
+import { type ComputerGrant } from "@fungi.computer/computer/fleet";
+import { type AgentComputerProjection, type ComputerAttachmentInput } from "../agent-computers.js";
+import type { AgentComputerConnection, AgentComputerPorts } from "../agent-computer-source.js";
+import { type OysterEnv, type OysterPrincipal } from "../host.js";
+import type { StandaloneAgentComputerRpc } from "./computer.js";
+/** The directory supplies live authority; this adapter never invents a grant. */
+export type StandaloneAgentComputerAccess = Readonly<{
+    admit: (connection: AgentComputerConnection) => Promise<ComputerGrant>;
+    computer: (computerId: string) => Rpc.Provider<StandaloneAgentComputerRpc>;
+}>;
+/** Native operations use the captured Computer, never the mutable workspace selection. */
+export declare function standaloneAgentComputerPorts(access: StandaloneAgentComputerAccess, connection: AgentComputerConnection): AgentComputerPorts;
+/** Persisted command outcome, with no fabricated attachment result on refusal. */
+export type StandaloneAgentComputerReply = Readonly<{
+    kind: "ok";
+    projection: AgentComputerProjection;
+}> | Readonly<{
+    kind: "refused";
+    error: "not_granted" | "not_found" | "request_conflict" | "attachment_identity_conflict";
+}>;
+/** Principal and persisted attachment transitions belong to the directory owner. */
+export type StandaloneAgentComputerControl = Readonly<{
+    attach: (principal: OysterPrincipal, command: ComputerAttachmentInput) => Promise<StandaloneAgentComputerReply>;
+    detach: (principal: OysterPrincipal, command: ComputerAttachmentInput) => Promise<StandaloneAgentComputerReply>;
+    read: (principal: OysterPrincipal, agentId: string) => Promise<StandaloneAgentComputerReply>;
+}>;
+/** Owner HTTP transport over the retained attachment command grammar. */
+export declare function standaloneAgentComputerRoutes(control: StandaloneAgentComputerControl): Hono<OysterEnv>;

package/dist/standalone/agent-computers.js

@@ -0,0 +1,101 @@
+import { Hono } from "hono";
+import { createComputerFilesPort } from "@fungi.computer/computer";
+import { checkComputerGrant, FleetGrantRefused, } from "@fungi.computer/computer/fleet";
+import { computerCapabilities, computerValueSchema, } from "@fungi.computer/computer-contract";
+import { attachComputerInputSchema, detachComputerInputSchema, readAgentComputersInputSchema, } from "../agent-computers.js";
+import { oysterPrincipalIsOwner, } from "../host.js";
+/** Native operations use the captured Computer, never the mutable workspace selection. */
+export function standaloneAgentComputerPorts(access, connection) {
+    const { computerId } = connection.attachment;
+    async function authorized(action) {
+        const grant = await access.admit(connection);
+        if (checkComputerGrant(grant, {
+            computerId,
+            action,
+            now: Date.now(),
+        }).kind !== "admitted")
+            throw new FleetGrantRefused();
+        return grant;
+    }
+    // Constructing or advertising this port opens no native handle or Workspace.
+    async function withFiles(action, context, use) {
+        context.signal.throwIfAborted();
+        await authorized(action);
+        context.signal.throwIfAborted();
+        return use(createComputerFilesPort(access.computer(computerId)));
+    }
+    return {
+        files: {
+            patch: async (input, context) => {
+                context.signal.throwIfAborted();
+                const grant = await authorized("files.edit");
+                context.signal.throwIfAborted();
+                return access.computer(computerId).filePatch(grant, input);
+            },
+            read: (input, context) => withFiles("files.readBytes", context, (files) => files.read(input, context)),
+            list: (input, context) => withFiles("files.list", context, (files) => files.list(input, context)),
+            glob: (input, context) => withFiles("files.glob", context, (files) => files.glob(input, context)),
+            grep: (input, context) => withFiles("files.grep", context, (files) => files.grep(input, context)),
+            replace: (input, context) => withFiles("files.edit", context, (files) => files.replace(input, context)),
+        },
+        computer: {
+            getCapabilities: (signal) => {
+                signal.throwIfAborted();
+                return Promise.resolve(computerValueSchema.parse(computerCapabilities()));
+            },
+            call: async (capabilityId, input, context) => {
+                context.signal.throwIfAborted();
+                // tool() retains the native advertised-operation/action mapping and decoders.
+                const grant = await access.admit(connection);
+                context.signal.throwIfAborted();
+                return computerValueSchema.parse(await access.computer(computerId).tool(grant, capabilityId, input));
+            },
+        },
+    };
+}
+/** Owner HTTP transport over the retained attachment command grammar. */
+export function standaloneAgentComputerRoutes(control) {
+    const routes = new Hono();
+    routes.post("/api/agents/:agentId/computers/:operation", async (context) => {
+        context.header("Cache-Control", "no-store");
+        const principal = context.get("principal");
+        if (!oysterPrincipalIsOwner(principal))
+            return context.json({ error: "not_granted" }, 403);
+        const operation = context.req.param("operation");
+        if (!["attach", "detach", "read"].includes(operation))
+            return context.json({ error: "not_found" }, 404);
+        let body;
+        try {
+            body = await context.req.json();
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+            return context.json({ error: "invalid_input" }, 400);
+        }
+        const schema = operation === "attach"
+            ? attachComputerInputSchema
+            : operation === "detach"
+                ? detachComputerInputSchema
+                : readAgentComputersInputSchema;
+        const decoded = schema.safeParse(body);
+        if (!decoded.success)
+            return context.json({ error: "invalid_input" }, 400);
+        if (decoded.data.agentId !== context.req.param("agentId"))
+            return context.json({ error: "not_found" }, 404);
+        const result = operation === "read"
+            ? await control.read(principal, decoded.data.agentId)
+            : operation === "attach"
+                ? await control.attach(principal, attachComputerInputSchema.parse(decoded.data))
+                : await control.detach(principal, detachComputerInputSchema.parse(decoded.data));
+        if (result.kind === "ok")
+            return context.json(result.projection);
+        const status = result.error === "not_granted"
+            ? 403
+            : result.error === "not_found"
+                ? 404
+                : 409;
+        return context.json({ error: result.error }, status);
+    });
+    return routes;
+}

package/dist/standalone/agent-mail.d.ts

@@ -1,24 +1,47 @@
+import type { WatchdogTickResult } from "@fungi.computer/watchdog";
 import { AgentMail, agentMailRoute } from "@fungi.computer/shiitake/delegation";
 /** Standalone borrows Shiitake's one Watchdog and Carrier's ordinary durable lane. */
 export declare function agentMail(options: Omit<ConstructorParameters<typeof AgentMail>[0], "post" | "drain"> & {
     namespace: Parameters<typeof agentMailRoute>[0];
 }): {
-    host: Required<Pick<Readonly<{
-        meta?: import("@fungi.computer/shiitake").HostMetaOptions;
-        model: import("@fungi.computer/shiitake").ModelSource;
-        instructions: import("@fungi.computer/shiitake").InstructionSource;
-        tools?: readonly [] | import("@fungi.computer/shiitake/cloudflare").CloudflareShiitakeTools;
-        storagePressure?: import("@fungi.computer/shiitake").StoragePressureCheck;
-        compaction?: import("@fungi.computer/shiitake").CompactionOptions;
-        extensions: import("@fungi.computer/shiitake").ExtensionRosterV0;
-        initialize?: (agent: import("@fungi.computer/shiitake").ShiitakeOwnerAgent) => Promise<void>;
-        hostWork?: readonly import("@fungi.computer/shiitake/cloudflare").CloudflareHostWork[];
-        hostJobs?: import("@fungi.computer/shiitake/cloudflare").CloudflareHostJobs;
-        mailRoom?: import("@fungi.computer/bird-dog/effect").BirdDogEffect;
-        acp?: (agent: import("@fungi.computer/shiitake").ShiitakeOwnerAgent) => Promise<import("@fungi.computer/shiitake/cloudflare").CloudflareShiitakeAcpServer>;
-    }>, "mailRoom" | "hostJobs" | "hostWork">>;
-    deliver: (value: Parameters<AgentMail["send"]>[0]) => Promise<Readonly<{
-        status: "accepted";
-        commandId: string;
-    }>>;
+    host: {
+        mailRoom: Readonly<{
+            fanOut: (settlement: import("@fungi.computer/bird-dog").BirdDogSettlement) => import("effect/Effect").Effect<void, import("@fungi.computer/bird-dog/effect").BirdDogError>;
+            postMail?: ((mail: import("@fungi.computer/bird-dog").BirdDogMail) => import("effect/Effect").Effect<void, import("@fungi.computer/bird-dog/effect").BirdDogError>) | undefined;
+            drainOutbox: () => import("effect/Effect").Effect<void, import("@fungi.computer/bird-dog/effect").BirdDogError>;
+            nextWakeAt: () => import("effect/Effect").Effect<number | undefined, import("@fungi.computer/bird-dog/effect").BirdDogError>;
+        }> & {
+            stageAcceptedNotice: (mail: import("@fungi.computer/bird-dog").BirdDogMail, scopeId: string) => void;
+        };
+        hostJobs: {
+            lane: string;
+            open: (owner: Readonly<{
+                transactional: import("@fungi.computer/watchdog").WatchdogTransactionalProjection;
+                readJob: (jobId: string) => Promise<import("@fungi.computer/watchdog").WatchdogReadResult>;
+                tickConcurrent: () => Promise<WatchdogTickResult>;
+            }>) => {
+                execute: (job: {
+                    readonly queue: string;
+                    readonly priority: number;
+                    readonly payload: unknown;
+                    readonly state: "running";
+                    readonly lane: string;
+                    readonly jobId: string;
+                    readonly recovery?: {
+                        readonly maxRecoveries: number;
+                    } | undefined;
+                }) => Promise<Readonly<{
+                    kind: "completed";
+                }>>;
+            };
+        };
+        hostWork: {
+            pending: () => {
+                due: boolean;
+                nextWakeAt: number | null;
+            };
+            run: () => Promise<void>;
+        }[];
+    };
+    deliver: (value: Parameters<AgentMail["send"]>[0]) => Promise<import("@fungi.computer/shiitake").DelegationReceipt>;
 };

package/dist/standalone/agent-model-choice.d.ts

@@ -0,0 +1,29 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import * as Schema from "effect/Schema";
+/** A credential-source address, not credential material or a custodian locator. */
+export declare const agentModelChoiceSchema: Schema.Struct<{
+    readonly keySource: Schema.Literals<readonly ["workers-ai", "ai-gateway", "byok"]>;
+    readonly model: Schema.Struct<{
+        readonly providerId: Schema.String;
+        readonly modelId: Schema.String;
+        readonly reasoning: Schema.optional<Schema.Literals<readonly ["minimal", "low", "medium", "high", "xhigh", "max"]>>;
+    }>;
+}>;
+/** The Agent's model preference and source reference, never credential material. */
+export type AgentModelChoice = typeof agentModelChoiceSchema.Type;
+/** Stable reason for rejecting a model or credential source before a run. */
+export type AgentModelRefusal = "invalid_model_choice" | "unsupported_key_source" | "key_source_mismatch" | "model_unavailable" | "key_not_connected";
+export declare class AgentModelRefused extends Error {
+    readonly reason: AgentModelRefusal;
+    constructor(reason: AgentModelRefusal);
+}
+/** Read the maintained Pi catalog; never accept a model from a different egress. */
+export declare function selectAgentModel(choice: AgentModelChoice): Promise<Model<Api>>;
+/** The Agent DO is the only durable owner. Absence is a new-format default, not an old-env reader. */
+export declare function agentModelChoice(storage: Readonly<{
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    put(key: string, value: AgentModelChoice): Promise<void>;
+}>, admit: (choice: AgentModelChoice) => void): {
+    read(): Promise<AgentModelChoice>;
+    set(input: AgentModelChoice): Promise<AgentModelChoice>;
+};

package/dist/standalone/agent-model-choice.js

@@ -0,0 +1,72 @@
+import { ModelPreferenceSchema } from "@fungi.computer/shiitake/model-preference";
+import { cloudflareWorkersAIProvider } from "@earendil-works/pi-ai/providers/cloudflare-workers-ai";
+import * as Schema from "effect/Schema";
+/** A credential-source address, not credential material or a custodian locator. */
+export const agentModelChoiceSchema = Schema.Struct({
+    keySource: Schema.Literals(["workers-ai", "ai-gateway", "byok"]),
+    model: ModelPreferenceSchema,
+});
+export class AgentModelRefused extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "AgentModelRefused";
+    }
+}
+const key = "agent-model-choice";
+const defaultChoice = {
+    keySource: "workers-ai",
+    model: {
+        providerId: "cloudflare-workers-ai",
+        modelId: "@cf/moonshotai/kimi-k2.6",
+    },
+};
+/** Read the maintained Pi catalog; never accept a model from a different egress. */
+export async function selectAgentModel(choice) {
+    if (choice.keySource === "byok")
+        throw new AgentModelRefused("unsupported_key_source");
+    const { providerId, modelId, reasoning } = choice.model;
+    if ((choice.keySource === "workers-ai" &&
+        providerId !== "cloudflare-workers-ai") ||
+        (choice.keySource === "ai-gateway" &&
+            (providerId !== "openai" || modelId !== "openai/gpt-6-luna")))
+        throw new AgentModelRefused("key_source_mismatch");
+    // Pi's OpenAI provider is needed only when Luna is selected, not at boot.
+    const model = choice.keySource === "workers-ai"
+        ? cloudflareWorkersAIProvider()
+            .getModels()
+            .find((item) => item.id === modelId)
+        : (await import("@earendil-works/pi-ai/providers/openai"))
+            .openaiProvider()
+            .getModels()
+            .find((item) => item.id === "gpt-6-luna");
+    if (model === undefined || (reasoning !== undefined && !model.reasoning))
+        throw new AgentModelRefused("model_unavailable");
+    return model;
+}
+/** The Agent DO is the only durable owner. Absence is a new-format default, not an old-env reader. */
+export function agentModelChoice(storage, admit) {
+    return {
+        async read() {
+            const stored = await storage.get(key);
+            return stored === undefined
+                ? defaultChoice
+                : Schema.decodeUnknownSync(agentModelChoiceSchema, {
+                    onExcessProperty: "error",
+                })(stored);
+        },
+        async set(input) {
+            const parsed = Schema.decodeUnknownOption(agentModelChoiceSchema, {
+                onExcessProperty: "error",
+            })(input);
+            if (parsed._tag === "None")
+                throw new AgentModelRefused("invalid_model_choice");
+            const choice = parsed.value;
+            await selectAgentModel(choice);
+            admit(choice);
+            await storage.put(key, choice);
+            return choice;
+        },
+    };
+}

package/dist/standalone/agents.d.ts

@@ -8,10 +8,15 @@ export type AiBinding = {
     /** AI binding transport supplied by the Worker runtime. */
     fetch?: (input: Request | string | URL, init?: RequestInit) => Promise<Response>;
 };
+import { type ComputerAttachmentInput } from "../agent-computers.js";
+import { type AgentComputerSnapshot, type AgentComputerConnection } from "../agent-computer-source.js";
+import { type StandaloneAgentComputerReply } from "./agent-computers.js";
+import { type ComputerGrant } from "@fungi.computer/computer/fleet";
 import { DurableObject } from "cloudflare:workers";
 import type { StandaloneComputerEnv } from "./computer.js";
 import { ShiitakeDO } from "@fungi.computer/shiitake/cloudflare";
 import type { CloudflareShiitakeOptions } from "@fungi.computer/shiitake/cloudflare";
+import { type AgentModelChoice, type AgentModelRefusal } from "./agent-model-choice.js";
 import * as Schema from "effect/Schema";
 import { type FrameBindingProps } from "../cloudflare.js";
 import type { Avatar } from "@fungi.computer/sprite/avatar";
@@ -45,8 +50,6 @@ export type StandaloneAgentsEnv = Readonly<{
     AI_GATEWAY_ID?: string;
     /** Workers AI, the default model door. */
     AI?: AiBinding;
-    /** The model: `@fungi/luna` via AI Gateway, or a Workers AI id (default {@link defaultAgentModel}). */
-    OYSTER_AGENT_MODEL?: string;
     /** The AI Gateway the binding routes through (default `default`). */
     OYSTER_AI_GATEWAY?: string;
     /** Maintained current-member authority; absent means no nondefault-tenant policy admission. */
@@ -77,6 +80,18 @@ export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv
     protected abstract hostFor(scope: TenantScope): Promise<OysterHost>;
     private uiOwner;
     private machineClient;
+    private computerSnapshot;
+    private computerSnapshotLoad;
+    private computerSnapshotGeneration;
+    private computerSnapshotRevision;
+    private readonly computerInvalidations;
+    /** Host invalidation drops captured discovery, not just its displayed names. */
+    invalidateComputerConnections(): void;
+    private computerConnections;
+    /** Revalidate the owner's generation before reusing a Home or tool snapshot. */
+    private preparedComputerSnapshot;
+    private readComputerGeneration;
+    private readComputerSnapshot;
     private ui;
     protected hostFetch(request: Request): Promise<Response> | undefined;
     protected closeShiitake(): Promise<void>;
@@ -94,8 +109,15 @@ export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv
     settlement(principal: MachineAgentSettlementPrincipal, sessionId: string, commandId: string): Promise<string | undefined>;
     /** The root host for this Agent's pinned policy directory; unpinned Agents have no App tools. */
     private appHost;
-    /** Choose this agent's model door; override to plug in another. */
+    private choice;
+    /** Secret-free default of this Agent; stored separately from Session history. */
+    readModelChoice(): Promise<AgentModelChoice>;
+    setModelChoice(input: AgentModelChoice): Promise<AgentModelChoice | Readonly<{
+        error: AgentModelRefusal;
+    }>>;
+    /** Capture one model and credential source when the Agent's run acquires it. */
     protected modelSource(): StandaloneModelSource;
+    private sourceFor;
     /** Host-only initialization; Agent/App transports never receive this directory binding. */
     usePolicyDirectory(input: {
         directoryName: string;
@@ -127,6 +149,8 @@ export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv
 }
 /** Names this Oyster's agents and remembers which Sessions the member opened. */
 export declare class AgentDirectory extends DurableObject<StandaloneAgentEnv> {
+    private readonly computers;
+    private readonly computerNames;
     private readonly directory;
     private readonly avatars;
     private composedTenancy;
@@ -169,6 +193,21 @@ export declare class AgentDirectory extends DurableObject<StandaloneAgentEnv> {
     alarm(): Promise<void>;
     private grant;
     constructor(ctx: DurableObjectState, env: StandaloneAgentEnv);
+    private computerOwner;
+    private loadComputerNames;
+    /** Check the existing transactional revision without resolving fleet names. */
+    agentComputerRevision(agentId: string, tenantId?: TenantId): Promise<number | null>;
+    /** Read the shared owner only after current membership and real fleet lookup. */
+    agentComputerSnapshot(agentId: string, tenantId?: TenantId): Promise<AgentComputerSnapshot | null>;
+    private computerCommand;
+    /** Owner attachment commands retain the shared owner's receipts and versions. */
+    attachComputer(command: ComputerAttachmentInput, principal: OysterPrincipal, tenantId?: TenantId): Promise<StandaloneAgentComputerReply>;
+    /** Detach advances the owner version and invalidates the Agent's held discovery. */
+    detachComputer(command: ComputerAttachmentInput, principal: OysterPrincipal, tenantId?: TenantId): Promise<StandaloneAgentComputerReply>;
+    /** The owner HTTP read uses the same projection as direct discovery. */
+    readAgentComputers(agentId: string, principal: OysterPrincipal, tenantId?: TenantId): Promise<StandaloneAgentComputerReply>;
+    /** Every captured native call rechecks the exact live attachment and credential owner. */
+    admitAgentComputer(captured: Pick<AgentComputerConnection, "scopeId" | "agentId" | "attachment">, tenantId: TenantId): Promise<Omit<ComputerGrant, "egress">>;
     list(): readonly AgentEntry[];
     has(agentId: string): boolean;
     /** Resolve the existing recorded creator for host-side owner admission. */
@@ -241,9 +280,9 @@ export declare const agentFrameMethods: {
                         readonly nodeId: string;
                         readonly iteration: string;
                     };
+                    readonly expiresAt: number;
                     readonly kind: "workflow-review";
                     readonly installationId: string;
-                    readonly expiresAt: number;
                     readonly workflowId: string | null;
                     readonly state: "pending" | "delivered" | "answered" | "timed_out" | "closed";
                     readonly workflowTitle: string;
@@ -281,6 +320,7 @@ export declare const agentFrameMethods: {
             decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Readonly<{
                 status: "accepted";
                 commandId: string;
+                sessionId?: string;
             }>;
             requiredOperations: () => string[];
         };