opencode-superagent 0.0.0-stage → 0.2.0

package/dist/src/sleep.d.ts

@@ -0,0 +1,35 @@
+import type { Plugin } from "@opencode/plugin/effect";
+import { Tool } from "@opencode/schema/tool";
+import { Effect, Schema } from "effect";
+/**
+ * Router-only `sleep` tool: a bounded, real pause after `dispatch` so the
+ * Worker gets execution time before the Router decides to act again. It is a
+ * timer, never a busy loop, so the Router session (and every other fiber in
+ * the process) stays responsive while it waits.
+ */
+export declare const SLEEP_DEFAULT_SECONDS = 30;
+export declare const SLEEP_MIN_SECONDS = 1;
+export declare const SLEEP_MAX_SECONDS = 600;
+export declare const SleepInput: Schema.Struct<{
+    readonly seconds: Schema.optionalKey<Schema.Number>;
+}>;
+export declare const SleepOutput: Schema.Struct<{
+    readonly slept: Schema.Number;
+    readonly text: Schema.String;
+}>;
+interface SleepInput {
+    readonly seconds?: number;
+}
+/** Performs the wait; tests inject a no-op so the default 30s never runs. */
+export type Sleeper = (seconds: number) => Effect.Effect<void>;
+/** The production sleeper: a platform timer, not a spin loop. */
+export declare const effectSleeper: Sleeper;
+export declare const runSleep: (input: SleepInput, caller: string, sleeper?: Sleeper | undefined) => Effect.Effect<{
+    output: {
+        slept: number;
+        text: string;
+    };
+    content: string;
+}, Tool.Error, never>;
+export declare const registerSleep: (ctx: Plugin.Context) => Effect.Effect<void, never, import("effect/Scope").Scope>;
+export {};

package/dist/src/sleep.js

@@ -0,0 +1,58 @@
+import { Tool } from "@opencode/schema/tool";
+import { Duration, Effect, Schema } from "effect";
+import { requireRouter } from "./guard.js";
+import { specFor, toolPermission } from "./tools.js";
+/**
+ * Router-only `sleep` tool: a bounded, real pause after `dispatch` so the
+ * Worker gets execution time before the Router decides to act again. It is a
+ * timer, never a busy loop, so the Router session (and every other fiber in
+ * the process) stays responsive while it waits.
+ */
+export const SLEEP_DEFAULT_SECONDS = 30;
+export const SLEEP_MIN_SECONDS = 1;
+export const SLEEP_MAX_SECONDS = 600;
+export const SleepInput = Schema.Struct({
+    seconds: Schema.optionalKey(Schema.Number),
+});
+export const SleepOutput = Schema.Struct({
+    slept: Schema.Number,
+    text: Schema.String,
+});
+/** The production sleeper: a platform timer, not a spin loop. */
+export const effectSleeper = (seconds) => Effect.sleep(Duration.seconds(seconds));
+export const runSleep = Effect.fn("superagent.sleep")(function* (input, caller, sleeper = effectSleeper) {
+    yield* requireRouter(caller, "sleep");
+    const seconds = input.seconds ?? SLEEP_DEFAULT_SECONDS;
+    // The registered schema already rejects non-numbers at the tool boundary;
+    // this re-check keeps direct/RPC-style callers from bypassing validation.
+    if (typeof seconds !== "number" || !Number.isFinite(seconds)) {
+        return yield* new Tool.Error({
+            message: `sleep seconds must be a number between ${SLEEP_MIN_SECONDS} and ${SLEEP_MAX_SECONDS} (got ${String(input.seconds)})`,
+        });
+    }
+    if (!Number.isInteger(seconds)) {
+        return yield* new Tool.Error({
+            message: `sleep seconds must be an integer between ${SLEEP_MIN_SECONDS} and ${SLEEP_MAX_SECONDS} (got ${seconds})`,
+        });
+    }
+    if (seconds < SLEEP_MIN_SECONDS || seconds > SLEEP_MAX_SECONDS) {
+        return yield* new Tool.Error({
+            message: `sleep seconds must be between ${SLEEP_MIN_SECONDS} and ${SLEEP_MAX_SECONDS} (got ${seconds})`,
+        });
+    }
+    yield* sleeper(seconds);
+    const text = `slept ${seconds}s`;
+    return { output: { slept: seconds, text }, content: text };
+});
+export const registerSleep = Effect.fn("superagent.registerSleep")(function* (ctx) {
+    yield* ctx.tool.transform((editor) => {
+        editor.add({
+            name: "sleep",
+            description: specFor("sleep").description,
+            input: SleepInput,
+            output: SleepOutput,
+            options: { permission: toolPermission(specFor("sleep")) },
+            execute: (input, context) => runSleep(input, context.sessionID),
+        });
+    });
+});

package/dist/src/state.d.ts

