@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/client-entry.js

@@ -0,0 +1,101 @@
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { ExtensionId, } from "./extension-contract.js";
+import { viewExtension } from "./extension-client.js";
+import { invokeExtensionHook } from "./internal/extension-hook.js";
+import { rowIdentitySchemaV1, rowLabelSchemaV1, rowSchemaV1, } from "@fungi.computer/gills";
+export { viewExtension } from "./extension-client.js";
+const unsigned = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const sequence = Schema.Int.check(Schema.isGreaterThan(0));
+const objectArguments = Schema.Record(Schema.String, Schema.Json);
+// Extension commands belong to Shiitake; Gill rows only carry navigation.
+const commandAction = Schema.Struct({
+    id: rowIdentitySchemaV1,
+    label: rowLabelSchemaV1,
+    input: Schema.optional(objectArguments),
+});
+const commandRow = Schema.Struct({
+    ...rowSchemaV1.fields,
+    actions: Schema.optional(Schema.Array(commandAction).check(Schema.isMaxLength(8))),
+});
+const chipRow = rowSchemaV1.check(Schema.makeFilter((row) => row.open === undefined, {
+    message: "Client chips are display only",
+}));
+const panelRow = Schema.Struct({
+    ...commandRow.fields,
+    inspection: Schema.optionalKey(Schema.Struct({
+        commandId: rowIdentitySchemaV1,
+        title: rowLabelSchemaV1,
+        rows: Schema.Array(chipRow).check(Schema.isMaxLength(200)),
+    })),
+});
+/** One display-only status chip; order is local to the entry. */
+export const clientChipSchemaV1 = Schema.Struct({
+    id: rowIdentitySchemaV1,
+    order: Schema.Number.check(Schema.isFinite()),
+    row: chipRow,
+    compact: Schema.optional(rowLabelSchemaV1),
+});
+/** One committed presentation event anchored to its real command, if any. */
+export const clientTimelineCellSchemaV1 = Schema.Struct({
+    id: rowIdentitySchemaV1,
+    sequence,
+    at: unsigned,
+    commandId: Schema.NullOr(Schema.String),
+    rows: Schema.Array(commandRow).check(Schema.isMaxLength(200)),
+}).check(Schema.makeFilter((cell) => cell.id === String(cell.sequence), {
+    message: "Client event identity must equal its sequence",
+}));
+const unique = (ids) => new Set(ids).size === ids.length;
+/** Closed, bounded presentation data shared by every renderer. */
+export const clientContributionSchemaV1 = Schema.Struct({
+    chips: Schema.Array(clientChipSchemaV1).check(Schema.isMaxLength(4)),
+    panel: Schema.Array(panelRow).check(Schema.isMaxLength(16)),
+    timeline: Schema.Struct({
+        cells: Schema.Array(clientTimelineCellSchemaV1).check(Schema.isMaxLength(32)),
+        omitted: unsigned,
+    }),
+    waiting: Schema.NullOr(Schema.Struct({ summary: rowLabelSchemaV1, cancel: commandAction })),
+}).check(Schema.makeFilter((value) => value.chips.length +
+    value.panel.reduce((count, row) => count + 1 + (row.inspection?.rows.length ?? 0), 0) +
+    value.timeline.cells.reduce((count, cell) => count + cell.rows.length, 0) <=
+    200, { message: "Client contribution exceeds 200 rows" }), Schema.makeFilter((value) => unique(value.chips.map((chip) => chip.id)) &&
+    unique(value.panel.map((row) => row.id)) &&
+    value.panel.every((row) => unique((row.inspection?.rows ?? []).map((child) => child.id))) &&
+    unique(value.timeline.cells.map((cell) => cell.id)) &&
+    value.timeline.cells.every((cell) => unique(cell.rows.map((row) => row.id))), { message: "Client contribution contains duplicate identities" }));
+const entrySchema = Schema.Struct({
+    protocol: Schema.Literal("shiitake.client/v1"),
+    id: ExtensionId,
+    correlatedPrompts: Schema.optionalKey(Schema.Literal("note")),
+    attach: Schema.optionalKey(Schema.declare((value) => Predicate.isFunction(value))),
+    contribute: Schema.optionalKey(Schema.declare((value) => Predicate.isFunction(value))),
+}).check(Schema.makeFilter((entry) => entry.attach !== undefined || entry.contribute !== undefined, { message: "Client entry requires attach or contribute" }));
+const decodeEntry = Schema.decodeUnknownSync(entrySchema, {
+    onExcessProperty: "error",
+});
+/** Admit exactly V1; installed executable code is not sandboxed. */
+export const parseClientEntryV1 = decodeEntry;
+/** One typed author seam, usable with ordinary async attachment code. */
+export function defineClientEntry(contract, client) {
+    if (client.contribute !== undefined && contract.projection === null)
+        throw new Error("Client contribution requires a projection");
+    const entry = {
+        protocol: "shiitake.client/v1",
+        id: contract.id,
+    };
+    if (client.correlatedPrompts !== undefined)
+        Object.assign(entry, { correlatedPrompts: client.correlatedPrompts });
+    const attach = client.attach;
+    const contribute = client.contribute;
+    if (attach !== undefined)
+        Object.assign(entry, {
+            attach: (context) => invokeExtensionHook(() => attach(context)),
+        });
+    if (contribute !== undefined)
+        Object.assign(entry, {
+            contribute: (slot) => contribute(viewExtension(contract, slot)),
+        });
+    return Object.freeze(parseClientEntryV1(entry));
+}

