opencode-courier 0.2.3 → 0.4.0

package/dist/person/question/shared.js

@@ -0,0 +1,52 @@
+import { addBounded } from "../../platform/bounded.js";
+import { hub, memberAt, sharedState } from "../../platform/hub.js";
+/** OpenCode's own question tool, which the relay wraps. */
+export const QUESTION_TOOL = "question";
+export const PREFIX = "question/";
+/** At most this many questions are kept in storage; the oldest go first. */
+export const MAX_STORED = 100;
+export const storedOf = ({ directory: _directory, call: _call, link: _link, relaying: _relaying, settling: _settling, ...asked }) => asked;
+export const isPassing = (requestID) => shared.passing.has(requestID) || shared.answered.has(requestID);
+/**
+ * The relay's state in `registry`, the hub's `questions`, with the fields it lacks made: field by
+ * field, since a copy before the hub may have made it without the fields added later.
+ */
+export function questionState(registry) {
+    const state = sharedState("questions", () => ({}), registry);
+    state.questions ??= new Map();
+    state.noticed ??= new Set();
+    state.shown ??= new Map();
+    state.passing ??= new Map();
+    state.answered ??= new Set();
+    state.loaded ??= new Set();
+    state.following ??= 0;
+    state.followed ??= false;
+    state.shutdowns ??= new Map();
+    state.closingWaiters ??= new Set();
+    return state;
+}
+// Shared by every plugin instance in the process, since a child and the session it asks can be in
+// different locations.
+export const shared = questionState();
+/** A member's question ports: every hub-v2 member's `questions` are its instance's, whichever copy joined it. */
+const portsOf = (member) => member?.questions;
+/**
+ * The ports of an instance still loaded, if any: a member of this copy's hub, or else one that a
+ * copy of another hub version, or a release before the hub, keeps in `loaded`.
+ */
+export const anyLoaded = () => portsOf(hub.members.values().next().value) ?? shared.loaded.values().next().value;
+/**
+ * The question ports of the member that just joined at `location`, while it is loaded: resolved once,
+ * so a later instance at the same location does not take its place while this one is still loaded.
+ */
+export function portsAt(location) {
+    const own = memberAt(location);
+    return () => (own && hub.members.has(own) ? portsOf(own) : undefined);
+}
+export const keyOf = (requestID) => `${PREFIX}${requestID}`;
+/** Whether a request id is a question's rather than a permission request's. */
+export const isQuestion = (requestID) => requestID.startsWith("question_");
+/** How many noticed and answered questions are remembered. */
+const REMEMBERED = 1_000;
+/** Adds to one of the shared bounded sets. */
+export const claim = (set, value) => addBounded(set, value, REMEMBERED);

package/dist/person/question/types.d.ts

