@fungi.computer/oyster 0.5.0 → 0.6.0

package/dist/build/candidate-cli.mjs

@@ -21745,6 +21745,12 @@ var BirdDogSystemIdentitySchema = Struct({
   systemId: Literal2("hub")
 });
 var BIRD_DOG_DIAGNOSTIC_MAX_LENGTH = 200;
+var BIRD_DOG_WAITING_MAX_ITEMS = 8;
+var BirdDogWaitingItemSchema = Struct({
+  itemId: Identifier,
+  kind: String4.check(isMinLength(1), isMaxLength(64)),
+  summary: String4.check(isMinLength(1), isMaxLength(200))
+});
 var SettledBirdDogReplySchema = Struct({
   commandId: Identifier,
   outcome: Literals([
@@ -21754,7 +21760,8 @@ var SettledBirdDogReplySchema = Struct({
     "cancelled",
     "outcome_unknown"
   ]),
-  diagnostic: optionalKey2(String4.check(isMinLength(1), isMaxLength(BIRD_DOG_DIAGNOSTIC_MAX_LENGTH)))
+  diagnostic: optionalKey2(String4.check(isMinLength(1), isMaxLength(BIRD_DOG_DIAGNOSTIC_MAX_LENGTH))),
+  waitingOnYou: optionalKey2(ArraySchema(BirdDogWaitingItemSchema).check(isMinLength(1), isMaxLength(BIRD_DOG_WAITING_MAX_ITEMS)))
 });
 var BirdDogUndeliverableReasonSchema = Literals([
   "recipient_offline",

package/dist/channels/binding.d.ts

@@ -9,11 +9,18 @@ export type ConversationBinding = Readonly<{
         verifier: "fungi-v1" | "github" | "secret-url";
         eventsPerMinute: number;
     }> | Readonly<{
-        provider: "web" | "discord" | "email" | "game";
+        provider: "web";
+        siteKey: string;
+        origins: readonly string[];
+        accent?: string | undefined;
+    }> | Readonly<{
+        provider: "discord" | "email" | "game";
     }>;
     /** Zod's optional binding projection may carry an explicit undefined. */
     limits?: BindingLimits | undefined;
 }>;
+/** Does one allowlisted origin admit this exact browser origin? */
+export declare function originAllowed(allowed: readonly string[], origin: string): boolean;
 /** Per-party edge limits applied before any work is accepted. */
 export declare const bindingLimitsSchema: z.ZodObject<{
     messagesPerPartyPerDay: z.ZodNumber;

package/dist/channels/binding.js

@@ -1,5 +1,17 @@
 import { z } from "zod";
 import { channelIds } from "./ids.js";
+/** Does one allowlisted origin admit this exact browser origin? */
+export function originAllowed(allowed, origin) {
+    return allowed.some((entry) => {
+        if (!entry.startsWith("https://*."))
+            return entry === origin;
+        const suffix = entry.slice("https://*".length);
+        if (!origin.startsWith("https://") || !origin.endsWith(suffix))
+            return false;
+        const label = origin.slice("https://".length, -suffix.length);
+        return label.length > 0 && !label.includes(".");
+    });
+}
 /** Per-party edge limits applied before any work is accepted. */
 export const bindingLimitsSchema = z.strictObject({
     messagesPerPartyPerDay: z.number().int().min(1).max(10_000),

package/dist/channels/conversations.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type FungiAuthor, type AuthorMeta, type MessageMetaValue } from "@fungi.computer/agar/agents";
+import { type FungiAuthor, type AuthorMeta } from "@fungi.computer/agar/agents";
 import { type Handoff } from "@fungi.computer/agar/channels";
 import { type ConversationBinding, type ChannelParty } from "./binding.js";
 export type HandoffEvent = Readonly<{
@@ -124,12 +124,11 @@ export type ChannelWithdrawResult = Readonly<{
     commandId: string;
     sessionId?: string;
 }>;
-/** Only the pending fields a channel visitor can read. */
-export type ChannelPendingPrompt = Readonly<{
+/** A host-projected intent contains no private metadata or internal request key. */
+export type VisitorPendingPrompt = Readonly<{
     requestId: string;
     commandId: string;
     text: string;
-    meta?: MessageMetaValue | undefined;
     delivery: "steer" | "followUp";
     images?: readonly Readonly<{
         type: "image";
@@ -137,10 +136,22 @@ export type ChannelPendingPrompt = Readonly<{
         mimeType: string;
     }>[] | undefined;
 }>;
+/** Only public baseline pagination crosses the visitor Session port. */
+export type VisitorReadOptions = Readonly<{
+    limit?: number;
+    before?: string;
+}>;
 /** The channel's narrow Session port; hosts translate to their durable client. */
 export type SessionDoor = Readonly<{
     withdraw: (sessionId: string, requestId: string) => Promise<ChannelWithdrawResult>;
-    latestPending: (sessionId: string, visitor: FungiAuthor) => Promise<ChannelPendingPrompt | null>;
+    latestPending: (sessionId: string, visitor: FungiAuthor) => Promise<VisitorPendingPrompt | null>;
+    participantDocument: (sessionId: string, visitorId: string, options: VisitorReadOptions) => Promise<string>;
+    participantStream: (sessionId: string, visitorId: string, options: Readonly<{
+        expiresAt: number;
+        now: () => number;
+        release: () => void;
+        canRead: () => Promise<boolean>;
+    }>) => Promise<ReadableStream<Uint8Array>>;
     createSession: (requestId: string) => Promise<string>;
     /** Deliver this conversation Session's tool grants to the runtime. */
     deliverGrants: (sessionId: string) => void;

package/dist/channels/visitor-channel.d.ts

@@ -0,0 +1,53 @@
+import { type ConversationBinding } from "./binding.js";
+import { type ChannelConversations, type ChannelWithdrawResult, type InboundEvent, type IntakeResult, type SessionDoor, type VisitorPendingPrompt, type VisitorReadOptions } from "./conversations.js";
+import type { ChannelVisitors, VisitorGrant } from "./visitors.js";
+/**
+ * Web visitor sequencing only. The host owns authorization, its admission
+ * receipt and the Session implementation; identity and conversations can live
+ * in different stores (and, in standalone, different Agents).
+ */
+export declare function createVisitorChannel(options: Readonly<{
+    binding: (bindingId: string) => ConversationBinding | null;
+    visitors: () => ChannelVisitors;
+    conversations: () => ChannelConversations;
+    sessionDoor: () => SessionDoor;
+    intake: (event: InboundEvent) => Promise<IntakeResult>;
+    acquireStream: (bindingId: string, visitorId: string, addressHash: string) => (() => void) | null;
+    now: () => number;
+}>): {
+    mint: (bindingId: string, siteKey: string, addressHash: string) => Promise<VisitorGrant>;
+    refresh: (bindingId: string, secret: string) => Promise<VisitorGrant>;
+    rotate: (bindingId: string, siteKey: string, token: string, addressHash: string) => Promise<VisitorGrant | Readonly<{
+        kind: "unauthorized";
+    }>>;
+    send: (bindingId: string, token: string, requestId: string, text: string) => Promise<IntakeResult | Readonly<{
+        kind: "unauthorized";
+    }>>;
+    withdraw: (bindingId: string, token: string, rawRequestId: string) => Promise<ChannelWithdrawResult | Readonly<{
+        kind: "unauthorized";
+    }> | Readonly<{
+        kind: "denied";
+        reason: "event_conflict" | "new_party_limit" | "banned";
+    }>>;
+    latestPending: (bindingId: string, token: string) => Promise<VisitorPendingPrompt | null | Readonly<{
+        kind: "unauthorized";
+    }>>;
+    open: (bindingId: string, token: string, read: VisitorReadOptions) => Promise<Readonly<{
+        kind: "session";
+        snapshot: string;
+    }> | Readonly<{
+        kind: "unauthorized";
+    }> | Readonly<{
+        kind: "denied";
+        reason: "new_party_limit" | "banned";
+    }>>;
+    watch: (bindingId: string, token: string, canRead: (visitorId: string) => Promise<boolean>) => Promise<Readonly<{
+        kind: "stream";
+        body: ReadableStream<Uint8Array>;
+    }> | Readonly<{
+        kind: "empty" | "unauthorized";
+    }> | Readonly<{
+        kind: "denied";
+        reason: "suspended" | "stream_limit";
+    }>>;
+};

package/dist/channels/visitor-channel.js

@@ -0,0 +1,124 @@
+import { partyLabel } from "./binding.js";
+import { channelRequestId, } from "./conversations.js";
+import { visitorMessageId, visitorRequestSchema } from "./visitor-request.js";
+/**
+ * Web visitor sequencing only. The host owns authorization, its admission
+ * receipt and the Session implementation; identity and conversations can live
+ * in different stores (and, in standalone, different Agents).
+ */
+export function createVisitorChannel(options) {
+    const active = (bindingId) => {
+        const binding = options.binding(bindingId);
+        return binding?.lifecycle === "active" &&
+            binding.selector.provider === "web"
+            ? binding
+            : null;
+    };
+    const authenticate = (bindingId, token) => options.visitors().authenticate(bindingId, token);
+    return {
+        mint: (bindingId, siteKey, addressHash) => options.visitors().mint(options.binding(bindingId), siteKey, addressHash),
+        refresh: (bindingId, secret) => options.visitors().refresh(options.binding(bindingId), secret),
+        rotate: async (bindingId, siteKey, token, addressHash) => {
+            const visitors = options.visitors();
+            const visitor = await visitors.authenticate(bindingId, token);
+            if (visitor === null)
+                return { kind: "unauthorized" };
+            visitors.forget(visitor.visitorId);
+            return await visitors.mint(options.binding(bindingId), siteKey, addressHash);
+        },
+        send: async (bindingId, token, requestId, text) => {
+            const visitor = await authenticate(bindingId, token);
+            if (visitor === null)
+                return { kind: "unauthorized" };
+            const { visitorId } = visitor;
+            return options.intake({
+                bindingId,
+                conversation: visitorId,
+                eventId: await visitorMessageId(requestId),
+                party: { kind: "visitor", visitorId },
+                text,
+                sourceRequestId: requestId,
+            });
+        },
+        withdraw: async (bindingId, token, rawRequestId) => {
+            const binding = active(bindingId);
+            const visitor = await authenticate(bindingId, token);
+            if (visitor === null || binding === null)
+                return { kind: "unauthorized" };
+            const { requestId } = visitorRequestSchema.parse({
+                requestId: rawRequestId,
+            });
+            const eventId = await visitorMessageId(requestId);
+            const conversations = options.conversations();
+            if (conversations.visitorEventConflict(bindingId, visitor.visitorId, eventId))
+                return { kind: "denied", reason: "event_conflict" };
+            const opened = await conversations.open(binding, visitor.visitorId, {
+                kind: "visitor",
+                visitorId: visitor.visitorId,
+            });
+            if (opened.kind === "denied")
+                return opened;
+            return options
+                .sessionDoor()
+                .withdraw(opened.conversation.sessionId, channelRequestId(binding.bindingId, eventId));
+        },
+        latestPending: async (bindingId, token) => {
+            const binding = active(bindingId);
+            const visitor = await authenticate(bindingId, token);
+            if (visitor === null || binding === null)
+                return { kind: "unauthorized" };
+            const { visitorId } = visitor;
+            const conversation = options.conversations().find(bindingId, visitorId);
+            if (conversation === null)
+                return null;
+            return await options.sessionDoor().latestPending(conversation.sessionId, {
+                id: visitorId,
+                name: partyLabel({ kind: "visitor", visitorId }),
+            });
+        },
+        open: async (bindingId, token, read) => {
+            const binding = active(bindingId);
+            const visitor = await authenticate(bindingId, token);
+            if (visitor === null || binding === null)
+                return { kind: "unauthorized" };
+            const { visitorId } = visitor;
+            const opened = await options.conversations().open(binding, visitorId, {
+                kind: "visitor",
+                visitorId,
+            });
+            if (opened.kind === "denied")
+                return opened;
+            return {
+                kind: "session",
+                snapshot: await options
+                    .sessionDoor()
+                    .participantDocument(opened.conversation.sessionId, visitorId, read),
+            };
+        },
+        watch: async (bindingId, token, canRead) => {
+            const visitor = await authenticate(bindingId, token);
+            if (visitor === null)
+                return { kind: "unauthorized" };
+            if (options.binding(bindingId)?.lifecycle !== "active")
+                return { kind: "denied", reason: "suspended" };
+            const { visitorId } = visitor;
+            const conversation = options.conversations().find(bindingId, visitorId);
+            if (conversation === null)
+                return { kind: "empty" };
+            const release = options.acquireStream(bindingId, visitorId, visitor.addressHash);
+            if (release === null)
+                return { kind: "denied", reason: "stream_limit" };
+            return {
+                kind: "stream",
+                body: await options
+                    .sessionDoor()
+                    .participantStream(conversation.sessionId, visitorId, {
+                    expiresAt: visitor.expiresAt,
+                    now: options.now,
+                    release,
+                    canRead: () => canRead(visitorId),
+                }),
+            };
+        },
+    };
+}

package/dist/channels/visitor-edge.d.ts

@@ -0,0 +1,115 @@
+import { Hono, type Context, type Env as HonoEnv } from "hono";
+import type { ChannelWithdrawResult, IntakeResult, VisitorPendingPrompt, VisitorReadOptions } from "./conversations.js";
+import { type VisitorGrant } from "./visitors.js";
+import type { Avatar } from "@fungi.computer/sprite/avatar";
+/** Public address facts the host supplies after looking up an embed site. */
+export type VisitorSiteAddress = Readonly<{
+    bindingId: string;
+}>;
+/** Embed-safe site chrome returned by the host after binding admission. */
+export type VisitorSiteFacts = Readonly<{
+    accent?: string;
+    name: string;
+    avatar: Avatar;
+    origins: readonly string[];
+}>;
+/** An opened host door, disposed after the edge has returned a response. */
+export type VisitorEdgeChannel = Readonly<{
+    [Symbol.dispose]: () => void;
+    readChannelSite: (input: Readonly<{
+        bindingId: string;
+        siteKey: string;
+    }>) => Promise<VisitorSiteFacts | null>;
+    mintChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        siteKey: string;
+        addressHash: string;
+    }>) => Promise<VisitorGrant>;
+    refreshChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        refreshSecret: string;
+    }>) => Promise<VisitorGrant>;
+    rotateChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        siteKey: string;
+        accessToken: string;
+        addressHash: string;
+    }>) => Promise<VisitorGrant | Readonly<{
+        kind: "unauthorized";
+    }>>;
+    sendAsChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        accessToken: string;
+        requestId: string;
+        text: string;
+    }>) => Promise<IntakeResult | Readonly<{
+        kind: "unauthorized";
+    }>>;
+    withdrawAsChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        accessToken: string;
+        requestId: string;
+    }>) => Promise<ChannelWithdrawResult | Readonly<{
+        kind: "unauthorized";
+    }> | Readonly<{
+        kind: "denied";
+        reason: "event_conflict" | "new_party_limit" | "banned";
+    }>>;
+    latestPendingAsChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        accessToken: string;
+    }>) => Promise<VisitorPendingPrompt | null | Readonly<{
+        kind: "unauthorized";
+    }>>;
+    watchAsChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        accessToken: string;
+    }>) => Promise<Readonly<{
+        kind: "stream";
+        body: ReadableStream<Uint8Array>;
+    }> | Readonly<{
+        kind: "empty";
+    }> | Readonly<{
+        kind: "unauthorized";
+    }> | Readonly<{
+        kind: "denied";
+        reason: "suspended" | "stream_limit";
+    }>>;
+    openVisitorSession: (input: Readonly<{
+        bindingId: string;
+        accessToken: string;
+        options: VisitorReadOptions;
+    }>) => Promise<Readonly<{
+        kind: "session";
+        snapshot: string;
+    }> | Readonly<{
+        kind: "unauthorized";
+    }> | Readonly<{
+        kind: "denied";
+        reason: "new_party_limit" | "banned";
+    }>>;
+    readAsChannelVisitor: (input: Readonly<{
+        bindingId: string;
+        accessToken: string;
+    }>) => Promise<Readonly<{
+        kind: "view";
+        view: unknown;
+    }> | Readonly<{
+        kind: "unauthorized";
+    }>>;
+}>;
+/**
+ * Address lookup and mint/refresh use the site owner; conversation work must
+ * receive a verified visitor first. A host may route different visitors to
+ * different Agents without teaching the conversation core about its registry.
+ */
+export type VisitorEdgeHost<E extends HonoEnv, Site extends VisitorSiteAddress, Visitor extends object> = Readonly<{
+    resolveSite: (context: Context<E>, siteKey: string) => Promise<Site | null>;
+    openSite: (context: Context<E>, site: Site) => Promise<VisitorEdgeChannel>;
+    authenticateVisitor: (context: Context<E>, site: Site, token: string) => Promise<Visitor | null>;
+    openChannel: (context: Context<E>, site: Site, visitor: Visitor) => Promise<VisitorEdgeChannel>;
+    addressHash: (context: Context<E>) => Promise<string>;
+    assetPath: (kind: "widget" | "styles") => string;
+    onError: (error: Error, context: Context<E>) => Response | Promise<Response>;
+}>;
+export declare function createVisitorEdge<E extends HonoEnv, Site extends VisitorSiteAddress, Visitor extends object>(host: VisitorEdgeHost<E, Site, Visitor>): Hono<E>;