@acorex-platform/module-ai-management-client 0.0.20

package/fesm2022/acorex-platform-module-ai-management-client-contracts.mjs

@@ -0,0 +1,1038 @@
+import { axpContextDefinitionIsAiPrompt, resolveMultiLanguageString } from '@acorex-platform/framework-shared/core';
+
+//#region ---- Feature keys ----
+/**
+ * Edition / feature flags for AI Management.
+ * `ManageCatalog` is Platform Console only (Intelligence config menu).
+ */
+const AXPAiManagementFeatureKeys = {
+    /** Configuration → Intelligence (agents, assists, models, endpoints, rules). */
+    ManageCatalog: 'AiManagement:Feature:ManageCatalog',
+};
+//#endregion
+
+//#region ---- Menu Keys ----
+/**
+ * AI Management menu keys.
+ * Pattern: AiManagement:Menu:{Path}
+ */
+const AXPAiManagementMenuKeys = {
+    /** Configuration > AI Management (models, assists) */
+    AiManagementConfig: 'Common:Menu:Configuration:AiManagement',
+    /** OpenAI-compatible HTTP endpoints (base URL + API key). */
+    OpenAiEndpoints: 'AiManagement:Menu:OpenAiEndpoints',
+    /** List of AI models (from providers). */
+    Models: 'AiManagement:Menu:Models',
+    /** List of Assists. */
+    Assists: 'AiManagement:Menu:Assists',
+    /** Delegated specialist agents (supervisor routing). */
+    Agents: 'AiManagement:Menu:Agents',
+    /** Reusable system-prompt rules (Markdown fragments). */
+    Rules: 'AiManagement:Menu:Rules',
+};
+//#endregion
+
+/**
+ * Administration capabilities used by this module.
+ * Domain capability keys for this module. Root groups live in `AXPCommonPermissionGroupKeys` (common contracts).
+ */
+const AXPAdministrationPermissionKeys = {
+    Access: 'Administration:Permission:Access',
+    MaintainUsersAndRoles: 'Administration:Permission:MaintainUsersAndRoles',
+    ManageSessions: 'Administration:Permission:ManageSessions',
+    MaintainPolicies: 'Administration:Permission:MaintainPolicies',
+    ViewIntegrations: 'Administration:Permission:ViewIntegrations',
+    MaintainConnections: 'Administration:Permission:MaintainConnections',
+    MaintainWorkflows: 'Administration:Permission:MaintainWorkflows',
+    ManageWorkflowActions: 'Administration:Permission:ManageWorkflowActions',
+    ViewRules: 'Administration:Permission:ViewRules',
+    MaintainRules: 'Administration:Permission:MaintainRules',
+    ManageRuleActions: 'Administration:Permission:ManageRuleActions',
+    MaintainAi: 'Administration:Permission:MaintainAi',
+    UseAiAssist: 'Administration:Permission:UseAiAssist',
+    MaintainDashboards: 'Administration:Permission:MaintainDashboards',
+    ViewJobs: 'Administration:Permission:ViewJobs',
+    ManageJobActions: 'Administration:Permission:ManageJobActions',
+    ViewObservability: 'Administration:Permission:ViewObservability',
+    MaintainObservability: 'Administration:Permission:MaintainObservability',
+};
+/**
+ * Dynamic assist access permissions (`Assist.{name}.Use`) as children of UseAiAssist.
+ * Parent Assist.Use maps to {@link AXPAdministrationPermissionKeys.UseAiAssist}.
+ */
+const AXMAiAssistPermissionKeys = {
+    Use: AXPAdministrationPermissionKeys.UseAiAssist,
+    useForAssist: (assistName) => `AiManagement:Permission:Assist.${assistName}.Use`,
+};
+/**
+ * @deprecated Prefer {@link AXPAdministrationPermissionKeys}.
+ * Legacy nested shape kept so existing imports compile during migration.
+ */
+const AXMPermissionsKeys = {
+    AiManagement: {
+        Management: AXPAdministrationPermissionKeys.MaintainAi,
+        Assist: AXMAiAssistPermissionKeys,
+    },
+};
+
+//#region ---- Setting Keys ----
+/**
+ * AI Management setting keys.
+ * Pattern: AiManagement:Setting:{Path}
+ */
+const AXPAiManagementSettings = {
+    /** Assist primary key (`id`) used when no assist is explicitly selected (tenant-scoped). */
+    DefaultAssistId: 'AiManagement:Setting:DefaultAssistId',
+    /**
+     * System instructions prepended to every assist/agent chat system prompt in {@link AXPAiEngine}.
+     * Empty string means no global layer (default).
+     */
+    GlobalSystemPrompt: 'AiManagement:Setting:GlobalSystemPrompt',
+    Providers: {
+        Gemini: {
+            ApiKey: 'AiManagement:Setting:Providers.Gemini.ApiKey',
+        },
+    },
+};
+//#endregion
+
+//#region ---- Module Config ----
+const config = {
+    i18n: 'ai-management',
+    module: 'AiManagement',
+    route: 'ai-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        name: config.module,
+        route: config.route,
+        title: `@${config.i18n}:module.title`,
+        icon: 'fa-light fa-robot',
+    },
+    entities: {
+        model: {
+            name: 'AiModel',
+            fullName: `${config.module}.AiModel`,
+            title: '@ai-management:models.entities.model.title',
+            titlePlural: '@ai-management:models.entities.model.plural',
+            icon: 'fa-light fa-microchip',
+        },
+        assist: {
+            name: 'Assist',
+            fullName: `${config.module}.Assist`,
+            title: '@ai-management:assists.entities.assist.title',
+            titlePlural: '@ai-management:assists.entities.assist.plural',
+            icon: 'fa-light fa-user-robot',
+        },
+        agent: {
+            name: 'AiAgent',
+            fullName: `${config.module}.AiAgent`,
+            title: '@ai-management:agents.entities.agent.title',
+            titlePlural: '@ai-management:agents.entities.agent.plural',
+            icon: 'fa-light fa-people-group',
+        },
+        openAiEndpoint: {
+            name: 'OpenAiEndpoint',
+            fullName: `${config.module}.OpenAiEndpoint`,
+            title: '@ai-management:open-ai-endpoints.entities.endpoint.title',
+            titlePlural: '@ai-management:open-ai-endpoints.entities.endpoint.plural',
+            icon: 'fa-light fa-plug',
+        },
+        rule: {
+            name: 'AiRule',
+            fullName: `${config.module}.AiRule`,
+            title: '@ai-management:rules.entities.rule.title',
+            titlePlural: '@ai-management:rules.entities.rule.plural',
+            icon: 'fa-light fa-list-check',
+        },
+        mcpServer: {
+            name: 'McpServer',
+            fullName: `${config.module}.McpServer`,
+            title: '@ai-management:mcp-servers.entities.mcp-server.title',
+            titlePlural: '@ai-management:mcp-servers.entities.mcp-server.plural',
+            icon: 'fa-light fa-plug-circle-bolt',
+        },
+    },
+};
+//#endregion
+
+//#endregion
+
+//#region ---- Platform runtime time & notes ----
+const AXM_AI_PLATFORM_RUNTIME_CONTEXT_DEFINITIONS = [
+    {
+        name: 'currentInstant',
+        title: 'Current instant (UTC)',
+        description: 'Current moment as ISO 8601 UTC, built when platform runtime context is assembled before an AI engine run.',
+        order: 80,
+        capabilities: ['ai'],
+    },
+    {
+        name: 'currentLocalDateTime',
+        title: 'Current local date and time',
+        description: 'Current date and time formatted in the user IANA time zone for natural-language interpretation in system prompts.',
+        order: 90,
+        capabilities: ['ai'],
+    },
+    {
+        name: 'notes',
+        title: 'Runtime notes',
+        description: 'Optional free-text or structured notes merged into platform runtime context for a specific AI run (caller-supplied).',
+        order: 100,
+        capabilities: ['ai'],
+    },
+];
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+
+//#region ----- Imports -----
+const AXP_AI_SDK_TOOL_CONTEXT_JSON_SCHEMA = {
+    type: 'object',
+    properties: {
+        runId: { type: 'string' },
+        assistId: { type: 'string' },
+        agentId: { type: 'string' },
+        chatTransport: { type: 'string' },
+        modelEntityId: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+function stringifyRuntimeValue(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    try {
+        const json = JSON.stringify(value);
+        return json && json !== '{}' && json !== '[]' ? json : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function compactStringRecord(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        const trimmed = value?.trim();
+        if (trimmed) {
+            out[key] = trimmed;
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * Turns registered AI-capable context definitions + live values into the
+ * `## Platform runtime` system-prompt block. Identity ids are never assembled into values.
+ */
+function formatAxpAiPlatformRuntimePrompt(platformRuntimeContext, definitions) {
+    if (!platformRuntimeContext || !definitions?.length) {
+        return '';
+    }
+    const lines = definitions
+        .filter(axpContextDefinitionIsAiPrompt)
+        .slice()
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+        .map((field) => {
+        const value = stringifyRuntimeValue(platformRuntimeContext[field.name]);
+        return value ? `- ${field.title}: ${value}` : null;
+    })
+        .filter((line) => line != null);
+    if (lines.length === 0) {
+        return '';
+    }
+    return ['## Platform runtime', ...lines].join('\n');
+}
+function buildAxpAiSdkChatContextBundle(input) {
+    const runtimeContext = compactStringRecord({
+        runId: input.runId,
+        assistId: input.assistId,
+        agentId: input.agentId,
+        agentName: input.agentName,
+        chatTransport: input.chatTransport,
+        modelEntityId: input.modelEntityId,
+        demisSessionUuid: input.demisSessionUuid,
+    });
+    const toolsContext = compactStringRecord({
+        runId: input.runId,
+        assistId: input.assistId,
+        agentId: input.agentId,
+        chatTransport: input.chatTransport,
+        modelEntityId: input.modelEntityId,
+    });
+    return {
+        ...(runtimeContext ? { runtimeContext } : {}),
+        ...(toolsContext ? { toolsContext } : {}),
+        promptAddendum: formatAxpAiPlatformRuntimePrompt(input.platformRuntimeContext, input.contextDefinitions),
+    };
+}
+function attachAxpAiSdkChatContext(options, bundle) {
+    const hasTools = Boolean(options.tools && options.tools.length > 0);
+    return {
+        ...options,
+        ...(bundle.runtimeContext ? { runtimeContext: bundle.runtimeContext } : {}),
+        ...(hasTools && bundle.toolsContext ? { toolsContext: bundle.toolsContext } : {}),
+    };
+}
+function formatAxpAiPlatformRuntimeLocalDateTime(now, ianaTimeZone) {
+    const tz = ianaTimeZone?.trim() || 'UTC';
+    try {
+        return (now.toLocaleString('en-US', {
+            timeZone: tz,
+            dateStyle: 'full',
+            timeStyle: 'long',
+        }) + ` (${tz})`);
+    }
+    catch {
+        return `${now.toISOString()} (UTC)`;
+    }
+}
+function assembleAxpAiPlatformRuntimeContext(sources) {
+    const now = sources.now ?? new Date();
+    const ctx = {};
+    const set = (key, value) => {
+        if (value == null) {
+            return;
+        }
+        const asString = typeof value === 'string' ? value.trim() : String(value).trim();
+        if (asString.length > 0) {
+            ctx[key] = typeof value === 'string' ? asString : value;
+        }
+    };
+    set('userDisplayName', sources.userDisplayName);
+    set('tenantTitle', sources.tenantTitle);
+    set('applicationTitle', sources.applicationTitle);
+    set('locale', sources.locale);
+    set('calendarSystem', sources.calendarSystem);
+    set('timeZone', sources.timeZone);
+    set('country', sources.country);
+    set('notes', sources.notes);
+    set('currentInstant', now.toISOString());
+    set('currentLocalDateTime', formatAxpAiPlatformRuntimeLocalDateTime(now, sources.timeZone));
+    return ctx;
+}
+//#endregion
+
+//#region ---- Imports ----
+/** Default structured retry count when `structuredRetries` is omitted on structured kinds. */
+const AXPAI_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES = 2;
+//#endregion
+//#region ---- Schema / response format parsers ----
+function isJsonSchemaLike$1(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function parseJsonSchemaLike(raw) {
+    if (!isJsonSchemaLike$1(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+function parseResponseFormat(raw) {
+    if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const o = raw;
+    const t = o['type'];
+    if (t === 'text') {
+        return { type: 'text' };
+    }
+    if (t === 'json_object') {
+        return { type: 'json_object' };
+    }
+    if (t === 'json_schema' && isJsonSchemaLike$1(o['schema'])) {
+        const name = typeof o['name'] === 'string' ? o['name'].trim() : undefined;
+        const strict = o['strict'] === true;
+        return {
+            type: 'json_schema',
+            schema: o['schema'],
+            ...(name && name.length > 0 ? { name } : {}),
+            ...(strict ? { strict: true } : {}),
+        };
+    }
+    return undefined;
+}
+//#endregion
+//#region ---- Resolve helpers ----
+const STRUCTURED_OUTPUT_KINDS$1 = new Set(['object', 'array']);
+function isOutputKind(value) {
+    return value === 'string' || value === 'object' || value === 'array';
+}
+function isTranscriptSegment(value) {
+    return value === 'text' || value === 'node' || value === 'followUp' || value === 'file';
+}
+/** Resolved transcript mapping for an object contract (defaults to `text`). */
+function resolveOutputTranscriptSegment(contract) {
+    if (contract.kind !== 'object') {
+        return 'text';
+    }
+    return contract.transcriptSegment ?? 'text';
+}
+//#endregion
+//#region ---- Parser ----
+/**
+ * Normalizes persisted `outputContract` (object or JSON string from entity forms).
+ * Returns `null` when absent or invalid (engine treats as implicit `string`).
+ */
+function parseAgentOutputContract(raw) {
+    let value = raw;
+    if (typeof raw === 'string') {
+        const t = raw.trim();
+        if (!t.length) {
+            return null;
+        }
+        try {
+            value = JSON.parse(t);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const o = value;
+    const kind = o['kind'];
+    if (!isOutputKind(kind)) {
+        return null;
+    }
+    const instruction = typeof o['instruction'] === 'string' ? o['instruction'].trim() : undefined;
+    const schemaSummary = typeof o['schemaSummary'] === 'string' ? o['schemaSummary'].trim() : undefined;
+    const validationCommandName = typeof o['validationCommandName'] === 'string' ? o['validationCommandName'].trim() : undefined;
+    const schema = parseJsonSchemaLike(o['schema']);
+    const schemaName = typeof o['schemaName'] === 'string' ? o['schemaName'].trim() : undefined;
+    const schemaStrict = o['schemaStrict'] === true;
+    const providerResponseFormat = parseResponseFormat(o['providerResponseFormat']);
+    const transcriptSegment = kind === 'object' && isTranscriptSegment(o['transcriptSegment']) ? o['transcriptSegment'] : undefined;
+    let structuredRetries;
+    if (typeof o['structuredRetries'] === 'number' && !Number.isNaN(o['structuredRetries'])) {
+        structuredRetries = Math.max(0, Math.min(10, Math.floor(o['structuredRetries'])));
+    }
+    return {
+        kind,
+        ...(transcriptSegment ? { transcriptSegment } : {}),
+        ...(instruction && instruction.length > 0 ? { instruction } : {}),
+        ...(schemaSummary && schemaSummary.length > 0 ? { schemaSummary } : {}),
+        ...(schema ? { schema } : {}),
+        ...(schemaName && schemaName.length > 0 ? { schemaName } : {}),
+        ...(schemaStrict ? { schemaStrict: true } : {}),
+        ...(validationCommandName && validationCommandName.length > 0 ? { validationCommandName } : {}),
+        ...(structuredRetries !== undefined ? { structuredRetries } : {}),
+        ...(providerResponseFormat ? { providerResponseFormat } : {}),
+    };
+}
+/** Resolved contract for engine (never null; defaults to string). */
+function resolveAgentOutputContract(raw) {
+    const parsed = parseAgentOutputContract(raw);
+    if (parsed) {
+        return parsed;
+    }
+    return { kind: 'string' };
+}
+function axpAiAgentOutputContractUsesStructuredFinalize(contract) {
+    return STRUCTURED_OUTPUT_KINDS$1.has(contract.kind);
+}
+/** Structured kinds omit the string role baseline (Markdown prose hint) in the mock engine. */
+function axpAiAgentOutputContractOmitsRoleBaseline(contract) {
+    return axpAiAgentOutputContractUsesStructuredFinalize(contract);
+}
+function axpAiAgentOutputContractStructuredRetryCap(contract) {
+    if (!axpAiAgentOutputContractUsesStructuredFinalize(contract)) {
+        return 0;
+    }
+    if (typeof contract.structuredRetries === 'number') {
+        return Math.max(0, Math.min(10, Math.floor(contract.structuredRetries)));
+    }
+    return AXPAI_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES;
+}
+//#endregion
+
+//#region ---- Imports ----
+function isSegmentPresetId(value) {
+    return value === 'text' || value === 'node' || value === 'followUp' || value === 'file';
+}
+function contractFromSegmentPresetId(id) {
+    if (id === 'text' || id === 'file') {
+        return { kind: 'string' };
+    }
+    if (id === 'node') {
+        return { kind: 'object', transcriptSegment: 'node' };
+    }
+    if (id === 'followUp') {
+        return { kind: 'object', transcriptSegment: 'followUp' };
+    }
+    return null;
+}
+function contractFromUnknown(raw) {
+    if (raw == null) {
+        return null;
+    }
+    if (typeof raw === 'string') {
+        const id = raw.trim();
+        if (!id.length) {
+            return null;
+        }
+        const preset = isSegmentPresetId(id) ? contractFromSegmentPresetId(id) : null;
+        if (preset) {
+            return preset;
+        }
+        return parseAgentOutputContract(raw);
+    }
+    if (typeof raw === 'object' && !Array.isArray(raw) && 'kind' in raw) {
+        const parsed = parseAgentOutputContract(raw);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return parseAgentOutputContract(raw);
+}
+/**
+ * Resolves the effective output contract for one engine turn.
+ *
+ * Priority: runtime > input > agent > assist > `{ kind: 'string' }`.
+ */
+function resolveEffectiveOutputContract(params) {
+    const runtime = contractFromUnknown(params.runtime);
+    if (runtime) {
+        return runtime;
+    }
+    const input = contractFromUnknown(params.input);
+    if (input) {
+        return input;
+    }
+    const agent = contractFromUnknown(params.agent);
+    if (agent) {
+        return agent;
+    }
+    const assist = contractFromUnknown(params.assist);
+    if (assist) {
+        return assist;
+    }
+    return resolveAgentOutputContract(null);
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- AXPWidgetNode (provider JSON Schema hint) ----
+/**
+ * JSON Schema hint for {@link AXPWidgetNode} roots returned by layout specialists.
+ * Intentionally permissive (`additionalProperties`) — strict validation runs via
+ * `AiFormbuilder:ValidateLayoutJsonForAi` when configured on the agent contract.
+ */
+const AXP_WIDGET_NODE_JSON_SCHEMA = {
+    type: 'object',
+    required: ['type'],
+    additionalProperties: true,
+    properties: {
+        type: {
+            type: 'string',
+            description: 'AXPWidgetNode.type — widget registry name (e.g. block-layout, table-layout).',
+        },
+        mode: {
+            type: 'string',
+            enum: ['view', 'edit', 'designer', 'print', 'column', 'filter'],
+            description: 'AXPWidgetNode.mode render surface.',
+        },
+        path: { type: 'string' },
+        name: { type: 'string' },
+        visible: { description: 'boolean or AXPExpression object.' },
+        defaultValue: { description: 'Widget default value.' },
+        children: {
+            type: 'array',
+            description: 'Nested AXPWidgetNode[]',
+            items: {
+                type: 'object',
+                required: ['type'],
+                additionalProperties: true,
+                properties: {
+                    type: { type: 'string' },
+                    mode: { type: 'string' },
+                    children: { type: 'array', items: { type: 'object', additionalProperties: true } },
+                    options: { type: 'object', additionalProperties: true },
+                },
+            },
+        },
+        options: { type: 'object', additionalProperties: true },
+        triggers: { type: 'object', additionalProperties: true },
+        meta: { type: 'object', additionalProperties: true },
+        valueTransforms: { type: 'object', additionalProperties: true },
+    },
+};
+//#endregion
+//#region ---- followUp envelope ----
+/** JSON Schema for the followUp transcript envelope (`type` + `content` chips). */
+const AXP_FOLLOW_UP_ENVELOPE_JSON_SCHEMA = {
+    type: 'object',
+    required: ['type', 'content'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', enum: ['followUp'] },
+        content: {
+            type: 'array',
+            minItems: 2,
+            maxItems: 5,
+            description: 'Suggestion chips: each item is either a plain string label or { text, command: { name, options? } }.',
+            items: {
+                oneOf: [
+                    { type: 'string', minLength: 1 },
+                    {
+                        type: 'object',
+                        required: ['text', 'command'],
+                        additionalProperties: false,
+                        properties: {
+                            text: { type: 'string' },
+                            command: {
+                                type: 'object',
+                                required: ['name'],
+                                additionalProperties: true,
+                                properties: {
+                                    name: { type: 'string' },
+                                    options: { type: 'object', additionalProperties: true },
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};
+//#endregion
+//#region ---- Resolve builtin schema ----
+/** Built-in JSON Schema for known transcript segments when the contract omits `schema`. */
+function resolveBuiltinSchemaForOutputContract(contract) {
+    if (contract.kind !== 'object') {
+        return undefined;
+    }
+    const segment = resolveOutputTranscriptSegment(contract);
+    if (segment === 'node') {
+        return AXP_WIDGET_NODE_JSON_SCHEMA;
+    }
+    if (segment === 'followUp') {
+        return AXP_FOLLOW_UP_ENVELOPE_JSON_SCHEMA;
+    }
+    return undefined;
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Structured output kinds ----
+const STRUCTURED_OUTPUT_KINDS = new Set(['object', 'array']);
+function usesStructuredFinalize(kind) {
+    return STRUCTURED_OUTPUT_KINDS.has(kind);
+}
+function isJsonSchemaLike(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+//#endregion
+//#region ---- Retry defaults ----
+/** Default structured retry count for a contract kind when `structuredRetries` is omitted. */
+function defaultRetriesForKind(kind) {
+    if (kind === 'string') {
+        return 0;
+    }
+    return AXPAI_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES;
+}
+//#endregion
+//#region ---- Derive provider format ----
+/**
+ * Maps an effective output contract to a provider request hint.
+ * Explicit {@link AXPAiAgentOutputContract.providerResponseFormat} wins; otherwise derived from `kind` + `schema`.
+ */
+function deriveProviderResponseFormat(contract) {
+    if (contract.providerResponseFormat) {
+        return contract.providerResponseFormat;
+    }
+    if (!usesStructuredFinalize(contract.kind)) {
+        return undefined;
+    }
+    const schema = (contract.schema && isJsonSchemaLike(contract.schema) ? contract.schema : undefined) ??
+        resolveBuiltinSchemaForOutputContract(contract);
+    if (schema) {
+        const segment = resolveOutputTranscriptSegment(contract);
+        const name = contract.schemaName?.trim() ||
+            (segment === 'node' ? 'widget_layout' : segment === 'followUp' ? 'follow_up' : 'structured_output');
+        return {
+            type: 'json_schema',
+            schema,
+            name,
+            strict: contract.schemaStrict === true,
+        };
+    }
+    return { type: 'json_object' };
+}
+//#endregion
+
+//#region ---- Imports ----
+/**
+ * Native structured output (AI SDK `output` / provider schema) must not run on tool-calling
+ * turns — only when tools are absent or explicitly disabled (`toolChoice: 'none'`).
+ */
+function axpAiShouldApplyChatStructuredOutput(params) {
+    const format = params.responseFormat;
+    if (!format || format.type === 'text') {
+        return false;
+    }
+    if (!params.hasTools) {
+        return true;
+    }
+    return params.toolChoice === 'none';
+}
+//#endregion
+//#region ---- Duplicate JSON in text ----
+function stripJsonFences(raw) {
+    const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    return fence ? fence[1].trim() : raw.trim();
+}
+function axpAiTryParseJsonValueFromAssistantText(text) {
+    const trimmed = stripJsonFences(text.trim());
+    if (!trimmed) {
+        return undefined;
+    }
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isFollowUpEnvelope(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const o = value;
+    return o['type'] === 'followUp' && Array.isArray(o['content']);
+}
+function isLikelyWidgetRoot(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const t = value['type'];
+    return typeof t === 'string' && t.trim().length > 0 && t !== 'node' && t !== 'followUp';
+}
+function isNodeEnvelope(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const o = value;
+    return o['type'] === 'node' && o['content'] != null;
+}
+/** True when assistant `text` duplicates a structured segment already attached as `node` / `followUp`. */
+function axpAiTextDuplicatesStructuredSegment(text, segment) {
+    const parsed = axpAiTryParseJsonValueFromAssistantText(text);
+    if (parsed === undefined) {
+        return false;
+    }
+    if (segment === 'followUp') {
+        return isFollowUpEnvelope(parsed);
+    }
+    return isLikelyWidgetRoot(parsed) || isNodeEnvelope(parsed);
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Supervisor delegated-agent helpers ----
+/** Prefix for supervisor-delegated specialist tools (`${AXPAI_SUPERVISOR_AGENT_TOOL_PREFIX}${agentId}`). */
+const AXPAI_SUPERVISOR_AGENT_TOOL_PREFIX = 'agent:';
+function axpAiSupervisorAgentToolName(agentCatalogId) {
+    return `${AXPAI_SUPERVISOR_AGENT_TOOL_PREFIX}${agentCatalogId.trim()}`;
+}
+function axpAiParseSupervisorAgentToolName(toolName) {
+    const n = toolName.trim();
+    if (!n.startsWith(AXPAI_SUPERVISOR_AGENT_TOOL_PREFIX)) {
+        return null;
+    }
+    const id = n.slice(AXPAI_SUPERVISOR_AGENT_TOOL_PREFIX.length).trim();
+    return id.length > 0 ? id : null;
+}
+//#endregion
+//#region ---- Message builders ----
+function axpAiChatTextMessage(role, text) {
+    return {
+        role,
+        responses: [{ type: 'text', content: text }],
+    };
+}
+function axpAiChatToolResultMessage(callId, content, toolName) {
+    const id = callId.trim();
+    return {
+        role: 'tool',
+        ...(toolName?.trim() ? { name: toolName.trim() } : {}),
+        responses: [
+            {
+                type: 'tool_result',
+                callId: id,
+                content,
+            },
+        ],
+    };
+}
+//#endregion
+//#region ---- Transcript read helpers ----
+function axpAiChatMessageGetText(message) {
+    const parts = [];
+    for (const r of message.responses) {
+        if (r.type === 'text') {
+            parts.push(r.content);
+        }
+        else if (r.type === 'node' || r.type === 'followUp') {
+            try {
+                parts.push(JSON.stringify({ type: r.type, content: r.content }));
+            }
+            catch {
+                parts.push(`[${r.type}]`);
+            }
+        }
+    }
+    return parts.join('\n\n');
+}
+//#endregion
+//#region ---- Tool result normalization ----
+function axpAiNormalizeHandlerResultToToolBody(handlerResult) {
+    if (handlerResult === undefined || handlerResult === null) {
+        return { success: false, error: 'Tool returned no result.' };
+    }
+    if (typeof handlerResult === 'string') {
+        const t = handlerResult.trim();
+        if (!t) {
+            return { success: false, error: 'Tool returned an empty string.' };
+        }
+        try {
+            return JSON.parse(t);
+        }
+        catch {
+            return { success: true, kind: 'object', data: handlerResult };
+        }
+    }
+    if (typeof handlerResult === 'object' && !Array.isArray(handlerResult)) {
+        return handlerResult;
+    }
+    return { success: true, kind: 'object', data: handlerResult };
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+
+//#region ----- Types -----
+//#endregion
+//#region ----- Constants -----
+const IMAGE_MIME_TYPES = new Set([
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+    'image/gif',
+    'image/bmp',
+    'image/tiff',
+]);
+const IMAGE_EXTENSION_PATTERN = /\.(png|jpe?g|gif|webp|bmp|tif|tiff)$/i;
+const TEXT_MIME_TYPES = new Set([
+    'text/plain',
+    'text/markdown',
+    'text/csv',
+    'application/json',
+]);
+const TEXT_EXTENSION_PATTERN = /\.(txt|md|csv|json)$/i;
+const PDF_MIME = 'application/pdf';
+const PDF_EXTENSION_PATTERN = /\.pdf$/i;
+//#endregion
+//#region ----- Helpers -----
+function normalizeMime(mimeType) {
+    return typeof mimeType === 'string' ? mimeType.trim().toLowerCase() : '';
+}
+function isTextMime(mime) {
+    if (TEXT_MIME_TYPES.has(mime)) {
+        return true;
+    }
+    return mime.startsWith('text/');
+}
+function classifyByFilename(filename) {
+    const name = typeof filename === 'string' ? filename.trim() : '';
+    if (!name) {
+        return 'unsupported';
+    }
+    if (IMAGE_EXTENSION_PATTERN.test(name)) {
+        return 'image';
+    }
+    if (PDF_EXTENSION_PATTERN.test(name)) {
+        return 'pdf';
+    }
+    if (TEXT_EXTENSION_PATTERN.test(name)) {
+        return 'text';
+    }
+    return 'unsupported';
+}
+//#endregion
+//#region ----- Classification -----
+/**
+ * Classifies a document for AI text extraction (image OCR, PDF file part, or UTF-8 text).
+ * Does not include Office formats.
+ */
+function classifyAiExtractDocument(mimeType, filename) {
+    const mime = normalizeMime(mimeType);
+    if (mime && mime !== 'application/octet-stream') {
+        if (mime.startsWith('image/') || IMAGE_MIME_TYPES.has(mime)) {
+            return 'image';
+        }
+        if (mime === PDF_MIME) {
+            return 'pdf';
+        }
+        if (isTextMime(mime)) {
+            return 'text';
+        }
+    }
+    return classifyByFilename(filename);
+}
+function canAiExtractDocument(mimeType, filename) {
+    return classifyAiExtractDocument(mimeType, filename) !== 'unsupported';
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+
+//#region ---- AI chat registry command keys ----
+const AIMANAGEMENT_CHAT_GENERATE_IMAGE_COMMAND_KEY = 'AiManagement:ChatGenerateImage';
+const AIMANAGEMENT_CHAT_TRANSCRIBE_SPEECH_COMMAND_KEY = 'AiManagement:ChatTranscribeSpeech';
+const AIMANAGEMENT_CHAT_SYNTHESIZE_SPEECH_COMMAND_KEY = 'AiManagement:ChatSynthesizeSpeech';
+const AIMANAGEMENT_EXTRACT_DOCUMENT_TEXT_COMMAND_KEY = 'AiManagement:ExtractDocumentText';
+const AIMANAGEMENT_STRUCTURED_TEXT_COMPLETION_COMMAND_KEY = 'AiManagement:StructuredTextCompletion';
+//#endregion
+
+//#region ---- AI engine runtime transport keys ----
+const AXMAiManagementTransportKeys = {
+    Engine: {
+        Run: 'AiManagement:Engine:Run',
+        SubmitToolResult: 'AiManagement:Engine:SubmitToolResult',
+    },
+    ConversationAssist: {
+        Subscribe: 'ConversationManagement:Assist:Subscribe',
+        AssistSync: 'ConversationManagement:Assist:AssistSync',
+        RetryAssist: 'ConversationManagement:Assist:RetryAssist',
+        CancelAssist: 'ConversationManagement:Assist:CancelAssist',
+    },
+};
+//#endregion
+
+//#region ---- Model catalog helpers ----
+function readModelPurposes(row) {
+    if (!row) {
+        return [];
+    }
+    const multi = row['modelPurposes'];
+    if (!Array.isArray(multi)) {
+        return [];
+    }
+    const out = multi
+        .map((x) => String(x).trim())
+        .filter((x) => x.length > 0);
+    return [...new Set(out)];
+}
+function modelRowHasPurpose(row, purpose) {
+    return readModelPurposes(row).includes(purpose);
+}
+function isChatPurposeModelRow(row) {
+    const p = readModelPurposes(row);
+    return p.includes('chat') || p.includes('vision');
+}
+function parseChatTransport(raw) {
+    let v = '';
+    if (typeof raw === 'string') {
+        v = raw.trim().toLowerCase();
+    }
+    else if (raw != null && typeof raw === 'object' && 'value' in raw) {
+        const inner = raw.value;
+        v = inner == null ? '' : String(inner).trim().toLowerCase();
+    }
+    if (v === 'gemini' || v === 'openai' || v === 'demis') {
+        return v;
+    }
+    return undefined;
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Transcript helpers ----
+function axpAiChatMessagesFromProviderAssistant(text, toolCalls) {
+    const normalized = (text ?? '')
+        .replace(/&lt;(\/?redacted_thinking)&gt;/gi, '<$1>')
+        .replace(/&lt;(\/?think)&gt;/gi, '<$1>');
+    const responses = [];
+    const thinkRe = /<(redacted_thinking|think)>([\s\S]*?)<\/\1>/gi;
+    let last = 0;
+    let m;
+    while ((m = thinkRe.exec(normalized)) !== null) {
+        const plain = normalized.slice(last, m.index).trim();
+        if (plain.length > 0) {
+            responses.push({ type: 'text', content: plain });
+        }
+        const think = (m[2] ?? '').trim();
+        if (think.length > 0) {
+            responses.push({ type: 'think', content: think });
+        }
+        last = m.index + m[0].length;
+    }
+    const tail = normalized.slice(last).trim();
+    if (tail.length > 0) {
+        responses.push({ type: 'text', content: tail });
+    }
+    const out = [];
+    if (responses.length > 0) {
+        out.push({ role: 'assistant', responses });
+    }
+    for (const tc of toolCalls ?? []) {
+        const isDelegatedAgent = axpAiParseSupervisorAgentToolName(tc.name) != null;
+        out.push({
+            role: 'assistant',
+            responses: [
+                isDelegatedAgent
+                    ? {
+                        type: 'agent',
+                        content: { command: tc.name, arguments: tc.arguments },
+                        callId: tc.id,
+                        ...(tc.metadata ? { metadata: { ...tc.metadata } } : {}),
+                    }
+                    : {
+                        type: 'tool',
+                        content: { command: tc.name, arguments: tc.arguments },
+                        callId: tc.id,
+                        ...(tc.metadata ? { metadata: { ...tc.metadata } } : {}),
+                    },
+            ],
+        });
+    }
+    return out;
+}
+function axcResolveAiMlOrPlainString(value, locale = 'en-US') {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    return resolveMultiLanguageString(value, locale).trim();
+}
+//#endregion
+
+//#region ---- Contracts barrel ----
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AIMANAGEMENT_CHAT_GENERATE_IMAGE_COMMAND_KEY, AIMANAGEMENT_CHAT_SYNTHESIZE_SPEECH_COMMAND_KEY, AIMANAGEMENT_CHAT_TRANSCRIBE_SPEECH_COMMAND_KEY, AIMANAGEMENT_EXTRACT_DOCUMENT_TEXT_COMMAND_KEY, AIMANAGEMENT_STRUCTURED_TEXT_COMPLETION_COMMAND_KEY, AXMAiAssistPermissionKeys, AXMAiManagementTransportKeys, AXMPermissionsKeys, AXM_AI_PLATFORM_RUNTIME_CONTEXT_DEFINITIONS, AXPAI_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES, AXPAI_SUPERVISOR_AGENT_TOOL_PREFIX, AXPAdministrationPermissionKeys, AXPAiManagementFeatureKeys, AXPAiManagementMenuKeys, AXPAiManagementSettings, AXP_AI_SDK_TOOL_CONTEXT_JSON_SCHEMA, AXP_FOLLOW_UP_ENVELOPE_JSON_SCHEMA, AXP_WIDGET_NODE_JSON_SCHEMA, RootConfig, assembleAxpAiPlatformRuntimeContext, attachAxpAiSdkChatContext, axcResolveAiMlOrPlainString, axpAiAgentOutputContractOmitsRoleBaseline, axpAiAgentOutputContractStructuredRetryCap, axpAiAgentOutputContractUsesStructuredFinalize, axpAiChatMessageGetText, axpAiChatMessagesFromProviderAssistant, axpAiChatTextMessage, axpAiChatToolResultMessage, axpAiNormalizeHandlerResultToToolBody, axpAiParseSupervisorAgentToolName, axpAiShouldApplyChatStructuredOutput, axpAiSupervisorAgentToolName, axpAiTextDuplicatesStructuredSegment, axpAiTryParseJsonValueFromAssistantText, buildAxpAiSdkChatContextBundle, canAiExtractDocument, classifyAiExtractDocument, defaultRetriesForKind, deriveProviderResponseFormat, formatAxpAiPlatformRuntimeLocalDateTime, formatAxpAiPlatformRuntimePrompt, isChatPurposeModelRow, modelRowHasPurpose, parseAgentOutputContract, parseChatTransport, parseJsonSchemaLike, parseResponseFormat, readModelPurposes, resolveAgentOutputContract, resolveBuiltinSchemaForOutputContract, resolveEffectiveOutputContract, resolveOutputTranscriptSegment };
+//# sourceMappingURL=acorex-platform-module-ai-management-client-contracts.mjs.map