@pasko70/pibo 1.7.4 → 1.7.5

package/dist/apps/chat/chat-api-routes.js

@@ -94,6 +94,20 @@ export function workflowDraftActionResource(pathname) {
         throw new PiboWebHttpError("Invalid workflow draft action", 400);
     }
 }
+export function workflowDraftManualTriggerRunResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/drafts/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 2 || !parts[0] || parts[1] !== "manual-trigger-runs")
+        return undefined;
+    try {
+        return { draftId: decodeURIComponent(parts[0]) };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow draft manual trigger route", 400);
+    }
+}
 export function workflowDuplicateResourceId(pathname) {
     const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
     const suffix = "/duplicate";

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

@@ -43,7 +43,7 @@ import { prepareChatFileAttachments, resolveDownloadPath, responseChatFileDownlo
 import { chatSettingsRoute, chatSettingsRouteInvalidatesBootstrapCatalog, chatSettingsRouteRequiresSameOrigin, handleChatSettingsRoute, } from "./chat-settings-routes.js";
 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, workflowDraftResourceId, workflowDuplicateResourceId, workflowNextDraftResourceId, workflowPickerKind, workflowPromptAssetResourceId, workflowVersionResource, } from "./chat-api-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 { 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";
@@ -51,6 +51,7 @@ import { createProjectWorkflowRunCurrent, createProjectWorkflowSessionSnapshot,
 import { STATIC_WORKFLOW_VERSION_CATALOG, buildProjectWorkflowVersionCatalog, buildProjectWorkflowVersionOptions, buildWorkflowCatalogInspect as buildWorkflowCatalogInspectWithServices, buildWorkflowCatalogList as buildWorkflowCatalogListWithServices, buildWorkflowVersionHistory, buildWorkflowVersionInspect as buildWorkflowVersionInspectWithServices, buildWorkflowVersionList as buildWorkflowVersionListWithServices, buildWorkflowVersionPicker, createPublishedWorkflowDefinition, selectWorkflowCatalogDisplayVersion, workflowDefinitionTags, workflowVersionPickerOptionFromCatalogRecord, } from "./workflow-catalog.js";
 import { cloneJsonObject, isWorkflowValidationPipelineDiagnostic, normalizeWorkflowValidationTrigger, normalizeWorkflowVersionIntent, parseWorkflowDraftDefinitionFromPatch, summarizeWorkflowDiagnostics, withoutRawWorkflowIrParseDiagnostic, } from "./workflow-validation-helpers.js";
 import { validateWorkflowEdgeAdapterOutputCompatibilityLike, validateWorkflowEdgeDirectCompatibilityLike, } from "./workflow-edge-compatibility.js";
+import { runWorkflowManualTextTrigger, } from "./workflow-manual-trigger-runtime.js";
 import { validateJsonSchemaObjectLike } from "./workflow-json-schema-validation.js";
 import { WORKFLOW_ADAPTER_REF_OPTIONS, WORKFLOW_GUARD_REF_OPTIONS, WORKFLOW_HUMAN_ACTION_REF_OPTIONS, buildWorkflowPromptAssetPicker, buildWorkflowRegisteredRefPicker, getWorkflowPromptAssetDocument, isWorkflowPromptAssetRegistered, } from "./workflow-registered-ref-pickers.js";
 import { validateRegisteredAdapterRefLike, validateWorkflowGuardRefLike, validateWorkflowHumanActionRefsLike, validateWorkflowPromptAssetRefLike, } from "./workflow-registered-ref-validation.js";
@@ -1536,6 +1537,31 @@ function runWorkflowDraftValidation(state, context, webSession, record, trigger)
     });
     return { validation, diagnostics };
 }
