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

package/dist/loop/contract.d.ts

@@ -0,0 +1,342 @@
+import * as Schema from "effect/Schema";
+/** A named cron cadence evaluated in one IANA time zone. */
+export declare const LoopCron: Schema.Struct<{
+    readonly expression: Schema.String;
+    readonly timeZone: Schema.String;
+}>;
+/** One Session's loop as every client sees it. */
+export declare const Loop: Schema.Struct<{
+    readonly loopId: Schema.String;
+    readonly origin: Schema.Literals<readonly ["human", "model"]>;
+    readonly expiresAt: Schema.NullOr<Schema.Int>;
+    /** Original instruction repeated for every occurrence. */
+    readonly prompt: Schema.String;
+    readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+    /** Cadence of a fixed-interval loop; null when the model paces it. */
+    readonly cron: Schema.NullOr<Schema.Struct<{
+        readonly expression: Schema.String;
+        readonly timeZone: Schema.String;
+    }>>;
+    readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+    /** Latest accepted command associated with this loop. */
+    readonly commandId: Schema.String;
+    /** The model's stated reason for the next self-paced occurrence. */
+    readonly reason: Schema.NullOr<Schema.String>;
+    /** When the next occurrence is due, if one is scheduled. */
+    readonly nextDueAt: Schema.NullOr<Schema.Int>;
+    /** Visible explanation when loop work failed. */
+    readonly lastError: Schema.NullOr<Schema.String>;
+}>;
+/** One Session's loop. */
+export type Loop = Schema.Schema.Type<typeof Loop>;
+/**
+ * Arguments of the human `/loop` command. `start` carries the typed text:
+ * `<prompt>` paces itself, `<N>m <prompt>` or `<N>h <prompt>` runs on an
+ * interval. A bare call opens the controls.
+ */
+export declare const LoopCommandInput: Schema.Union<readonly [Schema.Struct<{
+    readonly action: Schema.Literal<"start">;
+    readonly text: Schema.String;
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "new"]>;
+}>, Schema.Struct<{}>]>;
+/** Loop's contract: Session-scope controls and one projection slot. */
+export declare const LoopProjection: Schema.Struct<{
+    readonly loop: Schema.NullOr<Schema.Struct<{
+        readonly loopId: Schema.String;
+        readonly origin: Schema.Literals<readonly ["human", "model"]>;
+        readonly expiresAt: Schema.NullOr<Schema.Int>;
+        /** Original instruction repeated for every occurrence. */
+        readonly prompt: Schema.String;
+        readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+        /** Cadence of a fixed-interval loop; null when the model paces it. */
+        readonly cron: Schema.NullOr<Schema.Struct<{
+            readonly expression: Schema.String;
+            readonly timeZone: Schema.String;
+        }>>;
+        readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+        /** Latest accepted command associated with this loop. */
+        readonly commandId: Schema.String;
+        /** The model's stated reason for the next self-paced occurrence. */
+        readonly reason: Schema.NullOr<Schema.String>;
+        /** When the next occurrence is due, if one is scheduled. */
+        readonly nextDueAt: Schema.NullOr<Schema.Int>;
+        /** Visible explanation when loop work failed. */
+        readonly lastError: Schema.NullOr<Schema.String>;
+    }>>;
+    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 loopId: string;
+                readonly origin: "human" | "model";
+                readonly expiresAt: number | null;
+                readonly prompt: string;
+                readonly mode: "self_paced" | "fixed_interval";
+                readonly cron: {
+                    readonly expression: string;
+                    readonly timeZone: string;
+                } | null;
+                readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
+                readonly commandId: string;
+                readonly reason: string | null;
+                readonly nextDueAt: number | null;
+                readonly lastError: string | null;
+            }, {
+                readonly loopId: string;
+                readonly origin: "human" | "model";
+                readonly expiresAt: number | null;
+                readonly prompt: string;
+                readonly mode: "self_paced" | "fixed_interval";
+                readonly cron: {
+                    readonly expression: string;
+                    readonly timeZone: string;
+                } | null;
+                readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
+                readonly commandId: string;
+                readonly reason: string | null;
+                readonly nextDueAt: number | null;
+                readonly lastError: string | null;
+            }, never, never>;
+        }>>;
+    }>;
+}>;
+export declare const loopContract: {
+    readonly id: string & import("effect/Brand").Brand<"ExtensionId">;
+    readonly commands: {
+        readonly loop: {
+            readonly scope: "session";
+            readonly input: Schema.Union<readonly [Schema.Struct<{
+                readonly action: Schema.Literal<"start">;
+                readonly text: Schema.String;
+                readonly requestId: Schema.String;
+            }>, Schema.Struct<{
+                readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "new"]>;
+            }>, Schema.Struct<{}>]>;
+            readonly output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
+        };
+        readonly startSelfPaced: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{
+                readonly prompt: Schema.String;
+                readonly requestId: Schema.String;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly loop: Schema.Struct<{
+                    readonly loopId: Schema.String;
+                    readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                    readonly expiresAt: Schema.NullOr<Schema.Int>;
+                    /** Original instruction repeated for every occurrence. */
+                    readonly prompt: Schema.String;
+                    readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+                    /** Cadence of a fixed-interval loop; null when the model paces it. */
+                    readonly cron: Schema.NullOr<Schema.Struct<{
+                        readonly expression: Schema.String;
+                        readonly timeZone: Schema.String;
+                    }>>;
+                    readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+                    /** Latest accepted command associated with this loop. */
+                    readonly commandId: Schema.String;
+                    /** The model's stated reason for the next self-paced occurrence. */
+                    readonly reason: Schema.NullOr<Schema.String>;
+                    /** When the next occurrence is due, if one is scheduled. */
+                    readonly nextDueAt: Schema.NullOr<Schema.Int>;
+                    /** Visible explanation when loop work failed. */
+                    readonly lastError: Schema.NullOr<Schema.String>;
+                }>;
+                readonly accepted: Schema.Struct<{
+                    readonly status: Schema.Literal<"accepted">;
+                    readonly commandId: Schema.String;
+                }>;
+            }>;
+        };
+        readonly startFixedInterval: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+                readonly prompt: Schema.String;
+                readonly requestId: Schema.String;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly loop: Schema.Struct<{
+                    readonly loopId: Schema.String;
+                    readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                    readonly expiresAt: Schema.NullOr<Schema.Int>;
+                    /** Original instruction repeated for every occurrence. */
+                    readonly prompt: Schema.String;
+                    readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+                    /** Cadence of a fixed-interval loop; null when the model paces it. */
+                    readonly cron: Schema.NullOr<Schema.Struct<{
+                        readonly expression: Schema.String;
+                        readonly timeZone: Schema.String;
+                    }>>;
+                    readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+                    /** Latest accepted command associated with this loop. */
+                    readonly commandId: Schema.String;
+                    /** The model's stated reason for the next self-paced occurrence. */
+                    readonly reason: Schema.NullOr<Schema.String>;
+                    /** When the next occurrence is due, if one is scheduled. */
+                    readonly nextDueAt: Schema.NullOr<Schema.Int>;
+                    /** Visible explanation when loop work failed. */
+                    readonly lastError: Schema.NullOr<Schema.String>;
+                }>;
+                readonly accepted: Schema.Struct<{
+                    readonly status: Schema.Literal<"accepted">;
+                    readonly commandId: Schema.String;
+                }>;
+            }>;
+        };
+        readonly pause: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{}>;
+            readonly output: Schema.Struct<{
+                readonly loopId: Schema.String;
+                readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                readonly expiresAt: Schema.NullOr<Schema.Int>;
+                /** Original instruction repeated for every occurrence. */
+                readonly prompt: Schema.String;
+                readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+                /** Cadence of a fixed-interval loop; null when the model paces it. */
+                readonly cron: Schema.NullOr<Schema.Struct<{
+                    readonly expression: Schema.String;
+                    readonly timeZone: Schema.String;
+                }>>;
+                readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+                /** Latest accepted command associated with this loop. */
+                readonly commandId: Schema.String;
+                /** The model's stated reason for the next self-paced occurrence. */
+                readonly reason: Schema.NullOr<Schema.String>;
+                /** When the next occurrence is due, if one is scheduled. */
+                readonly nextDueAt: Schema.NullOr<Schema.Int>;
+                /** Visible explanation when loop work failed. */
+                readonly lastError: Schema.NullOr<Schema.String>;
+            }>;
+        };
+        readonly resume: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{}>;
+            readonly output: Schema.Struct<{
+                readonly loopId: Schema.String;
+                readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                readonly expiresAt: Schema.NullOr<Schema.Int>;
+                /** Original instruction repeated for every occurrence. */
+                readonly prompt: Schema.String;
+                readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+                /** Cadence of a fixed-interval loop; null when the model paces it. */
+                readonly cron: Schema.NullOr<Schema.Struct<{
+                    readonly expression: Schema.String;
+                    readonly timeZone: Schema.String;
+                }>>;
+                readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+                /** Latest accepted command associated with this loop. */
+                readonly commandId: Schema.String;
+                /** The model's stated reason for the next self-paced occurrence. */
+                readonly reason: Schema.NullOr<Schema.String>;
+                /** When the next occurrence is due, if one is scheduled. */
+                readonly nextDueAt: Schema.NullOr<Schema.Int>;
+                /** Visible explanation when loop work failed. */
+                readonly lastError: Schema.NullOr<Schema.String>;
+            }>;
+        };
+        readonly stop: {
+            readonly scope: "session";
+            readonly input: Schema.Struct<{}>;
+            readonly output: Schema.Struct<{
+                readonly loopId: Schema.String;
+                readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                readonly expiresAt: Schema.NullOr<Schema.Int>;
+                /** Original instruction repeated for every occurrence. */
+                readonly prompt: Schema.String;
+                readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+                /** Cadence of a fixed-interval loop; null when the model paces it. */
+                readonly cron: Schema.NullOr<Schema.Struct<{
+                    readonly expression: Schema.String;
+                    readonly timeZone: Schema.String;
+                }>>;
+                readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+                /** Latest accepted command associated with this loop. */
+                readonly commandId: Schema.String;
+                /** The model's stated reason for the next self-paced occurrence. */
+                readonly reason: Schema.NullOr<Schema.String>;
+                /** When the next occurrence is due, if one is scheduled. */
+                readonly nextDueAt: Schema.NullOr<Schema.Int>;
+                /** Visible explanation when loop work failed. */
+                readonly lastError: Schema.NullOr<Schema.String>;
+            }>;
+        };
+    };
+    readonly projection: {
+        readonly schema: Schema.Struct<{
+            readonly loop: Schema.NullOr<Schema.Struct<{
+                readonly loopId: Schema.String;
+                readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                readonly expiresAt: Schema.NullOr<Schema.Int>;
+                /** Original instruction repeated for every occurrence. */
+                readonly prompt: Schema.String;
+                readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+                /** Cadence of a fixed-interval loop; null when the model paces it. */
+                readonly cron: Schema.NullOr<Schema.Struct<{
+                    readonly expression: Schema.String;
+                    readonly timeZone: Schema.String;
+                }>>;
+                readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+                /** Latest accepted command associated with this loop. */
+                readonly commandId: Schema.String;
+                /** The model's stated reason for the next self-paced occurrence. */
+                readonly reason: Schema.NullOr<Schema.String>;
+                /** When the next occurrence is due, if one is scheduled. */
+                readonly nextDueAt: Schema.NullOr<Schema.Int>;
+                /** Visible explanation when loop work failed. */
+                readonly lastError: Schema.NullOr<Schema.String>;
+            }>>;
+            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 loopId: string;
+                        readonly origin: "human" | "model";
+                        readonly expiresAt: number | null;
+                        readonly prompt: string;
+                        readonly mode: "self_paced" | "fixed_interval";
+                        readonly cron: {
+                            readonly expression: string;
+                            readonly timeZone: string;
+                        } | null;
+                        readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
+                        readonly commandId: string;
+                        readonly reason: string | null;
+                        readonly nextDueAt: number | null;
+                        readonly lastError: string | null;
+                    }, {
+                        readonly loopId: string;
+                        readonly origin: "human" | "model";
+                        readonly expiresAt: number | null;
+                        readonly prompt: string;
+                        readonly mode: "self_paced" | "fixed_interval";
+                        readonly cron: {
+                            readonly expression: string;
+                            readonly timeZone: string;
+                        } | null;
+                        readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
+                        readonly commandId: string;
+                        readonly reason: string | null;
+                        readonly nextDueAt: number | null;
+                        readonly lastError: string | null;
+                    }, never, never>;
+                }>>;
+            }>;
+        }>;
+    };
+};

