@pasko70/pibo 1.9.9 → 1.9.11

package/dist/apps/chat/workflow-catalog.js

@@ -0,0 +1,572 @@
+import { PiboWebHttpError } from "../../web/http.js";
+import { compareWorkflowSemver, hashWorkflowDefinitionJson, parseWorkflowSemver, sanitizeWorkflowDiagnostics, } from "./workflow-persistence.js";
+export const STATIC_WORKFLOW_VERSION_CATALOG = [
+    {
+        id: "standard-project",
+        version: "1.0.0",
+        title: "Standard Project",
+        description: "Configured workflow-backed Project session for feature, bugfix, and review work. Creation saves the configuration without starting a run.",
+        source: "code",
+        status: "published",
+        tags: ["project", "workflow"],
+    },
+    {
+        id: "simple-chat",
+        version: "1.0.0",
+        title: "Simple Chat",
+        description: "Baseline Project chat workflow that preserves the existing one-session chat behavior.",
+        source: "code",
+        status: "published",
+        tags: ["project", "chat"],
+    },
+    {
+        id: "ui-review-workflow",
+        version: "2.0.0",
+        title: "UI Review Workflow",
+        description: "UI-authored published workflow fixture for next-version draft editing.",
+        source: "ui",
+        status: "published",
+        tags: ["workflow-ui", "review"],
+    },
+    {
+        id: "ui-draft-workflow",
+        version: "0.1.0-draft",
+        title: "UI Draft Workflow",
+        description: "Unpublished fixture used to enforce Project session creation boundaries.",
+        source: "ui",
+        status: "draft",
+        tags: ["workflow-ui", "draft"],
+    },
+    {
+        id: "archived-review-workflow",
+        version: "1.0.0",
+        title: "Archived Review Workflow",
+        description: "Archived fixture omitted from default Project session creation choices.",
+        source: "ui",
+        status: "archived",
+        tags: ["workflow-ui", "archived"],
+    },
+];
+export function buildWorkflowVersionPicker(state, selectedWorkflowId, selectedWorkflowVersion) {
+    const options = buildProjectWorkflowVersionOptions(state);
+    const normalizedWorkflowId = selectedWorkflowId?.trim() || undefined;
+    const normalizedWorkflowVersion = selectedWorkflowVersion?.trim() || undefined;
+    const selected = normalizedWorkflowId
+        ? options.find((option) => option.id === normalizedWorkflowId && (!normalizedWorkflowVersion || option.version === normalizedWorkflowVersion))
+        : options[0];
+    const diagnostics = [];
+    if (normalizedWorkflowId && !selected) {
+        diagnostics.push({
+            code: "WorkflowCatalogError.unknownWorkflowVersion",
+            message: `Workflow version '${normalizedWorkflowId}${normalizedWorkflowVersion ? `@${normalizedWorkflowVersion}` : ""}' is not available for Project session creation.`,
+            severity: "error",
+            path: "$.workflow",
+            registryRef: normalizedWorkflowVersion ? `${normalizedWorkflowId}@${normalizedWorkflowVersion}` : normalizedWorkflowId,
+            hint: "Select a published workflow version from the global workflow catalog.",
+        });
+    }
+    return {
+        kind: "workflow-versions",
+        options,
+        ...(selected ? { selectedWorkflowId: selected.id, selectedWorkflowVersion: selected.version } : {}),
+        diagnostics,
+    };
+}
+export function buildWorkflowVersionHistory(state, selectedWorkflowId, selectedWorkflowVersion) {
+    const options = [...buildProjectWorkflowVersionCatalog(state)]
+        .filter((option) => option.status !== "deleted")
+        .sort(compareWorkflowCatalogVersionRecords)
+        .map(workflowVersionHistoryOptionFromCatalogRecord);
+    const normalizedWorkflowId = selectedWorkflowId?.trim() || undefined;
+    const normalizedWorkflowVersion = selectedWorkflowVersion?.trim() || undefined;
+    const selected = normalizedWorkflowId
+        ? options.find((option) => option.id === normalizedWorkflowId && (!normalizedWorkflowVersion || option.version === normalizedWorkflowVersion))
+        : undefined;
+    const diagnostics = [];
+    if (normalizedWorkflowId && !selected) {
+        diagnostics.push({
+            code: "WorkflowCatalogError.unknownWorkflowVersion",
+            message: `Workflow version '${normalizedWorkflowId}${normalizedWorkflowVersion ? `@${normalizedWorkflowVersion}` : ""}' is not present in workflow version history.`,
+            severity: "error",
+            path: "$.workflow",
+            registryRef: normalizedWorkflowVersion ? `${normalizedWorkflowId}@${normalizedWorkflowVersion}` : normalizedWorkflowId,
+            hint: "Open a live, archived, or snapshot-backed workflow version record from the catalog history.",
+        });
+    }
+    return {
+        kind: "version-history",
+        options,
+        ...(selected ? { selectedWorkflowId: selected.id, selectedWorkflowVersion: selected.version } : {}),
+        diagnostics,
+    };
+}
+export function buildProjectWorkflowVersionOptions(state) {
+    return buildProjectWorkflowVersionCatalog(state)
+        .filter((option) => option.status === "published")
+        .map(workflowVersionPickerOptionFromCatalogRecord);
+}
+export function workflowVersionPickerOptionFromCatalogRecord(record) {
+    return {
+        ...record,
+        displayName: record.title,
+        paramsSchema: null,
+    };
+}
+function workflowVersionHistoryOptionFromCatalogRecord(record) {
+    const actions = workflowCatalogActionsFor(record);
+    return {
+        ...record,
+        actions,
+        editability: workflowCatalogEditability(actions),
+    };
+}
+export function buildProjectWorkflowVersionCatalog(state) {
+    const recordsByKey = new Map();
+    for (const record of STATIC_WORKFLOW_VERSION_CATALOG) {
+        const projected = workflowCatalogRecordWithArchiveState(record, state);
+        recordsByKey.set(workflowCatalogVersionKey(projected.id, projected.version), projected);
+    }
+    if (state) {
+        for (const record of state.workflowPublishedVersionStore.listPublishedVersions()) {
+            const projected = workflowCatalogRecordWithArchiveState(workflowCatalogRecordFromPublishedVersion(record), state);
+            recordsByKey.set(workflowCatalogVersionKey(projected.id, projected.version), projected);
+        }
+    }
+    return [...recordsByKey.values()];
+}
+function workflowCatalogRecordWithArchiveState(record, state) {
+    if (record.source === "ui" && state?.workflowTombstoneStore.getWorkflowTombstone(record.id))
+        return { ...record, status: "deleted" };
+    const archiveState = state?.workflowArchiveStore.getWorkflowArchiveState(record.id);
+    if (record.source === "ui" && archiveState?.archived)
+        return { ...record, status: "archived" };
+    return record;
+}
+function workflowCatalogVersionKey(workflowId, version) {
+    return `${workflowId}@${version}`;
+}
+function workflowCatalogRecordFromPublishedVersion(record) {
+    return {
+        id: record.workflowId,
+        version: record.version,
+        title: typeof record.definition.title === "string" ? record.definition.title : record.workflowId,
+        ...(typeof record.definition.description === "string" ? { description: record.definition.description } : {}),
+        source: "ui",
+        status: "published",
+        tags: workflowDefinitionTags(record.definition),
+    };
+}
+const WORKFLOW_CATALOG_STATUS_SORT_ORDER = {
+    published: 0,
+    draft: 1,
+    archived: 2,
+    deleted: 3,
+};
+export function compareWorkflowCatalogVersionRecords(left, right) {
+    return left.id.localeCompare(right.id)
+        || compareWorkflowCatalogVersionStrings(left.version, right.version)
+        || WORKFLOW_CATALOG_STATUS_SORT_ORDER[left.status] - WORKFLOW_CATALOG_STATUS_SORT_ORDER[right.status]
+        || left.title.localeCompare(right.title);
+}
+function compareWorkflowCatalogVersionStrings(left, right) {
+    const leftSemver = parseWorkflowSemver(left);
+    const rightSemver = parseWorkflowSemver(right);
+    if (leftSemver && rightSemver)
+        return compareWorkflowSemver(leftSemver, rightSemver);
+    if (leftSemver)
+        return -1;
+    if (rightSemver)
+        return 1;
+    return left.localeCompare(right, undefined, { numeric: true, sensitivity: "base" });
+}
+export function workflowDefinitionTags(definition) {
+    const metadata = isJsonObject(definition.metadata) ? definition.metadata : undefined;
+    const tags = metadata && Array.isArray(metadata.tags) ? metadata.tags : [];
+    return tags.filter((tag) => typeof tag === "string");
+}
+export function buildWorkflowCatalogList(state, context, webSession, services, options = {}) {
+    const includeArchived = options.includeArchived === true;
+    const workflows = new Map();
+    const buildContext = { state, context, webSession, includeArchived, services };
+    for (const record of STATIC_WORKFLOW_VERSION_CATALOG) {
+        if (record.status === "draft")
+            continue;
+        const summary = workflowCatalogVersionSummaryFromCatalogRecord(record, buildContext);
+        if (!isWorkflowCatalogSummaryVisible(summary, includeArchived))
+            continue;
+        addWorkflowCatalogVersion(workflows, summary);
+    }
+    for (const record of state.workflowPublishedVersionStore.listPublishedVersions()) {
+        const summary = workflowCatalogVersionSummaryFromPublishedVersion(record, buildContext);
+        if (!isWorkflowCatalogSummaryVisible(summary, includeArchived))
+            continue;
+        addWorkflowCatalogVersion(workflows, summary);
+    }
+    for (const draft of state.workflowDraftStore.listDrafts()) {
+        const summary = workflowCatalogVersionSummaryFromDraft(draft, state);
+        if (!isWorkflowCatalogSummaryVisible(summary, includeArchived))
+            continue;
+        addWorkflowCatalogVersion(workflows, summary);
+        const accumulator = workflows.get(draft.workflowId);
+        if (accumulator)
+            accumulator.activeDraftId = draft.draftId;
+    }
+    return {
+        kind: "workflow-catalog",
+        includeArchived,
+        workflows: [...workflows.values()]
+            .map(workflowCatalogRecordFromAccumulator)
+            .sort(compareWorkflowCatalogRecords),
+    };
+}
+function isWorkflowCatalogSummaryVisible(summary, includeArchived) {
+    if (summary.status === "deleted")
+        return false;
+    if (summary.status === "archived" && !includeArchived)
+        return false;
+    return true;
+}
+function addWorkflowCatalogVersion(workflows, summary) {
+    const existing = workflows.get(summary.id);
+    const accumulator = existing ?? {
+        id: summary.id,
+        title: summary.title,
+        ...(summary.description ? { description: summary.description } : {}),
+        source: summary.source,
+        tags: new Set(),
+        versions: [],
+    };
+    if (!existing)
+        workflows.set(summary.id, accumulator);
+    if (summary.source === "ui")
+        accumulator.source = "ui";
+    if (summary.status === "draft") {
+        accumulator.title = summary.title;
+        if (summary.description)
+            accumulator.description = summary.description;
+    }
+    for (const tag of summary.tags)
+        accumulator.tags.add(tag);
+    accumulator.versions.push(summary);
+}
+function workflowCatalogRecordFromAccumulator(accumulator) {
+    const versions = [...accumulator.versions].sort(compareWorkflowCatalogVersionRecords);
+    const diagnostics = uniqueWorkflowDiagnostics(versions.flatMap((version) => version.diagnostics));
+    const actions = uniqueWorkflowCatalogActions(versions.flatMap((version) => version.actions));
+    const latest = selectWorkflowCatalogDisplayVersion(versions);
+    return {
+        id: accumulator.id,
+        title: latest?.title ?? accumulator.title,
+        ...(latest?.description ?? accumulator.description ? { description: latest?.description ?? accumulator.description } : {}),
+        tags: [...new Set([...accumulator.tags, ...(latest?.tags ?? [])])].sort(),
+        source: accumulator.source,
+        status: deriveWorkflowCatalogStatus(versions),
+        versions,
+        ...(accumulator.activeDraftId ? { activeDraftId: accumulator.activeDraftId } : {}),
+        editability: workflowCatalogEditability(actions),
+        validationState: workflowCatalogValidationStateFromVersions(versions),
+        diagnostics,
+        missingRefs: workflowMissingRefDiagnostics(diagnostics),
+        actions,
+    };
+}
+export function selectWorkflowCatalogDisplayVersion(versions) {
+    const sorted = [...versions].sort(compareWorkflowCatalogVersionRecords);
+    return [...sorted].reverse().find((version) => version.status === "draft")
+        ?? [...sorted].reverse().find((version) => version.status === "published")
+        ?? sorted[0];
+}
+function deriveWorkflowCatalogStatus(versions) {
+    if (versions.some((version) => version.status === "draft"))
+        return "draft";
+    if (versions.some((version) => version.status === "published"))
+        return "published";
+    if (versions.some((version) => version.status === "archived"))
+        return "archived";
+    return versions[0]?.status ?? "deleted";
+}
+function workflowCatalogVersionSummaryFromCatalogRecord(record, context) {
+    const catalogRecord = workflowCatalogRecordWithArchiveState(record, context.state);
+    const definition = catalogRecord.status === "published" || catalogRecord.status === "archived"
+        ? createPublishedWorkflowDefinition(catalogRecord, "base")
+        : undefined;
+    const diagnostics = definition ? context.services.validateDefinition(definition, context) : [];
+    return {
+        ...catalogRecord,
+        ...(definition ? { definitionHash: hashWorkflowDefinitionJson(definition) } : {}),
+        validationState: workflowCatalogValidationStateFromDiagnostics(diagnostics, definition ? "valid" : "unknown"),
+        diagnostics,
+        missingRefs: workflowMissingRefDiagnostics(diagnostics),
+        actions: workflowCatalogActionsFor(catalogRecord),
+    };
+}
+function workflowCatalogVersionSummaryFromPublishedVersion(record, context) {
+    const catalogRecord = workflowCatalogRecordWithArchiveState(workflowCatalogRecordFromPublishedVersion(record), context.state);
+    const diagnostics = context.services.validateDefinition(record.definition, context);
+    return {
+        ...catalogRecord,
+        definitionHash: record.definitionHash,
+        validationState: workflowCatalogValidationStateFromDiagnostics(diagnostics, "valid"),
+        diagnostics,
+        missingRefs: workflowMissingRefDiagnostics(diagnostics),
+        actions: workflowCatalogActionsFor(catalogRecord),
+    };
+}
+function workflowCatalogVersionSummaryFromDraft(draft, state) {
+    const record = workflowCatalogRecordWithArchiveState(workflowCatalogRecordFromDraft(draft), state);
+    const diagnostics = sanitizeWorkflowDiagnostics(draft.diagnostics);
+    return {
+        ...record,
+        validationState: draft.validationState,
+        diagnostics,
+        missingRefs: workflowMissingRefDiagnostics(diagnostics),
+        actions: workflowCatalogActionsFor(record),
+    };
+}
+function workflowCatalogRecordFromDraft(draft) {
+    return {
+        id: draft.workflowId,
+        version: workflowDraftVersionLabel(draft),
+        title: typeof draft.definition.title === "string" ? draft.definition.title : draft.workflowId,
+        ...(typeof draft.definition.description === "string" ? { description: draft.definition.description } : {}),
+        source: "ui",
+        status: "draft",
+        tags: workflowDefinitionTags(draft.definition),
+    };
+}
+function workflowDraftVersionLabel(draft) {
+    if (typeof draft.definition.version === "string" && draft.definition.version.trim())
+        return draft.definition.version.trim();
+    return draft.targetWorkflowVersion ?? "draft";
+}
+export function workflowCatalogActionsFor(record) {
+    if (record.status === "draft")
+        return ["view", "edit_draft", "validate", "publish", "archive", "delete"];
+    if (record.status === "archived")
+        return ["view", "version_history"];
+    if (record.status === "deleted")
+        return ["view"];
+    const actions = ["view", "duplicate", "create_project_session", "version_history"];
+    if (record.source === "ui")
+        actions.push("create_next_draft", "archive", "delete");
+    return actions;
+}
+export function workflowCatalogEditability(actions) {
+    return {
+        canView: actions.includes("view"),
+        canDuplicate: actions.includes("duplicate"),
+        canEditDraft: actions.includes("edit_draft"),
+        canCreateDraft: actions.includes("create_next_draft"),
+        canValidate: actions.includes("validate"),
+        canPublish: actions.includes("publish"),
+        canArchive: actions.includes("archive"),
+        canDelete: actions.includes("delete"),
+        canCreateProjectSession: actions.includes("create_project_session"),
+    };
+}
+function workflowCatalogValidationStateFromDiagnostics(diagnostics, fallback = "unknown") {
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+        return "error";
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "warning"))
+        return "warning";
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "info"))
+        return fallback === "unknown" ? "warning" : fallback;
+    return fallback;
+}
+function workflowCatalogValidationStateFromVersions(versions) {
+    const states = versions.map((version) => version.validationState);
+    if (states.includes("error"))
+        return "error";
+    if (states.includes("warning"))
+        return "warning";
+    if (states.includes("valid"))
+        return "valid";
+    return "unknown";
+}
+const WORKFLOW_MISSING_REF_DIAGNOSTIC_CODES = new Set([
+    "WorkflowGraphError.unknownAgentProfileRef",
+    "WorkflowGraphError.archivedAgentProfileRef",
+    "WorkflowGraphError.unknownHandlerRef",
+    "WorkflowGraphError.unknownAdapterRef",
+    "WorkflowGraphError.unknownGuardRef",
+    "WorkflowGraphError.unknownPromptBuilderRef",
+    "WorkflowGraphError.unknownHumanActionRef",
+    "WorkflowCatalogError.unknownWorkflowVersion",
+]);
+export function workflowMissingRefDiagnostics(diagnostics) {
+    return uniqueWorkflowDiagnostics(sanitizeWorkflowDiagnostics(diagnostics).filter(isWorkflowMissingRefDiagnostic));
+}
+function isWorkflowMissingRefDiagnostic(diagnostic) {
+    return Boolean(diagnostic.registryRef && WORKFLOW_MISSING_REF_DIAGNOSTIC_CODES.has(diagnostic.code));
+}
+function uniqueWorkflowDiagnostics(diagnostics) {
+    const seen = new Set();
+    return diagnostics.filter((diagnostic) => {
+        const key = [diagnostic.code, diagnostic.path ?? "", diagnostic.nodeId ?? "", diagnostic.edgeId ?? "", diagnostic.registryRef ?? "", diagnostic.message].join("\u0000");
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function uniqueWorkflowCatalogActions(actions) {
+    return [...new Set(actions)].sort();
+}
+function compareWorkflowCatalogRecords(left, right) {
+    return left.id.localeCompare(right.id);
+}
+export function buildWorkflowCatalogInspect(state, context, webSession, services, workflowId, options = {}) {
+    let selectedDraft;
+    if (options.draftId) {
+        selectedDraft = state.workflowDraftStore.getDraft(options.draftId);
+        if (!selectedDraft || selectedDraft.workflowId !== workflowId)
+            throw new PiboWebHttpError("Workflow draft not found", 404);
+    }
+    else if (!options.version) {
+        selectedDraft = state.workflowDraftStore.findActiveDraftByWorkflowId(workflowId);
+    }
+    if (selectedDraft)
+        services.runDraftValidation(state, context, webSession, selectedDraft, "draft_load");
+    const catalog = buildWorkflowCatalogList(state, context, webSession, services, { includeArchived: options.includeArchived });
+    const workflow = catalog.workflows.find((record) => record.id === workflowId);
+    if (!workflow)
+        throw new PiboWebHttpError("Workflow not found", 404);
+    if (selectedDraft) {
+        return {
+            kind: "workflow-inspect",
+            workflow,
+            selected: { kind: "draft", draft: services.serializeDraft(selectedDraft) },
+            diagnostics: sanitizeWorkflowDiagnostics(selectedDraft.diagnostics),
+        };
+    }
+    const version = options.version ?? selectWorkflowCatalogDisplayVersion(workflow.versions)?.version;
+    const published = version ? workflowPublishedVersionInspection(state, context, webSession, services, workflowId, version, options.includeArchived === true) : undefined;
+    if (published) {
+        return {
+            kind: "workflow-inspect",
+            workflow,
+            selected: {
+                kind: "publishedVersion",
+                version: published.version,
+                definition: published.definition,
+                validation: published.validation,
+            },
+            diagnostics: published.diagnostics,
+        };
+    }
+    throw new PiboWebHttpError("Workflow version not found", 404);
+}
+function workflowPublishedVersionInspection(state, context, webSession, services, workflowId, version, includeArchived) {
+    const persisted = state.workflowPublishedVersionStore.listPublishedVersions({ workflowId }).find((record) => record.version === version);
+    if (persisted) {
+        const catalogRecord = workflowCatalogRecordWithArchiveState(workflowCatalogRecordFromPublishedVersion(persisted), state);
+        if (catalogRecord.status === "deleted" || (catalogRecord.status === "archived" && !includeArchived))
+            return undefined;
+        const diagnostics = services.validateDefinition(persisted.definition, { state, context, webSession });
+        return {
+            version: { ...catalogRecord, definitionHash: persisted.definitionHash },
+            definition: persisted.definition,
+            validation: services.summarizeDiagnostics(diagnostics, "draft_load"),
+            diagnostics,
+        };
+    }
+    const staticRecord = STATIC_WORKFLOW_VERSION_CATALOG.find((record) => record.id === workflowId && record.version === version);
+    const catalogRecord = staticRecord ? workflowCatalogRecordWithArchiveState(staticRecord, state) : undefined;
+    if (!catalogRecord || catalogRecord.status === "draft" || catalogRecord.status === "deleted" || (catalogRecord.status === "archived" && !includeArchived))
+        return undefined;
+    const definition = createPublishedWorkflowDefinition(catalogRecord, "base");
+    const diagnostics = services.validateDefinition(definition, { state, context, webSession });
+    return {
+        version: { ...catalogRecord, definitionHash: hashWorkflowDefinitionJson(definition) },
+        definition,
+        validation: services.summarizeDiagnostics(diagnostics, "draft_load"),
+        diagnostics,
+    };
+}
+export function buildWorkflowVersionList(state, context, webSession, services, workflowId, options = {}) {
+    const includeArchived = options.includeArchived === true;
+    const catalog = buildWorkflowCatalogList(state, context, webSession, services, { includeArchived });
+    const workflow = catalog.workflows.find((record) => record.id === workflowId);
+    if (!workflow)
+        throw new PiboWebHttpError("Workflow not found", 404);
+    return {
+        kind: "workflow-version-list",
+        workflowId,
+        includeArchived,
+        workflow,
+        versions: workflow.versions
+            .filter((version) => version.status === "published" || version.status === "archived")
+            .sort(compareWorkflowCatalogVersionRecords),
+    };
+}
+export function buildWorkflowVersionInspect(state, context, webSession, services, workflowId, version, options = {}) {
+    const includeArchived = options.includeArchived === true;
+    const catalog = buildWorkflowCatalogList(state, context, webSession, services, { includeArchived });
+    const workflow = catalog.workflows.find((record) => record.id === workflowId);
+    if (!workflow)
+        throw new PiboWebHttpError("Workflow not found", 404);
+    const published = workflowPublishedVersionInspection(state, context, webSession, services, workflowId, version, includeArchived);
+    if (!published)
+        throw new PiboWebHttpError("Workflow version not found", 404);
+    const diagnostics = sanitizeWorkflowDiagnostics(published.diagnostics);
+    return {
+        kind: "workflow-version-inspect",
+        workflow,
+        version: published.version,
+        definition: published.definition,
+        validation: published.validation,
+        diagnostics,
+        missingRefs: workflowMissingRefDiagnostics(diagnostics),
+    };
+}
+export function createPublishedWorkflowDefinition(workflow, profileId) {
+    return createRunnableWorkflowDefinition({
+        workflowId: workflow.id,
+        version: workflow.version,
+        title: workflow.title,
+        description: workflow.description ?? `${workflow.title} workflow.`,
+        tags: workflow.tags,
+        profileId,
+    });
+}
+function createRunnableWorkflowDefinition(input) {
+    return {
+        id: input.workflowId,
+        version: input.version,
+        title: input.title,
+        description: input.description,
+        input: {
+            kind: "text",
+            description: "Workflow input provided when a Project session starts.",
+        },
+        output: {
+            kind: "text",
+            description: "Workflow output returned to the Project session.",
+        },
+        initial: "agent",
+        nodes: {
+            agent: {
+                kind: "agent",
+                runtime: "pibo",
+                profile: { kind: "fixed", id: input.profileId },
+                promptTemplate: "Use the workflow input to produce a concise answer.\n\n{{input}}",
+                metadata: { sessionOverrides: { prompt: true } },
+                ui: { position: { x: 80, y: 80 } },
+            },
+        },
+        edges: {},
+        metadata: {
+            tags: input.tags,
+            ...(input.metadata ?? {}),
+        },
+        ui: {
+            layout: "auto",
+            positions: {
+                agent: { x: 80, y: 80 },
+            },
+        },
+    };
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/apps/chat/workflow-edge-compatibility.js

@@ -0,0 +1,51 @@
+import { normalizeForCanonicalJson } from "./workflow-persistence.js";
+export function validateWorkflowEdgeAdapterOutputCompatibilityLike(edgeId, adapterOutput, edge, nodes, diagnostics) {
+    const targetPort = readEdgeTargetInputPort(edge, nodes);
+    if (targetPort && isJsonObject(adapterOutput) && !areWorkflowPortsDirectlyCompatible(adapterOutput, targetPort)) {
+        diagnostics.push({
+            code: "WorkflowGraphError.incompatibleEdgeAdapterOutput",
+            message: `Workflow edge '${edgeId}' adapter output is incompatible with the target input port.`,
+            severity: "error",
+            path: `$.edges.${edgeId}.adapter.output`,
+            edgeId,
+            hint: "Set the registered adapter output port to the target input contract; do not use hidden LLM coercion.",
+        });
+    }
+}
+export function validateWorkflowEdgeDirectCompatibilityLike(edgeId, edge, nodes, diagnostics) {
+    const sourcePort = readEdgeSourceOutputPort(edge, nodes);
+    const targetPort = readEdgeTargetInputPort(edge, nodes);
+    if (!sourcePort || !targetPort || areWorkflowPortsDirectlyCompatible(sourcePort, targetPort))
+        return;
+    diagnostics.push({
+        code: "WorkflowGraphError.incompatibleEdgePorts",
+        message: `Workflow edge '${edgeId}' connects incompatible source output and target input ports without a registered adapter.`,
+        severity: "error",
+        path: `$.edges.${edgeId}`,
+        edgeId,
+        hint: "Add a visible registered edge adapter or adapter node. Hidden LLM coercion is not allowed in V2.",
+    });
+}
+function readEdgeSourceOutputPort(edge, nodes) {
+    const node = readWorkflowEdgeNode(edge.from, nodes);
+    return node && isJsonObject(node.output) ? node.output : undefined;
+}
+function readEdgeTargetInputPort(edge, nodes) {
+    const node = readWorkflowEdgeNode(edge.to, nodes);
+    return node && isJsonObject(node.input) ? node.input : undefined;
+}
+function readWorkflowEdgeNode(endpoint, nodes) {
+    const nodeId = isJsonObject(endpoint) && typeof endpoint.nodeId === "string" ? endpoint.nodeId.trim() : undefined;
+    const node = nodeId ? nodes[nodeId] : undefined;
+    return isJsonObject(node) ? node : undefined;
+}
+function areWorkflowPortsDirectlyCompatible(left, right) {
+    if (left.kind === "text" && right.kind === "text")
+        return true;
+    if (left.kind !== "json" || right.kind !== "json")
+        return false;
+    return JSON.stringify(normalizeForCanonicalJson(left.schema)) === JSON.stringify(normalizeForCanonicalJson(right.schema));
+}
+function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}