agents 0.28.1 → 0.30.0

package/dist/harness/opencode/index.js

@@ -1,7 +1,7 @@
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../../classPrivateFieldGet2-DZBYAB34.js";
 import { t as _classPrivateMethodInitSpec } from "../../classPrivateMethodInitSpec-qMjJ6sHQ.js";
 import { t as LifecycleCapability } from "../../capability-DBAKc6UZ.js";
-import "../../lifecycle-DGorpAmA.js";
+import "../../lifecycle-v1rKHV2C.js";
 //#region src/harness/table-prefix.ts
 /**
 * A view of `storage` whose SQL is rewritten into `prefix`'s namespace.

package/dist/harness/pi/index.d.ts

@@ -4,7 +4,7 @@ import {
   s as LifecycleCapability,
   v as LifecycleJobOutcome
 } from "../../capability-runner-BiVUtjqC.js";
-import { T as SkillSource } from "../../index-kbSUIer3.js";
+import { S as SkillSource } from "../../index-iv9FTXX9.js";
 import { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import {
   AgentChange,
@@ -13,33 +13,14 @@ import {
   EntryRecord,
   Extension,
   Harness,
+  InputEntry,
   ToolRegistration,
-  UserInput
+  UserInput,
+  Wake
 } from "@earendil-works/pi-durable";
+import { Context as Context$1 } from "@earendil-works/chord/context";
 import { SqliteStorage } from "@earendil-works/pi-durable/storage/sqlite";
 
-//#region src/harness/pi/context.d.ts
-/**
- * pi's invocation context, as `@earendil-works/chord` defines it.
- *
- * pi-durable takes a chord `Context` on every call but does not re-export
- * the type or its constructors. The harness needs only a background context
- * and a way to add an abort signal, so both are inlined here instead of
- * depending on chord directly. A chord `Context` is a plain structural
- * interface (an abort signal, keyed values, and a name), so these interoperate
- * with chord's own contexts inside pi.
- *
- * One limit: chord's own derived contexts read the abort signal through a
- * private key rather than `abortSignal`, so a chord `withContextValue`
- * wrapped around one of these would not see its signal. pi-durable does not
- * use `withContextValue` to wrap a caller's context that way; `withAbortSignal`
- * and `withCancel` read `abortSignal` and work.
- *
- * If pi-durable starts re-exporting chord's context helpers, replace this
- * file with those.
- */
-type Context$1 = Parameters<Harness["close"]>[0];
-//#endregion
 //#region src/harness/pi/types.d.ts
 /**
  * `PiHarness`'s own types: how the harness addresses sessions and reports
@@ -59,6 +40,14 @@ type PiSubmitOptions = {
   /** Default: the root session. */ readonly session?: PiSessionId /** Idempotency key. Submitting the same id twice returns the same receipt. */;
   readonly operationId?: string;
   readonly whenBusy?: PiWhenBusy;
