@zachwill/pi-orchestrate 0.8.0 → 0.9.0

package/extension/worker-settlement.ts

@@ -1,41 +1,18 @@
 import { Schema } from "effect";
-import type { RunId, WorkerId } from "./domain.js";
+import {
+  RunId,
+  WorkerAbortedOutcome,
+  WorkerCompletedOutcome,
+  WorkerFailedOutcome,
+  WorkerId,
+  WorkerReadyOutcome,
+  WorkerResponseOutcome,
+  WorkerUsage,
+} from "./domain.js";
 
-const NonnegativeFinite = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
 const NonnegativeInteger = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 const PositiveInteger = Schema.Int.check(Schema.isGreaterThan(0));
 
-const WorkerUsage = Schema.Struct({
-  input: NonnegativeFinite,
-  output: NonnegativeFinite,
-  cacheRead: NonnegativeFinite,
-  cacheWrite: NonnegativeFinite,
-  cost: NonnegativeFinite,
-  contextTokens: NonnegativeFinite,
-  turns: NonnegativeInteger,
-});
-
-const WorkerOutcome = Schema.Union([
-  Schema.Struct({
-    status: Schema.Literal("completed"),
-    assistantText: Schema.String,
-  }),
-  Schema.Struct({
-    status: Schema.Literal("ready"),
-    assistantText: Schema.String,
-  }),
-  Schema.Struct({
-    status: Schema.Literal("failed"),
-    message: Schema.String,
-    assistantText: Schema.optionalKey(Schema.String),
-  }),
-  Schema.Struct({
-    status: Schema.Literal("aborted"),
-    message: Schema.optionalKey(Schema.String),
-    assistantText: Schema.optionalKey(Schema.String),
-  }),
-]);
-
 const FailureStage = Schema.Literals([
   "startup",
   "prompt",
@@ -48,15 +25,15 @@ export const WorkerSettlementDetails = Schema.Struct({
   eventId: Schema.String,
   sequence: PositiveInteger,
   ownerSessionId: Schema.String,
-  runId: Schema.String,
-  workerId: Schema.String,
+  runId: RunId,
+  workerId: WorkerId,
   generation: PositiveInteger,
   mode: Schema.Literals(["async", "inline"]),
   worker: Schema.String,
   title: Schema.String,
   lifecycle: Schema.Literals(["one-shot", "interactive"]),
   status: Schema.Literals(["completed", "ready", "failed", "aborted"]),
-  outcome: WorkerOutcome,
+  outcome: WorkerResponseOutcome,
   usage: WorkerUsage,
   startedAt: NonnegativeInteger,
   settledAt: NonnegativeInteger,
@@ -107,14 +84,9 @@ export type SettlementFailureStage = NonNullable<
   WorkerSettlementDetails["failureStage"]
 >;
 
-/** Runtime refinement preserves the nominal IDs already allocated by the domain. */
-export type WorkerSettlement = Omit<
-  WorkerSettlementDetails,
-  "runId" | "workerId"
-> & {
-  readonly runId: RunId;
-  readonly workerId: WorkerId;
-};
+export type WorkerSettlement = Schema.Schema.Type<
+  typeof WorkerSettlementDetails
+>;
 
 const decodeCurrentWorkerSettlement = Schema.decodeUnknownResult(
   WorkerSettlementDetails,
@@ -123,3 +95,92 @@ const decodeCurrentWorkerSettlement = Schema.decodeUnknownResult(
 export function decodePersistedWorkerSettlementDetails(value: unknown) {
   return decodeCurrentWorkerSettlement(value);
 }
+
+const InlineWorkerOutcome = Schema.Union([
+  WorkerCompletedOutcome.pipe(
+    Schema.encodeKeys({ assistantText: "assistant_text" }),
+  ),
+  WorkerReadyOutcome.pipe(
+    Schema.encodeKeys({ assistantText: "assistant_text" }),
+  ),
+  WorkerFailedOutcome.pipe(
+    Schema.encodeKeys({ assistantText: "assistant_text" }),
+  ),
+  WorkerAbortedOutcome.pipe(
+    Schema.encodeKeys({ assistantText: "assistant_text" }),
+  ),
+]);
+
+const InlineWorkerUsage = WorkerUsage.pipe(
+  Schema.encodeKeys({
+    cacheRead: "cache_read",
+    cacheWrite: "cache_write",
+    contextTokens: "context_tokens",
+  }),
+);
+
+/** Tool transport projection derived from the canonical settlement field schemas. */
+export const InlineWorkerSettlementDetails = Schema.Struct({
+  workerId: WorkerSettlementDetails.fields.workerId,
+  worker: WorkerSettlementDetails.fields.worker,
+  title: WorkerSettlementDetails.fields.title,
+  status: WorkerSettlementDetails.fields.status,
+  outcome: InlineWorkerOutcome,
+  usage: InlineWorkerUsage,
+  startedAt: WorkerSettlementDetails.fields.startedAt,
+  settledAt: WorkerSettlementDetails.fields.settledAt,
+  sessionFile: WorkerSettlementDetails.fields.sessionFile,
+}).pipe(
+  Schema.encodeKeys({
+    workerId: "worker_id",
+    startedAt: "started_at",
+    settledAt: "settled_at",
+    sessionFile: "session_file",
+  }),
+).check(
+  Schema.makeFilter((settlement) => {
+    if (settlement.outcome.status !== settlement.status) {
+      return "outcome status must match settlement status";
+    }
+    if (settlement.settledAt < settlement.startedAt) {
+      return "settlement timestamp must not precede start timestamp";
+    }
+  }),
+);
+
+export interface InlineWorkerSettlementDetails
+  extends Schema.Schema.Type<typeof InlineWorkerSettlementDetails> {}
+
+export const InlineWorkerToolDetails = Schema.Struct({
+  mode: Schema.Literal("inline"),
+  runId: Schema.optionalKey(WorkerSettlementDetails.fields.runId),
+  ownerSessionId: Schema.optionalKey(
+    WorkerSettlementDetails.fields.ownerSessionId,
+  ),
+  result: InlineWorkerSettlementDetails,
+}).pipe(
+  Schema.encodeKeys({
+    runId: "run_id",
+    ownerSessionId: "owner_session_id",
+  }),
+);
+
+export interface InlineWorkerToolDetails
+  extends Schema.Schema.Type<typeof InlineWorkerToolDetails> {}
+
+const decodeInlineWorkerToolDetailsResult = Schema.decodeUnknownResult(
+  InlineWorkerToolDetails,
+);
+const encodeInlineWorkerToolDetailsSync = Schema.encodeSync(
+  InlineWorkerToolDetails,
+);
+
+export function decodeInlineWorkerToolDetails(value: unknown) {
+  return decodeInlineWorkerToolDetailsResult(value);
+}
+
+export function encodeInlineWorkerToolDetails(
+  value: InlineWorkerToolDetails,
+) {
+  return encodeInlineWorkerToolDetailsSync(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zachwill/pi-orchestrate",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "description": "Concurrent worker orchestration for Pi",
   "files": ["extension/", "examples/", "README.md", "LICENSE"],

package/extension/scheduler.ts

@@ -1,85 +0,0 @@
-import { Cause, Context, Effect, FiberMap, Layer, ManagedRuntime } from "effect";
-
-export type WorkflowDefectHandler = (error: unknown) => void;
-
-export interface WorkflowScheduler<Key> {
-  /** Starts a workflow immediately, interrupting and replacing the previous workflow at the key. */
-  start(
-    key: Key,
-    workflow: Effect.Effect<void, never>,
-    onDefect: WorkflowDefectHandler,
-  ): void;
-  /** Interrupts the current workflow at the key and waits for its fiber to settle. */
-  remove(key: Key): Promise<void>;
-  /** Interrupts every retained workflow and closes the scheduler scope. */
-  close(): Promise<void>;
-}
-
-interface WorkflowSupervisorService {
-  readonly start: (
-    key: unknown,
-    workflow: Effect.Effect<void, never>,
-  ) => void;
-  readonly remove: (key: unknown) => Effect.Effect<void>;
-}
-
-class WorkflowSupervisor extends Context.Service<
-  WorkflowSupervisor,
-  WorkflowSupervisorService
->()("@zachwill/pi-orchestrate/WorkflowSupervisor") {}
-
-const workflowSupervisorLayer = Layer.effect(
-  WorkflowSupervisor,
-  Effect.gen(function* () {
-    const fibers = yield* FiberMap.make<unknown, void, never>();
-    const run = yield* FiberMap.runtime(fibers)<never>();
-    return WorkflowSupervisor.of({
-      start(key, workflow) {
-        run(key, workflow);
-      },
-      remove: (key) => FiberMap.remove(fibers, key),
-    });
-  }),
-);
-
-class EffectWorkflowScheduler<Key> implements WorkflowScheduler<Key> {
-  private readonly managedRuntime = ManagedRuntime.make(workflowSupervisorLayer);
-  private readonly supervisor = this.managedRuntime.runSync(WorkflowSupervisor);
-  private closePromise: Promise<void> | undefined;
-
-  start(
-    key: Key,
-    workflow: Effect.Effect<void, never>,
-    onDefect: WorkflowDefectHandler,
-  ): void {
-    const supervised = workflow.pipe(
-      Effect.catchCause((cause) => {
-        if (!Cause.hasInterruptsOnly(cause)) {
-          return Effect.sync(() => {
-            try {
-              onDefect(Cause.squash(cause));
-            } catch {
-              // Defect reporting must not become another unsupervised defect.
-            }
-          });
-        }
-        return Effect.void;
-      }),
-    );
-
-    this.supervisor.start(key, supervised);
-  }
-
-  remove(key: Key): Promise<void> {
-    return this.managedRuntime.runPromise(this.supervisor.remove(key));
-  }
-
-  close(): Promise<void> {
-    this.closePromise ??= this.managedRuntime.dispose();
-    return this.closePromise;
-  }
-}
-
-export function createWorkflowScheduler<Key>(): WorkflowScheduler<Key> {
-  return new EffectWorkflowScheduler<Key>();
-}