package/dist/client-wire.d.ts

@@ -0,0 +1,199 @@
+import * as Schema from "effect/Schema";
+import type { Accepted, CancelResult, ForkedSession, SessionFrame, SessionSnapshot, SessionSummaryPage, SessionTerminal } from "./client.js";
+import { ShiitakeError } from "./errors.js";
+import type { ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
+/** Existing terminal wire grammar, shared by exact host settlement facts. */
+export declare const SessionTerminalSchema: Schema.Codec<SessionTerminal>;
+export declare const SessionSnapshotSchema: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly cursor: Schema.NullOr<Schema.String>;
+    readonly hasMore: Schema.Boolean;
+    readonly oldestCursor: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly messages: Schema.$Array<Schema.Codec<Readonly<{
+        meta?: Json;
+        origin?: Readonly<{
+            extensionId: string;
+            correlation: string | null;
+        }>;
+        id: string;
+        sequence: number;
+        commandId: string | null;
+        value: import("@earendil-works/pi-ai").Message;
+    }>, Readonly<{
+        meta?: Json;
+        origin?: Readonly<{
+            extensionId: string;
+            correlation: string | null;
+        }>;
+        id: string;
+        sequence: number;
+        commandId: string | null;
+        value: import("@earendil-works/pi-ai").Message;
+    }>, never, never>>;
+    readonly terminals: Schema.$Array<Schema.Codec<Readonly<{
+        commandId: string;
+        outcome: "completed" | "cancelled" | "failed" | "interrupted";
+        sequence: number;
+        diagnostic: string | null;
+        meta?: Json;
+    }>, Readonly<{
+        commandId: string;
+        outcome: "completed" | "cancelled" | "failed" | "interrupted";
+        sequence: number;
+        diagnostic: string | null;
+        meta?: Json;
+    }>, never, never>>;
+    readonly sandboxFailures: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"sandbox_failure">;
+        readonly ref: Schema.String;
+        readonly executionId: Schema.String;
+        readonly adapter: Schema.String;
+        readonly buildSha: Schema.NullOr<Schema.String>;
+        readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<import("zod").JSONType, import("zod").JSONType, never, never>>;
+        readonly healthAlert: Schema.Boolean;
+    }>>>;
+    readonly compactions: Schema.optionalKey<Schema.$Array<Schema.Codec<Readonly<{
+        id: string;
+        sequence: number;
+        at: number;
+        tokensBefore: number;
+        tokensAfter: number | null;
+        trigger: import("./client.js").SessionCompactionTrigger | null;
+    }>, Readonly<{
+        id: string;
+        sequence: number;
+        at: number;
+        tokensBefore: number;
+        tokensAfter: number | null;
+        trigger: import("./client.js").SessionCompactionTrigger | null;
+    }>, never, never>>>;
+    readonly compactionNotices: Schema.optionalKey<Schema.$Array<Schema.Codec<Readonly<{
+        id: string;
+        sequence: number;
+        at: number;
+        trigger: import("./client.js").SessionCompactionTrigger;
+        result: "nothing_to_compact" | "failed";
+        diagnostic: string | null;
+    }>, Readonly<{
+        id: string;
+        sequence: number;
+        at: number;
+        trigger: import("./client.js").SessionCompactionTrigger;
+        result: "nothing_to_compact" | "failed";
+        diagnostic: string | null;
+    }>, never, never>>>;
+    readonly pending: Schema.Codec<Readonly<{
+        total: number;
+        prompts: readonly import("./client.js").SessionPendingPrompt[];
+        hasMore: boolean;
+    }>, Readonly<{
+        total: number;
+        prompts: readonly import("./client.js").SessionPendingPrompt[];
+        hasMore: boolean;
+    }>, never, never>;
+    readonly activity: Schema.Codec<Readonly<{
+        queue: Readonly<{
+            state: "idle";
+        }> | Readonly<{
+            state: "queued";
+            commandId: string;
+            runningWork: import("./client.js").AgentRunningWork | null;
+        }> | Readonly<{
+            state: "running";
+            commandId: string;
+        }>;
+        cancellationRequested: boolean;
+        retry: Readonly<{
+            attempt: number;
+            maxAttempts: number;
+            delayMs: number;
+            errorMessage: string;
+            scheduledAt: number;
+        }> | null;
+        activeTool: string | null;
+        lastModelChoiceSequence: number | null;
+        compaction: Readonly<{
+            trigger: import("./client.js").SessionCompactionTrigger;
+        }> | null;
+    }>, Readonly<{
+        queue: Readonly<{
+            state: "idle";
+        }> | Readonly<{
+            state: "queued";
+            commandId: string;
+            runningWork: import("./client.js").AgentRunningWork | null;
+        }> | Readonly<{
+            state: "running";
+            commandId: string;
+        }>;
+        cancellationRequested: boolean;
+        retry: Readonly<{
+            attempt: number;
+            maxAttempts: number;
+            delayMs: number;
+            errorMessage: string;
+            scheduledAt: number;
+        }> | null;
+        activeTool: string | null;
+        lastModelChoiceSequence: number | null;
+        compaction: Readonly<{
+            trigger: import("./client.js").SessionCompactionTrigger;
+        }> | null;
+    }>, never, never>;
+    readonly progress: Schema.NullOr<Schema.Codec<Readonly<{
+        messageId: string;
+        revision: number;
+        text: string;
+        thinking: string;
+        textTruncated: boolean;
+        thinkingTruncated: boolean;
+    }>, Readonly<{
+        messageId: string;
+        revision: number;
+        text: string;
+        thinking: string;
+        textTruncated: boolean;
+        thinkingTruncated: boolean;
+    }>, never, never>>;
+    readonly extensions: Schema.$Record<Schema.String, Schema.Codec<ExtensionSlotV0, ExtensionSlotV0, never, never>>;
+    readonly attention: Schema.$Array<Schema.Struct<{
+        readonly extensionId: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+        readonly kind: Schema.NonEmptyString;
+        readonly summary: Schema.NonEmptyString;
+        readonly since: Schema.Int;
+        readonly expiresAt: Schema.optional<Schema.Int>;
+    }>>;
+    readonly context: Schema.optionalKey<Schema.Struct<{
+        readonly tokens: Schema.Int;
+        readonly window: Schema.NullOr<Schema.Int>;
+    }>>;
+}>;
+export declare const SessionFrameSchema: Schema.Codec<SessionFrame>;
+/** Decode a durable command acceptance value at an RPC boundary. */
+export declare const AcceptedSchema: Schema.Codec<Accepted>;
+/** Parse one serialized extension status. */
+export declare function parseExtensionStatus(value: string): ExtensionStatusV0;
+/** Parse the serialized list of rostered extension statuses. */
+export declare function parseExtensionStatuses(value: string): readonly ExtensionStatusV0[];
+/** Parse one encoded extension command output; its contract decodes it. */
+export declare function parseExtensionOutput(value: string): Json;
+/** Parse one serialized command acceptance using Shiitake's public grammar. */
+export declare function parseAccepted(value: string): Accepted;
+/** Parse one serialized cancel outcome: accepted, or too late. */
+export declare function parseCancelResult(value: string): CancelResult;
+/** Parse one serialized fork result using Shiitake's public client grammar. */
+export declare function parseForkedSession(value: string): ForkedSession;
+/** Parse one serialized snapshot using Shiitake's public client grammar. */
+export declare function parseSessionSnapshot(value: string): SessionSnapshot;
+/** Parse one serialized frame using Shiitake's public client grammar. */
+export declare function parseSessionFrame(value: string): SessionFrame;
+/** Parse one serialized canonical Shiitake failure. */
+export declare function parseShiitakeError(value: string): ShiitakeError;
+/** Decode the existing bounded saved-conversation projection. */
+export declare function parseSessionSummaryPage(value: string): SessionSummaryPage;
+/** Decode whether the owner deleted an existing Session. */
+export declare function parseDeletedSession(value: string): boolean;
+/** Decode the fresh identity issued by the Agent owner. */
+export declare function parseCreatedSession(value: string): string;

