@pasko70/pibo 1.9.13 → 1.10.1

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

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import { monitorEventLoopDelay } from "node:perf_hooks";
+import { PiboSteeringUnavailableError } from "../../core/events.js";
 import { summarizeSessionSignalStatus } from "../../signals/status.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { OutputCompactor } from "./output-compactor.js";
@@ -33,9 +34,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";
@@ -45,7 +46,7 @@ import { chatSettingsRoute, chatSettingsRouteInvalidatesBootstrapCatalog, chatSe
 import { chatCapabilityRoute, chatCapabilityRouteRequiresSameOrigin, handleChatCapabilityRoute, } from "./chat-capability-routes.js";
 import { chatUserSkillRoute, chatUserSkillRouteRequiresSameOrigin, handleChatUserSkillRoute, syncChatUserSkills, } from "./chat-user-skill-routes.js";
 import { CHAT_WEB_API_PREFIX, agentResourceId, projectResourcePath, projectSessionResourceId, projectWorkflowHumanActionsResource, projectWorkflowSessionStartResource, roomResourcePath, sessionActionResource, sessionResourceId, signalResource, workflowArchiveResourceId, workflowCatalogResourceId, workflowDraftActionResource, workflowDraftManualTriggerRunResource, workflowDraftResourceId, workflowDuplicateResourceId, workflowNextDraftResourceId, workflowPickerKind, workflowPromptAssetResourceId, workflowVersionResource, } from "./chat-api-routes.js";
-import { assertProjectSessionPatchFields, buildStreamingFixtureSchedule, createAgentInput, createAgentUpdate, createRoomUpdate, createSessionUpdate, normalizeAgentArchived, normalizeClientTxnId, normalizeMessageText, normalizeParentRoomId, normalizeProjectArchived, normalizeProjectDescription, normalizeProjectPath, normalizeProjectSessionArchived, normalizeRoomDeleteConfirmation, normalizeRoomName, normalizeRoomTopic, normalizeRoomType, normalizeRoomWorkspace, normalizeSessionDeleteConfirmation, normalizeSessionTitle, normalizeStreamingFixtureCadenceMs, normalizeStreamingFixtureDeltas, normalizeStreamingFixtureMix, normalizeStreamingFixturePreludeMessages, normalizeStreamingFixturePreludeOnly, normalizeStreamingFixtureProfile, normalizeStreamingFixtureSuppressLiveDeltas, normalizeStreamingFixtureTraceSnapshots, resolveCreateSessionProfile, } from "./chat-request-normalizers.js";
+import { assertProjectSessionPatchFields, buildStreamingFixtureSchedule, createAgentInput, createAgentUpdate, createRoomUpdate, createSessionUpdate, normalizeAgentArchived, normalizeClientTxnId, normalizeMessageDelivery, normalizeMessageText, normalizeParentRoomId, normalizeProjectArchived, normalizeProjectDescription, normalizeProjectPath, normalizeProjectSessionArchived, normalizeRoomDeleteConfirmation, normalizeRoomName, normalizeRoomTopic, normalizeRoomType, normalizeRoomWorkspace, normalizeSessionDeleteConfirmation, normalizeSessionTitle, normalizeStreamingFixtureCadenceMs, normalizeStreamingFixtureDeltas, normalizeStreamingFixtureMix, normalizeStreamingFixturePreludeMessages, normalizeStreamingFixturePreludeOnly, normalizeStreamingFixtureProfile, normalizeStreamingFixtureSuppressLiveDeltas, normalizeStreamingFixtureTraceSnapshots, resolveCreateSessionProfile, } from "./chat-request-normalizers.js";
 import { ChatWorkflowArchiveStore, ChatWorkflowDraftStore, ChatWorkflowLifecycleEventStore, ChatWorkflowPromptAssetStore, ChatWorkflowPublishedVersionStore, ChatWorkflowTombstoneStore, hashWorkflowDefinitionJson, normalizeWorkflowPromptAssetLabel, sanitizeWorkflowDiagnostics, } from "./workflow-persistence.js";
 import { normalizeProjectWorkflowHumanActionBody, projectWorkflowHumanActionDiagnosticResponse, projectWorkflowHumanActionLifecyclePayload, projectWorkflowHumanActionRuntimeDiagnostic, projectWorkflowHumanActionSubmittedLifecyclePayload, projectWorkflowPendingHumanActionFromToken, validateProjectWorkflowHumanActionRequest, } from "./project-workflow-human-actions.js";
 import { createProjectWorkflowRunCurrent, createProjectWorkflowSessionSnapshot, normalizeProjectWorkflowSessionConfiguration, workflowVersionFromSnapshot, } from "./project-workflow-sessions.js";
@@ -2785,6 +2786,7 @@ function applyProjectSessionArchiveState(nodes, archivedBySessionId) {
 }
 async function sendProjectMessage(input) {
     const text = normalizeMessageText(input.body.text);
+    const delivery = normalizeMessageDelivery(input.body.delivery);
     const clientTxnId = normalizeClientTxnId(input.body.clientTxnId);
     if (typeof input.body.piboSessionId !== "string")
         throw new PiboWebHttpError("Project session is required", 400);
@@ -2808,20 +2810,30 @@ async function sendProjectMessage(input) {
             piboSessionId: selectedSession.id,
             projectId: projectSession.projectId,
             text,
+            delivery,
             ...(clientTxnId ? { clientTxnId } : {}),
         },
     });
     for (const listener of input.state.liveListeners)
         listener(accepted);
     const messageId = clientTxnId ?? randomUUID();