@@ -0,0 +1,126 @@
+import type { Plugin } from "@opencode/plugin/effect";
+import type { Session } from "@opencode/schema/session";
+import { Effect, type Schema } from "effect";
+export type WorkerState = "running" | "idle" | "failed" | "done" | "aborted";
+export interface WorkerRecord {
+    readonly sessionID: string;
+    readonly title?: string;
+    /**
+     * Primary thread this worker was dispatched for. Legacy records decode to
+     * `""` and `hydrate` backfills it from `thread.workers`, so every live record
+     * carries a forward link to its thread without losing the multi-thread
+     * `threads` list.
+     */
+    threadID: string;
+    /** Trigger that authorized the dispatch, when the record knows it. */
+    triggerID?: string;
+    readonly threads: Array<string>;
+    state: WorkerState;
+    readonly createdAt: number;
+    /** Last persisted write. Refreshed by `saveWorker`, so an aborted record keeps a traceable timestamp. */
+    updatedAt?: number;
+    lastReport?: string;
+    directory?: string;
+}
+export interface ThreadRecord {
+    readonly threadID: string;
+    readonly workers: Array<string>;
+    readonly updatedAt: number;
+}
+export interface TriggerInput {
+    readonly id?: string;
+    readonly source: string;
+    readonly threadID: string;
+    readonly author?: string;
+    readonly text: string;
+    readonly title?: string;
+    readonly createdAt?: number;
+}
+export interface PendingTrigger {
+    readonly trigger: TriggerInput;
+    readonly arrivedAt: number;
+}
+export type TriggerRoute = "router" | "worker";
+export interface TriggerRecord {
+    readonly id: string;
+    readonly source: string;
+    readonly threadID: string;
+    readonly author?: string;
+    readonly text: string;
+    readonly title?: string;
+    readonly createdAt: number;
+    route?: TriggerRoute;
+    sessionID?: string;
+    /** Workers dispatched from this trigger (reverse of `WorkerRecord.triggerID`). */
+    workerIDs?: Array<string>;
+}
+export interface DirectTriggerInput {
+    readonly id: string;
+    readonly source: string;
+    readonly threadID: string;
+    readonly author?: string;
+    readonly text: string;
+    readonly createdAt: number;
+}
+export declare function triggerIdFor(input: TriggerInput): string;
+/**
+ * Queue that transparently records trigger history. `server.ts` and
+ * `router.ts` keep using plain `push`/`splice`; interception here writes
+ * the memory map synchronously and persists to KV in the background, so
+ * no caller changes are needed.
+ */
+export declare class PendingQueue extends Array<PendingTrigger> {
+    push(...items: Array<PendingTrigger>): number;
+    splice(start: number, deleteCount?: number, ...items: Array<PendingTrigger>): Array<PendingTrigger>;
+}
+/**
+ * Record a trigger delivered straight to a worker (it never passes the
+ * pending queue). The text comes from the admitted prompt, so it carries
+ * the same truncation as the worker-visible format; queued triggers keep
+ * their full text via `rememberQueued`.
+ */
+export declare function upsertDirectTrigger(input: DirectTriggerInput, sessionID: string): TriggerRecord;
+export interface Store {
+    routerID: string | undefined;
+    routerBusy: boolean;
+    readonly workers: Map<string, WorkerRecord>;
+    readonly threads: Map<string, Array<string>>;
+    readonly pending: Array<PendingTrigger>;
+    readonly triggers: Map<string, TriggerRecord>;
+    triggerTotal: number;
+}
+export declare const store: Store;
+export declare const ROUTER_KEY = "router";
+export declare const WORKER_PREFIX = "worker:";
+export declare const THREAD_PREFIX = "thread:";
+export declare const TRIGGER_PREFIX = "trigger:";
+export declare const workerKey: (sessionID: string) => string;
+export declare const threadKey: (threadID: string) => string;
+export declare const triggerKey: (id: string) => string;
+/** Brands are compile-time only, so a validated session id string converts freely. */
+export declare const toSessionID: (id: string) => Session.ID;
+/** A Session is running while `time.busy` is newer than the last completed execution's `time.idle`. */
+export declare function isRunning(info: Session.Info): boolean;
+export declare function decodeWorker(value: Schema.Json | undefined): WorkerRecord | undefined;
+export declare function decodeThread(value: Schema.Json | undefined): ThreadRecord | undefined;
+export declare function decodeTrigger(value: Schema.Json | undefined): TriggerRecord | undefined;
+export declare function encodeWorker(record: WorkerRecord): Schema.Json;
+export declare function encodeThread(record: ThreadRecord): Schema.Json;
+export declare function encodeTrigger(record: TriggerRecord): Schema.Json;
+/**
+ * Load KV state into the in-memory maps. Storage is the unique source of
+ * truth; every loaded session is validated with `session.get` and stale
+ * entries are cleaned from both memory and KV.
+ */
+export declare const hydrate: (ctx: Plugin.Context) => Effect.Effect<void, never, never>;
+/** Every worker write refreshes `updatedAt`, so an aborted record keeps a traceable timestamp. */
+export declare const saveWorker: (ctx: Plugin.Context, record: WorkerRecord) => Effect.Effect<void, never, never>;
+export declare const saveTrigger: (ctx: Plugin.Context, record: TriggerRecord) => Effect.Effect<void, never, never>;
+/**
+ * Record the worker on the trigger that authorized it (`trigger.workerIDs`),
+ * completing the reverse edge of `WorkerRecord.triggerID`. Memory holds only
+ * the newest triggers, so an older trigger is read from KV once; a missing
+ * trigger is not invented. Repeating the call is a no-op.
+ */
+export declare const linkTriggerToWorker: (ctx: Plugin.Context, triggerID: string, sessionID: string) => Effect.Effect<boolean, never, never>;
+export declare const saveThread: (ctx: Plugin.Context, record: ThreadRecord) => Effect.Effect<void, never, never>;