@fungi.computer/shiitake-extensions 0.0.0-stage → 0.0.1

package/dist/plan/client.js

@@ -0,0 +1,51 @@
+import { defineClientEntry, } from "@fungi.computer/shiitake/client-entry";
+import { planContract, planIsOpen } from "./contract.js";
+const summary = (plan) => {
+    const active = plan.steps.findIndex((step) => step.status === "in_progress");
+    const completed = plan.steps.filter((step) => step.status === "completed").length;
+    const next = active < 0
+        ? plan.steps.find((step) => step.status === "pending")
+        : plan.steps[active];
+    return {
+        title: next?.step ?? "Plan complete",
+        detail: `${String(active < 0 ? completed : active + 1)}/${String(plan.steps.length)}`,
+    };
+};
+const rows = (plan) => plan.steps.map((step, index) => ({
+    id: String(index),
+    title: step.step,
+    tone: step.status === "completed"
+        ? "settled"
+        : step.status === "in_progress"
+            ? "running"
+            : "muted",
+}));
+/**
+ * Only an open plan occupies the footer, where it is inspectable and clearable;
+ * a finished or cleared plan hides while its committed history stays in state.
+ */
+export default defineClientEntry(planContract, {
+    contribute: (view) => ({
+        chips: [],
+        panel: view.status !== "running" ||
+            view.value === null ||
+            !planIsOpen(view.value.plan)
+            ? []
+            : [
+                {
+                    id: "plan",
+                    ...summary(view.value.plan),
+                    actions: [
+                        { id: "plan", label: "Clear plan", input: { action: "clear" } },
+                    ],
+                    inspection: {
+                        commandId: "plan",
+                        title: "Plan",
+                        rows: rows(view.value.plan),
+                    },
+                },
+            ],
+        timeline: { cells: [], omitted: 0 },
+        waiting: null,
+    }),
+});

package/dist/plan/contract.d.ts

@@ -0,0 +1,105 @@
+import * as Schema from "effect/Schema";
+/**
+ * One Session's replaceable checklist, independent of goals and loops. No
+ * steps means no plan: replacing it with an empty checklist clears it.
+ */
+export declare const Plan: Schema.Struct<{
+    readonly explanation: Schema.optionalKey<Schema.String>;
+    readonly steps: Schema.$Array<Schema.Struct<{
+        readonly step: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed"]>;
+    }>>;
+}>;
+export declare const PlanInput: Schema.Struct<{
+    readonly explanation: Schema.optionalKey<Schema.String>;
+    readonly steps: Schema.$Array<Schema.Struct<{
+        readonly step: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed"]>;
+    }>>;
+}>;
+export type Plan = Schema.Schema.Type<typeof Plan>;
+/** Open work remains: some step is not completed. Cleared and finished plans are closed. */
+export declare function planIsOpen(plan: Plan): boolean;
+/** The current checklist and every committed replacement, clears included. */
+export declare const PlanProjection: Schema.Struct<{
+    readonly plan: Schema.Struct<{
+        readonly explanation: Schema.optionalKey<Schema.String>;
+        readonly steps: Schema.$Array<Schema.Struct<{
+            readonly step: Schema.String;
+            readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed"]>;
+        }>>;
+    }>;
+    readonly history: Schema.Struct<{
+        readonly nextSequence: Schema.Int;
+        readonly omitted: Schema.Int;
+        readonly events: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly sequence: Schema.Int;
+            readonly at: Schema.Int;
+            readonly commandId: Schema.NullOr<Schema.String>;
+            readonly event: Schema.Codec<{
+                readonly steps: readonly {
+                    readonly step: string;
+                    readonly status: "pending" | "completed" | "in_progress";
+                }[];
+                readonly explanation?: string;
+            }, {
+                readonly steps: readonly {
+                    readonly step: string;
+                    readonly status: "pending" | "completed" | "in_progress";
+                }[];
+                readonly explanation?: string;
+            }, never, never>;
+        }>>;
+    }>;
+}>;
+/** Arguments of the human `/plan` command: a bare call views, `clear` empties it. */
+export declare const PlanCommandInput: Schema.Union<readonly [Schema.Struct<{
+    readonly action: Schema.Literal<"clear">;
+}>, Schema.Struct<{}>]>;
+export declare const planContract: {
+    id: string & import("effect/Brand").Brand<"ExtensionId">;
+    commands: {
+        plan: {
+            scope: "session";
+            input: Schema.Union<readonly [Schema.Struct<{
+                readonly action: Schema.Literal<"clear">;
+            }>, Schema.Struct<{}>]>;
+            output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
+        };
+    };
+    projection: {
+        schema: Schema.Struct<{
+            readonly plan: Schema.Struct<{
+                readonly explanation: Schema.optionalKey<Schema.String>;
+                readonly steps: Schema.$Array<Schema.Struct<{
+                    readonly step: Schema.String;
+                    readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed"]>;
+                }>>;
+            }>;
+            readonly history: Schema.Struct<{
+                readonly nextSequence: Schema.Int;
+                readonly omitted: Schema.Int;
+                readonly events: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly sequence: Schema.Int;
+                    readonly at: Schema.Int;
+                    readonly commandId: Schema.NullOr<Schema.String>;
+                    readonly event: Schema.Codec<{
+                        readonly steps: readonly {
+                            readonly step: string;
+                            readonly status: "pending" | "completed" | "in_progress";
+                        }[];
+                        readonly explanation?: string;
+                    }, {
+                        readonly steps: readonly {
+                            readonly step: string;
+                            readonly status: "pending" | "completed" | "in_progress";
+                        }[];
+                        readonly explanation?: string;
+                    }, never, never>;
+                }>>;
+            }>;
+        }>;
+    };
+};

