@pasko70/pibo 1.9.9 → 1.9.10

package/dist/apps/chat/workflow-json-schema-validation.js

@@ -0,0 +1,335 @@
+function isJsonValue(value) {
+    if (value === null
+        || typeof value === "string"
+        || typeof value === "boolean"
+        || (typeof value === "number" && Number.isFinite(value))) {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (value && typeof value === "object")
+        return Object.values(value).every(isJsonValue);
+    return false;
+}
+function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value) && isJsonValue(value);
+}
+const WORKFLOW_JSON_SCHEMA_SUPPORTED_TYPES = new Set(["string", "number", "integer", "boolean", "object", "array", "null"]);
+const WORKFLOW_JSON_SCHEMA_SUPPORTED_KEYS = new Set([
+    "type",
+    "title",
+    "description",
+    "enum",
+    "const",
+    "default",
+    "properties",
+    "required",
+    "additionalProperties",
+    "items",
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "$defs",
+    "$ref",
+]);
+export function validateJsonSchemaObjectLike(value, path, diagnostics, options) {
+    const { requireObjectRoot, ...target } = options;
+    if (!isJsonObject(value)) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowSchemaError.invalidJsonSchema",
+            message: `JSON schema at '${path}' must be an object.`,
+            path,
+            hint: "Use the existing JSON Schema subset object; Zod schemas are not part of V2 authoring.",
+        });
+        return;
+    }
+    validateWorkflowJsonSchemaSubsetLike(value, path, diagnostics, target, {
+        context: { rootSchema: value, seenRefs: new Set() },
+        root: true,
+        requireObjectRoot,
+    });
+}
+function validateWorkflowJsonSchemaSubsetLike(value, path, diagnostics, target, options) {
+    if (!isJsonObject(value)) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.schemaNotObject",
+            message: "JSON schema must be an object in the V1 Structured Outputs subset.",
+            path,
+            hint: "Use an object JSON Schema with a supported type, properties, and required fields.",
+        });
+        return;
+    }
+    for (const key of Object.keys(value)) {
+        if (!WORKFLOW_JSON_SCHEMA_SUPPORTED_KEYS.has(key)) {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.unsupportedSchemaKeyword",
+                message: `JSON Schema keyword '${key}' is not supported by the V1 Structured Outputs subset.`,
+                path: `${path}.${key}`,
+                hint: "Remove the keyword or model the contract with type, properties, items, enum, const, anyOf, $defs, or $ref.",
+            });
+        }
+    }
+    if (value.oneOf !== undefined) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.unsupportedOneOf",
+            message: "oneOf is not supported by the V1 Structured Outputs subset.",
+            path: `${path}.oneOf`,
+            hint: "Use anyOf for supported alternatives, or split the contract into explicit adapter/workflow steps.",
+        });
+    }
+    if (value.allOf !== undefined) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.unsupportedAllOf",
+            message: "allOf is not supported by the V1 Structured Outputs subset.",
+            path: `${path}.allOf`,
+            hint: "Flatten the schema into one object with explicit properties and required fields.",
+        });
+    }
+    validateWorkflowJsonSchemaDefsLike(value, path, diagnostics, target, options.context);
+    validateWorkflowJsonSchemaRefLike(value, path, diagnostics, target, options);
+    if (value.type === undefined && value.$ref === undefined && value.anyOf === undefined) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.schemaTypeMissing",
+            message: "JSON schemas must declare a supported type unless they are local $ref or anyOf wrappers.",
+            path: `${path}.type`,
+            hint: "Add type: 'object', 'array', 'string', 'number', 'integer', 'boolean', or 'null'.",
+        });
+    }
+    const schemaTypes = validateWorkflowJsonSchemaTypeLike(value.type, path, diagnostics, target);
+    if (options.root && value.anyOf !== undefined) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.rootAnyOf",
+            message: "Root anyOf is not supported for workflow structured output schemas.",
+            path: `${path}.anyOf`,
+            hint: "Use a root object and place anyOf inside a property or $defs entry.",
+        });
+    }
+    validateWorkflowJsonSchemaAnyOfLike(value, path, diagnostics, target, options.context);
+    if (options.root && options.requireObjectRoot && value.$ref === undefined && !schemaTypes.includes("object")) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.rootMustBeObject",
+            message: "Structured workflow JSON schemas must have an object root in V1.",
+            path: `${path}.type`,
+            hint: "Wrap scalar or array values in an object property, e.g. { type: 'object', properties: { value: ... }, required: ['value'], additionalProperties: false }.",
+        });
+    }
+    if (schemaTypes.includes("object") || value.properties !== undefined || value.required !== undefined || value.additionalProperties !== undefined) {
+        validateWorkflowJsonObjectSchemaLike(value, path, diagnostics, target, options.context);
+    }
+    if (schemaTypes.includes("array")) {
+        if (value.items === undefined) {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.arrayMissingItems",
+                message: "Array schemas must declare an items schema.",
+                path: `${path}.items`,
+                hint: "Add items with another supported V1 schema.",
+            });
+        }
+        else {
+            validateWorkflowJsonSchemaSubsetLike(value.items, `${path}.items`, diagnostics, target, {
+                context: options.context,
+                root: false,
+                requireObjectRoot: false,
+            });
+        }
+    }
+    if (value.enum !== undefined && !Array.isArray(value.enum)) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.invalidEnum",
+            message: "enum must be an array of JSON values.",
+            path: `${path}.enum`,
+            hint: "Use enum: ['one', 'two'] or remove the enum constraint.",
+        });
+    }
+}
+function validateWorkflowJsonSchemaDefsLike(schema, path, diagnostics, target, context) {
+    if (schema.$defs === undefined)
+        return;
+    if (!isJsonObject(schema.$defs)) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.invalidDefs",
+            message: "$defs must be an object keyed by local definition name.",
+            path: `${path}.$defs`,
+            hint: "Use $defs: { Name: { type: 'object', ... } } for reusable schemas.",
+        });
+        return;
+    }
+    for (const [defName, defSchema] of Object.entries(schema.$defs)) {
+        validateWorkflowJsonSchemaSubsetLike(defSchema, `${path}.$defs.${defName}`, diagnostics, target, {
+            context,
+            root: false,
+            requireObjectRoot: false,
+        });
+    }
+}
+function validateWorkflowJsonSchemaRefLike(schema, path, diagnostics, target, options) {
+    if (schema.$ref === undefined)
+        return;
+    if (typeof schema.$ref !== "string") {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.invalidRef",
+            message: "$ref must be a string local reference.",
+            path: `${path}.$ref`,
+            hint: "Use local references such as '#/$defs/MyObject'.",
+        });
+        return;
+    }
+    const refTarget = resolveWorkflowJsonSchemaLocalRef(options.context.rootSchema, schema.$ref);
+    if (!refTarget) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.unresolvedRef",
+            message: `JSON Schema reference '${schema.$ref}' could not be resolved.`,
+            path: `${path}.$ref`,
+            hint: "Only local $defs references are supported in V1, for example '#/$defs/MyObject'.",
+        });
+        return;
+    }
+    if (options.context.seenRefs.has(schema.$ref))
+        return;
+    options.context.seenRefs.add(schema.$ref);
+    validateWorkflowJsonSchemaSubsetLike(refTarget, `${path}.$ref(${schema.$ref})`, diagnostics, target, options);
+    options.context.seenRefs.delete(schema.$ref);
+}
+function validateWorkflowJsonSchemaAnyOfLike(schema, path, diagnostics, target, context) {
+    if (schema.anyOf === undefined)
+        return;
+    if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.invalidAnyOf",
+            message: "anyOf must be a non-empty array of schema objects.",
+            path: `${path}.anyOf`,
+            hint: "Provide one or more supported schema alternatives.",
+        });
+        return;
+    }
+    schema.anyOf.forEach((item, index) => validateWorkflowJsonSchemaSubsetLike(item, `${path}.anyOf.${index}`, diagnostics, target, {
+        context,
+        root: false,
+        requireObjectRoot: false,
+    }));
+}
+function validateWorkflowJsonSchemaTypeLike(value, path, diagnostics, target) {
+    if (value === undefined)
+        return [];
+    const values = Array.isArray(value) ? value : [value];
+    if (values.length === 0) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.emptyType",
+            message: "Schema type arrays must include at least one supported type.",
+            path: `${path}.type`,
+            hint: "Use a supported type such as 'object', or a nullable pair such as ['string', 'null'].",
+        });
+        return [];
+    }
+    const seen = new Set();
+    const validTypes = [];
+    values.forEach((typeName, index) => {
+        if (typeof typeName !== "string" || !WORKFLOW_JSON_SCHEMA_SUPPORTED_TYPES.has(typeName)) {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.unsupportedSchemaType",
+                message: `Schema type '${String(typeName)}' is not supported by the V1 Structured Outputs subset.`,
+                path: Array.isArray(value) ? `${path}.type.${index}` : `${path}.type`,
+                hint: "Use one of string, number, integer, boolean, object, array, or null.",
+            });
+            return;
+        }
+        if (seen.has(typeName)) {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.duplicateSchemaType",
+                message: `Schema type '${typeName}' is duplicated.`,
+                path: Array.isArray(value) ? `${path}.type.${index}` : `${path}.type`,
+                hint: "List each schema type only once.",
+            });
+            return;
+        }
+        seen.add(typeName);
+        validTypes.push(typeName);
+    });
+    return validTypes;
+}
+function validateWorkflowJsonObjectSchemaLike(schema, path, diagnostics, target, context) {
+    if (schema.additionalProperties !== false) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.objectAdditionalProperties",
+            message: "Object schemas must set additionalProperties: false in the V1 Structured Outputs subset.",
+            path: `${path}.additionalProperties`,
+            hint: "Add additionalProperties: false to every object schema.",
+        });
+    }
+    if (schema.properties !== undefined && !isJsonObject(schema.properties)) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.invalidProperties",
+            message: "Object schema properties must be an object.",
+            path: `${path}.properties`,
+            hint: "Use properties: { fieldName: { type: 'string' } }.",
+        });
+        return;
+    }
+    const propertyEntries = Object.entries(isJsonObject(schema.properties) ? schema.properties : {});
+    if (propertyEntries.length > 0 && !Array.isArray(schema.required)) {
+        addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+            code: "WorkflowInterfaceError.objectRequiredMissing",
+            message: "Object schemas must list every property in required.",
+            path: `${path}.required`,
+            hint: "Set required to exactly the object property names; use nullable types for optional semantics.",
+        });
+    }
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const requiredSet = new Set(required.filter((entry) => typeof entry === "string"));
+    for (const [propertyName, propertySchema] of propertyEntries) {
+        if (!requiredSet.has(propertyName)) {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.objectPropertyNotRequired",
+                message: `Object property '${propertyName}' must be listed in required.`,
+                path: `${path}.required`,
+                hint: "Structured Outputs requires every object field to be required; use a union with null for nullable fields.",
+            });
+        }
+        validateWorkflowJsonSchemaSubsetLike(propertySchema, `${path}.properties.${propertyName}`, diagnostics, target, {
+            context,
+            root: false,
+            requireObjectRoot: false,
+        });
+    }
+    for (const requiredName of required) {
+        if (typeof requiredName !== "string") {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.invalidRequiredEntry",
+                message: "required entries must be strings.",
+                path: `${path}.required`,
+                hint: "List required property names as strings.",
+            });
+            continue;
+        }
+        if (isJsonObject(schema.properties) && !Object.hasOwn(schema.properties, requiredName)) {
+            addWorkflowJsonSchemaDiagnostic(diagnostics, target, {
+                code: "WorkflowInterfaceError.requiredUnknownProperty",
+                message: `Required property '${requiredName}' is not declared in properties.`,
+                path: `${path}.required`,
+                hint: "Remove the unknown required name or add a matching property schema.",
+            });
+        }
+    }
+}
+function resolveWorkflowJsonSchemaLocalRef(rootSchema, ref) {
+    if (!ref.startsWith("#/$defs/"))
+        return undefined;
+    const defs = isJsonObject(rootSchema.$defs) ? rootSchema.$defs : undefined;
+    if (!defs)
+        return undefined;
+    const pointer = ref.slice("#/$defs/".length).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let current = defs;
+    for (const segment of pointer) {
+        if (!isJsonObject(current) || !Object.hasOwn(current, segment))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function addWorkflowJsonSchemaDiagnostic(diagnostics, target, input) {
+    diagnostics.push({
+        ...input,
+        severity: "error",
+        ...target,
+    });
+}

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

@@ -0,0 +1,232 @@
+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 lastAssistantMessage;
+        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}'.`));
+            void channelContext.emit({ type: "execution", piboSessionId, action: "abort", id: `wfm_abort_${randomUUID()}` }).catch(() => { });
+        }, timeoutMs);
+        unsubscribe = channelContext.subscribe((event) => {
+            if (event.piboSessionId !== piboSessionId)
+                return;
+            if (!("eventId" in event) || event.eventId !== eventId)
+                return;
+            if (event.type === "assistant_message") {
+                lastAssistantMessage = event.text;
+                return;
+            }
+            if (event.type === "message_finished") {
+                finish(lastAssistantMessage ?? new Error(`Workflow agent session '${piboSessionId}' finished without an assistant reply.`));
+                return;
+            }
+            if (event.type === "session_error")
+                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;
+}