@pasko70/pibo 1.9.7 → 1.9.9

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

@@ -1,335 +0,0 @@
-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

@@ -1,232 +0,0 @@
-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;
-}