package/dist/plan/contract.js

@@ -0,0 +1,38 @@
+import { historySchema } from "../internal/history.js";
+import { ExtensionId, } from "@fungi.computer/shiitake/extensions";
+import * as Schema from "effect/Schema";
+import { CatalogStep } from "../internal/catalog.js";
+/**
+ * One Session's replaceable checklist, independent of goals and loops. No
+ * steps means no plan: replacing it with an empty checklist clears it.
+ */
+export const Plan = Schema.Struct({
+    explanation: Schema.optionalKey(Schema.String.pipe(Schema.check(Schema.isMaxLength(2_000)))),
+    steps: Schema.Array(Schema.Struct({
+        step: Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(500))),
+        status: Schema.Literals(["pending", "in_progress", "completed"]),
+    })).pipe(Schema.check(Schema.isMaxLength(50))),
+});
+export const PlanInput = Plan.pipe(Schema.check(Schema.makeFilter((plan) => plan.steps.filter((step) => step.status === "in_progress").length <=
+    1 || "At most one plan step may be in progress")));
+/** Open work remains: some step is not completed. Cleared and finished plans are closed. */
+export function planIsOpen(plan) {
+    return plan.steps.some((step) => step.status !== "completed");
+}
+/** The current checklist and every committed replacement, clears included. */
+export const PlanProjection = Schema.Struct({
+    plan: Plan,
+    history: historySchema(Plan),
+});
+/** Arguments of the human `/plan` command: a bare call views, `clear` empties it. */
+export const PlanCommandInput = Schema.Union([
+    Schema.Struct({ action: Schema.Literal("clear") }),
+    Schema.Struct({}),
+]);
+export const planContract = {
+    id: ExtensionId.make("botanical-session-plan"),
+    commands: {
+        plan: { scope: "session", input: PlanCommandInput, output: CatalogStep },
+    },
+    projection: { schema: PlanProjection },
+};

package/dist/plan/host.d.ts

@@ -0,0 +1,3 @@
+import { type RosteredExtensionV0 } from "@fungi.computer/shiitake/extensions";
+/** Durable plan owner: replace, project and advertise through core's granted doors. */
+export declare const planExtension: RosteredExtensionV0;

package/dist/plan/host.js