-    const output = await input.context.channelContext.emit({
-        type: "message",
-        piboSessionId: selectedSession.id,
-        id: messageId,
-        text,
-        source: "user",
-    });
-    return responseJson({ accepted, output });
+    try {
+        const output = await input.context.channelContext.emit({
+            type: "message",
+            piboSessionId: selectedSession.id,
+            id: messageId,
+            text,
+            delivery,
+            source: "user",
+        });
+        return responseJson({ accepted, output });
+    }
+    catch (error) {
+        if (error instanceof PiboSteeringUnavailableError) {
+            throw new PiboWebHttpError(error.message, 409);
+        }
+        throw error;
+    }
 }
 function startChatStreamingFixture(input) {
     const requestedRoomId = typeof input.body.roomId === "string" ? input.body.roomId : undefined;
@@ -2918,6 +2930,7 @@ function startChatStreamingFixture(input) {
 }
 async function sendChatMessage(input) {
     const text = normalizeMessageText(input.body.text);
+    const delivery = normalizeMessageDelivery(input.body.delivery);
     const clientTxnId = normalizeClientTxnId(input.body.clientTxnId);
     const requestedRoomId = input.forcedRoomId ?? (typeof input.body.roomId === "string" ? input.body.roomId : undefined);
     const selectedSession = resolveRequestedSession(input.state, input.context, input.webSession, input.defaultProfile, typeof input.body.piboSessionId === "string" ? input.body.piboSessionId : undefined, requestedRoomId);
@@ -2955,6 +2968,7 @@ async function sendChatMessage(input) {
             piboSessionId: selectedSession.id,
             roomId: room.id,
             text: fileAttachmentContext.messageText,
+            delivery,
             ...(webAnnotationContext.attachments.length ? {
                 webAnnotationIds: webAnnotationContext.ids,
                 webAnnotationAttachments: webAnnotationContext.attachments,
@@ -2991,12 +3005,15 @@ async function sendChatMessage(input) {
             piboSessionId: selectedSession.id,
             id: messageId,
             text: fileAttachmentContext.messageText,
+            delivery,
             source: "user",
         });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        input.context.channelContext.reportSessionError?.(selectedSession.id, errorMessage, { eventId: messageId, source: "pibo" });
+        if (!(error instanceof PiboSteeringUnavailableError)) {
+            input.context.channelContext.reportSessionError?.(selectedSession.id, errorMessage, { eventId: messageId, source: "pibo" });
+        }
         const failed = input.state.eventCommands.appendEvent({
             roomId: room.id,
             piboSessionId: selectedSession.id,
@@ -3014,6 +3031,9 @@ async function sendChatMessage(input) {
         });
         for (const listener of input.state.liveListeners)
             listener(failed);
+        if (error instanceof PiboSteeringUnavailableError) {
+            throw new PiboWebHttpError(error.message, 409);
+        }
         throw error;
     }
     markWebAnnotationsAttached(webAnnotationContext);
@@ -3034,7 +3054,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 +3242,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 = [];