@@ -0,0 +1,121 @@
+import type { Plugin } from "@opencode/plugin";
+import type { Storage } from "../../platform/storage.js";
+type Context = Plugin.Context;
+/** One question of OpenCode's question tool, as the asking model wrote it. */
+export interface Prompt {
+    readonly question: string;
+    readonly header: string;
+    readonly options: ReadonlyArray<{
+        readonly label: string;
+        readonly description: string;
+    }>;
+    readonly multiple?: boolean;
+}
+/** The answers to a question call, as the question tool returns them: one list per question. */
+export type Answers = string[][];
+/** A question a spawned session asked with its question tool, stored until it is answered. */
+export interface Asked {
+    readonly requestID: string;
+    readonly sessionID: string;
+    /** The session told, at the top of the sessions started with courier_spawn; it alone answers. */
+    readonly top: string;
+    readonly title: string;
+    /** The session that started the asking one, when that is not the top session itself. */
+    readonly startedBy?: string;
+    readonly questions: ReadonlyArray<Prompt>;
+    readonly askedAt: number;
+    /** A native child's, whose form OpenCode shows the person in the top session's own view; not linked while shown. */
+    readonly native?: true;
+}
+/**
+ * How a question was settled without the top session: in the asking session (or, `via` "inbox", by the
+ * person in the TUI's asks inbox), or not at all.
+ */
+export type Elsewhere = {
+    readonly by: "child";
+    readonly answers: Answers;
+    readonly via?: "inbox";
+} | {
+    readonly by: "dismissed";
+} | {
+    readonly by: "failed";
+    readonly error: string;
+};
+/** What the top session's answer does to a call that waits: answers it, or dismisses it. */
+export type Outcome = {
+    readonly answers: Answers;
+} | {
+    readonly dismissed: true;
+};
+/**
+ * Why a linked call is withdrawn: its question was settled elsewhere, or the top session's outcome
+ * reached it another way (courier_answer, or a dismissal through an earlier call linked to it).
+ */
+export type Withdrawal = Elsewhere | {
+    readonly by: "top";
+    readonly outcome: Outcome;
+};
+/**
+ * A question this process knows: its call waits (`call`), or was cut off and is answered by message.
+ * `link` withdraws the top session's call passing the answer on, once settled without that call.
+ */
+export interface Question extends Asked {
+    /** The directory of the location the call runs in, whose shutdown withdraws its form. */
+    directory?: string;
+    /** Hands the waiting call the top session's outcome; true once the call has ended with it. */
+    call?: (outcome: Outcome) => Promise<boolean>;
+    link?: (how: Withdrawal) => void;
+    /** Storing the question and telling the top session, while that is under way. */
+    relaying?: Promise<boolean>;
+    /** Working out what became of it once its call ended without the top session's answer. */
+    settling?: Promise<void>;
+}
+/**
+ * The relay's timings, carried by its ports: the closing grace before a cut-off question is told, the
+ * wait for an answer still being passed on, the wait for a notice to go out, and the dismissal hold.
+ */
+export interface QuestionTiming {
+    readonly closingGraceMs: number;
+    readonly passingWaitMs: number;
+    readonly relayWaitMs: number;
+    readonly dismissalGraceMs: number;
+}
+export interface QuestionPorts {
+    readonly storage: Storage;
+    readonly session: Pick<Context["session"], "synthetic">;
+    /** The directory of the instance's location. */
+    readonly directory: string;
+    /** The clock, in epoch milliseconds, as OpenCode's location shutdowns are recorded. */
+    readonly now: () => number;
+    readonly timing: QuestionTiming;
+    readonly newID: () => string;
+    readonly log: (message: string) => void;
+}
+/**
+ * The question relay's state, shared by every instance, as a child and the session it asks can be in
+ * different locations: open questions, cut-off ones already told, and calls waiting for their form.
+ */
+export interface QuestionState {
+    readonly questions: Map<string, Question>;
+    readonly noticed: Set<string>;
+    readonly shown: Map<string, () => void>;
+    /** The questions whose answer is being passed on, each until that is done, and those whose answer went out. */
+    readonly passing: Map<string, Promise<unknown>>;
+    readonly answered: Set<string>;
+    /**
+     * The ports of every loaded instance of every copy. A release before the hub picks one here to tell
+     * a cut-off question through, so every copy fills it; this copy reads it only for another copy.
+     */
+    readonly loaded: Set<QuestionPorts>;
+    /** How many instances follow OpenCode's events now, and whether any has since the process started. */
+    following: number;
+    followed: boolean;
+    /**
+     * When OpenCode last reported each location shutting down (`location.shutdown`), by directory
+     * in epoch milliseconds by the clock of the watcher that saw it; under `""` when the event named no location.
+     */
+    readonly shutdowns: Map<string, number>;
+    /** Woken when a location shuts down or an instance unloads: dismissals held to see whether one follows. */
+    readonly closingWaiters: Set<() => void>;
+}
+export {};

package/dist/person/question/types.js

@@ -0,0 +1 @@
+export {};

package/dist/person/rpc-handlers.d.ts

