@pasko70/pibo 1.9.13 → 1.10.0

package/dist/apps/chat/web-app.js

@@ -33,9 +33,9 @@ import { ChatTimelineQueryService } from "./data/timeline-query-service.js";
 import { ChatProjectService } from "./data/project-service.js";
 import { PiboDataStore } from "../../data/pibo-store.js";
 import { createDefaultPiboCronStore } from "../../cron/store.js";
-import { createDefaultPiboRalphStore } from "../../ralph/store.js";
+import { createDefaultPiboLoopStore } from "../../loops/store.js";
 import { handleChatCronApiRequest } from "./cron-api.js";
-import { handleChatRalphApiRequest } from "./ralph-api.js";
+import { handleChatLoopApiRequest } from "./loop-api.js";
 import { prepareWebAnnotationMessageAttachments } from "../../web-annotations/attachments.js";
 import { createDefaultWebAnnotationStore } from "../../web-annotations/store.js";
 import { CHAT_WEB_MOUNT_PATH, isChatAppPath, responseBuiltChatAsset, responseBuiltChatPublicFile, responseChatAppShell, isVscodeAppPath, responseBuiltVscodeAsset, responseVscodeAppShell } from "./static-assets.js";
@@ -3034,7 +3034,7 @@ export function createChatWebApp(options = {}) {
         agentStore: createAgentStore(options.agentStorePath),
         reliabilityStore: createReliabilityStore(options.reliabilityStorePath),
         cronStore: createDefaultPiboCronStore({ path: options.cronStorePath }),
-        ralphStore: createDefaultPiboRalphStore({ path: options.ralphStorePath }),
+        loopStore: createDefaultPiboLoopStore({ path: options.ralphStorePath }),
         dataStore,
         ingestService: new ChatDataIngestService(dataStore),
         traceCache: new Map(),
@@ -3222,14 +3222,14 @@ export function createChatWebApp(options = {}) {
                 if (response)
                     return response;
             }
-            if (url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/ralph`)) {
+            if (url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/loops`) || url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/loop`) || url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/ralph`)) {
                 const webSession = await requireSession(request, context);
-                const response = await handleChatRalphApiRequest({
+                const response = await handleChatLoopApiRequest({
                     request,
                     context,
                     webSession,
                     roomService: state.roomService,
-                    ralphStore: state.ralphStore,
+                    loopStore: state.loopStore,
                     defaultProfile,
                 });
                 if (response)

package/dist/apps/chat/workflow-manual-trigger-runtime.js

@@ -1,4 +1,8 @@
 import { randomUUID } from "node:crypto";
+import { Annotation, END, START, StateGraph } from "@langchain/langgraph";
+const WorkflowManualTriggerState = Annotation.Root({
+    execution: Annotation(),
+});
 export async function runWorkflowManualTextTrigger(options) {
     const diagnostics = validateWorkflowManualTextTrigger(options.definition, options.triggerNodeId, options.input, options.resolveProfile);
     if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
@@ -17,8 +21,6 @@ export async function runWorkflowManualTextTrigger(options) {
         createdAt: now,
         updatedAt: now,
     };
-    const nodeAttempts = [];
-    const edgeTransfers = [];
     const triggerAttempt = {
         id: `wna_${randomUUID()}`,
         workflowRunId: run.id,
@@ -30,52 +32,153 @@ export async function runWorkflowManualTextTrigger(options) {
         startedAt: now,
         completedAt: now,
     };
-    nodeAttempts.push(triggerAttempt);
-    const queue = [];
-    enqueueOutgoingEdges(options.definition, run.id, triggerAttempt, queue, edgeTransfers);
-    const executedNodes = new Set();
-    let lastOutput = options.input;
-    while (queue.length) {
-        const pending = queue.shift();
-        if (executedNodes.has(pending.nodeId)) {
-            const failedAt = new Date().toISOString();
-            run.status = "failed";
-            run.failedAt = failedAt;
-            run.updatedAt = failedAt;
-            return {
-                ok: false,
-                run,
-                nodeAttempts,
-                edgeTransfers,
-                diagnostics: [{
-                        code: "WorkflowRuntimeError.joinUnsupported",
-                        message: `Workflow node '${pending.nodeId}' received more than one input, but manual trigger V1 does not support joins yet.`,
-                        severity: "error",
-                        nodeId: pending.nodeId,
-                        edgeId: pending.viaEdgeId,
-                        path: `$.edges.${pending.viaEdgeId}`,
-                    }],
-                error: { code: "WorkflowRuntimeError.joinUnsupported", message: "Manual trigger run failed because a join node was reached." },
-            };
-        }
-        executedNodes.add(pending.nodeId);
-        const result = await runAgentNode({ ...options, runId: run.id, nodeId: pending.nodeId, input: pending.input });
-        nodeAttempts.push(result.attempt);
-        if (!result.ok) {
-            const failedAt = new Date().toISOString();
-            run.status = "failed";
-            run.failedAt = failedAt;
-            run.updatedAt = failedAt;
-            return { ok: false, run, nodeAttempts, edgeTransfers, diagnostics: result.diagnostics, error: result.attempt.error };
-        }
-        lastOutput = result.output;
-        enqueueOutgoingEdges(options.definition, run.id, result.attempt, queue, edgeTransfers);
+    const initialState = {
+        run,
+        nodeAttempts: [triggerAttempt],
+        edgeTransfers: [],
+        pending: [],
+        executedNodeIds: [],
+        lastOutput: options.input,
+    };
+    let execution;
+    try {
+        const graph = compileWorkflowManualTriggerGraph(options);
+        const result = await graph.invoke({ execution: initialState }, { recursionLimit: workflowGraphRecursionLimit(options.definition) });
+        execution = result.execution;
+    }
+    catch (error) {
+        const failedAt = new Date().toISOString();
+        run.status = "failed";
+        run.failedAt = failedAt;
+        run.updatedAt = failedAt;
+        return {
+            ok: false,
+            run,
+            nodeAttempts: initialState.nodeAttempts,
+            edgeTransfers: initialState.edgeTransfers,
+            diagnostics: [{
+                    code: "WorkflowRuntimeError.langGraphExecutionFailed",
+                    message: error instanceof Error ? error.message : "LangGraph execution failed with a non-Error value.",
+                    severity: "error",
+                    path: "$",
+                }],
+            error: {
+                code: "WorkflowRuntimeError.langGraphExecutionFailed",
+                message: "Manual trigger run failed during LangGraph execution.",
+            },
+        };
+    }
+    if (execution.failure) {
+        return {
+            ok: false,
+            run: execution.run,
+            nodeAttempts: execution.nodeAttempts,
+            edgeTransfers: execution.edgeTransfers,
+            diagnostics: execution.failure.diagnostics,
+            error: execution.failure.error,
+        };
     }
     const completedAt = new Date().toISOString();
-    run.output = lastOutput;
-    run.completedAt = completedAt;
-    run.updatedAt = completedAt;
-    return { ok: true, run, nodeAttempts, edgeTransfers, diagnostics, output: lastOutput };
+    execution.run.output = execution.lastOutput;
+    execution.run.completedAt = completedAt;
+    execution.run.updatedAt = completedAt;
+    return {
+        ok: true,
+        run: execution.run,
+        nodeAttempts: execution.nodeAttempts,
+        edgeTransfers: execution.edgeTransfers,
+        diagnostics,
+        output: execution.lastOutput,
+    };
+}
+function compileWorkflowManualTriggerGraph(options) {
+    const nodes = objectValue(options.definition.nodes) ?? {};
+    const graphNodeNames = new Map();
+    for (const nodeId of Object.keys(nodes))
+        graphNodeNames.set(nodeId, workflowGraphNodeName(nodeId));
+    const triggerGraphNode = graphNodeNames.get(options.triggerNodeId) ?? workflowGraphNodeName(options.triggerNodeId);
+    const graph = new StateGraph(WorkflowManualTriggerState);
+    graph.addNode(triggerGraphNode, async (state) => {
+        const execution = state.execution;
+        const triggerAttempt = execution.nodeAttempts[0];
+        enqueueOutgoingEdges(options.definition, execution.run.id, triggerAttempt, execution.pending, execution.edgeTransfers);
+        execution.current = execution.pending.shift();
+        return { execution };
+    });
+    for (const [nodeId, rawNode] of Object.entries(nodes)) {
+        if (nodeId === options.triggerNodeId || objectValue(rawNode)?.kind !== "agent")
+            continue;
+        const graphNodeName = graphNodeNames.get(nodeId);
+        graph.addNode(graphNodeName, async (state) => {
+            const execution = state.execution;
+            const pending = execution.current;
+            if (!pending || pending.nodeId !== nodeId) {
+                markWorkflowGraphFailure(execution, {
+                    diagnostics: [{
+                            code: "WorkflowRuntimeError.langGraphStateMismatch",
+                            message: `LangGraph scheduled workflow node '${nodeId}' without its pending input.`,
+                            severity: "error",
+                            nodeId,
+                            path: `$.nodes.${nodeId}`,
+                        }],
+                    error: { code: "WorkflowRuntimeError.langGraphStateMismatch", message: "Manual trigger run reached an invalid LangGraph state." },
+                });
+                return { execution };
+            }
+            if (execution.executedNodeIds.includes(nodeId)) {
+                markWorkflowGraphFailure(execution, {
+                    diagnostics: [{
+                            code: "WorkflowRuntimeError.joinUnsupported",
+                            message: `Workflow node '${nodeId}' received more than one input, but manual trigger V1 does not support joins yet.`,
+                            severity: "error",
+                            nodeId,
+                            edgeId: pending.viaEdgeId,
+                            path: `$.edges.${pending.viaEdgeId}`,
+                        }],
+                    error: { code: "WorkflowRuntimeError.joinUnsupported", message: "Manual trigger run failed because a join node was reached." },
+                });
+                return { execution };
+            }
+            execution.executedNodeIds.push(nodeId);
+            const result = await runAgentNode({ ...options, runId: execution.run.id, nodeId, input: pending.input });
+            execution.nodeAttempts.push(result.attempt);
+            if (!result.ok) {
+                markWorkflowGraphFailure(execution, { diagnostics: result.diagnostics, error: result.attempt.error });
+                return { execution };
+            }
+            execution.lastOutput = result.output;
+            enqueueOutgoingEdges(options.definition, execution.run.id, result.attempt, execution.pending, execution.edgeTransfers);
+            execution.current = execution.pending.shift();
+            return { execution };
+        });
+    }
+    const route = (state) => {
+        if (state.execution.failure || !state.execution.current)
+            return END;
+        return graphNodeNames.get(state.execution.current.nodeId) ?? END;
+    };
+    graph.addEdge(START, triggerGraphNode);
+    graph.addConditionalEdges(triggerGraphNode, route);
+    for (const [nodeId, rawNode] of Object.entries(nodes)) {
+        if (nodeId === options.triggerNodeId || objectValue(rawNode)?.kind !== "agent")
+            continue;
+        graph.addConditionalEdges(graphNodeNames.get(nodeId), route);
+    }
+    return graph.compile();
+}
+function workflowGraphNodeName(nodeId) {
+    return `pibo_${Buffer.from(nodeId).toString("base64url")}`;
+}
+function workflowGraphRecursionLimit(definition) {
+    return Math.max(25, Object.keys(objectValue(definition.nodes) ?? {}).length * 2 + 2);
+}
+function markWorkflowGraphFailure(execution, failure) {
+    const failedAt = new Date().toISOString();
+    execution.run.status = "failed";
+    execution.run.failedAt = failedAt;
+    execution.run.updatedAt = failedAt;
+    execution.failure = failure;
+    execution.current = undefined;
 }
 export function validateWorkflowManualTextTrigger(definition, triggerNodeId, input, resolveProfile) {
     const diagnostics = [];