@uns-kit/assistant-workflow 2.0.72

package/dist/definition-catalog.d.ts

@@ -0,0 +1,45 @@
+import type { AssistantWorkflowDefinition } from "./definition.js";
+import { type AssistantWorkflowSerializedDefinition } from "./definition-json.js";
+import type { AssistantWorkflowJsonValue } from "./run-report-json.js";
+export type AssistantWorkflowDefinitionCatalogDiagnosticCode = "duplicate_definition_version";
+export type AssistantWorkflowDefinitionCatalogDiagnostic = {
+    severity: "error" | "warning";
+    code: AssistantWorkflowDefinitionCatalogDiagnosticCode;
+    workflowId: string;
+    workflowVersion: number;
+    message: string;
+};
+export type AssistantWorkflowDefinitionCatalogEntry = {
+    workflowId: string;
+    workflowVersion: number;
+    valid: boolean;
+    errorCount: number;
+    warningCount: number;
+    intentCount: number;
+    toolCapabilityCount: number;
+    toolBindingCount: number;
+    definition: AssistantWorkflowSerializedDefinition;
+};
+export type AssistantWorkflowDefinitionCatalog = {
+    generatedAt: string;
+    definitionCount: number;
+    workflowCount: number;
+    validDefinitionCount: number;
+    invalidDefinitionCount: number;
+    warningDefinitionCount: number;
+    duplicateVersionCount: number;
+    diagnostics: AssistantWorkflowDefinitionCatalogDiagnostic[];
+    entries: AssistantWorkflowDefinitionCatalogEntry[];
+};
+export type AssistantWorkflowDefinitionCatalogOptions = {
+    generatedAt?: string;
+};
+export type AssistantWorkflowDefinitionLookupOptions = {
+    includeInvalid?: boolean;
+};
+export declare function buildAssistantWorkflowDefinitionCatalog(definitions: readonly AssistantWorkflowDefinition<string, string, string, string>[], options?: AssistantWorkflowDefinitionCatalogOptions): AssistantWorkflowDefinitionCatalog;
+export declare function buildAssistantWorkflowSerializedDefinitionCatalog(definitions: readonly AssistantWorkflowSerializedDefinition[], options?: AssistantWorkflowDefinitionCatalogOptions): AssistantWorkflowDefinitionCatalog;
+export declare function findAssistantWorkflowCatalogDefinition(catalog: AssistantWorkflowDefinitionCatalog, workflowId: string, version?: number, options?: AssistantWorkflowDefinitionLookupOptions): AssistantWorkflowSerializedDefinition | null;
+export declare function findLatestAssistantWorkflowCatalogDefinition(catalog: AssistantWorkflowDefinitionCatalog, workflowId: string, options?: AssistantWorkflowDefinitionLookupOptions): AssistantWorkflowSerializedDefinition | null;
+export declare function buildAssistantWorkflowDefinitionCatalogTracePayload(catalog: AssistantWorkflowDefinitionCatalog): Record<string, AssistantWorkflowJsonValue>;
+//# sourceMappingURL=definition-catalog.d.ts.map

package/dist/definition-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-catalog.d.ts","sourceRoot":"","sources":["../src/definition-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAGL,KAAK,qCAAqC,EAC3C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAEvE,MAAM,MAAM,gDAAgD,GACxD,8BAA8B,CAAC;AAEnC,MAAM,MAAM,4CAA4C,GAAG;IACzD,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,gDAAgD,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,qCAAqC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,WAAW,EAAE,4CAA4C,EAAE,CAAC;IAC5D,OAAO,EAAE,uCAAuC,EAAE,CAAC;CACpD,CAAC;AAEF,MAAM,MAAM,yCAAyC,GAAG;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,wCAAwC,GAAG;IACrD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,wBAAgB,uCAAuC,CACrD,WAAW,EAAE,SAAS,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,EACnF,OAAO,GAAE,yCAA8C,GACtD,kCAAkC,CAKpC;AAED,wBAAgB,iDAAiD,CAC/D,WAAW,EAAE,SAAS,qCAAqC,EAAE,EAC7D,OAAO,GAAE,yCAA8C,GACtD,kCAAkC,CAqBpC;AAED,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,kCAAkC,EAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,GAAE,wCAA6C,GACrD,qCAAqC,GAAG,IAAI,CAO9C;AAED,wBAAgB,4CAA4C,CAC1D,OAAO,EAAE,kCAAkC,EAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,wCAA6C,GACrD,qCAAqC,GAAG,IAAI,CAE9C;AAED,wBAAgB,mDAAmD,CACjE,OAAO,EAAE,kCAAkC,GAC1C,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CA4B5C"}

package/dist/definition-catalog.js

