@fungi.computer/truffle 0.1.1 → 0.2.1

package/dist/private-mcp-form-contract.d.ts

@@ -0,0 +1,186 @@
+import * as Schema from "effect/Schema";
+/** The actual MCP form, not a ledger record or an authorization decision. */
+export declare const McpFormApprovalRequestSchema: Schema.Struct<{
+    readonly message: Schema.String;
+    readonly requestedSchema: Schema.Struct<{
+        readonly type: Schema.Literal<"object">;
+        readonly properties: Schema.Struct<{
+            readonly approve: Schema.Struct<{
+                readonly type: Schema.Literal<"boolean">;
+                readonly title: Schema.optionalKey<Schema.String>;
+            }>;
+        }>;
+        readonly required: Schema.Tuple<readonly [Schema.Literal<"approve">]>;
+    }>;
+}>;
+export type McpFormApprovalRequest = typeof McpFormApprovalRequestSchema.Type;
+/** Human dispositions of one live protocol request. */
+export type McpFormApprovalDecision = "approve" | "decline" | "cancel";
+declare const answerResult: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"answered">;
+    readonly view: Schema.Struct<{
+        readonly record: Schema.Struct<{
+            readonly recordId: Schema.String;
+            readonly requester: Schema.Struct<{
+                readonly principalId: Schema.String;
+                readonly agentId: Schema.NullOr<Schema.String>;
+                readonly sessionId: Schema.NullOr<Schema.String>;
+                readonly displayName: Schema.String;
+            }>;
+            readonly module: Schema.String;
+            readonly operation: Schema.String;
+            readonly access: Schema.Literals<readonly ["write", "external"]>;
+            readonly description: Schema.Struct<{
+                readonly title: Schema.String;
+                readonly inputBytes: Schema.Int;
+                readonly inputSha256: Schema.String;
+            }>;
+            readonly evidence: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literal<"artifact">;
+                readonly ref: Schema.String;
+                readonly mediaType: Schema.Literal<"image/png">;
+                readonly bytes: Schema.Int;
+            }>>>;
+            readonly authorityFence: Schema.String;
+            readonly reversibility: Schema.Literals<readonly ["reversible", "irreversible-external"]>;
+            readonly state: Schema.Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+            readonly by: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"human">;
+                readonly memberId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"policy">;
+            }>]>>;
+            readonly reason: Schema.NullOr<Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+            readonly requestedAt: Schema.Int;
+            readonly expiresAt: Schema.Int;
+            readonly updatedAt: Schema.Int;
+            readonly revision: Schema.Int;
+        }>;
+        readonly canAnswer: Schema.Boolean;
+        readonly canSetAutoApprove: Schema.Boolean;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"refused">;
+    readonly reason: Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"submitted">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"refused">;
+    readonly reason: Schema.Literals<readonly ["not-attached", "not-pending"]>;
+}>]>;
+export type McpFormAnswerResult = typeof answerResult.Type;
+/** The existing Session extension slot carries only display-safe form data. */
+export declare const mcpFormApprovalContract: {
+    id: string & import("effect/Brand").Brand<"ExtensionId">;
+    commands: {
+        answer: {
+            scope: "session";
+            input: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly decision: Schema.Literals<readonly ["approve", "deny"]>;
+                readonly expectedRevision: Schema.Int;
+            }>;
+            output: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"answered">;
+                readonly view: Schema.Struct<{
+                    readonly record: Schema.Struct<{
+                        readonly recordId: Schema.String;
+                        readonly requester: Schema.Struct<{
+                            readonly principalId: Schema.String;
+                            readonly agentId: Schema.NullOr<Schema.String>;
+                            readonly sessionId: Schema.NullOr<Schema.String>;
+                            readonly displayName: Schema.String;
+                        }>;
+                        readonly module: Schema.String;
+                        readonly operation: Schema.String;
+                        readonly access: Schema.Literals<readonly ["write", "external"]>;
+                        readonly description: Schema.Struct<{
+                            readonly title: Schema.String;
+                            readonly inputBytes: Schema.Int;
+                            readonly inputSha256: Schema.String;
+                        }>;
+                        readonly evidence: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                            readonly kind: Schema.Literal<"artifact">;
+                            readonly ref: Schema.String;
+                            readonly mediaType: Schema.Literal<"image/png">;
+                            readonly bytes: Schema.Int;
+                        }>>>;
+                        readonly authorityFence: Schema.String;
+                        readonly reversibility: Schema.Literals<readonly ["reversible", "irreversible-external"]>;
+                        readonly state: Schema.Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+                        readonly by: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                            readonly kind: Schema.Literal<"human">;
+                            readonly memberId: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly kind: Schema.Literal<"policy">;
+                        }>]>>;
+                        readonly reason: Schema.NullOr<Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+                        readonly requestedAt: Schema.Int;
+                        readonly expiresAt: Schema.Int;
+                        readonly updatedAt: Schema.Int;
+                        readonly revision: Schema.Int;
+                    }>;
+                    readonly canAnswer: Schema.Boolean;
+                    readonly canSetAutoApprove: Schema.Boolean;
+                }>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"refused">;
+                readonly reason: Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"submitted">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"refused">;
+                readonly reason: Schema.Literals<readonly ["not-attached", "not-pending"]>;
+            }>]>;
+        };
+    };
+    projection: {
+        schema: Schema.Struct<{
+            readonly pending: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly approval: Schema.Struct<{
+                    readonly record: Schema.Struct<{
+                        readonly recordId: Schema.String;
+                        readonly requester: Schema.Struct<{
+                            readonly principalId: Schema.String;
+                            readonly agentId: Schema.NullOr<Schema.String>;
+                            readonly sessionId: Schema.NullOr<Schema.String>;
+                            readonly displayName: Schema.String;
+                        }>;
+                        readonly module: Schema.String;
+                        readonly operation: Schema.String;
+                        readonly access: Schema.Literals<readonly ["write", "external"]>;
+                        readonly description: Schema.Struct<{
+                            readonly title: Schema.String;
+                            readonly inputBytes: Schema.Int;
+                            readonly inputSha256: Schema.String;
+                        }>;
+                        readonly evidence: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                            readonly kind: Schema.Literal<"artifact">;
+                            readonly ref: Schema.String;
+                            readonly mediaType: Schema.Literal<"image/png">;
+                            readonly bytes: Schema.Int;
+                        }>>>;
+                        readonly authorityFence: Schema.String;
+                        readonly reversibility: Schema.Literals<readonly ["reversible", "irreversible-external"]>;
+                        readonly state: Schema.Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+                        readonly by: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                            readonly kind: Schema.Literal<"human">;
+                            readonly memberId: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly kind: Schema.Literal<"policy">;
+                        }>]>>;
+                        readonly reason: Schema.NullOr<Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+                        readonly requestedAt: Schema.Int;
+                        readonly expiresAt: Schema.Int;
+                        readonly updatedAt: Schema.Int;
+                        readonly revision: Schema.Int;
+                    }>;
+                    readonly canAnswer: Schema.Boolean;
+                    readonly canSetAutoApprove: Schema.Boolean;
+                }>;
+            }>>;
+        }>;
+    };
+};
+export {};

