@osolmaz/pi-workflows 0.14.0 → 0.15.1

package/src/controllers/workflow-engine-scheduler.ts

@@ -1,246 +0,0 @@
-import { compositionMetadata } from "../workflows/composition.js";
-import { WorkflowEngine, workflowIdentityMismatch } from "../workflows/engine.js";
-import type { WorkflowRunStore } from "../workflows/store.js";
-import type {
-  WorkflowDefinition,
-  WorkflowRunResult,
-  WorkflowRunStatus,
-  WorkflowSource,
-} from "../workflows/types.js";
-import type {
-  ControllerFollowUpResult,
-  ControllerQueueFollowUpRequest,
-  ControllerRemoveFollowUpRequest,
-  ControllerSettingsChangeRequest,
-  ControllerSettingsChangeResult,
-} from "./types.js";
-import type {
-  ControllerWorkflowControlRequest,
-  ControllerWorkflowScheduler,
-  WorkflowSchedulerRequest,
-  WorkflowSchedulerResult,
-} from "./workflows.js";
-
-export type ResolvedChildWorkflow = {
-  workflow: WorkflowDefinition;
-  workflowSource?: WorkflowSource;
-};
-
-export type WorkflowEngineSchedulerOptions = {
-  store: WorkflowRunStore;
-  resolveWorkflow: (name: string) => Promise<ResolvedChildWorkflow>;
-  createEngine: (request: WorkflowSchedulerRequest) => WorkflowEngine;
-  /**
-   * Release resources the engine held after its run settles, for example a
-   * headless child process. Called once per finished run.
-   */
-  disposeEngine?: (engine: WorkflowEngine) => Promise<void>;
-};
-
-export class WorkflowEngineScheduler implements ControllerWorkflowScheduler {
-  private readonly active = new Map<string, { runId: string; promise: Promise<void> }>();
-
-  constructor(private readonly options: WorkflowEngineSchedulerOptions) {}
-
-  async ensure(
-    request: WorkflowSchedulerRequest,
-    signal: AbortSignal,
-    onComplete: (result: WorkflowSchedulerResult) => void,
-  ): Promise<WorkflowSchedulerResult> {
-    if (signal.aborted) {
-      throw signal.reason ?? new Error("Workflow scheduling aborted");
-    }
-    const activeKey = requestKey(request);
-    const active = this.active.get(activeKey);
-    if (active !== undefined) {
-      return { state: "running", runId: active.runId };
-    }
-
-    const bundle = this.options.store.readRun(request.runId, { includeTrace: true });
-    if (bundle !== null) {
-      const recovered =
-        bundle.state.status === "running"
-          ? await this.options.store.markRunInterrupted(request.runId)
-          : bundle;
-      if (recovered !== null) {
-        const lastTraceEvent = recovered.traceEvents?.at(-1) ?? null;
-        return resultFromStatus(
-          recovered.state.status,
-          request.runId,
-          recovered.state.error,
-          lastTraceEvent?.type === "run_interrupted",
-        );
-      }
-      return { state: "pending" };
-    }
-
-    const resolved = await this.options.resolveWorkflow(request.workflow);
-    if (signal.aborted) {
-      throw signal.reason ?? new Error("Workflow scheduling aborted");
-    }
-    const runId = request.runId;
-    const engine = this.options.createEngine(request);
-    const promise = engine
-      .run(resolved.workflow, request.input, {
-        runId,
-        ...(resolved.workflowSource !== undefined
-          ? { workflowSource: resolved.workflowSource }
-          : {}),
-      })
-      .then((result) => {
-        callCompletion(onComplete, resultFromRun(result));
-      })
-      .catch((error: unknown) => {
-        callCompletion(onComplete, {
-          state: "failed",
-          runId,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      })
-      .finally(() => {
-        this.active.delete(activeKey);
-        void this.options.disposeEngine?.(engine).catch(() => undefined);
-      });
-    this.active.set(activeKey, { runId, promise });
-    return { state: "running", runId };
-  }
-
-  async changeSettings(
-    request: ControllerWorkflowControlRequest<ControllerSettingsChangeRequest>,
-    signal: AbortSignal,
-  ): Promise<ControllerSettingsChangeResult> {
-    signal.throwIfAborted();
-    const bundle = this.options.store.readRun(request.runId);
-    if (bundle === null) throw new Error(`Workflow run not found: ${request.runId}`);
-    const resolved = await this.options.resolveWorkflow(bundle.state.workflowName);
-    signal.throwIfAborted();
-    if (workflowIdentityMismatch(bundle.state, resolved.workflow, resolved.workflowSource)) {
-      throw new Error(`Workflow source changed since run ${request.runId} started`);
-    }
-    const scopes = this.options.store.listSettingsScopes(request.runId);
-    const scopeId = request.scopeId ?? (scopes.length === 1 ? scopes[0]?.scopeId : undefined);
-    if (scopeId === undefined) {
-      throw new Error("Controller settings changes require scopeId when several scopes exist");
-    }
-    const scope = this.options.store.getSettingsScope(scopeId);
-    if (scope === undefined || scope.activeRunId !== request.runId) {
-      throw new Error(`Workflow settings scope not found: ${scopeId}`);
-    }
-    const definition =
-      scope.mountPath === ""
-        ? resolved.workflow.settings
-        : compositionMetadata(resolved.workflow)?.scopes[scope.mountPath]?.settings;
-    if (definition === undefined) {
-      throw new Error(`Workflow scope ${scopeId} does not declare editable settings`);
-    }
-    const result = await this.options.store.changeSettings(definition, {
-      runId: request.runId,
-      scopeId,
-      requestId: request.actorRequestKey,
-      ...(request.expectedChangeNumber !== undefined
-        ? { expectedChangeNumber: request.expectedChangeNumber }
-        : {}),
-      actor: { type: "controller", id: request.controllerResourceUid },
-      source: "controller-request",
-      patch: request.patch,
-    });
-    return {
-      runId: request.runId,
-      scopeId,
-      changeNumber: result.scope.changeNumber,
-      adopted: result.adopted,
-    };
-  }
-
-  async queueFollowUp(
-    request: ControllerWorkflowControlRequest<ControllerQueueFollowUpRequest>,
-    signal: AbortSignal,
-  ): Promise<ControllerFollowUpResult> {
-    signal.throwIfAborted();
-    const targetSessionId = this.options.store.originSessionId(request.runId);
-    if (targetSessionId === undefined) {
-      throw new Error("Controller follow-up requires a workflow run with an origin Pi session");
-    }
-    const result = this.options.store.queueFollowUp({
-      runId: request.runId,
-      requestId: request.actorRequestKey,
-      targetSessionId,
-      actor: { type: "controller", id: request.controllerResourceUid },
-      source: "controller-request",
-      prompt: request.prompt,
-    });
-    return {
-      runId: request.runId,
-      followUpId: result.followUp.followUpId,
-      order: result.followUp.order,
-      state: result.followUp.state,
-      adopted: result.adopted,
-    };
-  }
-
-  async removeFollowUp(
-    request: ControllerWorkflowControlRequest<ControllerRemoveFollowUpRequest>,
-    signal: AbortSignal,
-  ): Promise<ControllerFollowUpResult> {
-    signal.throwIfAborted();
-    const result = this.options.store.removeFollowUp({
-      runId: request.runId,
-      followUpId: request.followUpId,
-      actor: { type: "controller", id: request.controllerResourceUid },
-      source: "controller-request",
-    });
-    return {
-      runId: request.runId,
-      followUpId: result.followUpId,
-      order: result.order,
-      state: result.state,
-      adopted: false,
-    };
-  }
-
-  async waitForIdle(): Promise<void> {
-    await Promise.all([...this.active.values()].map((entry) => entry.promise));
-  }
-}
-
-function callCompletion(
-  callback: (result: WorkflowSchedulerResult) => void,
-  result: WorkflowSchedulerResult,
-): void {
-  try {
-    callback(result);
-  } catch {
-    // A later reconciliation recovers completion from the immutable run event.
-  }
-}
-
-function requestKey(request: WorkflowSchedulerRequest): string {
-  return `${request.requestId}:${request.attempt}`;
-}
-
-function resultFromRun(result: WorkflowRunResult): WorkflowSchedulerResult {
-  return resultFromStatus(result.state.status, result.state.runId, result.state.error);
-}
-
-function resultFromStatus(
-  status: WorkflowRunStatus,
-  runId: string,
-  error?: string,
-  interrupted = false,
-): WorkflowSchedulerResult {
-  if (interrupted) {
-    return { state: "interrupted", runId, ...(error !== undefined ? { error } : {}) };
-  }
-  switch (status) {
-    case "running":
-      return { state: "running", runId };
-    case "waiting":
-      return { state: "waiting", runId };
-    case "completed":
-      return { state: "succeeded", runId };
-    case "failed":
-    case "timed_out":
-    case "cancelled":
-      return { state: "failed", runId, ...(error !== undefined ? { error } : {}) };
-  }
-}

package/src/extension/controller-host.ts

@@ -1,167 +0,0 @@
-import {
-  ControllerManager,
-  SqliteControllerStore,
-  loadDiscoveredControllers,
-  type AnyControllerDefinition,
-  type ControllerResource,
-  type ControllerWorkflowScheduler,
-  type WorkflowSchedulerRequest,
-  type WorkflowSchedulerResult,
-} from "../controllers/index.js";
-
-export type ParsedControllerArgs =
-  | { kind: "list" }
-  | { kind: "get"; controller: string; key: string }
-  | { kind: "apply"; controller: string; key: string; spec: unknown }
-  | { kind: "reconcile"; controller: string; key: string }
-  | { kind: "delete"; controller: string; key: string }
-  | { kind: "start" }
-  | { kind: "stop" };
-
-export type PiChildWorkflowStarter = (
-  request: WorkflowSchedulerRequest,
-  signal: AbortSignal,
-  onComplete: (result: WorkflowSchedulerResult) => void,
-) => Promise<WorkflowSchedulerResult>;
-
-export function parseControllerArgs(args: string): ParsedControllerArgs {
-  const trimmed = args.trim();
-  if (trimmed.length === 0 || trimmed === "list") {
-    return { kind: "list" };
-  }
-  if (trimmed === "start" || trimmed === "stop") {
-    return { kind: trimmed };
-  }
-  const apply = trimmed.match(/^apply\s+(\S+)\s+(\S+)\s+([\s\S]+)$/);
-  if (apply !== null) {
-    let spec: unknown;
-    try {
-      spec = JSON.parse(apply[3] as string) as unknown;
-    } catch (error) {
-      throw new Error(
-        `Invalid controller spec JSON: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-    return {
-      kind: "apply",
-      controller: apply[1] as string,
-      key: apply[2] as string,
-      spec,
-    };
-  }
-  const operation = trimmed.match(/^(get|reconcile|delete)\s+(\S+)\s+(\S+)$/);
-  if (operation !== null) {
-    return {
-      kind: operation[1] as "get" | "reconcile" | "delete",
-      controller: operation[2] as string,
-      key: operation[3] as string,
-    };
-  }
-  throw new Error(
-    "Usage: /controller [list|get <controller> <key>|apply <controller> <key> <json>|reconcile <controller> <key>|delete <controller> <key>|start|stop]",
-  );
-}
-
-export class PiControllerHost {
-  readonly definitions: AnyControllerDefinition[];
-  readonly store: SqliteControllerStore;
-  readonly manager: ControllerManager;
-  private running = false;
-
-  private constructor(
-    definitions: AnyControllerDefinition[],
-    store: SqliteControllerStore,
-    manager: ControllerManager,
-  ) {
-    this.definitions = definitions;
-    this.store = store;
-    this.manager = manager;
-  }
-
-  static async create(options: {
-    cwd: string;
-    startChild: PiChildWorkflowStarter;
-    workflowControls?: Pick<
-      ControllerWorkflowScheduler,
-      "changeSettings" | "queueFollowUp" | "removeFollowUp"
-    >;
-  }): Promise<PiControllerHost | undefined> {
-    const definitions = await loadDiscoveredControllers({ cwd: options.cwd });
-    if (definitions.length === 0) {
-      return undefined;
-    }
-    const store = new SqliteControllerStore(undefined, { projectPath: options.cwd });
-    const manager = new ControllerManager({
-      store,
-      controllers: definitions,
-      workflowScheduler: { ensure: options.startChild, ...options.workflowControls },
-    });
-    return new PiControllerHost(definitions, store, manager);
-  }
-
-  start(): void {
-    this.manager.start();
-    this.running = true;
-  }
-
-  async stop(): Promise<void> {
-    await this.manager.stop();
-    this.running = false;
-  }
-
-  async close(): Promise<void> {
-    await this.stop();
-    this.store.close();
-  }
-
-  get isRunning(): boolean {
-    return this.running;
-  }
-
-  list(): string {
-    const names = this.definitions.map((item) => item.name).join(", ");
-    const resources = this.store.listResources();
-    if (resources.length === 0) {
-      return `Controllers: ${names}. No resources.`;
-    }
-    const rows = resources.map((resource) => resourceSummary(resource)).join("; ");
-    return `Controllers: ${names}. Resources: ${rows}.`;
-  }
-
-  get(controller: string, key: string): string {
-    const resource = this.store.getResource({ controller, key });
-    if (resource === undefined) {
-      throw new Error(`Controller resource not found: ${controller}/${key}`);
-    }
-    return JSON.stringify(
-      {
-        resource,
-        effects: this.store.listEffects(resource.metadata.uid),
-        workflows: this.store.listWorkflows(resource.metadata.uid),
-      },
-      null,
-      2,
-    );
-  }
-
-  apply(controller: string, key: string, spec: unknown): ControllerResource {
-    return this.manager.putResourceByName(controller, key, spec);
-  }
-
-  reconcile(controller: string, key: string): void {
-    this.manager.enqueue({ controller, key });
-  }
-
-  delete(controller: string, key: string): void {
-    this.manager.requestDeletion({ controller, key });
-  }
-}
-
-function resourceSummary(resource: ControllerResource): string {
-  const condition =
-    resource.status.conditions.find((item) => item.type === "Ready") ??
-    resource.status.conditions[0];
-  const state =
-    condition === undefined ? "unknown" : `${String(condition.status)}:${condition.reason}`;
-  return `${resource.metadata.controller}/${resource.metadata.key} generation=${resource.metadata.generation} ready=${state}`;
-}

package/src/extension/deferred-turn-coordinator.ts

@@ -1,171 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type {
-  SqliteControllerStore,
-  WorkflowTurnIntentRecord,
-  WorkflowTurnIntentResolution,
-} from "../controllers/sqlite.js";
-import { deferredTurnMessageId } from "./deferred-turn.js";
-
-export type BranchIntentResolution = {
-  resolution: WorkflowTurnIntentResolution;
-  messageId: string;
-};
-
-type NaturalDelivery = {
-  runId: string;
-  targetSessionId: string;
-  resolution: Exclude<WorkflowTurnIntentResolution, "fallback">;
-  send: (turnIntentId?: string) => void;
-};
-
-type FallbackDelivery = {
-  targetSessionId: string;
-  send: (intent: WorkflowTurnIntentRecord) => void;
-};
-
-export class DeferredTurnCoordinator {
-  private readonly store: () => SqliteControllerStore | null;
-  private readonly branchResolution: (intentId: string) => BranchIntentResolution | null;
-  private readonly leaseMs: number;
-  private readonly deferredNatural = new Map<string, NaturalDelivery>();
-
-  constructor(options: {
-    store: () => SqliteControllerStore | null;
-    branchResolution: (intentId: string) => BranchIntentResolution | null;
-    leaseMs: number;
-  }) {
-    this.store = options.store;
-    this.branchResolution = options.branchResolution;
-    this.leaseMs = options.leaseMs;
-  }
-
-  sendNatural(delivery: NaturalDelivery, idle: boolean): "sent" | "deferred" | "suppressed" {
-    const store = this.store();
-    const intent = store?.findPendingWorkflowTurnIntent({
-      runId: delivery.runId,
-      targetSessionId: delivery.targetSessionId,
-    });
-    if (store === null || store === undefined || intent === undefined) {
-      delivery.send();
-      return "sent";
-    }
-    if (!idle) {
-      this.deferredNatural.set(intent.intentId, delivery);
-      return "deferred";
-    }
-    const result = this.deliverNatural(intent.intentId, delivery);
-    if (result === "deferred") this.deferredNatural.set(intent.intentId, delivery);
-    return result;
-  }
-
-  flushNatural(idle: boolean): number {
-    if (!idle) return 0;
-    let sent = 0;
-    for (const [intentId, delivery] of this.deferredNatural) {
-      const result = this.deliverNatural(intentId, delivery);
-      if (result !== "deferred") {
-        this.deferredNatural.delete(intentId);
-      }
-      if (result === "sent") sent += 1;
-    }
-    return sent;
-  }
-
-  deliverFallbacks(delivery: FallbackDelivery, idle: boolean): number {
-    const store = this.store();
-    if (!idle || store === null) return 0;
-    const claimToken = randomUUID();
-    const intents = store.claimEligibleWorkflowTurnIntents({
-      targetSessionId: delivery.targetSessionId,
-      claimToken,
-      leaseMs: this.leaseMs,
-    });
-    let sent = 0;
-    for (const [index, intent] of intents.entries()) {
-      const branch = this.branchResolution(intent.intentId);
-      if (branch !== null) {
-        store.resolveWorkflowTurnIntent({
-          intentId: intent.intentId,
-          targetSessionId: delivery.targetSessionId,
-          claimToken,
-          resolution: branch.resolution,
-          messageId: branch.messageId,
-        });
-        continue;
-      }
-      try {
-        delivery.send(intent);
-        store.resolveWorkflowTurnIntent({
-          intentId: intent.intentId,
-          targetSessionId: delivery.targetSessionId,
-          claimToken,
-          resolution: "fallback",
-          messageId: deferredTurnMessageId(intent.intentId, "fallback"),
-        });
-        sent += 1;
-      } catch (error) {
-        for (const pending of intents.slice(index)) {
-          store.releaseWorkflowTurnIntentClaim({
-            intentId: pending.intentId,
-            targetSessionId: delivery.targetSessionId,
-            claimToken,
-          });
-        }
-        throw error;
-      }
-    }
-    return sent;
-  }
-
-  clearDeferred(): void {
-    this.deferredNatural.clear();
-  }
-
-  private deliverNatural(
-    intentId: string,
-    delivery: NaturalDelivery,
-  ): "sent" | "deferred" | "suppressed" {
-    const store = this.store();
-    if (store === null) return "deferred";
-    const claimToken = randomUUID();
-    const intent = store.claimWorkflowTurnIntent({
-      intentId,
-      targetSessionId: delivery.targetSessionId,
-      claimToken,
-      leaseMs: this.leaseMs,
-    });
-    if (intent === undefined) {
-      const current = store.getWorkflowTurnIntent(intentId);
-      return current?.resolvedAt === null ? "deferred" : "suppressed";
-    }
-    const branch = this.branchResolution(intent.intentId);
-    if (branch !== null) {
-      store.resolveWorkflowTurnIntent({
-        intentId: intent.intentId,
-        targetSessionId: delivery.targetSessionId,
-        claimToken,
-        resolution: branch.resolution,
-        messageId: branch.messageId,
-      });
-      return "suppressed";
-    }
-    try {
-      delivery.send(intent.intentId);
-      store.resolveWorkflowTurnIntent({
-        intentId: intent.intentId,
-        targetSessionId: delivery.targetSessionId,
-        claimToken,
-        resolution: delivery.resolution,
-        messageId: deferredTurnMessageId(intent.intentId, delivery.resolution),
-      });
-      return "sent";
-    } catch (error) {
-      store.releaseWorkflowTurnIntentClaim({
-        intentId: intent.intentId,
-        targetSessionId: delivery.targetSessionId,
-        claimToken,
-      });
-      throw error;
-    }
-  }
-}