@@ -0,0 +1,97 @@
+import { buildAssistantWorkflowDefinitionTracePayload, serializeAssistantWorkflowDefinition, } from "./definition-json.js";
+export function buildAssistantWorkflowDefinitionCatalog(definitions, options = {}) {
+    return buildAssistantWorkflowSerializedDefinitionCatalog(definitions.map(serializeAssistantWorkflowDefinition), options);
+}
+export function buildAssistantWorkflowSerializedDefinitionCatalog(definitions, options = {}) {
+    const entries = definitions
+        .map(toCatalogEntry)
+        .sort((left, right) => {
+        if (left.workflowId !== right.workflowId)
+            return left.workflowId.localeCompare(right.workflowId);
+        return right.workflowVersion - left.workflowVersion;
+    });
+    const diagnostics = collectCatalogDiagnostics(entries);
+    const workflowIds = new Set(entries.map((entry) => entry.workflowId));
+    return {
+        generatedAt: options.generatedAt ?? new Date().toISOString(),
+        definitionCount: entries.length,
+        workflowCount: workflowIds.size,
+        validDefinitionCount: entries.filter((entry) => entry.valid).length,
+        invalidDefinitionCount: entries.filter((entry) => !entry.valid).length,
+        warningDefinitionCount: entries.filter((entry) => entry.warningCount > 0).length,
+        duplicateVersionCount: diagnostics.filter((diagnostic) => diagnostic.code === "duplicate_definition_version").length,
+        diagnostics,
+        entries,
+    };
+}
+export function findAssistantWorkflowCatalogDefinition(catalog, workflowId, version, options = {}) {
+    const candidates = catalog.entries.filter((entry) => entry.workflowId === workflowId &&
+        (version === undefined || entry.workflowVersion === version) &&
+        (options.includeInvalid === true || entry.valid));
+    return candidates[0]?.definition ?? null;
+}
+export function findLatestAssistantWorkflowCatalogDefinition(catalog, workflowId, options = {}) {
+    return findAssistantWorkflowCatalogDefinition(catalog, workflowId, undefined, options);
+}
+export function buildAssistantWorkflowDefinitionCatalogTracePayload(catalog) {
+    return {
+        generatedAt: catalog.generatedAt,
+        definitionCount: catalog.definitionCount,
+        workflowCount: catalog.workflowCount,
+        validDefinitionCount: catalog.validDefinitionCount,
+        invalidDefinitionCount: catalog.invalidDefinitionCount,
+        warningDefinitionCount: catalog.warningDefinitionCount,
+        duplicateVersionCount: catalog.duplicateVersionCount,
+        diagnostics: catalog.diagnostics.map((diagnostic) => ({
+            severity: diagnostic.severity,
+            code: diagnostic.code,
+            workflowId: diagnostic.workflowId,
+            workflowVersion: diagnostic.workflowVersion,
+            message: diagnostic.message,
+        })),
+        entries: catalog.entries.map((entry) => ({
+            workflowId: entry.workflowId,
+            workflowVersion: entry.workflowVersion,
+            valid: entry.valid,
+            errorCount: entry.errorCount,
+            warningCount: entry.warningCount,
+            intentCount: entry.intentCount,
+            toolCapabilityCount: entry.toolCapabilityCount,
+            toolBindingCount: entry.toolBindingCount,
+            definition: buildAssistantWorkflowDefinitionTracePayload(entry.definition),
+        })),
+    };
+}
+function toCatalogEntry(definition) {
+    return {
+        workflowId: definition.workflowId,
+        workflowVersion: definition.workflowVersion,
+        valid: definition.summary.valid,
+        errorCount: definition.summary.errorCount,
+        warningCount: definition.summary.warningCount,
+        intentCount: definition.summary.intentCount,
+        toolCapabilityCount: definition.summary.toolCapabilityCount,
+        toolBindingCount: definition.summary.toolBindingCount,
+        definition,
+    };
+}
+function collectCatalogDiagnostics(entries) {
+    const counts = new Map();
+    for (const entry of entries) {
+        const key = `${entry.workflowId}@${entry.workflowVersion}`;
+        counts.set(key, [...(counts.get(key) ?? []), entry]);
+    }
+    return [...counts.values()]
+        .filter((group) => group.length > 1)
+        .map((group) => {
+        const first = group[0];
+        return {
+            severity: "error",
+            code: "duplicate_definition_version",
+            workflowId: first?.workflowId ?? "",
+            workflowVersion: first?.workflowVersion ?? 0,
+            message: `Duplicate assistant workflow definition version: ${first?.workflowId}@${first?.workflowVersion}.`,
+        };
+    });
+}
+//# sourceMappingURL=definition-catalog.js.map