+  /**
+   * The transcript entry the input is placed as, instead of pi's `pi.user`:
+   * for input the user did not type, such as a scheduled prompt, a webhook,
+   * or an approval's outcome. The model still gets the input as a user
+   * message; `kind` and `data` record where it came from. The kind must not
+   * start with `pi.`.
+   */
+  readonly entry?: InputEntry;
 };
 type PiSessionOptions = {
   /** Default: the root session. */ readonly session?: PiSessionId;
@@ -85,8 +74,13 @@ type PiPromptResponse = PiOperationResult & {
 /** A submission pi has not settled yet. */
 type PiPendingOperation = {
   readonly operationId: string;
-  readonly session: PiSessionId /** `queued` in pi's inbox, or `running` as part of the current run. */;
-  readonly status: "queued" | "running";
+  readonly session: PiSessionId;
+  /**
+   * `queued` in pi's inbox, or `running` as part of the current run.
+   * `parked`: running, but pi's crash-loop guard (`settings.restartLimit`)
+   * stopped a task of the session; `retry()` runs it again.
+   */
+  readonly status: "queued" | "running" | "parked";
 };
 type PiSessionInfo = {
   readonly id: PiSessionId /** The session this one was forked from. */;
@@ -98,22 +92,34 @@ type PiSessionInfo = {
 /** The root session's id. */
 declare const ROOT_SESSION: PiSessionId;
 /**
- * What the factory is handed: the two things only the harness can build.
+ * What the factory is handed: the things only the harness can build.
  * Everything else `Harness.open` takes (models, registry, settings, env,
  * onReport) the factory builds itself.
  */
 type PiHarnessContext = {
   /** pi's storage over this object's SQLite, its migrations already run. */ readonly storage: SqliteStorage /** Background context, for the open itself. */;
   readonly context: Context$1;
+  /**
+   * Pass this to `Harness.open` as its `onWake` option. pi calls it when it
+   * next needs to run, and the harness sets this object's alarm for then.
+   *
+   * With it, pi sets no in-memory timer for a sleeping task (a retry
+   * backoff, a poll, a `sleepUntil`), so the object can hibernate until the
+   * alarm. Without it the harness still works, but pi's timer keeps the
+   * object in memory, and billed, while a task sleeps, and the harness logs
+   * a warning when it opens pi.
+   */
+  readonly onWake: (wake: Wake) => void;
 };
 /**
- * Opens pi's `Harness`. The harness adopts what it returns.
+ * Opens pi's `Harness`. The harness adopts what it returns. Pass `onWake`
+ * through to `Harness.open`.
  *
  * ```ts
- * harness: async ({ storage, context }) => {
+ * harness: async ({ storage, context, onWake }) => {
  *   const registry = createRegistry();
  *   registry.install(await skills(sources));
- *   return Harness.open(storage, { models, registry }, context);
+ *   return Harness.open(storage, { models, registry, onWake }, context);
  * }
  * ```
  */
@@ -160,12 +166,14 @@ type PiHarnessOptions = {
  *
  * What pi cannot do on a Durable Object is wake itself: its scheduler runs
  * in memory, and an evicted object has no memory. The harness is that wake,
- * with one Lifecycle job per session. Input goes to pi once, in `submit()`,
- * after the session's job is scheduled. The job waits while pi has live
- * tasks in the session, rescheduling itself as a heartbeat, and completes
- * when there are none. An eviction mid-run leaves the job due, so its alarm
- * restarts the object, pi reopens and resumes its own tasks, and the job
- * waits again.
+ * with one Lifecycle job driven by `pi.wake()`. Input goes to pi once, in
+ * `submit()`, after the job is scheduled. While pi has work running, the
+ * job waits on it, rescheduling itself as a heartbeat. While pi's tasks
+ * sleep, the job is due when the first one wakes; pi tells the harness
+ * through the `onWake` the factory passes to `Harness.open`. When pi has
+ * nothing to do, the job completes. An eviction mid-run leaves the job due,
+ * so its alarm restarts the object, pi reopens and resumes its own tasks,
+ * and the job waits again.
  *
  * @beta The API may change between releases.
  */
@@ -175,6 +183,16 @@ declare class PiHarness extends LifecycleCapability {
   constructor(options: PiHarnessOptions);
   onStart(_context: CapabilityStartContext): Promise<void>;
   onJob(context: LifecycleJobContext): Promise<LifecycleJobOutcome | void>;
+  /**
+   * A wake dispatch that failed through Lifecycle's retries, as when pi
+   * cannot be opened. Lifecycle would complete the job, and pi's work would
+   * never be woken again, so try again later: at the heartbeat, doubling
+   * while the failures continue, up to 10 minutes.
+   */
+  onJobError(
+    context: LifecycleJobContext,
+    error: unknown
+  ): LifecycleJobOutcome | void;
   /** Close pi's in-memory resources. Durable state is untouched. */
   dispose(): Promise<void>;
   /** A handle on one session. No I/O until you call it. */
@@ -192,6 +210,11 @@ declare class PiHarness extends LifecycleCapability {
       readonly operationId?: string;
     }
   ): Promise<boolean>;
+  /**
+   * Run again the tasks pi's crash-loop guard parked in a session's work.
+   * False when nothing was parked.
+   */
+  retry(options?: PiSessionOptions): Promise<boolean>;
   wait(
     operationId: string,
     options?: PiSessionOptions & {
@@ -214,6 +237,8 @@ declare class PiHarness extends LifecycleCapability {
     input: UserInput,
     options: PiSubmitOptions
   ): Promise<PiReceipt>;
+  /** @internal Run again the tasks pi's restart limit parked in a session. */
+  retryParked(session: PiSessionId): Promise<boolean>;
   /** @internal Withdraw a queued input, or abort the run it joined. */
   withdraw(session: PiSessionId, operationId: string): Promise<boolean>;
   /** @internal Wait for pi to settle an operation, by its request id. */
@@ -250,6 +275,12 @@ declare class PiSession {
    * running work.
    */
   abort(operationId?: string): Promise<boolean>;
+  /**
+   * Run again the tasks pi's crash-loop guard (`settings.restartLimit`)
+   * parked in this session's work, including subagent sessions it owns.
+   * False when nothing was parked.
+   */
+  retry(): Promise<boolean>;
   /** Start a new context, optionally from a handoff note. */
   reset(handoff?: string): Promise<void>;
   /**
@@ -285,10 +316,9 @@ declare class PiSessions {
  *
  * pi owns its sessions: conversations, entries, tasks, submissions, and
  * documents live in pi's own schema, created and migrated by pi's portable
- * `SqliteStorage`. This file only supplies the asynchronous database facade
- * pi asks for, over `ctx.storage.sql`, and moves pi's tables under a prefix
- * so they cannot collide with the SDK's or the host's tables in the same
- * object.
+ * `SqliteStorage` through pi's own Durable Object adapter. The store keeps
+ * pi's tables under a prefix, so they cannot collide with the SDK's or the
+ * host's tables in the same object.
  *
  * It is the Durable Object counterpart of `agents/sessions` for a harness
  * that brings its own session model, and has nothing pi-harness specific in