package/dist/private-mcp-form-contract.js

@@ -0,0 +1,53 @@
+import { ExtensionId, } from "@fungi.computer/shiitake/extensions";
+import * as Schema from "effect/Schema";
+import { ApprovalAnswerInputSchema, ApprovalRefusalSchema, ApprovalViewSchema, } from "@fungi.computer/approvals";
+/** The actual MCP form, not a ledger record or an authorization decision. */
+export const McpFormApprovalRequestSchema = Schema.Struct({
+    message: Schema.String,
+    requestedSchema: Schema.Struct({
+        type: Schema.Literal("object"),
+        properties: Schema.Struct({
+            approve: Schema.Struct({
+                type: Schema.Literal("boolean"),
+                title: Schema.optionalKey(Schema.String),
+            }),
+        }),
+        required: Schema.Tuple([Schema.Literal("approve")]),
+    }),
+});
+const answerResult = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("answered"),
+        view: ApprovalViewSchema,
+    }),
+    ApprovalRefusalSchema,
+    // The attached client awaits the private host's post-commit decision.
+    Schema.Struct({ kind: Schema.Literal("submitted") }),
+    Schema.Struct({
+        kind: Schema.Literal("refused"),
+        reason: Schema.Literals(["not-attached", "not-pending"]),
+    }),
+]);
+/** The ephemeral id references the canonical record; it grants no authority. */
+const McpFormPendingSchema = Schema.Struct({
+    id: Schema.String,
+    approval: ApprovalViewSchema,
+});
+/** The existing Session extension slot carries only display-safe form data. */
+export const mcpFormApprovalContract = {
+    id: ExtensionId.make("botanical-local-mcp-form"),
+    commands: {
+        answer: {
+            scope: "session",
+            input: Schema.Struct({
+                id: Schema.String,
+                decision: ApprovalAnswerInputSchema.fields.decision,
+                expectedRevision: ApprovalAnswerInputSchema.fields.expectedRevision,
+            }),
+            output: answerResult,
+        },
+    },
+    projection: {
+        schema: Schema.Struct({ pending: Schema.Array(McpFormPendingSchema) }),
+    },
+};