package/dist/definition-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-catalog.js","sourceRoot":"","sources":["../src/definition-catalog.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AssistantWorkflowDefinition } from \"./definition.js\";\nimport {\n  buildAssistantWorkflowDefinitionTracePayload,\n  serializeAssistantWorkflowDefinition,\n  type AssistantWorkflowSerializedDefinition,\n} from \"./definition-json.js\";\nimport type { AssistantWorkflowJsonValue } from \"./run-report-json.js\";\n\nexport type AssistantWorkflowDefinitionCatalogDiagnosticCode =\n  | \"duplicate_definition_version\";\n\nexport type AssistantWorkflowDefinitionCatalogDiagnostic = {\n  severity: \"error\" | \"warning\";\n  code: AssistantWorkflowDefinitionCatalogDiagnosticCode;\n  workflowId: string;\n  workflowVersion: number;\n  message: string;\n};\n\nexport type AssistantWorkflowDefinitionCatalogEntry = {\n  workflowId: string;\n  workflowVersion: number;\n  valid: boolean;\n  errorCount: number;\n  warningCount: number;\n  intentCount: number;\n  toolCapabilityCount: number;\n  toolBindingCount: number;\n  definition: AssistantWorkflowSerializedDefinition;\n};\n\nexport type AssistantWorkflowDefinitionCatalog = {\n  generatedAt: string;\n  definitionCount: number;\n  workflowCount: number;\n  validDefinitionCount: number;\n  invalidDefinitionCount: number;\n  warningDefinitionCount: number;\n  duplicateVersionCount: number;\n  diagnostics: AssistantWorkflowDefinitionCatalogDiagnostic[];\n  entries: AssistantWorkflowDefinitionCatalogEntry[];\n};\n\nexport type AssistantWorkflowDefinitionCatalogOptions = {\n  generatedAt?: string;\n};\n\nexport type AssistantWorkflowDefinitionLookupOptions = {\n  includeInvalid?: boolean;\n};\n\nexport function buildAssistantWorkflowDefinitionCatalog(\n  definitions: readonly AssistantWorkflowDefinition<string, string, string, string>[],\n  options: AssistantWorkflowDefinitionCatalogOptions = {},\n): AssistantWorkflowDefinitionCatalog {\n  return buildAssistantWorkflowSerializedDefinitionCatalog(\n    definitions.map(serializeAssistantWorkflowDefinition),\n    options,\n  );\n}\n\nexport function buildAssistantWorkflowSerializedDefinitionCatalog(\n  definitions: readonly AssistantWorkflowSerializedDefinition[],\n  options: AssistantWorkflowDefinitionCatalogOptions = {},\n): AssistantWorkflowDefinitionCatalog {\n  const entries = definitions\n    .map(toCatalogEntry)\n    .sort((left, right) => {\n      if (left.workflowId !== right.workflowId) return left.workflowId.localeCompare(right.workflowId);\n      return right.workflowVersion - left.workflowVersion;\n    });\n  const diagnostics = collectCatalogDiagnostics(entries);\n  const workflowIds = new Set(entries.map((entry) => entry.workflowId));\n\n  return {\n    generatedAt: options.generatedAt ?? new Date().toISOString(),\n    definitionCount: entries.length,\n    workflowCount: workflowIds.size,\n    validDefinitionCount: entries.filter((entry) => entry.valid).length,\n    invalidDefinitionCount: entries.filter((entry) => !entry.valid).length,\n    warningDefinitionCount: entries.filter((entry) => entry.warningCount > 0).length,\n    duplicateVersionCount: diagnostics.filter((diagnostic) => diagnostic.code === \"duplicate_definition_version\").length,\n    diagnostics,\n    entries,\n  };\n}\n\nexport function findAssistantWorkflowCatalogDefinition(\n  catalog: AssistantWorkflowDefinitionCatalog,\n  workflowId: string,\n  version?: number,\n  options: AssistantWorkflowDefinitionLookupOptions = {},\n): AssistantWorkflowSerializedDefinition | null {\n  const candidates = catalog.entries.filter((entry) =>\n    entry.workflowId === workflowId &&\n    (version === undefined || entry.workflowVersion === version) &&\n    (options.includeInvalid === true || entry.valid)\n  );\n  return candidates[0]?.definition ?? null;\n}\n\nexport function findLatestAssistantWorkflowCatalogDefinition(\n  catalog: AssistantWorkflowDefinitionCatalog,\n  workflowId: string,\n  options: AssistantWorkflowDefinitionLookupOptions = {},\n): AssistantWorkflowSerializedDefinition | null {\n  return findAssistantWorkflowCatalogDefinition(catalog, workflowId, undefined, options);\n}\n\nexport function buildAssistantWorkflowDefinitionCatalogTracePayload(\n  catalog: AssistantWorkflowDefinitionCatalog,\n): Record<string, AssistantWorkflowJsonValue> {\n  return {\n    generatedAt: catalog.generatedAt,\n    definitionCount: catalog.definitionCount,\n    workflowCount: catalog.workflowCount,\n    validDefinitionCount: catalog.validDefinitionCount,\n    invalidDefinitionCount: catalog.invalidDefinitionCount,\n    warningDefinitionCount: catalog.warningDefinitionCount,\n    duplicateVersionCount: catalog.duplicateVersionCount,\n    diagnostics: catalog.diagnostics.map((diagnostic) => ({\n      severity: diagnostic.severity,\n      code: diagnostic.code,\n      workflowId: diagnostic.workflowId,\n      workflowVersion: diagnostic.workflowVersion,\n      message: diagnostic.message,\n    })),\n    entries: catalog.entries.map((entry) => ({\n      workflowId: entry.workflowId,\n      workflowVersion: entry.workflowVersion,\n      valid: entry.valid,\n      errorCount: entry.errorCount,\n      warningCount: entry.warningCount,\n      intentCount: entry.intentCount,\n      toolCapabilityCount: entry.toolCapabilityCount,\n      toolBindingCount: entry.toolBindingCount,\n      definition: buildAssistantWorkflowDefinitionTracePayload(entry.definition),\n    })),\n  };\n}\n\nfunction toCatalogEntry(definition: AssistantWorkflowSerializedDefinition): AssistantWorkflowDefinitionCatalogEntry {\n  return {\n    workflowId: definition.workflowId,\n    workflowVersion: definition.workflowVersion,\n    valid: definition.summary.valid,\n    errorCount: definition.summary.errorCount,\n    warningCount: definition.summary.warningCount,\n    intentCount: definition.summary.intentCount,\n    toolCapabilityCount: definition.summary.toolCapabilityCount,\n    toolBindingCount: definition.summary.toolBindingCount,\n    definition,\n  };\n}\n\nfunction collectCatalogDiagnostics(\n  entries: readonly AssistantWorkflowDefinitionCatalogEntry[],\n): AssistantWorkflowDefinitionCatalogDiagnostic[] {\n  const counts = new Map<string, AssistantWorkflowDefinitionCatalogEntry[]>();\n  for (const entry of entries) {\n    const key = `${entry.workflowId}@${entry.workflowVersion}`;\n    counts.set(key, [...(counts.get(key) ?? []), entry]);\n  }\n  return [...counts.values()]\n    .filter((group) => group.length > 1)\n    .map((group) => {\n      const first = group[0];\n      return {\n        severity: \"error\",\n        code: \"duplicate_definition_version\",\n        workflowId: first?.workflowId ?? \"\",\n        workflowVersion: first?.workflowVersion ?? 0,\n        message: `Duplicate assistant workflow definition version: ${first?.workflowId}@${first?.workflowVersion}.`,\n      };\n    });\n}\n"]}