@@ -0,0 +1,154 @@
+import * as Clock from "effect/Clock";
+import { appendHistory, emptyHistory, historySchema, } from "../internal/history.js";
+import { Mycelium } from "@fungi.computer/mycelium";
+import { defineCollection, defineExtension, ExtensionCommandError, } from "@fungi.computer/shiitake/extensions";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { z } from "zod";
+import { catalog, done } from "../internal/catalog.js";
+import { Plan, PlanInput, planContract, planIsOpen } from "./contract.js";
+const config = Object.freeze({
+    promptLimit: 2_000,
+    guide: "Session checklist tool in execute: plan.update_plan({explanation?,steps:[{step,status:'pending'|'in_progress'|'completed'}]}). Find it with forage.search({query:'plan'}) and forage.describe. Use it for multi-step work, with at most one in-progress step; replace the whole plan on each update, and pass steps:[] to clear a plan that no longer applies. A completed checklist is not proof of goal completion.",
+});
+const collections = {
+    history: defineCollection(Schema.Struct({ sessionId: Schema.String, history: historySchema(Plan) }), { key: (row) => row.sessionId }),
+    plans: defineCollection(Schema.Struct({ sessionId: Schema.String, plan: Plan }), { key: (row) => row.sessionId }),
+};
+const input = z
+    .strictObject({
+    explanation: z.string().max(2_000).optional(),
+    steps: z
+        .array(z.strictObject({
+        step: z.string().min(1).max(500),
+        status: z.enum(["pending", "in_progress", "completed"]),
+    }))
+        .max(50),
+})
+    .transform((value) => value.explanation === undefined
+    ? { steps: value.steps }
+    : { steps: value.steps, explanation: value.explanation });
+/**
+ * The one write: the Agent's tool and the human's clear both replace the
+ * checklist here, and every distinct replacement joins the history.
+ */
+function replacePlan(ctx, sessionId, plan, commandId) {
+    return Effect.gen(function* () {
+        const previous = Option.getOrUndefined(yield* ctx.state.plans.get(sessionId));
+        if (JSON.stringify(previous?.plan) !== JSON.stringify(plan)) {
+            const history = Option.getOrUndefined(yield* ctx.state.history.get(sessionId))
+                ?.history ?? emptyHistory();
+            yield* ctx.state.history.put({
+                sessionId,
+                history: appendHistory(history, plan, commandId, yield* Clock.currentTimeMillis),
+            });
+            yield* ctx.state.plans.put({ sessionId, plan });
+        }
+        yield* ctx.observe(sessionId);
+    });
+}
+/** Durable plan owner: replace, project and advertise through core's granted doors. */
+export const planExtension = defineExtension({
+    id: planContract.id,
+    version: "2.0.0",
+})
+    .config(config)
+    .state({ version: 2, migrations: {}, collections })
+    .define({
+    catalog: catalog([
+        {
+            id: "plan",
+            title: "Plan",
+            category: "Conversation",
+            description: "View or clear the checklist",
+            projections: {
+                help: { order: 4 },
+                palette: { order: 4 },
+                slash: {
+                    aliases: ["plan"],
+                    order: 4,
+                    arguments: {
+                        hint: "[clear]",
+                        words: [
+                            {
+                                word: "clear",
+                                description: "Clear the plan",
+                                arguments: { action: "clear" },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+    ]),
+    projection: {
+        schema: planContract.projection.schema,
+        read: (ctx, sessionId) => Option.map(ctx.state.plans.peek(sessionId), (row) => ({
+            plan: row.plan,
+            history: Option.getOrUndefined(ctx.state.history.peek(sessionId))?.history ??
+                emptyHistory(),
+        })),
+    },
+    prompt: (ctx, { sessionId }) => ctx.state.plans.get(sessionId).pipe(Effect.map((found) => [
+        {
+            name: "plan",
+            text: (ctx.config.guide +
+                "\n" +
+                (Option.isSome(found) && found.value.plan.steps.length > 0
+                    ? JSON.stringify(found.value.plan)
+                    : "No current plan.")).slice(0, ctx.config.promptLimit),
+        },
+    ])),
+    tools: (ctx, { sessionId, workId }) => Effect.succeed(Option.some(Mycelium.module({
+        id: "botanical.session-plan",
+        name: "plan",
+        description: "Session checklist planning tools.",
+        operations: {
+            update_plan: Mycelium.operation({
+                replay: "safe",
+                description: "Replace the Session plan checklist. At most one step in_progress; up to 50 steps; steps:[] clears the plan.",
+                input,
+                output: z.strictObject({
+                    completed: z.number(),
+                    total: z.number(),
+                }),
+                execute: (value) => Effect.runPromise(ctx.transact(Effect.gen(function* () {
+                    const plan = yield* Schema.decodeUnknownEffect(PlanInput)(value).pipe(Effect.mapError(() => new ExtensionCommandError({
+                        reason: "invalid",
+                        message: "Invalid plan: at most one in-progress step",
+                    })));
+                    yield* replacePlan(ctx, sessionId, plan, workId);
+                    return {
+                        completed: plan.steps.filter((step) => step.status === "completed").length,
+                        total: plan.steps.length,
+                    };
+                }))),
+            }),
+        },
+    }))),
+    commands: {
+        specs: planContract.commands,
+        handlers: (ctx) => ({
+            plan: ({ sessionId, input }) => Effect.gen(function* () {
+                const plan = Option.getOrUndefined(yield* ctx.state.plans.get(sessionId))?.plan;
+                if (plan === undefined || plan.steps.length === 0)
+                    return done({
+                        type: "info",
+                        message: "This Session has no plan.",
+                    });
+                if ("action" in input) {
+                    yield* replacePlan(ctx, sessionId, { steps: [] }, null);
+                    return done({ type: "success", message: "Plan cleared." });
+                }
+                // An open plan's footer row opens its checklist; a finished one is hidden.
+                return planIsOpen(plan)
+                    ? { type: "done" }
+                    : done({
+                        type: "info",
+                        message: `Plan complete: ${String(plan.steps.length)}/${String(plan.steps.length)} steps.`,
+                    });
+            }),
+        }),
+    },
+});

package/dist/question/client.d.ts

@@ -0,0 +1,10 @@
+import { type ClientContributionV1 } from "@fungi.computer/shiitake/client-entry";
+/** Pending decisions use the existing footer rows and advertised answer flow. */
+declare const _default: Readonly<{
+    protocol: "shiitake.client/v1";
+    id: import("@fungi.computer/shiitake/extensions").ExtensionId;
+    correlatedPrompts?: "note";
+    attach?: (context: import("@fungi.computer/shiitake/client-entry").ClientExtensionContextV1) => import("effect/Effect").Effect<void, Error, import("effect/Scope").Scope>;
+    contribute?: (slot: import("@fungi.computer/shiitake").ExtensionSlotV0 | undefined) => ClientContributionV1;
+}>;
+export default _default;

package/dist/question/client.js

@@ -0,0 +1,28 @@
+import { defineClientEntry, } from "@fungi.computer/shiitake/client-entry";
+import { questionContract } from "./contract.js";
+/** Pending decisions use the existing footer rows and advertised answer flow. */
+export default defineClientEntry(questionContract, {
+    contribute: (view) => ({
+        chips: [],
+        panel: view.status !== "running" || view.value === null
+            ? []
+            : view.value.asks.map((ask) => {
+                const first = ask.questions[0];
+                return {
+                    id: ask.askId,
+                    title: `${first?.question ?? "Question"}${ask.questions.length > 1 ? ` (+${String(ask.questions.length - 1)} more)` : ""}`,
+                    detail: first?.options.map((option) => option.label).join(" · ") ?? "",
+                    tone: "attention",
+                    actions: [
+                        {
+                            id: "answerFlow",
+                            label: "Answer",
+                            input: { askId: ask.askId },
+                        },
+                    ],
+                };
+            }),
+        timeline: { cells: [], omitted: 0 },
+        waiting: null,
+    }),
+});

package/dist/question/contract.d.ts

@@ -0,0 +1,251 @@
+import * as Schema from "effect/Schema";
+/** A decision question: first option is recommended, free text belongs to the host. */
+export declare const Question: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly header: Schema.String;
+    readonly question: Schema.String;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly description: Schema.String;
+    }>>;
+    readonly multiple: Schema.optionalKey<Schema.Boolean>;
+}>;
+export declare const Questions: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly header: Schema.String;
+    readonly question: Schema.String;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly description: Schema.String;
+    }>>;
+    readonly multiple: Schema.optionalKey<Schema.Boolean>;
+}>>;
+export type Question = Schema.Schema.Type<typeof Question>;
+/** The complete question data shared by ordinary Session clients. */
+export declare const OpenAsk: Schema.Struct<{
+    readonly askId: Schema.String;
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly header: Schema.String;
+        readonly question: Schema.String;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+        }>>;
+        readonly multiple: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly status: Schema.Literals<readonly ["live", "parked"]>;
+    readonly createdAt: Schema.Number;
+    readonly expiresAt: Schema.NullOr<Schema.Number>;
+}>;
+export type OpenAsk = Schema.Schema.Type<typeof OpenAsk>;
+export declare const AskProjection: Schema.Struct<{
+    readonly asks: Schema.$Array<Schema.Struct<{
+        readonly askId: Schema.String;
+        readonly questions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly header: Schema.String;
+            readonly question: Schema.String;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.String;
+                readonly description: Schema.String;
+            }>>;
+            readonly multiple: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+        readonly status: Schema.Literals<readonly ["live", "parked"]>;
+        readonly createdAt: Schema.Number;
+        readonly expiresAt: Schema.NullOr<Schema.Number>;
+    }>>;
+}>;
+/** Stable identity for a human command and its retry. */
+export declare const RequestId: Schema.String;
+export declare const Answers: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly selected: Schema.$Array<Schema.String>;
+    readonly text: Schema.optionalKey<Schema.String>;
+}>>;
+export type Answers = Schema.Schema.Type<typeof Answers>;
+export declare const AnswerInput: Schema.Struct<{
+    readonly askId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly selected: Schema.$Array<Schema.String>;
+        readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type AnswerInput = Schema.Schema.Type<typeof AnswerInput>;
+export declare const DeclineInput: Schema.Struct<{
+    readonly askId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly note: Schema.optionalKey<Schema.String>;
+}>;
+export type DeclineInput = Schema.Schema.Type<typeof DeclineInput>;
+/** Terminal question outcomes, shared by human replies and model withdrawal. */
+export declare const ClosedStatus: Schema.Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>;
+export declare const HumanResult: Schema.Union<readonly [Schema.Struct<{
+    readonly result: Schema.Literal<"accepted">;
+    readonly via: Schema.Literals<readonly ["in_turn", "follow_up"]>;
+}>, Schema.Struct<{
+    readonly result: Schema.Literal<"closed">;
+    readonly status: Schema.Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>;
+}>, Schema.Struct<{
+    readonly result: Schema.Literal<"not_found">;
+}>]>;
+export type HumanResult = Schema.Schema.Type<typeof HumanResult>;
+/** The ordinary /answer conversation carries its draft between typed steps. */
+export declare const AnswerFlowInput: Schema.Union<readonly [Schema.Struct<{
+    readonly selection: Schema.String;
+    readonly askId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly index: Schema.Number;
+    readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly selected: Schema.$Array<Schema.String>;
+        readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly stage: Schema.Literal<"multiple">;
+}>, Schema.Struct<{
+    readonly selection: Schema.String;
+    readonly askId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly index: Schema.Number;
+    readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly selected: Schema.$Array<Schema.String>;
+        readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly stage: Schema.Literal<"selection">;
+}>, Schema.Struct<{
+    readonly selected: Schema.$Array<Schema.String>;
+    readonly text: Schema.String;
+    readonly askId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly index: Schema.Number;
+    readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly selected: Schema.$Array<Schema.String>;
+        readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly stage: Schema.Literal<"text">;
+}>, Schema.Struct<{
+    readonly askId: Schema.String;
+}>, Schema.Struct<{}>]>;
+/** Human reads and the ordinary projection slot; model operations belong to the host. */
+export declare const questionContract: {
+    readonly id: string & import("effect/Brand").Brand<"ExtensionId">;
+    readonly commands: {
+        readonly answerFlow: {
+            readonly scope: "session";
+            readonly input: Schema.Union<readonly [Schema.Struct<{
+                readonly selection: Schema.String;
+                readonly askId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly index: Schema.Number;
+                readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly selected: Schema.$Array<Schema.String>;
+                    readonly text: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly stage: Schema.Literal<"multiple">;
+            }>, Schema.Struct<{
+                readonly selection: Schema.String;
+                readonly askId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly index: Schema.Number;
+                readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly selected: Schema.$Array<Schema.String>;
+                    readonly text: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly stage: Schema.Literal<"selection">;
+            }>, Schema.Struct<{
+                readonly selected: Schema.$Array<Schema.String>;
+                readonly text: Schema.String;
+                readonly askId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly index: Schema.Number;
+                readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly selected: Schema.$Array<Schema.String>;
+                    readonly text: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly stage: Schema.Literal<"text">;
+            }>, Schema.Struct<{
+                readonly askId: Schema.String;
+            }>, Schema.Struct<{}>]>;
+            readonly output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
+        };
+        readonly answer: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{
+                readonly askId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly selected: Schema.$Array<Schema.String>;
+                    readonly text: Schema.optionalKey<Schema.String>;
+                }>>;
+            }>;
+            readonly output: Schema.Union<readonly [Schema.Struct<{
+                readonly result: Schema.Literal<"accepted">;
+                readonly via: Schema.Literals<readonly ["in_turn", "follow_up"]>;
+            }>, Schema.Struct<{
+                readonly result: Schema.Literal<"closed">;
+                readonly status: Schema.Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>;
+            }>, Schema.Struct<{
+                readonly result: Schema.Literal<"not_found">;
+            }>]>;
+        };
+        readonly decline: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{
+                readonly askId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly note: Schema.optionalKey<Schema.String>;
+            }>;
+            readonly output: Schema.Union<readonly [Schema.Struct<{
+                readonly result: Schema.Literal<"accepted">;
+                readonly via: Schema.Literals<readonly ["in_turn", "follow_up"]>;
+            }>, Schema.Struct<{
+                readonly result: Schema.Literal<"closed">;
+                readonly status: Schema.Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>;
+            }>, Schema.Struct<{
+                readonly result: Schema.Literal<"not_found">;
+            }>]>;
+        };
+        readonly list: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{}>;
+            readonly output: Schema.Struct<{
+                readonly asks: Schema.$Array<Schema.Struct<{
+                    readonly askId: Schema.String;
+                    readonly questions: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly header: Schema.String;
+                        readonly question: Schema.String;
+                        readonly options: Schema.$Array<Schema.Struct<{
+                            readonly label: Schema.String;
+                            readonly description: Schema.String;
+                        }>>;
+                        readonly multiple: Schema.optionalKey<Schema.Boolean>;
+                    }>>;
+                    readonly status: Schema.Literals<readonly ["live", "parked"]>;
+                    readonly createdAt: Schema.Number;
+                    readonly expiresAt: Schema.NullOr<Schema.Number>;
+                }>>;
+            }>;
+        };
+    };
+    readonly projection: {
+        readonly schema: Schema.Struct<{
+            readonly asks: Schema.$Array<Schema.Struct<{
+                readonly askId: Schema.String;
+                readonly questions: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly header: Schema.String;
+                    readonly question: Schema.String;
+                    readonly options: Schema.$Array<Schema.Struct<{
+                        readonly label: Schema.String;
+                        readonly description: Schema.String;
+                    }>>;
+                    readonly multiple: Schema.optionalKey<Schema.Boolean>;
+                }>>;
+                readonly status: Schema.Literals<readonly ["live", "parked"]>;
+                readonly createdAt: Schema.Number;
+                readonly expiresAt: Schema.NullOr<Schema.Number>;
+            }>>;
+        }>;
+    };
+};