@@ -0,0 +1,160 @@
+import type { Plugin } from "@opencode/plugin";
+import { type Permissions } from "./permission.js";
+import { type QuestionPorts } from "./question/index.js";
+import { type Answered, type Asks } from "./rpc.js";
+/** What the person's RPC reads and answers through: the relay's ports, which carry the storage, and every location's permissions. */
+export interface PersonRpcPorts {
+    readonly questions: QuestionPorts;
+    readonly permissions: () => Iterable<Permissions>;
+    /** At most this many sessions of a tree are read, as courier_tree reads them. */
+    readonly maxTotal: number;
+}
+/**
+ * The permission requests and questions waiting in the courier tree a session is in, from the roster: read from the
+ * top of its lineage down, so each session of the tree sees the same inbox.
+ */
+export declare function asks(ports: PersonRpcPorts, sessionID: string): Promise<Asks>;
+/** Passes the person's answers to a question on, as courier_answer does; a refusal, such as answers that do not fit, comes back as `problem`. */
+export declare function answer(ports: PersonRpcPorts, input: {
+    sessionID: string;
+    requestID: string;
+    answers: ReadonlyArray<ReadonlyArray<string>>;
+}): Promise<Answered>;
+/** Serves the person's RPC at the plugin's location; disposed with the plugin. */
+export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "register">, ports: PersonRpcPorts): Promise<import("@opencode/plugin/promise/rpc").RpcRegistration<{
+    readonly id: "courier-person";
+    readonly methods: {
+        readonly asks: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+            }, {
+                readonly sessionID: string;
+            }> & import("effect/Schema").Struct<{
+                readonly sessionID: import("effect/Schema").String;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly questions: readonly {
+                    readonly questions: readonly {
+                        readonly options: readonly {
+                            readonly label: string;
+                            readonly description: string;
+                        }[];
+                        readonly question: string;
+                        readonly header: string;
+                        readonly multiple?: boolean | undefined;
+                    }[];
+                    readonly sessionID: string;
+                    readonly requestID: string;
+                    readonly stopped?: boolean | undefined;
+                }[];
+                readonly permissions: readonly {
+                    readonly sessionID: string;
+                    readonly resources: readonly string[];
+                    readonly action: string;
+                    readonly requestID: string;
+                    readonly save?: readonly string[] | undefined;
+                }[];
+                readonly top: string;
+                readonly sessions: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly group?: string | undefined;
+                }[];
+                readonly truncated?: number | undefined;
+            }, {
+                readonly questions: readonly {
+                    readonly questions: readonly {
+                        readonly options: readonly {
+                            readonly label: string;
+                            readonly description: string;
+                        }[];
+                        readonly question: string;
+                        readonly header: string;
+                        readonly multiple?: boolean | undefined;
+                    }[];
+                    readonly sessionID: string;
+                    readonly requestID: string;
+                    readonly stopped?: boolean | undefined;
+                }[];
+                readonly permissions: readonly {
+                    readonly sessionID: string;
+                    readonly resources: readonly string[];
+                    readonly action: string;
+                    readonly requestID: string;
+                    readonly save?: readonly string[] | undefined;
+                }[];
+                readonly top: string;
+                readonly sessions: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly group?: string | undefined;
+                }[];
+                readonly truncated?: number | undefined;
+            }> & import("effect/Schema").Struct<{
+                readonly top: import("effect/Schema").String;
+                readonly sessions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly sessionID: import("effect/Schema").String;
+                    readonly title: import("effect/Schema").String;
+                    readonly parentID: import("effect/Schema").String;
+                    readonly depth: import("effect/Schema").Int;
+                    readonly group: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+                }>>;
+                readonly permissions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly sessionID: import("effect/Schema").String;
+                    readonly requestID: import("effect/Schema").String;
+                    readonly action: import("effect/Schema").String;
+                    readonly resources: import("effect/Schema").$Array<import("effect/Schema").String>;
+                    readonly save: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+                }>>;
+                readonly questions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly sessionID: import("effect/Schema").String;
+                    readonly requestID: import("effect/Schema").String;
+                    readonly questions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                        readonly question: import("effect/Schema").String;
+                        readonly header: import("effect/Schema").String;
+                        readonly options: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                            readonly label: import("effect/Schema").String;
+                            readonly description: import("effect/Schema").String;
+                        }>>;
+                        readonly multiple: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+                    }>>;
+                    readonly stopped: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+                }>>;
+                readonly truncated: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+            }>;
+        };
+        readonly answer: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+                readonly requestID: string;
+                readonly answers: readonly (readonly string[])[];
+            }, {
+                readonly sessionID: string;
+                readonly requestID: string;
+                readonly answers: readonly (readonly string[])[];
+            }> & import("effect/Schema").Struct<{
+                readonly sessionID: import("effect/Schema").String;
+                readonly requestID: import("effect/Schema").String;
+                readonly answers: import("effect/Schema").$Array<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly answered: boolean;
+                readonly by?: "message" | "result" | undefined;
+                readonly problem?: string | undefined;
+            }, {
+                readonly answered: boolean;
+                readonly by?: "message" | "result" | undefined;
+                readonly problem?: string | undefined;
+            }> & import("effect/Schema").Struct<{
+                readonly answered: import("effect/Schema").Boolean;
+                readonly by: import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["result", "message"]>>;
+                readonly problem: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            }>;
+        };
+    };
+    readonly events: {};
+}>>;

