@osolmaz/pi-workflows 0.12.1 → 0.13.1

package/src/viewer/watch.ts

@@ -1,28 +1,25 @@
 import fs from "node:fs";
+import path from "node:path";
 
 export type Unsubscribe = () => void;
 
-/**
- * Watch a directory tree for changes with a polling fallback. `onChange` is
- * debounced so bursts of writes trigger one refresh.
- */
-export function watchRunsDir(
-  dir: string,
+/** Watch the canonical database and its WAL with a polling fallback. */
+export function watchStateDatabase(
+  databasePath: string,
   onChange: () => void,
   options: { pollMs?: number; debounceMs?: number } = {},
 ): Unsubscribe {
   const pollMs = options.pollMs ?? 1_000;
   const debounceMs = options.debounceMs ?? 80;
+  const directory = path.dirname(databasePath);
+  const base = path.basename(databasePath);
+  const relevant = new Set([base, `${base}-wal`, `${base}-shm`]);
   let debounceTimer: NodeJS.Timeout | null = null;
   let closed = false;
 
   const fire = () => {
-    if (closed) {
-      return;
-    }
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
+    if (closed) return;
+    if (debounceTimer !== null) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => {
       debounceTimer = null;
       onChange();
@@ -31,7 +28,9 @@ export function watchRunsDir(
 
   let watcher: fs.FSWatcher | null = null;
   try {
-    watcher = fs.watch(dir, { recursive: true }, fire);
+    watcher = fs.watch(directory, (_event, filename) => {
+      if (filename === null || relevant.has(filename.toString())) fire();
+    });
     watcher.on("error", () => {
       watcher?.close();
       watcher = null;
@@ -40,15 +39,12 @@ export function watchRunsDir(
     watcher = null;
   }
 
-  // Polling fallback covers platforms without recursive fs.watch and missed events.
   const poller = setInterval(fire, pollMs);
   poller.unref?.();
 
   return () => {
     closed = true;
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
+    if (debounceTimer !== null) clearTimeout(debounceTimer);
     clearInterval(poller);
     watcher?.close();
   };

package/src/workflows/composition.ts

@@ -3,7 +3,6 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import type {
   ActionNodeDefinition,
-  AgentNodeDefinition,
   CheckpointNodeDefinition,
   ComputeNodeDefinition,
   FunctionActionNodeDefinition,
@@ -451,11 +450,20 @@ function wrapNode(
     ...(node.statusDetail !== undefined ? { statusDetail: node.statusDetail } : {}),
   };
   switch (node.nodeType) {
-    case "agent":
+    case "agent": {
+      const prompt = (context: WorkflowNodeContext) => node.prompt(project(context));
+      if (typeof node.expectedOutput === "object") {
+        return {
+          ...common,
+          nodeType: "agent",
+          prompt,
+          expectedOutput: node.expectedOutput,
+        };
+      }
       return {
         ...common,
         nodeType: "agent",
-        prompt: (context) => (node as AgentNodeDefinition).prompt(project(context)),
+        prompt,
         ...(node.expectedOutput !== undefined ? { expectedOutput: node.expectedOutput } : {}),
         ...(node.validate !== undefined
           ? {
@@ -464,6 +472,7 @@ function wrapNode(
             }
           : {}),
       };
+    }
     case "compute":
       return {
         ...common,

package/src/workflows/definition.ts

@@ -9,6 +9,9 @@ import {
 } from "./schema.js";
 import type {
   AgentNodeDefinition,
+  AssistantAgentNodeDefinition,
+  AssistantMessageOutput,
+  SubmittedAgentNodeDefinition,
   ActionNodeDefinition,
   CheckpointNodeDefinition,
   ComputeNodeDefinition,
@@ -154,11 +157,41 @@ export function isWorkflowDefinition(value: unknown): value is WorkflowDefinitio
   );
 }
 
+export function assistantMessage(options: { maxChars?: number } = {}): AssistantMessageOutput {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new Error("Invalid workflow definition: assistantMessage options must be an object");
+  }
+  const unknown = Object.keys(options).filter((key) => key !== "maxChars");
+  if (unknown.length > 0) {
+    throw new Error(
+      `Invalid workflow definition: assistantMessage has unknown option ${JSON.stringify(unknown[0])}`,
+    );
+  }
+  if (
+    options.maxChars !== undefined &&
+    (!Number.isInteger(options.maxChars) || options.maxChars <= 0)
+  ) {
+    throw new Error(
+      "Invalid workflow definition: assistantMessage maxChars must be a positive integer",
+    );
+  }
+  return Object.freeze({
+    kind: "assistant-message" as const,
+    ...(options.maxChars !== undefined ? { maxChars: options.maxChars } : {}),
+  });
+}
+
+export function agent(
+  definition: Omit<SubmittedAgentNodeDefinition, "nodeType">,
+): SubmittedAgentNodeDefinition;
+export function agent(
+  definition: Omit<AssistantAgentNodeDefinition, "nodeType">,
+): AssistantAgentNodeDefinition;
 export function agent(definition: Omit<AgentNodeDefinition, "nodeType">): AgentNodeDefinition {
-  const node: AgentNodeDefinition = {
-    nodeType: "agent",
+  const node = {
+    nodeType: "agent" as const,
     ...definition,
-  };
+  } as AgentNodeDefinition;
   assertValidAgentNode(node);
   return node;
 }