@exellix/ai-tasks 9.0.6 → 9.1.1

package/dist/core/task-sdk.js

@@ -10,6 +10,7 @@ import { buildRunTaskResultMetaFromModelId } from "../invocation/buildRunTaskRes
 import { logRunTaskInvocationPlan } from "../observability/logLlmProviderInvocation.js";
 import { registerBuiltInLocalTasks } from "../localTasks/index.js";
 import { getByPath } from "../utils/jsonPaths.js";
+import { readInvokePayloadRecord } from "../utils/executionMemoryInputRecord.js";
 import { passthroughJobTemplateVariables } from "../utils/skillTemplateVariables.js";
 import { emitRunTaskRequestWarnings } from "../utils/runTaskRequestShape.js";
 import { configureFuncxLogging } from "@x12i/funcx";
@@ -32,14 +33,13 @@ import { getActivixClient } from "../activix/activixClient.js";
 import { withPhaseRecord } from "../activix/phaseTracking.js";
 import { activixOuterTier } from "@x12i/activix";
 import { createDebugTraceCollector, traceWrap } from "../observability/debugTrace.js";
-import { loadSynthesisTemplates, buildSynthesisSystemPrompt, buildSynthesisUserPrompt, resolveSourceMaterial, resolveSourceMaterialParts, getRenderedTemplates, buildSynthesizedContextMarkdown, resolveSynthesisQuestion, runStructuredSynthesisGatewayCallRobust, getContextSynthesizer, normalizeAndValidateSynthesizedPayload, discoverTemplateCores, } from "../synthesis/index.js";
+import { resolveSourceMaterial, resolveSourceMaterialParts, getRenderedTemplates, buildSynthesizedContextMarkdown, resolveSynthesisQuestion, runStructuredSynthesisGatewayCallRobust, getContextSynthesizer, normalizeAndValidateSynthesizedPayload, discoverTemplateCores, } from "../synthesis/index.js";
 import { resolveOutputExpectation as resolveOutputExpectationXynthesis } from "@exellix/xynthesis/ai-actions";
 import { llmCallEnvPrefix, resolveLlmCall } from "../post-steps/resolvePostStepConfig.js";
 import { buildXynthesisWorkScopeIdentity } from "../internal/buildXynthesisWorkScopeIdentity.js";
 import { getPostActionModelFromSlots, prepareMainSkillModelConfigForInvoke, resolvePreActionModel, } from "../utils/routeModelConfigSlots.js";
 import { assertPhaseModelAlias } from "../errors/modelConfigRequiredError.js";
 import { isRunTaskModelResolutionError } from "../errors/runTaskModelResolutionError.js";