package/dist/loop/contract.js

@@ -0,0 +1,94 @@
+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";
+/**
+ * Session loop: one repeated prompt per Session, either paced by the model
+ * (`schedule_next`) or by a fixed cron cadence. Shared by the server
+ * extension and every client; its schemas are the one decoder.
+ */
+const Prompt = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256 * 1024)));
+const RequestId = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(200)));
+/** A named cron cadence evaluated in one IANA time zone. */
+export const LoopCron = Schema.Struct({
+    expression: Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256))),
+    timeZone: Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(128))),
+});
+/** One Session's loop as every client sees it. */
+export const Loop = Schema.Struct({
+    loopId: Schema.String,
+    origin: Schema.Literals(["human", "model"]),
+    expiresAt: Schema.NullOr(Schema.Int),
+    /** Original instruction repeated for every occurrence. */
+    prompt: Prompt,
+    mode: Schema.Literals(["self_paced", "fixed_interval"]),
+    /** Cadence of a fixed-interval loop; null when the model paces it. */
+    cron: Schema.NullOr(LoopCron),
+    state: Schema.Literals([
+        "active",
+        "paused",
+        "finished",
+        "failed",
+        "cancelled",
+    ]),
+    /** Latest accepted command associated with this loop. */
+    commandId: Schema.String,
+    /** The model's stated reason for the next self-paced occurrence. */
+    reason: Schema.NullOr(Schema.String),
+    /** When the next occurrence is due, if one is scheduled. */
+    nextDueAt: Schema.NullOr(Schema.Int),
+    /** Visible explanation when loop work failed. */
+    lastError: Schema.NullOr(Schema.String),
+});
+const StartResult = Schema.Struct({
+    loop: Loop,
+    accepted: Schema.Struct({
+        status: Schema.Literal("accepted"),
+        commandId: Schema.String,
+    }),
+});
+/**
+ * Arguments of the human `/loop` command. `start` carries the typed text:
+ * `<prompt>` paces itself, `<N>m <prompt>` or `<N>h <prompt>` runs on an
+ * interval. A bare call opens the controls.
+ */
+export const LoopCommandInput = Schema.Union([
+    Schema.Struct({
+        action: Schema.Literal("start"),
+        text: Prompt,
+        requestId: RequestId,
+    }),
+    Schema.Struct({
+        action: Schema.Literals(["status", "pause", "resume", "stop", "new"]),
+    }),
+    Schema.Struct({}),
+]);
+/** Loop's contract: Session-scope controls and one projection slot. */
+export const LoopProjection = Schema.Struct({
+    loop: Schema.NullOr(Loop),
+    history: historySchema(Loop),
+});
+export const loopContract = {
+    id: ExtensionId.make("botanical-session-loop"),
+    commands: {
+        loop: { scope: "session", input: LoopCommandInput, output: CatalogStep },
+        startSelfPaced: {
+            scope: "session",
+            input: Schema.Struct({ prompt: Prompt, requestId: RequestId }),
+            output: StartResult,
+        },
+        startFixedInterval: {
+            scope: "session",
+            input: Schema.Struct({
+                prompt: Prompt,
+                requestId: RequestId,
+                ...LoopCron.fields,
+            }),
+            output: StartResult,
+        },
+        pause: { scope: "session", input: Schema.Struct({}), output: Loop },
+        resume: { scope: "session", input: Schema.Struct({}), output: Loop },
+        stop: { scope: "session", input: Schema.Struct({}), output: Loop },
+    },
+    projection: { schema: LoopProjection },
+};

package/dist/loop/host.d.ts

@@ -0,0 +1,4 @@
+import { type RosteredExtensionV0 } from "@fungi.computer/shiitake/extensions";
+/** The commands this extension advertises to every client. */
+export declare const loopCatalog: import("@fungi.computer/shiitake/extensions").Json;
+export declare const loopExtension: RosteredExtensionV0;