package/dist/definition-diagnostics.d.ts

@@ -0,0 +1,17 @@
+import { type AssistantWorkflowDefinition } from "./definition.js";
+export type AssistantWorkflowDefinitionDiagnosticSeverity = "error" | "warning";
+export type AssistantWorkflowDefinitionDiagnosticCode = "missing_workflow_id" | "invalid_workflow_version" | "missing_intents" | "missing_id" | "unnormalized_id" | "duplicate_id" | "missing_description" | "missing_tool_hints" | "missing_tool_output_kinds" | "missing_binding_field" | "invalid_http_method" | "invalid_tool_selection_profile_condition" | "invalid_planning_step_profile_condition" | "missing_repl_target" | "unknown_tool_capability" | "tool_provider_mismatch" | "unknown_presentation" | "unknown_memory_slot" | "unknown_planning_step" | "unknown_clarification_rule" | "invalid_confidence_threshold" | "unbound_tool_capability" | "binding_without_capability";
+export type AssistantWorkflowDefinitionDiagnostic = {
+    severity: AssistantWorkflowDefinitionDiagnosticSeverity;
+    code: AssistantWorkflowDefinitionDiagnosticCode;
+    path: string;
+    message: string;
+};
+export type AssistantWorkflowDefinitionValidationResult = {
+    valid: boolean;
+    errorCount: number;
+    warningCount: number;
+    diagnostics: AssistantWorkflowDefinitionDiagnostic[];
+};
+export declare function validateAssistantWorkflowDefinition(workflow: AssistantWorkflowDefinition<string, string, string, string>): AssistantWorkflowDefinitionValidationResult;
+//# sourceMappingURL=definition-diagnostics.d.ts.map

package/dist/definition-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-diagnostics.d.ts","sourceRoot":"","sources":["../src/definition-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,2BAA2B,EAOjC,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,6CAA6C,GAAG,OAAO,GAAG,SAAS,CAAC;AAEhF,MAAM,MAAM,yCAAyC,GACjD,qBAAqB,GACrB,0BAA0B,GAC1B,iBAAiB,GACjB,YAAY,GACZ,iBAAiB,GACjB,cAAc,GACd,qBAAqB,GACrB,oBAAoB,GACpB,2BAA2B,GAC3B,uBAAuB,GACvB,qBAAqB,GACrB,0CAA0C,GAC1C,yCAAyC,GACzC,qBAAqB,GACrB,yBAAyB,GACzB,wBAAwB,GACxB,sBAAsB,GACtB,qBAAqB,GACrB,uBAAuB,GACvB,4BAA4B,GAC5B,8BAA8B,GAC9B,yBAAyB,GACzB,4BAA4B,CAAC;AAEjC,MAAM,MAAM,qCAAqC,GAAG;IAClD,QAAQ,EAAE,6CAA6C,CAAC;IACxD,IAAI,EAAE,yCAAyC,CAAC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,2CAA2C,GAAG;IACxD,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,qCAAqC,EAAE,CAAC;CACtD,CAAC;AAEF,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACpE,2CAA2C,CAwB7C"}

package/dist/definition-diagnostics.js