+function normalizeWorkflowDraftManualTriggerRunBody(body) {
+    const triggerNodeId = typeof body.triggerNodeId === "string" ? body.triggerNodeId.trim() : "";
+    if (!triggerNodeId)
+        throw new PiboWebHttpError("Manual trigger node id is required", 400);
+    if (typeof body.input !== "string")
+        throw new PiboWebHttpError("Manual trigger input must be text", 400);
+    return { triggerNodeId, input: body.input };
+}
+function resolveWorkflowRuntimeProfile(input) {
+    const profile = input.context.channelContext.getProfiles?.().find((candidate) => candidate.name === input.requestedId || candidate.aliases.includes(input.requestedId));
+    return profile?.name;
+}
+function workflowManualTriggerRunResponse(result, validation, draft) {
+    return {
+        ok: result.ok,
+        draft: serializeWorkflowDraft(draft),
+        validation: validation.validation,
+        diagnostics: sanitizeWorkflowDiagnostics([...validation.diagnostics, ...result.diagnostics]),
+        ...(result.run ? { run: result.run } : {}),
+        nodeAttempts: result.nodeAttempts,
+        edgeTransfers: result.edgeTransfers,
+        ...(result.output !== undefined ? { output: result.output } : {}),
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
 function validatePublishedWorkflowBoundary(input) {
     const diagnostics = sanitizeWorkflowDiagnostics(validateWorkflowDefinitionForV2(input.definition, input));
     return {
@@ -1656,15 +1682,62 @@ function validateWorkflowNodeLike(nodeId, value, input, diagnostics) {
         validateWorkflowHumanNodeLike(nodeId, value, diagnostics);
         return;
     }
+    if (kind === "trigger") {
+        validateWorkflowTriggerNodeLike(nodeId, value, diagnostics);
+        return;
+    }
     diagnostics.push({
         code: "WorkflowValidationError.unknownNodeKind",
-        message: `Workflow node '${nodeId}' must use kind agent, code, workflow, adapter, or human.`,
+        message: `Workflow node '${nodeId}' must use kind trigger, agent, code, workflow, adapter, or human.`,
         severity: "error",
         path: `${path}.kind`,
         nodeId,
         hint: "Use one of the registered V2 editable node kinds.",
     });
 }
+function validateWorkflowTriggerNodeLike(nodeId, node, diagnostics) {
+    const path = `$.nodes.${nodeId}`;
+    const trigger = isJsonObject(node.trigger) ? node.trigger : undefined;
+    if (!trigger) {
+        diagnostics.push({
+            code: "WorkflowValidationError.missingTriggerConfig",
+            message: `Trigger node '${nodeId}' must include a trigger configuration object.`,
+            severity: "error",
+            path: `${path}.trigger`,
+            nodeId,
+        });
+        return;
+    }
+    if (trigger.kind !== "manual") {
+        diagnostics.push({
+            code: "WorkflowValidationError.unsupportedTriggerKind",
+            message: `Trigger node '${nodeId}' must use manual trigger kind in this Workflow V1 slice.`,
+            severity: "error",
+            path: `${path}.trigger.kind`,
+            nodeId,
+            hint: "Webhook, cron, and other trigger providers are planned but not implemented yet.",
+        });
+    }
+    if (trigger.mode !== undefined && trigger.mode !== "editor" && trigger.mode !== "api") {
+        diagnostics.push({
+            code: "WorkflowValidationError.unsupportedTriggerMode",
+            message: `Trigger node '${nodeId}' has unsupported manual trigger mode.`,
+            severity: "error",
+            path: `${path}.trigger.mode`,
+            nodeId,
+        });
+    }
+    if (!node.output) {
+        diagnostics.push({
+            code: "WorkflowValidationError.missingTriggerOutput",
+            message: `Trigger node '${nodeId}' must declare an output port.`,
+            severity: "error",
+            path: `${path}.output`,
+            nodeId,
+            hint: "Use a text output port for the first manual trigger implementation.",
+        });
+    }
+}
 function validateWorkflowAgentNodeLike(nodeId, node, input, diagnostics) {
     const path = `$.nodes.${nodeId}`;
     if (node.runtime !== "pibo") {
@@ -3522,6 +3595,56 @@ export function createChatWebApp(options = {}) {
                 const body = await readJsonBody(request);
                 return responseJson({ asset: saveWorkflowPromptAssetRevision(state, webSession, body) }, { status: 201 });
             }
+            const workflowDraftManualTriggerRun = workflowDraftManualTriggerRunResource(url.pathname);
+            if (workflowDraftManualTriggerRun && request.method === "POST") {
+                requireSameOriginJsonRequest(request);
+                const webSession = await requireSession(request, context);
+                const body = normalizeWorkflowDraftManualTriggerRunBody(await readJsonBody(request));
+                const record = requireMutableWorkflowDraft(state, webSession, workflowDraftManualTriggerRun.draftId);
+                const validation = runWorkflowDraftValidation(state, context, webSession, record, "before_workflow_start");
+                if (!validation.validation.ok) {
+                    recordWorkflowLifecycleEvent(state, webSession, {
+                        type: "workflow.editor_test_run.blocked",
+                        workflowId: record.workflowId,
+                        workflowVersion: typeof record.definition.version === "string" ? record.definition.version : undefined,
+                        draftId: record.draftId,
+                        status: "blocked",
+                        validation: validation.validation,
+                        diagnostics: validation.diagnostics,
+                        payload: { triggerNodeId: body.triggerNodeId },
+                    });
+                    return workflowValidationBlockedResponse("Workflow draft has validation errors and cannot be test-run", validation, { draft: serializeWorkflowDraft(record) });
+                }
+                const result = await runWorkflowManualTextTrigger({
+                    definition: record.definition,
+                    triggerNodeId: body.triggerNodeId,
+                    input: body.input,
+                    actorId: auditActorIdFor(webSession),
+                    draftId: record.draftId,
+                    channelContext: context.channelContext,
+                    channel: CHAT_WEB_CHANNEL,
+                    defaultWorkspace: getDefaultPiboWorkspace(),
+                    onSessionCreated: (session) => state.sessionQuery.upsertSession(session),
+                    resolveProfile: (profileId) => resolveWorkflowRuntimeProfile({ context, requestedId: profileId }),
+                });
+                const diagnostics = result.ok ? validation.diagnostics : sanitizeWorkflowDiagnostics([...validation.diagnostics, ...result.diagnostics]);
+                recordWorkflowLifecycleEvent(state, webSession, {
+                    type: result.ok ? "workflow.editor_test_run.completed" : "workflow.editor_test_run.failed",
+                    workflowId: record.workflowId,
+                    workflowVersion: typeof record.definition.version === "string" ? record.definition.version : undefined,
+                    draftId: record.draftId,
+                    workflowRunId: result.run?.id,
+                    status: result.ok ? "accepted" : "blocked",
+                    validation: validation.validation,
+                    diagnostics,
+                    payload: {
+                        triggerNodeId: body.triggerNodeId,
+                        ...(result.run?.status ? { status: result.run.status } : {}),
+                        ...(result.ok && result.output !== undefined ? { output: result.output } : {}),
+                    },
+                });
+                return responseJson(workflowManualTriggerRunResponse(result, { validation: validation.validation, diagnostics }, record), { status: result.ok ? 202 : 400 });
+            }
             const workflowDraftAction = workflowDraftActionResource(url.pathname);
             if (workflowDraftAction && request.method === "POST") {
                 requireSameOriginJsonRequest(request);

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

@@ -0,0 +1,223 @@
+import { randomUUID } from "node:crypto";
+export async function runWorkflowManualTextTrigger(options) {
+    const diagnostics = validateWorkflowManualTextTrigger(options.definition, options.triggerNodeId, options.input, options.resolveProfile);
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+        return { ok: false, nodeAttempts: [], edgeTransfers: [], diagnostics, error: { code: "WorkflowRuntimeError.manualTriggerRunBlocked", message: "Manual trigger run was blocked by validation errors." } };
+    }
+    const now = new Date().toISOString();
+    const workflowId = stringValue(options.definition.id) || "workflow";
+    const workflowVersion = stringValue(options.definition.version) || "draft";
+    const run = {
+        id: `wfr_${randomUUID()}`,
+        workflowId,
+        workflowVersion,
+        status: "completed",
+        triggerNodeId: options.triggerNodeId,
+        input: options.input,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const nodeAttempts = [];
+    const edgeTransfers = [];
+    const triggerAttempt = {
+        id: `wna_${randomUUID()}`,
+        workflowRunId: run.id,
+        nodeId: options.triggerNodeId,
+        kind: "trigger",
+        status: "completed",
+        input: options.input,
+        output: options.input,
+        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 completedAt = new Date().toISOString();
+    run.output = lastOutput;
+    run.completedAt = completedAt;
+    run.updatedAt = completedAt;
+    return { ok: true, run, nodeAttempts, edgeTransfers, diagnostics, output: lastOutput };
+}
+export function validateWorkflowManualTextTrigger(definition, triggerNodeId, input, resolveProfile) {
+    const diagnostics = [];
+    const nodes = objectValue(definition.nodes);
+    const edges = objectValue(definition.edges);
+    const trigger = objectValue(nodes?.[triggerNodeId]);
+    if (!trigger) {
+        diagnostics.push({ code: "WorkflowRuntimeError.unknownTriggerNode", message: `Manual trigger node '${triggerNodeId}' does not exist.`, severity: "error", nodeId: triggerNodeId, path: `$.nodes.${triggerNodeId}` });
+        return diagnostics;
+    }
+    if (trigger.kind !== "trigger")
+        diagnostics.push({ code: "WorkflowRuntimeError.triggerNodeRequired", message: `Workflow node '${triggerNodeId}' is not a trigger node.`, severity: "error", nodeId: triggerNodeId, path: `$.nodes.${triggerNodeId}.kind` });
+    const triggerConfig = objectValue(trigger.trigger);
+    if (triggerConfig?.kind !== "manual")
+        diagnostics.push({ code: "WorkflowRuntimeError.manualTriggerRequired", message: `Workflow trigger node '${triggerNodeId}' must use manual trigger kind.`, severity: "error", nodeId: triggerNodeId, path: `$.nodes.${triggerNodeId}.trigger.kind` });
+    if (objectValue(trigger.output)?.kind !== "text")
+        diagnostics.push({ code: "WorkflowRuntimeError.textTriggerOutputRequired", message: `Workflow trigger node '${triggerNodeId}' must declare a text output port.`, severity: "error", nodeId: triggerNodeId, path: `$.nodes.${triggerNodeId}.output` });
+    if (typeof input !== "string")
+        diagnostics.push({ code: "WorkflowInterfaceError.textValueExpected", message: "Manual trigger input must be text.", severity: "error", path: "$.input" });
+    for (const [edgeId, rawEdge] of Object.entries(edges ?? {})) {
+        const edge = objectValue(rawEdge);
+        if (!edge)
+            continue;
+        if (edge.guard)
+            diagnostics.push({ code: "WorkflowRuntimeError.edgeGuardUnsupported", message: `Workflow edge '${edgeId}' uses a guard, which manual trigger V1 does not execute yet.`, severity: "error", edgeId, path: `$.edges.${edgeId}.guard` });
+        if (edge.adapter)
+            diagnostics.push({ code: "WorkflowRuntimeError.edgeAdapterUnsupported", message: `Workflow edge '${edgeId}' uses an adapter, which manual trigger V1 does not execute yet.`, severity: "error", edgeId, path: `$.edges.${edgeId}.adapter` });
+        const from = objectValue(edge.from);
+        const to = objectValue(edge.to);
+        const source = typeof from?.nodeId === "string" ? objectValue(nodes?.[from.nodeId]) : undefined;
+        const targetNodeId = typeof to?.nodeId === "string" ? to.nodeId : "";
+        const target = targetNodeId ? objectValue(nodes?.[targetNodeId]) : undefined;
+        if (!source || !target)
+            continue;
+        if (source.kind !== "trigger" && source.kind !== "agent")
+            continue;
+        if (target.kind !== "agent")
+            diagnostics.push({ code: "WorkflowRuntimeError.agentTargetRequired", message: `Workflow edge '${edgeId}' targets a non-agent node, which manual trigger V1 does not execute yet.`, severity: "error", edgeId, nodeId: targetNodeId, path: `$.edges.${edgeId}.to.nodeId` });
+        const sourceOutput = objectValue(source.output);
+        const targetInput = objectValue(target.input);
+        if (sourceOutput?.kind && targetInput?.kind && (sourceOutput.kind !== "text" || targetInput.kind !== "text")) {
+            diagnostics.push({ code: "WorkflowGraphError.incompatibleEdgePorts", message: `Workflow edge '${edgeId}' must connect text output to text input for manual trigger V1.`, severity: "error", edgeId, path: `$.edges.${edgeId}` });
+        }
+        if (target.kind === "agent") {
+            const profile = objectValue(target.profile);
+            const profileId = typeof profile?.id === "string" ? profile.id : "";
+            if (!profileId || !resolveProfile(profileId))
+                diagnostics.push({ code: "WorkflowRuntimeError.unknownAgentProfile", message: `Agent node '${targetNodeId}' references unavailable profile '${profileId || "<missing>"}'.`, severity: "error", nodeId: targetNodeId, path: `$.nodes.${targetNodeId}.profile.id` });
+        }
+    }
+    return diagnostics;
+}
+function enqueueOutgoingEdges(definition, runId, sourceAttempt, queue, transfers) {
+    const edges = objectValue(definition.edges) ?? {};
+    for (const [edgeId, rawEdge] of Object.entries(edges).sort(([left], [right]) => left.localeCompare(right))) {
+        const edge = objectValue(rawEdge);
+        const from = objectValue(edge?.from);
+        const to = objectValue(edge?.to);
+        if (from?.nodeId !== sourceAttempt.nodeId || typeof to?.nodeId !== "string")
+            continue;
+        const payload = sourceAttempt.output ?? "";
+        transfers.push({ id: `wet_${randomUUID()}`, workflowRunId: runId, edgeId, sourceNodeAttemptId: sourceAttempt.id, targetNodeId: to.nodeId, status: "transferred", payload, createdAt: new Date().toISOString() });
+        queue.push({ nodeId: to.nodeId, input: payload, viaEdgeId: edgeId, sourceAttemptId: sourceAttempt.id });
+    }
+}
+async function runAgentNode(options) {
+    const startedAt = new Date().toISOString();
+    const node = objectValue(objectValue(options.definition.nodes)?.[options.nodeId]) ?? {};
+    const profileId = stringValue(objectValue(node.profile)?.id) || "base";
+    const resolvedProfile = options.resolveProfile(profileId) ?? profileId;
+    const attempt = { id: `wna_${randomUUID()}`, workflowRunId: options.runId, nodeId: options.nodeId, kind: "agent", status: "completed", input: options.input, startedAt };
+    try {
+        const session = options.channelContext.createSession({
+            channel: options.channel,
+            kind: "workflow-agent",
+            profile: resolvedProfile,
+            workspace: options.defaultWorkspace,
+            title: `${stringValue(options.definition.id) || "Workflow"} · ${stringValue(node.label) || options.nodeId}`,
+            metadata: {
+                workflowRunId: options.runId,
+                workflowRunSource: "manual.editor",
+                ...(options.draftId ? { workflowDraftId: options.draftId } : {}),
+                workflowTriggerNodeId: options.triggerNodeId,
+                workflowNodeId: options.nodeId,
+                workflowNodeAttemptId: attempt.id,
+                workflowNodeLabel: stringValue(node.label) || options.nodeId,
+                ...(options.actorId ? { actorId: options.actorId } : {}),
+            },
+        });
+        options.onSessionCreated?.(session);
+        attempt.piboSessionId = session.id;
+        const prompt = renderPromptTemplate(stringValue(node.promptTemplate) || "{{input}}", options.input);
+        const output = await emitMessageAndWaitForAssistant(options.channelContext, session.id, prompt);
+        attempt.output = output;
+        attempt.completedAt = new Date().toISOString();
+        return { ok: true, attempt, output };
+    }
+    catch (error) {
+        attempt.status = "failed";
+        attempt.failedAt = new Date().toISOString();
+        attempt.error = { code: "WorkflowRuntimeError.agentNodeFailed", message: error instanceof Error ? error.message : "Agent node failed with a non-Error value." };
+        return { ok: false, attempt, diagnostics: [{ code: attempt.error.code, message: attempt.error.message, severity: "error", nodeId: options.nodeId, path: `$.nodes.${options.nodeId}` }] };
+    }
+}
+function emitMessageAndWaitForAssistant(channelContext, piboSessionId, text, timeoutMs = 120000) {
+    return new Promise((resolve, reject) => {
+        const eventId = `wfm_${randomUUID()}`;
+        let settled = false;
+        let timeout;
+        let unsubscribe = () => { };
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            unsubscribe();
+            if (value instanceof Error)
+                reject(value);
+            else
+                resolve(value);
+        };
+        timeout = setTimeout(() => finish(new Error(`Timed out waiting for assistant reply from workflow agent session '${piboSessionId}'.`)), timeoutMs);
+        unsubscribe = channelContext.subscribe((event) => {
+            if (event.piboSessionId !== piboSessionId)
+                return;
+            if (event.type === "assistant_message") {
+                if (event.eventId === eventId)
+                    finish(event.text);
+                return;
+            }
+            if (event.type === "session_error" && event.eventId === eventId)
+                finish(new Error(event.error));
+        });
+        channelContext.emit({ type: "message", piboSessionId, id: eventId, text, source: "actor" }).catch(finish);
+    });
+}
+function renderPromptTemplate(template, input) {
+    return template.replace(/{{\s*input\s*}}/g, input);
+}
+function objectValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}