-import { runPostStepLlmCall } from "../internal/runPostStepLlmCall.js";
 registerBuiltInLocalTasks();
 const DEFAULT_SYNTH_INPUT_MAX_CHARS = 200_000;
 function maxSynthesizedInputChars() {
@@ -260,10 +260,13 @@ function coerceTaskMemoryNarrixToAttachment(taskMemoryNarrix) {
     };
 }
 function resolveSynthesisMode(config) {
-    if (config.synthesisMode === "structured" || config.synthesisMode === "markdown") {
-        return config.synthesisMode;
+    if (config.synthesisMode === "structured") {
+        return "structured";
     }
-    return "markdown";
+    if (config.synthesisMode === "markdown") {
+        return "structured";
+    }
+    return "structured";
 }
 function detectedTemplateCoresFromExecutionMemory(executionMemory) {
     const artifact = executionMemory?.synthesizedContext;
@@ -437,6 +440,18 @@ function buildSynthesizerInputMaterial(strategy, resolveOpts) {
     const parts = resolveSourceMaterialParts(resolveOpts);
     return { sourceMaterial, parts };
 }
+function buildPreSynthesisGateway(request) {
+    return {
+        aiRequestId: randomUUID(),
+        agentId: typeof request.agentId === "string"
+            ? request.agentId
+            : (request.skillKey ?? "ai-tasks"),
+        sessionId: typeof request.taskId === "string" && request.taskId.trim()
+            ? request.taskId.trim()
+            : randomUUID(),
+        temperature: 0.7,
+    };
+}
 function safeResolveSynthesisQuestion(synthesisRequest, config, renderedPrompt) {
     try {
         const q = resolveSynthesisQuestion(synthesisRequest, config, renderedPrompt);
@@ -1083,14 +1098,18 @@ export class WorexClientTasks {
                 };
             }
             const execMem = (enrichedBundle.executionMemory ?? memoryBundle.executionMemory);
-            const recordRaw = isRecord(execMem?.input) ? execMem.input.raw : undefined;
+            const recordRaw = readInvokePayloadRecord(request);
             const recordMd = recordRaw !== undefined
-                ? `## Record (executionMemory.input.raw)\n\n\`\`\`json\n${truncate(JSON.stringify(recordRaw, null, 2), maxOutputLength ? Math.min(maxOutputLength, 60_000) : 60_000)}\n\`\`\`\n`
+                ? `## Record (input)\n\n\`\`\`json\n${truncate(JSON.stringify(recordRaw, null, 2), maxOutputLength ? Math.min(maxOutputLength, 60_000) : 60_000)}\n\`\`\`\n`
                 : "";
             const webContextEntry = execMem?.webContext;
             const webMd = buildWebContextEvidenceMarkdown(webContextEntry, config.webEvidence);
-            const { system: systemTemplate, user: userTemplate } = await loadSynthesisTemplates();
-            const systemPrompt = buildSynthesisSystemPrompt(systemTemplate, config.synthesisPromptOverride, config.customSynthesizingGuidelines);
+            const { templateCores } = discoverTemplateCores({
+                templates: [
+                    { name: "instructions", content: rawInstructions },
+                    { name: "prompt", content: rawPrompt },
+                ],
+            });
             const extractWebEvidence = () => {
                 if (!isRecord(webContextEntry))
                     return { webUnavailableReason: "webContext missing" };
@@ -1153,58 +1172,48 @@ export class WorexClientTasks {
                 if (allowWeb)
                     materialParts.push(webMd || "## Web sources (primary evidence)\n\n[unavailable]");
                 const perQuestionMaterial = materialParts.join("\n");
-                const userPrompt = buildSynthesisUserPrompt(renderedInstructions, renderedPrompt, perQuestionMaterial, userTemplate);
                 let synthesisText;
                 if (allowWeb && !hasWeb && !allowRecord) {
                     const reason = webEvidence.webUnavailableReason ?? "web scoping unavailable";
                     synthesisText = `Unknown — web-derived context unavailable (${reason}).`;
                 }
                 else if (allowRecord && !hasRecord && !allowWeb) {
-                    synthesisText = `Unknown — record-derived context unavailable (missing executionMemory.input.raw).`;
+                    synthesisText = `Unknown — record-derived context unavailable (missing executionMemory.input).`;
                 }
                 else if (allowRecord && allowWeb && !hasRecord && !hasWeb) {
                     const reason = webEvidence.webUnavailableReason ?? "web scoping unavailable";
                     synthesisText =
-                        `Unknown — no inputs available (missing executionMemory.input.raw; web unavailable: ${reason}).`;
+                        `Unknown — no inputs available (missing executionMemory.input; web unavailable: ${reason}).`;
                 }
                 else {
-                    const res = await runPostStepLlmCall({
-                        systemPrompt,
-                        userPrompt,
-                        llmCall: synthLlmCall,
-                        stage: "pre-synthesis-question",
-                        stepId: `questionDriven:${id}`,
+                    const payload = await runStructuredSynthesisGatewayCallRobust({
+                        templateCores,
+                        question: question.trim(),
+                        localMarkdown: perQuestionMaterial,
+                        supportingMarkdown: "",
+                        renderedInstructions,
+                        renderedPrompt,
+                        model,
+                        timeoutMs,
+                        maxOutputLength,
+                        outputExpectation: synthLlmCall.outputExpectation,
+                        reasoningEffort: synthLlmCall.reasoningEffort,
+                        topP: synthLlmCall.topP,
+                        executionMode: traceCollector ? "trace" : undefined,
                         jobId: request.jobId,
                         taskId: request.taskId,
                         agentId: request.agentId,
-                        workScopeIdentity,
-                        traceCollector,
-                        traceTask: traceCollector
-                            ? {
-                                taskType: "pre-execution",
-                                details: "synthesized-context question call",
-                                modelUsed: model ?? null,
-                                metadata: {
-                                    jobId: request.jobId,
-                                    taskId: request.taskId,
-                                    skillKey: request.skillKey,
-                                    phase: "pipeline_pre",
-                                    preStepType: "synthesized-context",
-                                    step: { phase: "pre", type: "synthesized-context", stepId: `questionDriven:${id}` },
-                                    questionId: id,
-                                },
-                            }
-                            : undefined,
-                        observationSink: synthObservationSink,
+                        identity: workScopeIdentity,
+                        gateway: buildPreSynthesisGateway(request),
                     });
-                    synthesisText = res.text;
+                    synthesisText = buildSynthesizedContextMarkdown(payload);
                 }
                 answers[id] = {
                     question: question.trim(),
                     source,
                     synthesis: synthesisText,
                     evidence: {
-                        recordPaths: allowRecord ? ["executionMemory.input.raw"] : undefined,
+                        recordPaths: allowRecord ? ["executionMemory.input"] : undefined,
                         webScopeIds: allowWeb ? webEvidence.webScopeIds : undefined,
                         sources: allowWeb ? webEvidence.sources : undefined,
                     },
@@ -1231,148 +1240,85 @@ export class WorexClientTasks {
             };
         }
         const synthesisMode = resolveSynthesisMode(config);
-        if (synthesisMode === "structured") {
-            const parts = sourceMaterialParts;
-            const question = safeResolveSynthesisQuestion(synthesisRequest, config, renderedPrompt);
-            const { templateCores } = discoverTemplateCores({
-                templates: [
-                    { name: "instructions", content: rawInstructions },
-                    { name: "prompt", content: rawPrompt },
-                ],
-            });
-            if (templateCores.length === 0) {
-                if (!rawInstructions.trim() && !rawPrompt.trim()) {
-                    throw new Error(`structured synthesized-context could not resolve raw instructions/prompt templates for skillKey: ${request.skillKey}. ` +
-                        `Ensure ai-skills content registry is available for resolveRawTemplate().`);
-                }
-                throw new Error(`structured synthesized-context requires at least one template core token in instructions or prompt. skillKey: ${request.skillKey}`);
+        const parts = sourceMaterialParts;
+        const question = safeResolveSynthesisQuestion(synthesisRequest, config, renderedPrompt);
+        const { templateCores } = discoverTemplateCores({
+            templates: [
+                { name: "instructions", content: rawInstructions },
+                { name: "prompt", content: rawPrompt },
+            ],
+        });
+        if (templateCores.length === 0) {
+            if (!rawInstructions.trim() && !rawPrompt.trim()) {
+                throw new Error(`structured synthesized-context could not resolve raw instructions/prompt templates for skillKey: ${request.skillKey}. ` +
+                    `Ensure ai-skills content registry is available for resolveRawTemplate().`);
             }
-            const validateOpts = {
-                expectedTemplateCores: templateCores,
-                expectedQuestion: question,
-                maxItemsPerSide: config.structuredMaxItemsPerSide,
-                maxItemContentChars: config.structuredMaxItemContentChars,
-            };
-            try {
-                const custom = getContextSynthesizer();
-                let payload;
-                if (custom) {
-                    payload = await custom.synthesize({
-                        templateCores,
-                        question,
-                        localRaw: parts.localMarkdown,
-                        supportingRaw: parts.supportingMarkdown,
-                        metadata: {
-                            renderedInstructions,
-                            renderedPrompt,
-                            templateCores,
-                            skillKey: request.skillKey,
-                            jobId: request.jobId,
-                            taskId: request.taskId,
-                        },
-                    });
-                    payload = normalizeAndValidateSynthesizedPayload(payload, validateOpts);
-                }
-                else {
-                    payload = await runStructuredSynthesisGatewayCallRobust({
-                        question,
-                        localMarkdown: parts.localMarkdown,
-                        supportingMarkdown: parts.supportingMarkdown,
+            throw new Error(`structured synthesized-context requires at least one template core token in instructions or prompt. skillKey: ${request.skillKey}`);
+        }
+        const validateOpts = {
+            expectedTemplateCores: templateCores,
+            expectedQuestion: question,
+            maxItemsPerSide: config.structuredMaxItemsPerSide,
+            maxItemContentChars: config.structuredMaxItemContentChars,
+        };
+        try {
+            const custom = getContextSynthesizer();
+            let payload;
+            if (custom) {
+                payload = await custom.synthesize({
+                    templateCores,
+                    question,
+                    localRaw: parts.localMarkdown,
+                    supportingRaw: parts.supportingMarkdown,
+                    metadata: {
                         renderedInstructions,
                         renderedPrompt,
-                        templatesBasePath: config.templatesBasePath,
-                        synthesisPromptOverride: config.synthesisPromptOverride,
-                        customSynthesizingGuidelines: config.customSynthesizingGuidelines,
-                        model: model,
-                        timeoutMs: timeoutMs,
-                        maxOutputLength: maxOutputLength,
-                        // Caller-supplied outputExpectation overrides the per-action default in the structured-repair path.
-                        outputExpectation: synthLlmCall.outputExpectation,
-                        reasoningEffort: synthLlmCall.reasoningEffort,
-                        topP: synthLlmCall.topP,
-                        // Forward trace mode so the structured gateway returns a `debugTrace` (lifted into observations elsewhere).
-                        executionMode: traceCollector ? "trace" : undefined,
+                        templateCores,
+                        skillKey: request.skillKey,
                         jobId: request.jobId,
                         taskId: request.taskId,
-                        agentId: request.agentId,
-                        identity: workScopeIdentity,
-                    });
-                }
-                const contextMarkdown = buildSynthesizedContextMarkdown(payload);
-                return {
-                    contextMarkdown,
-                    artifact: {
-                        templateCores,
-                        question,
-                        mode: synthesisMode,
-                        payload,
-                        contextMarkdown,
                     },
-                    synthesizedInput: buildSynthesizedInputArtifact(synthesisMode, sourceMaterial, parts, {
-                        question,
-                        templateCores,
-                    }),
-                    synthesizedContextLlmCalls: traceCollector ? synthLlmCalls : undefined,
-                };
+                });
+                payload = normalizeAndValidateSynthesizedPayload(payload, validateOpts);
             }
-            catch (e) {
-                if (config.fallbackToDirect === true)
-                    return {
-                        contextMarkdown: "",
-                        synthesizedContextLlmCalls: traceCollector ? synthLlmCalls : undefined,
-                    };
-                throw e;
+            else {
+                payload = await runStructuredSynthesisGatewayCallRobust({
+                    templateCores,
+                    question,
+                    localMarkdown: parts.localMarkdown,
+                    supportingMarkdown: parts.supportingMarkdown,
+                    renderedInstructions,
+                    renderedPrompt,
+                    templatesBasePath: config.templatesBasePath,
+                    synthesisPromptOverride: config.synthesisPromptOverride,
+                    customSynthesizingGuidelines: config.customSynthesizingGuidelines,
+                    model: model,
+                    timeoutMs: timeoutMs,
+                    maxOutputLength: maxOutputLength,
+                    // Caller-supplied outputExpectation overrides the per-action default in the structured-repair path.
+                    outputExpectation: synthLlmCall.outputExpectation,
+                    reasoningEffort: synthLlmCall.reasoningEffort,
+                    topP: synthLlmCall.topP,
+                    // Forward trace mode so the structured gateway returns a `debugTrace` (lifted into observations elsewhere).
+                    executionMode: traceCollector ? "trace" : undefined,
+                    jobId: request.jobId,
+                    taskId: request.taskId,
+                    agentId: request.agentId,
+                    identity: workScopeIdentity,
+                    gateway: buildPreSynthesisGateway(request),
+                });
             }
-        }
-        const { system: systemTemplate, user: userTemplate } = await loadSynthesisTemplates();
-        const systemPrompt = buildSynthesisSystemPrompt(systemTemplate, config.synthesisPromptOverride, config.customSynthesizingGuidelines);
-        const userPrompt = buildSynthesisUserPrompt(renderedInstructions, renderedPrompt, sourceMaterial, userTemplate);
-        try {
-            const { text: contextMarkdown } = await runPostStepLlmCall({
-                systemPrompt,
-                userPrompt,
-                extraMaterial: sourceMaterial,
-                llmCall: synthLlmCall,
-                stage: "pre-synthesis-markdown",
-                jobId: request.jobId,
-                taskId: request.taskId,
-                agentId: request.agentId,
-                workScopeIdentity,
-                traceCollector,
-                traceTask: traceCollector
-                    ? {
-                        taskType: "pre-execution",
-                        details: "synthesized-context markdown call",
-                        modelUsed: model ?? null,
-                        metadata: {
-                            jobId: request.jobId,
-                            taskId: request.taskId,
-                            skillKey: request.skillKey,
-                            phase: "pipeline_pre",
-                            preStepType: "synthesized-context",
-                            step: { phase: "pre", type: "synthesized-context", stepId: "markdown" },
-                        },
-                    }
-                    : undefined,
-                observationSink: synthObservationSink,
-            });
-            const question = safeResolveSynthesisQuestion(synthesisRequest, config, renderedPrompt);
-            const { templateCores } = discoverTemplateCores({
-                templates: [
-                    { name: "instructions", content: rawInstructions },
-                    { name: "prompt", content: rawPrompt },
-                ],
-            });
+            const contextMarkdown = buildSynthesizedContextMarkdown(payload);
             return {
                 contextMarkdown,
                 artifact: {
                     templateCores,
                     question,
-                    mode: "markdown",
-                    payload: { kind: "markdown-synthesis" },
+                    mode: synthesisMode,
+                    payload,
                     contextMarkdown,
                 },
-                synthesizedInput: buildSynthesizedInputArtifact("markdown", sourceMaterial, sourceMaterialParts, {
+                synthesizedInput: buildSynthesizedInputArtifact(synthesisMode, sourceMaterial, parts, {
                     question,
                     templateCores,
                 }),