@@ -0,0 +1,353 @@
+import { normalizeAssistantWorkflowId, } from "./definition.js";
+export function validateAssistantWorkflowDefinition(workflow) {
+    const diagnostics = [];
+    validateHeader(workflow, diagnostics);
+    validateVocabulary("intent", "intents", workflow.intents, diagnostics);
+    validateVocabulary("subintent", "subintents", workflow.subintents ?? [], diagnostics);
+    validateVocabulary("presentation", "presentations", workflow.presentations ?? [], diagnostics);
+    validateVocabulary("derived transform", "derivedTransforms", workflow.derivedTransforms ?? [], diagnostics);
+    validateToolCapabilities(workflow.tools ?? [], diagnostics);
+    validateToolBindings(workflow.toolBindings ?? [], diagnostics);
+    validateMemorySlots(workflow.memorySlots ?? [], diagnostics);
+    validatePlanningSteps(workflow.planningSteps ?? [], diagnostics);
+    validateClarificationRules(workflow.clarificationRules ?? [], diagnostics);
+    validateDirectRoutes(workflow.directRoutes ?? [], diagnostics);
+    validateReferences(workflow, diagnostics);
+    const errorCount = diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+    const warningCount = diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length;
+    return {
+        valid: errorCount === 0,
+        errorCount,
+        warningCount,
+        diagnostics,
+    };
+}
+function validateHeader(workflow, diagnostics) {
+    if (!workflow.id.trim().length) {
+        addDiagnostic(diagnostics, "error", "missing_workflow_id", "id", "Assistant workflow id is required.");
+    }
+    if (!Number.isInteger(workflow.version) || workflow.version < 1) {
+        addDiagnostic(diagnostics, "error", "invalid_workflow_version", "version", "Assistant workflow version must be a positive integer.");
+    }
+    if (!workflow.intents.length) {
+        addDiagnostic(diagnostics, "error", "missing_intents", "intents", "Assistant workflow must define at least one intent.");
+    }
+}
+function validateVocabulary(kind, path, items, diagnostics) {
+    const seen = new Map();
+    for (const [index, item] of items.entries()) {
+        const itemPath = `${path}[${index}]`;
+        const normalized = normalizeAssistantWorkflowId(item.id);
+        if (!normalized) {
+            addDiagnostic(diagnostics, "error", "missing_id", `${itemPath}.id`, `Assistant workflow ${kind} id is required.`);
+            continue;
+        }
+        if (normalized !== item.id) {
+            addDiagnostic(diagnostics, "error", "unnormalized_id", `${itemPath}.id`, `Assistant workflow ${kind} id must already be normalized: ${item.id}.`);
+        }
+        const firstIndex = seen.get(normalized);
+        if (firstIndex !== undefined) {
+            addDiagnostic(diagnostics, "error", "duplicate_id", `${itemPath}.id`, `Duplicate assistant workflow ${kind} id: ${normalized}; first seen at ${path}[${firstIndex}].`);
+        }
+        else {
+            seen.set(normalized, index);
+        }
+        if (!item.description.trim().length) {
+            addDiagnostic(diagnostics, "error", "missing_description", `${itemPath}.description`, `Assistant workflow ${kind} ${normalized} description is required.`);
+        }
+    }
+}
+function validateToolCapabilities(tools, diagnostics) {
+    const seen = new Map();
+    for (const [index, tool] of tools.entries()) {
+        const path = `tools[${index}]`;
+        const normalized = normalizeAssistantWorkflowId(tool.name);
+        if (!normalized) {
+            addDiagnostic(diagnostics, "error", "missing_id", `${path}.name`, "Assistant workflow tool capability name is required.");
+            continue;
+        }
+        if (normalized !== tool.name) {
+            addDiagnostic(diagnostics, "error", "unnormalized_id", `${path}.name`, `Assistant workflow tool capability name must already be normalized: ${tool.name}.`);
+        }
+        const firstIndex = seen.get(normalized);
+        if (firstIndex !== undefined) {
+            addDiagnostic(diagnostics, "error", "duplicate_id", `${path}.name`, `Duplicate assistant workflow tool capability: ${normalized}; first seen at tools[${firstIndex}].`);
+        }
+        else {
+            seen.set(normalized, index);
+        }
+        if (!tool.outputKinds.length) {
+            addDiagnostic(diagnostics, "error", "missing_tool_output_kinds", `${path}.outputKinds`, `Assistant workflow tool capability ${normalized} must define at least one output kind.`);
+        }
+    }
+}
+function validateToolBindings(bindings, diagnostics) {
+    const seen = new Map();
+    for (const [index, binding] of bindings.entries()) {
+        const path = `toolBindings[${index}]`;
+        const normalized = normalizeAssistantWorkflowId(binding.name);
+        if (!normalized) {
+            addDiagnostic(diagnostics, "error", "missing_id", `${path}.name`, "Assistant workflow tool binding name is required.");
+            continue;
+        }
+        if (normalized !== binding.name) {
+            addDiagnostic(diagnostics, "error", "unnormalized_id", `${path}.name`, `Assistant workflow tool binding name must already be normalized: ${binding.name}.`);
+        }
+        const firstIndex = seen.get(normalized);
+        if (firstIndex !== undefined) {
+            addDiagnostic(diagnostics, "error", "duplicate_id", `${path}.name`, `Duplicate assistant workflow tool binding: ${normalized}; first seen at toolBindings[${firstIndex}].`);
+        }
+        else {
+            seen.set(normalized, index);
+        }
+        validateToolBindingTarget(binding, path, diagnostics);
+    }
+}
+function validateToolBindingTarget(binding, path, diagnostics) {
+    switch (binding.provider) {
+        case "local-function":
+            validateRequiredField(binding.handlerId, `${path}.handlerId`, binding.name, "handlerId", diagnostics);
+            return;
+        case "http":
+            validateRequiredField(binding.path, `${path}.path`, binding.name, "path", diagnostics);
+            if (binding.method !== undefined && binding.method !== binding.method.toUpperCase()) {
+                addDiagnostic(diagnostics, "error", "invalid_http_method", `${path}.method`, `Assistant workflow tool binding ${binding.name} HTTP method must be uppercase.`);
+            }
+            return;
+        case "openai-hosted":
+            validateRequiredField(binding.hostedToolType, `${path}.hostedToolType`, binding.name, "hostedToolType", diagnostics);
+            return;
+        case "mcp":
+            validateRequiredField(binding.serverId, `${path}.serverId`, binding.name, "serverId", diagnostics);
+            validateRequiredField(binding.toolName, `${path}.toolName`, binding.name, "toolName", diagnostics);
+            return;
+        case "repl":
+            validateRequiredField(binding.runtimeId, `${path}.runtimeId`, binding.name, "runtimeId", diagnostics);
+            if (!binding.functionName?.trim().length && !binding.commandTemplate?.trim().length) {
+                addDiagnostic(diagnostics, "error", "missing_repl_target", path, `Assistant workflow tool binding ${binding.name} must define functionName or commandTemplate.`);
+            }
+            return;
+    }
+}
+function validateRequiredField(value, path, toolName, fieldName, diagnostics) {
+    if (!value.trim().length) {
+        addDiagnostic(diagnostics, "error", "missing_binding_field", path, `Assistant workflow tool binding ${toolName} ${fieldName} is required.`);
+    }
+}
+function validateMemorySlots(slots, diagnostics) {
+    validateVocabulary("memory slot", "memorySlots", slots, diagnostics);
+}
+function validatePlanningSteps(steps, diagnostics) {
+    validateVocabulary("planning step", "planningSteps", steps, diagnostics);
+}
+function validateClarificationRules(rules, diagnostics) {
+    validateVocabulary("clarification rule", "clarificationRules", rules, diagnostics);
+    for (const [index, rule] of rules.entries()) {
+        if (rule.condition === "low_confidence" &&
+            rule.confidenceBelow !== undefined &&
+            (!Number.isFinite(rule.confidenceBelow) || rule.confidenceBelow < 0 || rule.confidenceBelow > 1)) {
+            addDiagnostic(diagnostics, "error", "invalid_confidence_threshold", `clarificationRules[${index}].confidenceBelow`, `Assistant workflow clarification rule ${rule.id} confidenceBelow must be between 0 and 1.`);
+        }
+    }
+}
+function validateDirectRoutes(routes, diagnostics) {
+    validateVocabulary("direct route", "directRoutes", routes, diagnostics);
+    for (const [routeIndex, route] of routes.entries()) {
+        validateVocabulary(`direct route ${route.id} strategy`, `directRoutes[${routeIndex}].strategies`, route.strategies ?? [], diagnostics);
+    }
+}
+function validateReferences(workflow, diagnostics) {
+    const toolCapabilities = new Map((workflow.tools ?? []).map((tool) => [tool.name, tool]));
+    const toolBindings = new Map((workflow.toolBindings ?? []).map((binding) => [binding.name, binding]));
+    const toolNames = new Set(toolCapabilities.keys());
+    const presentationIds = new Set((workflow.presentations ?? []).map((presentation) => presentation.id));
+    const subintentIds = new Set((workflow.subintents ?? []).map((subintent) => subintent.id));
+    const memorySlotIds = new Set((workflow.memorySlots ?? []).map((slot) => slot.id));
+    const planningStepIds = new Set((workflow.planningSteps ?? []).map((step) => step.id));
+    const clarificationRuleIds = new Set((workflow.clarificationRules ?? []).map((rule) => rule.id));
+    for (const [index, binding] of (workflow.toolBindings ?? []).entries()) {
+        const capability = toolCapabilities.get(binding.name);
+        if (toolCapabilities.size > 0 && !capability) {
+            addDiagnostic(diagnostics, "error", "binding_without_capability", `toolBindings[${index}].name`, `Assistant workflow tool binding references unknown tool capability: ${binding.name}.`);
+        }
+        if (capability && capability.provider !== binding.provider) {
+            addDiagnostic(diagnostics, "error", "tool_provider_mismatch", `toolBindings[${index}].provider`, `Assistant workflow tool binding ${binding.name} provider ${binding.provider} does not match capability provider ${capability.provider}.`);
+        }
+    }
+    for (const [index, tool] of (workflow.tools ?? []).entries()) {
+        if (!toolBindings.has(tool.name)) {
+            addDiagnostic(diagnostics, "warning", "unbound_tool_capability", `tools[${index}].name`, `Assistant workflow tool capability ${tool.name} has no binding.`);
+        }
+    }
+    for (const [index, step] of (workflow.planningSteps ?? []).entries()) {
+        for (const toolName of [...(step.toolHints ?? []), ...(step.requiredToolHints ?? [])]) {
+            if (toolNames.size > 0 && !toolNames.has(toolName)) {
+                addDiagnostic(diagnostics, "error", "unknown_tool_capability", `planningSteps[${index}].toolHints`, `Assistant workflow planning step ${step.id} references unknown tool capability: ${toolName}.`);
+            }
+        }
+        for (const slotId of [...(step.readsMemory ?? []), ...(step.writesMemory ?? [])]) {
+            if (memorySlotIds.size > 0 && !memorySlotIds.has(slotId)) {
+                addDiagnostic(diagnostics, "error", "unknown_memory_slot", `planningSteps[${index}].readsMemory`, `Assistant workflow planning step ${step.id} references unknown memory slot: ${slotId}.`);
+            }
+        }
+    }
+    for (const [index, rule] of (workflow.clarificationRules ?? []).entries()) {
+        for (const slotId of [...(rule.readsMemory ?? []), ...(rule.writesMemory ?? [])]) {
+            if (memorySlotIds.size > 0 && !memorySlotIds.has(slotId)) {
+                addDiagnostic(diagnostics, "error", "unknown_memory_slot", `clarificationRules[${index}].readsMemory`, `Assistant workflow clarification rule ${rule.id} references unknown memory slot: ${slotId}.`);
+            }
+        }
+    }
+    for (const [index, intent] of workflow.intents.entries()) {
+        validateIntentToolSelectionProfiles(intent, index, toolNames, diagnostics);
+        validateIntentPlanningStepProfiles(intent, index, planningStepIds, toolNames, subintentIds, presentationIds, diagnostics);
+        if (intent.defaultPresentation && !presentationIds.has(intent.defaultPresentation)) {
+            addDiagnostic(diagnostics, "error", "unknown_presentation", `intents[${index}].defaultPresentation`, `Assistant workflow intent ${intent.id} references unknown presentation: ${intent.defaultPresentation}.`);
+        }
+        for (const toolName of [...(intent.toolHints ?? []), ...(intent.requiredToolHints ?? [])]) {
+            if (toolNames.size > 0 && !toolNames.has(toolName)) {
+                addDiagnostic(diagnostics, "error", "unknown_tool_capability", `intents[${index}].toolHints`, `Assistant workflow intent ${intent.id} references unknown tool capability: ${toolName}.`);
+            }
+        }
+        for (const slotId of [
+            ...(intent.memoryPolicy?.read ?? []),
+            ...(intent.memoryPolicy?.write ?? []),
+            ...(intent.memoryPolicy?.inject ?? []),
+        ]) {
+            if (memorySlotIds.size > 0 && !memorySlotIds.has(slotId)) {
+                addDiagnostic(diagnostics, "error", "unknown_memory_slot", `intents[${index}].memoryPolicy`, `Assistant workflow intent ${intent.id} references unknown memory slot: ${slotId}.`);
+            }
+        }
+        for (const stepId of intent.planningSteps ?? []) {
+            if (planningStepIds.size > 0 && !planningStepIds.has(stepId)) {
+                addDiagnostic(diagnostics, "error", "unknown_planning_step", `intents[${index}].planningSteps`, `Assistant workflow intent ${intent.id} references unknown planning step: ${stepId}.`);
+            }
+        }
+        for (const ruleId of intent.clarificationRules ?? []) {
+            if (clarificationRuleIds.size > 0 && !clarificationRuleIds.has(ruleId)) {
+                addDiagnostic(diagnostics, "error", "unknown_clarification_rule", `intents[${index}].clarificationRules`, `Assistant workflow intent ${intent.id} references unknown clarification rule: ${ruleId}.`);
+            }
+        }
+    }
+}
+function validateIntentPlanningStepProfiles(intent, intentIndex, planningStepIds, toolNames, subintentIds, presentationIds, diagnostics) {
+    const seen = new Map();
+    for (const [profileIndex, profile] of (intent.planningStepProfiles ?? []).entries()) {
+        const profilePath = `intents[${intentIndex}].planningStepProfiles[${profileIndex}]`;
+        const normalized = normalizeAssistantWorkflowId(profile.id);
+        if (!normalized) {
+            addDiagnostic(diagnostics, "error", "missing_id", `${profilePath}.id`, `Assistant workflow intent ${intent.id} planning step profile id is required.`);
+            continue;
+        }
+        if (normalized !== profile.id) {
+            addDiagnostic(diagnostics, "error", "unnormalized_id", `${profilePath}.id`, `Assistant workflow intent ${intent.id} planning step profile id must already be normalized: ${profile.id}.`);
+        }
+        const firstIndex = seen.get(normalized);
+        if (firstIndex !== undefined) {
+            addDiagnostic(diagnostics, "error", "duplicate_id", `${profilePath}.id`, `Duplicate assistant workflow intent ${intent.id} planning step profile: ${normalized}; first seen at intents[${intentIndex}].planningStepProfiles[${firstIndex}].`);
+        }
+        else {
+            seen.set(normalized, profileIndex);
+        }
+        if (!profile.description.trim().length) {
+            addDiagnostic(diagnostics, "error", "missing_description", `${profilePath}.description`, `Assistant workflow intent ${intent.id} planning step profile ${normalized} description is required.`);
+        }
+        if (!profile.planningSteps.length) {
+            addDiagnostic(diagnostics, "error", "unknown_planning_step", `${profilePath}.planningSteps`, `Assistant workflow intent ${intent.id} planning step profile ${normalized} must define at least one planning step.`);
+        }
+        for (const stepId of profile.planningSteps) {
+            if (planningStepIds.size > 0 && !planningStepIds.has(stepId)) {
+                addDiagnostic(diagnostics, "error", "unknown_planning_step", `${profilePath}.planningSteps`, `Assistant workflow intent ${intent.id} planning step profile ${normalized} references unknown planning step: ${stepId}.`);
+            }
+        }
+        for (const toolName of profile.condition?.requiredTools ?? []) {
+            if (toolNames.size > 0 && !toolNames.has(toolName)) {
+                addDiagnostic(diagnostics, "error", "unknown_tool_capability", `${profilePath}.condition.requiredTools`, `Assistant workflow intent ${intent.id} planning step profile ${normalized} references unknown required tool: ${toolName}.`);
+            }
+        }
+        const condition = profile.condition;
+        if (condition?.subintent && subintentIds.size > 0 && !subintentIds.has(condition.subintent)) {
+            addDiagnostic(diagnostics, "error", "missing_id", `${profilePath}.condition.subintent`, `Assistant workflow intent ${intent.id} planning step profile ${normalized} references unknown subintent: ${condition.subintent}.`);
+        }
+        if (condition?.presentation && presentationIds.size > 0 && !presentationIds.has(condition.presentation)) {
+            addDiagnostic(diagnostics, "error", "unknown_presentation", `${profilePath}.condition.presentation`, `Assistant workflow intent ${intent.id} planning step profile ${normalized} references unknown presentation: ${condition.presentation}.`);
+        }
+        validatePlanningStepProfileCondition(intent.id, profile, profilePath, diagnostics);
+    }
+}
+function validateIntentToolSelectionProfiles(intent, intentIndex, toolNames, diagnostics) {
+    const seen = new Map();
+    for (const [profileIndex, profile] of (intent.toolSelectionProfiles ?? []).entries()) {
+        const profilePath = `intents[${intentIndex}].toolSelectionProfiles[${profileIndex}]`;
+        const normalized = normalizeAssistantWorkflowId(profile.id);
+        if (!normalized) {
+            addDiagnostic(diagnostics, "error", "missing_id", `${profilePath}.id`, `Assistant workflow intent ${intent.id} tool selection profile id is required.`);
+            continue;
+        }
+        if (normalized !== profile.id) {
+            addDiagnostic(diagnostics, "error", "unnormalized_id", `${profilePath}.id`, `Assistant workflow intent ${intent.id} tool selection profile id must already be normalized: ${profile.id}.`);
+        }
+        const firstIndex = seen.get(normalized);
+        if (firstIndex !== undefined) {
+            addDiagnostic(diagnostics, "error", "duplicate_id", `${profilePath}.id`, `Duplicate assistant workflow intent ${intent.id} tool selection profile: ${normalized}; first seen at intents[${intentIndex}].toolSelectionProfiles[${firstIndex}].`);
+        }
+        else {
+            seen.set(normalized, profileIndex);
+        }
+        if (!profile.description.trim().length) {
+            addDiagnostic(diagnostics, "error", "missing_description", `${profilePath}.description`, `Assistant workflow intent ${intent.id} tool selection profile ${normalized} description is required.`);
+        }
+        if (!profile.toolHints.length) {
+            addDiagnostic(diagnostics, "error", "missing_tool_hints", `${profilePath}.toolHints`, `Assistant workflow intent ${intent.id} tool selection profile ${normalized} must define at least one tool hint.`);
+        }
+        for (const toolName of profile.toolHints) {
+            if (toolNames.size > 0 && !toolNames.has(toolName)) {
+                addDiagnostic(diagnostics, "error", "unknown_tool_capability", `${profilePath}.toolHints`, `Assistant workflow intent ${intent.id} tool selection profile ${normalized} references unknown tool capability: ${toolName}.`);
+            }
+        }
+        validateToolSelectionProfileCondition(intent.id, profile, profilePath, diagnostics);
+    }
+}
+function validatePlanningStepProfileCondition(intentId, profile, profilePath, diagnostics) {
+    const { minConfidence, maxConfidence, subintent, presentation, timeWindowHint, requiredTools } = profile.condition ?? {};
+    if (minConfidence !== undefined && (!Number.isFinite(minConfidence) || minConfidence < 0 || minConfidence > 1)) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition.minConfidence`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} minConfidence must be between 0 and 1.`);
+    }
+    if (maxConfidence !== undefined && (!Number.isFinite(maxConfidence) || maxConfidence < 0 || maxConfidence > 1)) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition.maxConfidence`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} maxConfidence must be between 0 and 1.`);
+    }
+    if (minConfidence !== undefined && maxConfidence !== undefined && minConfidence > maxConfidence) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} minConfidence must not exceed maxConfidence.`);
+    }
+    if (subintent !== undefined && !subintent.trim().length) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition.subintent`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} subintent must not be empty.`);
+    }
+    if (presentation !== undefined && !presentation.trim().length) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition.presentation`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} presentation must not be empty.`);
+    }
+    if (timeWindowHint !== undefined && !timeWindowHint.trim().length) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition.timeWindowHint`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} timeWindowHint must not be empty.`);
+    }
+    if (requiredTools !== undefined && requiredTools.length === 0) {
+        addDiagnostic(diagnostics, "error", "invalid_planning_step_profile_condition", `${profilePath}.condition.requiredTools`, `Assistant workflow intent ${intentId} planning step profile ${profile.id} requiredTools must not be empty.`);
+    }
+}
+function validateToolSelectionProfileCondition(intentId, profile, profilePath, diagnostics) {
+    const { minHop, maxHop, selectedReason } = profile.condition ?? {};
+    if (minHop !== undefined && (!Number.isInteger(minHop) || minHop < 0)) {
+        addDiagnostic(diagnostics, "error", "invalid_tool_selection_profile_condition", `${profilePath}.condition.minHop`, `Assistant workflow intent ${intentId} tool selection profile ${profile.id} minHop must be a non-negative integer.`);
+    }
+    if (maxHop !== undefined && (!Number.isInteger(maxHop) || maxHop < 0)) {
+        addDiagnostic(diagnostics, "error", "invalid_tool_selection_profile_condition", `${profilePath}.condition.maxHop`, `Assistant workflow intent ${intentId} tool selection profile ${profile.id} maxHop must be a non-negative integer.`);
+    }
+    if (minHop !== undefined && maxHop !== undefined && minHop > maxHop) {
+        addDiagnostic(diagnostics, "error", "invalid_tool_selection_profile_condition", `${profilePath}.condition`, `Assistant workflow intent ${intentId} tool selection profile ${profile.id} minHop must not exceed maxHop.`);
+    }
+    if (selectedReason !== undefined && !selectedReason.trim().length) {
+        addDiagnostic(diagnostics, "error", "invalid_tool_selection_profile_condition", `${profilePath}.condition.selectedReason`, `Assistant workflow intent ${intentId} tool selection profile ${profile.id} selectedReason must not be empty.`);
+    }
+}
+function addDiagnostic(diagnostics, severity, code, path, message) {
+    diagnostics.push({ severity, code, path, message });
+}
+//# sourceMappingURL=definition-diagnostics.js.map