package/dist/private-mcp-form-elicitation.d.ts

@@ -0,0 +1,18 @@
+import type { Client } from "@modelcontextprotocol/client";
+import { type McpFormApprovalRequest, type McpFormApprovalDecision } from "./private-mcp-form-contract.js";
+/** Host-owned human interaction. No callback means immediate cancellation. */
+export type RequestMcpFormApproval = (pending: McpFormApprovalRequest, signal: AbortSignal, 
+/** Session captured by source acquisition, never supplied by tool arguments. */
+sessionId: string | undefined) => Promise<McpFormApprovalDecision>;
+/** A refused form is a failed tool call, not an uncertain transport outcome. */
+export declare class McpFormApprovalError extends Error {
+    readonly reason: "declined" | "cancelled";
+    readonly kind = "mcp_approval_refused";
+    constructor(reason: "declined" | "cancelled");
+}
+/** Discriminant carried in a failed MCP tool result's structuredContent. */
+export type McpFormApprovalRefusal = Readonly<Pick<McpFormApprovalError, "kind" | "reason">>;
+export declare function registerMcpFormElicitation(client: Client, requestApproval: RequestMcpFormApproval | undefined, sessionId: string | undefined): {
+    close: () => void;
+    run: <T>(signal: AbortSignal, invoke: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+};

package/dist/private-mcp-form-elicitation.js

@@ -0,0 +1,97 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { addAbortListener } from "node:events";
+import * as Schema from "effect/Schema";
+import { McpFormApprovalRequestSchema, } from "./private-mcp-form-contract.js";
+const decodePendingForm = Schema.decodeUnknownSync(McpFormApprovalRequestSchema);
+/** A refused form is a failed tool call, not an uncertain transport outcome. */
+export class McpFormApprovalError extends Error {
+    reason;
+    kind = "mcp_approval_refused";
+    constructor(reason) {
+        super(`MCP approval was ${reason}.`);
+        this.reason = reason;
+        this.name = "McpFormApprovalError";
+    }
+}
+export function registerMcpFormElicitation(client, requestApproval, sessionId) {
+    // The producer sends its form on the requesting tools/call response stream.
+    // Keep that call's refusal local even when another call shares this client.
+    const calls = new AsyncLocalStorage();
+    const lifetime = new AbortController();
+    const close = () => {
+        lifetime.abort();
+        calls.disable();
+    };
+    client.onclose = close;
+    client.registerCapabilities({ elicitation: { form: {} } });
+    client.setRequestHandler("elicitation/create", async (request, context) => {
+        const call = calls.getStore();
+        if (call === undefined || call.failure !== undefined)
+            return { action: "cancel" };
+        const signal = AbortSignal.any([call.signal, context.mcpReq.signal]);
+        let abortListener;
+        call.pending++;
+        try {
+            signal.throwIfAborted();
+            const pending = decodePendingForm(request.params);
+            const aborted = new Promise((_resolve, reject) => {
+                abortListener = addAbortListener(signal, () => {
+                    reject(new McpFormApprovalError("cancelled"));
+                });
+            });
+            const decision = await Promise.race([
+                requestApproval === undefined
+                    ? Promise.resolve("cancel")
+                    : Promise.resolve().then(() => requestApproval(pending, signal, sessionId)),
+                aborted,
+            ]);
+            // Cancellation wins over a late Approve, including a UI ignoring abort.
+            signal.throwIfAborted();
+            if (decision === "approve")
+                return { action: "accept", content: { approve: true } };
+            call.failure ??= new McpFormApprovalError(decision === "decline" ? "declined" : "cancelled");
+            call.cancel();
+            return { action: decision };
+        }
+        catch {
+            call.failure ??= new McpFormApprovalError("cancelled");
+            call.cancel();
+            return { action: "cancel" };
+        }
+        finally {
+            call.pending--;
+            abortListener?.[Symbol.dispose]();
+        }
+    });
+    return {
+        close,
+        run: (signal, invoke) => {
+            const settled = new AbortController();
+            const call = {
+                signal: AbortSignal.any([signal, lifetime.signal, settled.signal]),
+                cancel: () => {
+                    settled.abort();
+                },
+                pending: 0,
+            };
+            return calls.run(call, async () => {
+                try {
+                    const result = await invoke(call.signal);
+                    if (call.failure !== undefined)
+                        throw call.failure;
+                    return result;
+                }
+                catch (cause) {
+                    if (call.failure !== undefined)
+                        throw call.failure;
+                    if (call.pending > 0)
+                        throw new McpFormApprovalError("cancelled");
+                    throw cause;
+                }
+                finally {
+                    settled.abort();
+                }
+            });
+        },
+    };
+}

package/dist/private-mcp-form-session.d.ts

@@ -0,0 +1,172 @@
+import type { Approvals, PendingApproval } from "@fungi.computer/approvals";
+import type { ShiitakeSession } from "@fungi.computer/shiitake";
+import { type LocalUiAttachment } from "./private-local-ui-attachment.js";
+/** Host-owned references to canonical approvals; no suspended tool or second ledger. */
+export declare function createMcpFormSession(): {
+    extension: import("@fungi.computer/shiitake/extensions").DefinedExtensionV0<{
+        answer: {
+            scope: "session";
+            input: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").String;
+                readonly decision: import("effect/Schema").Literals<readonly ["approve", "deny"]>;
+                readonly expectedRevision: import("effect/Schema").Int;
+            }>;
+            output: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"answered">;
+                readonly view: import("effect/Schema").Struct<{
+                    readonly record: import("effect/Schema").Struct<{
+                        readonly recordId: import("effect/Schema").String;
+                        readonly requester: import("effect/Schema").Struct<{
+                            readonly principalId: import("effect/Schema").String;
+                            readonly agentId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+                            readonly sessionId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+                            readonly displayName: import("effect/Schema").String;
+                        }>;
+                        readonly module: import("effect/Schema").String;
+                        readonly operation: import("effect/Schema").String;
+                        readonly access: import("effect/Schema").Literals<readonly ["write", "external"]>;
+                        readonly description: import("effect/Schema").Struct<{
+                            readonly title: import("effect/Schema").String;
+                            readonly inputBytes: import("effect/Schema").Int;
+                            readonly inputSha256: import("effect/Schema").String;
+                        }>;
+                        readonly evidence: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                            readonly kind: import("effect/Schema").Literal<"artifact">;
+                            readonly ref: import("effect/Schema").String;
+                            readonly mediaType: import("effect/Schema").Literal<"image/png">;
+                            readonly bytes: import("effect/Schema").Int;
+                        }>>>;
+                        readonly authorityFence: import("effect/Schema").String;
+                        readonly reversibility: import("effect/Schema").Literals<readonly ["reversible", "irreversible-external"]>;
+                        readonly state: import("effect/Schema").Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+                        readonly by: import("effect/Schema").NullOr<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                            readonly kind: import("effect/Schema").Literal<"human">;
+                            readonly memberId: import("effect/Schema").String;
+                        }>, import("effect/Schema").Struct<{
+                            readonly kind: import("effect/Schema").Literal<"policy">;
+                        }>]>>;
+                        readonly reason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+                        readonly requestedAt: import("effect/Schema").Int;
+                        readonly expiresAt: import("effect/Schema").Int;
+                        readonly updatedAt: import("effect/Schema").Int;
+                        readonly revision: import("effect/Schema").Int;
+                    }>;
+                    readonly canAnswer: import("effect/Schema").Boolean;
+                    readonly canSetAutoApprove: import("effect/Schema").Boolean;
+                }>;
+            }>, import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"refused">;
+                readonly reason: import("effect/Schema").Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>;
+            }>, import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"submitted">;
+            }>, import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"refused">;
+                readonly reason: import("effect/Schema").Literals<readonly ["not-attached", "not-pending"]>;
+            }>]>;
+        };
+    }, {
+        readonly pending: readonly {
+            readonly id: string;
+            readonly approval: {
+                readonly record: {
+                    readonly operation: string;
+                    readonly state: "pending" | "expired" | "requested" | "approved" | "claimed" | "applied" | "denied" | "outcome_unknown";
+                    readonly access: "write" | "external";
+                    readonly reason: "pending" | "not-found" | "not-eligible" | "already-answered" | "stale-revision" | "expired" | "declined" | "fenced" | "not-granted" | "read-only" | "in-flight" | "outcome-unknown" | "identity-conflict" | null;
+                    readonly recordId: string;
+                    readonly requester: {
+                        readonly principalId: string;
+                        readonly agentId: string | null;
+                        readonly sessionId: string | null;
+                        readonly displayName: string;
+                    };
+                    readonly module: string;
+                    readonly description: {
+                        readonly title: string;
+                        readonly inputBytes: number;
+                        readonly inputSha256: string;
+                    };
+                    readonly authorityFence: string;
+                    readonly reversibility: "reversible" | "irreversible-external";
+                    readonly by: {
+                        readonly kind: "human";
+                        readonly memberId: string;
+                    } | {
+                        readonly kind: "policy";
+                    } | null;
+                    readonly requestedAt: number;
+                    readonly expiresAt: number;
+                    readonly updatedAt: number;
+                    readonly revision: number;
+                    readonly evidence?: readonly {
+                        readonly kind: "artifact";
+                        readonly ref: string;
+                        readonly mediaType: "image/png";
+                        readonly bytes: number;
+                    }[];
+                };
+                readonly canAnswer: boolean;
+                readonly canSetAutoApprove: boolean;
+            };
+        }[];
+    }, {
+        readonly pending: readonly {
+            readonly id: string;
+            readonly approval: {
+                readonly record: {
+                    readonly operation: string;
+                    readonly state: "pending" | "expired" | "requested" | "approved" | "claimed" | "applied" | "denied" | "outcome_unknown";
+                    readonly access: "write" | "external";
+                    readonly reason: "pending" | "not-found" | "not-eligible" | "already-answered" | "stale-revision" | "expired" | "declined" | "fenced" | "not-granted" | "read-only" | "in-flight" | "outcome-unknown" | "identity-conflict" | null;
+                    readonly recordId: string;
+                    readonly requester: {
+                        readonly principalId: string;
+                        readonly agentId: string | null;
+                        readonly sessionId: string | null;
+                        readonly displayName: string;
+                    };
+                    readonly module: string;
+                    readonly description: {
+                        readonly title: string;
+                        readonly inputBytes: number;
+                        readonly inputSha256: string;
+                    };
+                    readonly authorityFence: string;
+                    readonly reversibility: "reversible" | "irreversible-external";
+                    readonly by: {
+                        readonly kind: "human";
+                        readonly memberId: string;
+                    } | {
+                        readonly kind: "policy";
+                    } | null;
+                    readonly requestedAt: number;
+                    readonly expiresAt: number;
+                    readonly updatedAt: number;
+                    readonly revision: number;
+                    readonly evidence?: readonly {
+                        readonly kind: "artifact";
+                        readonly ref: string;
+                        readonly mediaType: "image/png";
+                        readonly bytes: number;
+                    }[];
+                };
+                readonly canAnswer: boolean;
+                readonly canSetAutoApprove: boolean;
+            };
+        }[];
+    }>;
+    presentApproval: (sessionId: string, submitted: PendingApproval, approvals: Approvals) => Promise<{
+        readonly kind: "refused";
+        readonly reason: "not-pending";
+        readonly id?: never;
+    } | {
+        readonly kind: "presented";
+        readonly id: string;
+        reason?: never;
+    } | {
+        readonly kind: "refused";
+        readonly reason: "capacity";
+        readonly id?: never;
+    }>;
+    bindSession: (sessionId: string, session: ShiitakeSession, attachment: LocalUiAttachment | undefined) => ShiitakeSession;
+};