@pasko70/pibo 1.9.7 → 1.9.9

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

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

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