package/dist/client-wire.js

@@ -0,0 +1,271 @@
+import { SessionAttentionListSchema } from "./session-attention.js";
+import { PromptImageSchema } from "./internal/client-boundary.js";
+import { SandboxFailureEventSchema } from "@fungi.computer/mycelium";
+import * as Schema from "effect/Schema";
+import { ShiitakeError, ShiitakeErrorWireSchema } from "./errors.js";
+import { JsonValueSchema } from "./internal/json-value.js";
+import { StoredPiMessageSchema, ExtensionAdmissionOriginSchema, } from "./internal/woodstock/index.js";
+const ExtensionOriginSchema = ExtensionAdmissionOriginSchema.mapFields(({ extensionId, correlation }) => ({ extensionId, correlation }));
+const SessionMessageSchema = Schema.Struct({
+    meta: Schema.optionalKey(JsonValueSchema),
+    origin: Schema.optionalKey(ExtensionOriginSchema),
+    id: Schema.String,
+    sequence: Schema.Int.check(Schema.isGreaterThan(0)),
+    commandId: Schema.NullOr(Schema.String),
+    value: StoredPiMessageSchema,
+});
+const SessionCompactionTriggerSchema = Schema.Literals([
+    "manual",
+    "threshold",
+    "overflow",
+]);
+const SessionActivitySchema = Schema.Struct({
+    queue: Schema.Union([
+        Schema.Struct({ state: Schema.Literal("idle") }),
+        Schema.Struct({
+            state: Schema.Literal("queued"),
+            commandId: Schema.NonEmptyString,
+            runningWork: Schema.NullOr(Schema.Union([
+                Schema.Struct({
+                    kind: Schema.Literal("session"),
+                    sessionId: Schema.NonEmptyString,
+                    commandId: Schema.NonEmptyString,
+                }),
+                Schema.Struct({
+                    kind: Schema.Literal("host"),
+                    lane: Schema.NonEmptyString,
+                    jobId: Schema.NonEmptyString,
+                }),
+            ])),
+        }),
+        Schema.Struct({
+            state: Schema.Literal("running"),
+            commandId: Schema.NonEmptyString,
+        }),
+    ]),
+    cancellationRequested: Schema.Boolean,
+    retry: Schema.NullOr(Schema.Struct({
+        attempt: Schema.Int.check(Schema.isGreaterThan(0)),
+        maxAttempts: Schema.Int.check(Schema.isGreaterThan(0)),
+        delayMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        errorMessage: Schema.String,
+        scheduledAt: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    })),
+    activeTool: Schema.NullOr(Schema.String),
+    lastModelChoiceSequence: Schema.NullOr(Schema.Int.check(Schema.isGreaterThan(0))),
+    compaction: Schema.NullOr(Schema.Struct({ trigger: SessionCompactionTriggerSchema })),
+});
+const ExtensionRevisionSchema = Schema.String;
+const ExtensionSlotSchema = Schema.Union([
+    Schema.Struct({
+        status: Schema.Literal("running"),
+        revision: ExtensionRevisionSchema,
+        value: JsonValueSchema,
+        catalog: Schema.optionalKey(JsonValueSchema),
+    }),
+    Schema.Struct({
+        status: Schema.Literal("stopped"),
+        revision: ExtensionRevisionSchema,
+        reason: Schema.String,
+    }),
+]);
+const ExtensionSlotsSchema = Schema.Record(Schema.String, ExtensionSlotSchema);
+const ExtensionStatusSchema = Schema.Struct({
+    id: Schema.String,
+    version: Schema.String,
+    revision: ExtensionRevisionSchema,
+    status: Schema.Literals(["running", "stopped"]),
+    reason: Schema.NullOr(Schema.String),
+    stoppedAt: Schema.NullOr(Schema.Number),
+});
+/** Existing terminal wire grammar, shared by exact host settlement facts. */
+export const SessionTerminalSchema = Schema.Struct({
+    commandId: Schema.String,
+    outcome: Schema.Literals([
+        "completed",
+        "cancelled",
+        "failed",
+        "interrupted",
+    ]),
+    sequence: Schema.Int.check(Schema.isGreaterThan(0)),
+    diagnostic: Schema.NullOr(Schema.String),
+    meta: Schema.optionalKey(JsonValueSchema),
+});
+const SessionCompactionMarkerSchema = Schema.Struct({
+    id: Schema.String,
+    sequence: Schema.Int.check(Schema.isGreaterThan(0)),
+    at: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    tokensBefore: Schema.Number,
+    tokensAfter: Schema.NullOr(Schema.Number),
+    trigger: Schema.NullOr(SessionCompactionTriggerSchema),
+});
+const SessionCompactionNoticeSchema = Schema.Struct({
+    id: Schema.String,
+    sequence: Schema.Int.check(Schema.isGreaterThan(0)),
+    at: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    trigger: SessionCompactionTriggerSchema,
+    result: Schema.Literals(["nothing_to_compact", "failed"]),
+    diagnostic: Schema.NullOr(Schema.String),
+});
+const SessionProgressSchema = Schema.Struct({
+    messageId: Schema.String,
+    revision: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    text: Schema.String,
+    thinking: Schema.String,
+    textTruncated: Schema.Boolean,
+    thinkingTruncated: Schema.Boolean,
+});
+const SessionPendingPromptsSchema = Schema.Struct({
+    total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    prompts: Schema.Array(Schema.Struct({
+        commandId: Schema.String,
+        meta: Schema.optionalKey(JsonValueSchema),
+        origin: Schema.optionalKey(ExtensionOriginSchema),
+        text: Schema.String,
+        images: Schema.optionalKey(Schema.Array(PromptImageSchema)),
+        delivery: Schema.Literals(["steer", "followUp"]),
+    })),
+    hasMore: Schema.Boolean,
+});
+const SessionContextSchema = Schema.Struct({
+    tokens: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    window: Schema.NullOr(Schema.Int.check(Schema.isGreaterThan(0))),
+});
+export const SessionSnapshotSchema = Schema.Struct({
+    sessionId: Schema.String,
+    cursor: Schema.NullOr(Schema.String),
+    hasMore: Schema.Boolean,
+    oldestCursor: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    messages: Schema.Array(SessionMessageSchema),
+    terminals: Schema.Array(SessionTerminalSchema),
+    sandboxFailures: Schema.optionalKey(Schema.Array(SandboxFailureEventSchema)),
+    compactions: Schema.optionalKey(Schema.Array(SessionCompactionMarkerSchema)),
+    compactionNotices: Schema.optionalKey(Schema.Array(SessionCompactionNoticeSchema)),
+    pending: SessionPendingPromptsSchema,
+    activity: SessionActivitySchema,
+    progress: Schema.NullOr(SessionProgressSchema),
+    extensions: ExtensionSlotsSchema,
+    attention: SessionAttentionListSchema,
+    context: Schema.optionalKey(SessionContextSchema),
+});
+export const SessionFrameSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("update"),
+        delivery: Schema.Literals(["replay", "live"]),
+        cursor: Schema.NullOr(Schema.String),
+        messages: Schema.Array(SessionMessageSchema),
+        terminals: Schema.Array(SessionTerminalSchema),
+        sandboxFailures: Schema.optionalKey(Schema.Array(SandboxFailureEventSchema)),
+        compactions: Schema.optionalKey(Schema.Array(SessionCompactionMarkerSchema)),
+        compactionNotices: Schema.optionalKey(Schema.Array(SessionCompactionNoticeSchema)),
+        pending: SessionPendingPromptsSchema,
+        activity: SessionActivitySchema,
+        extensions: ExtensionSlotsSchema,
+        attention: SessionAttentionListSchema,
+        context: Schema.optionalKey(SessionContextSchema),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("progress"),
+        progress: SessionProgressSchema,
+        activity: SessionActivitySchema,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("reset"),
+        reason: Schema.Literal("history_unavailable"),
+        cursor: Schema.NullOr(Schema.String),
+        baseline: SessionSnapshotSchema,
+    }),
+]);
+/** Decode a durable command acceptance value at an RPC boundary. */
+export const AcceptedSchema = Schema.Struct({
+    status: Schema.Literal("accepted"),
+    commandId: Schema.String,
+});
+const CancelResultSchema = Schema.Union([
+    AcceptedSchema,
+    Schema.Struct({
+        status: Schema.Literal("too_late"),
+        commandId: Schema.String,
+    }),
+]);
+const ForkedSessionSchema = Schema.Struct({
+    sessionId: Schema.String,
+});
+const decodeSnapshot = Schema.decodeUnknownSync(Schema.fromJsonString(SessionSnapshotSchema), { onExcessProperty: "error" });
+const decodeFrame = Schema.decodeUnknownSync(Schema.fromJsonString(SessionFrameSchema), { onExcessProperty: "error" });
+const decodeAccepted = Schema.decodeUnknownSync(Schema.fromJsonString(AcceptedSchema));
+const decodeCancelResult = Schema.decodeUnknownSync(Schema.fromJsonString(CancelResultSchema));
+const decodeForkedSession = Schema.decodeUnknownSync(Schema.fromJsonString(ForkedSessionSchema));
+const decodeError = Schema.decodeUnknownSync(Schema.fromJsonString(ShiitakeErrorWireSchema));
+const decodeExtensionStatus = Schema.decodeUnknownSync(Schema.fromJsonString(ExtensionStatusSchema));
+const decodeExtensionStatuses = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Array(ExtensionStatusSchema)));
+const decodeJsonValue = Schema.decodeUnknownSync(Schema.fromJsonString(JsonValueSchema));
+/** Parse one serialized extension status. */
+export function parseExtensionStatus(value) {
+    return decodeExtensionStatus(value);
+}
+/** Parse the serialized list of rostered extension statuses. */
+export function parseExtensionStatuses(value) {
+    return decodeExtensionStatuses(value);
+}
+/** Parse one encoded extension command output; its contract decodes it. */
+export function parseExtensionOutput(value) {
+    return decodeJsonValue(value);
+}
+/** Parse one serialized command acceptance using Shiitake's public grammar. */
+export function parseAccepted(value) {
+    return decodeAccepted(value);
+}
+/** Parse one serialized cancel outcome: accepted, or too late. */
+export function parseCancelResult(value) {
+    return decodeCancelResult(value);
+}
+/** Parse one serialized fork result using Shiitake's public client grammar. */
+export function parseForkedSession(value) {
+    return decodeForkedSession(value);
+}
+/** Parse one serialized snapshot using Shiitake's public client grammar. */
+export function parseSessionSnapshot(value) {
+    return decodeSnapshot(value);
+}
+/** Parse one serialized frame using Shiitake's public client grammar. */
+export function parseSessionFrame(value) {
+    return decodeFrame(value);
+}
+/** Parse one serialized canonical Shiitake failure. */
+export function parseShiitakeError(value) {
+    const failure = decodeError(value);
+    return new ShiitakeError(failure.boundary, failure.cause, failure.message, failure.requestId);
+}
+const decodeSessionSummaryPage = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Struct({
+    sessions: Schema.Array(Schema.Union([
+        Schema.Struct({
+            sessionId: Schema.NonEmptyString,
+            createdAt: Schema.Number,
+            lastActivityAt: Schema.Number,
+            settledAt: Schema.optionalKey(Schema.Number),
+            title: Schema.String,
+            state: Schema.Literals(["needs_you", "running", "errored", "done"]),
+        }),
+        Schema.Struct({
+            sessionId: Schema.NonEmptyString,
+            state: Schema.Literal("unavailable"),
+        }),
+    ])),
+    next: Schema.optional(Schema.NonEmptyString),
+})));
+/** Decode the existing bounded saved-conversation projection. */
+export function parseSessionSummaryPage(value) {
+    const page = decodeSessionSummaryPage(value);
+    return { sessions: page.sessions, next: page.next };
+}
+const decodeCreatedSession = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Struct({ sessionId: Schema.NonEmptyString })));
+const decodeDeletedSession = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Struct({ deleted: Schema.Boolean })));
+/** Decode whether the owner deleted an existing Session. */
+export function parseDeletedSession(value) {
+    return decodeDeletedSession(value).deleted;
+}
+/** Decode the fresh identity issued by the Agent owner. */
+export function parseCreatedSession(value) {
+    return decodeCreatedSession(value).sessionId;
+}