package/dist/person/rpc-handlers.js

@@ -0,0 +1,62 @@
+import { lineage, subtree } from "../tree/index.js";
+import { pendingOf } from "./permission.js";
+import { answerForPerson, pendingQuestions } from "./question/index.js";
+import { personRpc } from "./rpc.js";
+/**
+ * The permission requests and questions waiting in the courier tree a session is in, from the roster: read from the
+ * top of its lineage down, so each session of the tree sees the same inbox.
+ */
+export async function asks(ports, sessionID) {
+    const { storage } = ports.questions;
+    const top = (await lineage(storage, sessionID)).at(-1)?.parentID ?? sessionID;
+    const { nodes, truncated } = await subtree(storage, top, ports.maxTotal);
+    const waiting = await Promise.all(nodes.map(({ entry }) => Promise.all([
+        pendingOf(ports.permissions(), entry.sessionID).catch(() => []),
+        pendingQuestions(storage, entry.sessionID).catch(() => []),
+    ])));
+    return {
+        top,
+        sessions: nodes.map(({ entry, depth }) => ({
+            sessionID: entry.sessionID,
+            title: entry.title,
+            parentID: entry.parentID,
+            depth,
+            ...(entry.group ? { group: entry.group } : {}),
+        })),
+        permissions: nodes.flatMap(({ entry }, index) => waiting[index][0].flatMap((pending) => pending.type === "permission"
+            ? [
+                {
+                    sessionID: entry.sessionID,
+                    requestID: pending.requestID,
+                    action: pending.action,
+                    resources: pending.resources,
+                    ...(pending.save ? { save: pending.save } : {}),
+                },
+            ]
+            : [])),
+        questions: nodes.flatMap(({ entry }, index) => waiting[index][1].map(({ requestID, questions, stopped }) => ({
+            sessionID: entry.sessionID,
+            requestID,
+            questions,
+            ...(stopped ? { stopped } : {}),
+        }))),
+        ...(truncated ? { truncated: ports.maxTotal } : {}),
+    };
+}
+/** Passes the person's answers to a question on, as courier_answer does; a refusal, such as answers that do not fit, comes back as `problem`. */
+export async function answer(ports, input) {
+    try {
+        const result = await answerForPerson(ports.questions, input);
+        return result.answered ? { answered: true, by: result.by } : { answered: false };
+    }
+    catch (error) {
+        return { answered: false, problem: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Serves the person's RPC at the plugin's location; disposed with the plugin. */
+export function registerPersonRpc(rpc, ports) {
+    return rpc.register(personRpc, {
+        asks: ({ sessionID }) => asks(ports, sessionID),
+        answer: (input) => answer(ports, input),
+    });
+}

package/dist/person/rpc.d.ts

@@ -0,0 +1,227 @@
+import { Schema } from "effect";
+/** A session of the tree, as the inbox names where an ask comes from. */
+declare const Session: Schema.Struct<{
+    readonly sessionID: Schema.String;
+    readonly title: Schema.String;
+    readonly parentID: Schema.String;
+    /** A child of the tree's top session is at depth 1. */
+    readonly depth: Schema.Int;
+    readonly group: Schema.optionalKey<Schema.String>;
+}>;
+/** A permission request a session of the tree waits on. */
+declare const Permission: Schema.Struct<{
+    readonly sessionID: Schema.String;
+    readonly requestID: Schema.String;
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    /** What "always" would allow from now on; absent when it is not offered. */
+    readonly save: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+/** A question a session of the tree waits on; `stopped` when its call was cut off and the answer goes as a message. */
+declare const Question: Schema.Struct<{
+    readonly sessionID: Schema.String;
+    readonly requestID: Schema.String;
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly question: Schema.String;
+        readonly header: Schema.String;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+        }>>;
+        readonly multiple: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly stopped: Schema.optionalKey<Schema.Boolean>;
+}>;
+/** What the sessions of a courier tree wait on the person for, but forms, which the TUI lists itself. */
+declare const Asks: Schema.Struct<{
+    /** The session at the top of the tree, which the sessions below were started from. */
+    readonly top: Schema.String;
+    /** The sessions below the top, in the order a tree is drawn. */
+    readonly sessions: Schema.$Array<Schema.Struct<{
+        readonly sessionID: Schema.String;
+        readonly title: Schema.String;
+        readonly parentID: Schema.String;
+        /** A child of the tree's top session is at depth 1. */
+        readonly depth: Schema.Int;
+        readonly group: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly permissions: Schema.$Array<Schema.Struct<{
+        readonly sessionID: Schema.String;
+        readonly requestID: Schema.String;
+        readonly action: Schema.String;
+        readonly resources: Schema.$Array<Schema.String>;
+        /** What "always" would allow from now on; absent when it is not offered. */
+        readonly save: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>;
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly sessionID: Schema.String;
+        readonly requestID: Schema.String;
+        readonly questions: Schema.$Array<Schema.Struct<{
+            readonly question: Schema.String;
+            readonly header: Schema.String;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.String;
+                readonly description: Schema.String;
+            }>>;
+            readonly multiple: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+        readonly stopped: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    /** Set when the tree had more sessions than `maxTotal`, which were not read. */
+    readonly truncated: Schema.optionalKey<Schema.Int>;
+}>;
+export type Asks = typeof Asks.Type;
+export type AskedQuestion = typeof Question.Type;
+export type AskedPermission = typeof Permission.Type;
+export type TreeSession = typeof Session.Type;
+/** What answering a question did; `problem` says why nothing was passed on, when it was refused. */
+declare const Answered: Schema.Struct<{
+    readonly answered: Schema.Boolean;
+    readonly by: Schema.optionalKey<Schema.Literals<readonly ["result", "message"]>>;
+    readonly problem: Schema.optionalKey<Schema.String>;
+}>;
+export type Answered = typeof Answered.Type;
+export declare const personRpc: {
+    readonly id: "courier-person";
+    readonly methods: {
+        readonly asks: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+            }, {
+                readonly sessionID: string;
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly questions: readonly {
+                    readonly sessionID: string;
+                    readonly requestID: string;
+                    readonly questions: readonly {
+                        readonly options: readonly {
+                            readonly label: string;
+                            readonly description: string;
+                        }[];
+                        readonly question: string;
+                        readonly header: string;
+                        readonly multiple?: boolean | undefined;
+                    }[];
+                    readonly stopped?: boolean | undefined;
+                }[];
+                readonly sessions: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly group?: string | undefined;
+                }[];
+                readonly permissions: readonly {
+                    readonly sessionID: string;
+                    readonly resources: readonly string[];
+                    readonly requestID: string;
+                    readonly action: string;
+                    readonly save?: readonly string[] | undefined;
+                }[];
+                readonly top: string;
+                readonly truncated?: number | undefined;
+            }, {
+                readonly questions: readonly {
+                    readonly sessionID: string;
+                    readonly requestID: string;
+                    readonly questions: readonly {
+                        readonly options: readonly {
+                            readonly label: string;
+                            readonly description: string;
+                        }[];
+                        readonly question: string;
+                        readonly header: string;
+                        readonly multiple?: boolean | undefined;
+                    }[];
+                    readonly stopped?: boolean | undefined;
+                }[];
+                readonly sessions: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly group?: string | undefined;
+                }[];
+                readonly permissions: readonly {
+                    readonly sessionID: string;
+                    readonly resources: readonly string[];
+                    readonly requestID: string;
+                    readonly action: string;
+                    readonly save?: readonly string[] | undefined;
+                }[];
+                readonly top: string;
+                readonly truncated?: number | undefined;
+            }> & Schema.Struct<{
+                /** The session at the top of the tree, which the sessions below were started from. */
+                readonly top: Schema.String;
+                /** The sessions below the top, in the order a tree is drawn. */
+                readonly sessions: Schema.$Array<Schema.Struct<{
+                    readonly sessionID: Schema.String;
+                    readonly title: Schema.String;
+                    readonly parentID: Schema.String;
+                    /** A child of the tree's top session is at depth 1. */
+                    readonly depth: Schema.Int;
+                    readonly group: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly permissions: Schema.$Array<Schema.Struct<{
+                    readonly sessionID: Schema.String;
+                    readonly requestID: Schema.String;
+                    readonly action: Schema.String;
+                    readonly resources: Schema.$Array<Schema.String>;
+                    /** What "always" would allow from now on; absent when it is not offered. */
+                    readonly save: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>>;
+                readonly questions: Schema.$Array<Schema.Struct<{
+                    readonly sessionID: Schema.String;
+                    readonly requestID: Schema.String;
+                    readonly questions: Schema.$Array<Schema.Struct<{
+                        readonly question: Schema.String;
+                        readonly header: Schema.String;
+                        readonly options: Schema.$Array<Schema.Struct<{
+                            readonly label: Schema.String;
+                            readonly description: Schema.String;
+                        }>>;
+                        readonly multiple: Schema.optionalKey<Schema.Boolean>;
+                    }>>;
+                    readonly stopped: Schema.optionalKey<Schema.Boolean>;
+                }>>;
+                /** Set when the tree had more sessions than `maxTotal`, which were not read. */
+                readonly truncated: Schema.optionalKey<Schema.Int>;
+            }>;
+        };
+        readonly answer: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+                readonly requestID: string;
+                readonly answers: readonly (readonly string[])[];
+            }, {
+                readonly sessionID: string;
+                readonly requestID: string;
+                readonly answers: readonly (readonly string[])[];
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+                readonly requestID: Schema.String;
+                readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly answered: boolean;
+                readonly by?: "result" | "message" | undefined;
+                readonly problem?: string | undefined;
+            }, {
+                readonly answered: boolean;
+                readonly by?: "result" | "message" | undefined;
+                readonly problem?: string | undefined;
+            }> & Schema.Struct<{
+                readonly answered: Schema.Boolean;
+                readonly by: Schema.optionalKey<Schema.Literals<readonly ["result", "message"]>>;
+                readonly problem: Schema.optionalKey<Schema.String>;
+            }>;
+        };
+    };
+    readonly events: {};
+};
+export type PersonRpc = typeof personRpc;
+export {};