langflower 0.0.8 → 0.0.10

package/vendor/common-nodes/dist/ai/nodes/critique/node.js

@@ -0,0 +1,227 @@
+import { filter, map, Observable } from 'rxjs';
+import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
+import { collectAgentToolHandles } from '../../../tools/collect-agent-tool-handles.js';
+import { buildEffectiveSystemPrompt } from '../../features/prompt/build-effective-system-prompt.js';
+import { resolveChatProviderModel } from '../../features/prompt/resolve-chat-provider-model.js';
+import { createLlmSessionCycle$, demuxByKind, normalizeMaxFeedbackTurns, } from '../../features/llm-session/llm-session-shell.js';
+import { llmCompactionUiSchema } from '../../features/ui-schema/llm-compaction-ui-schema.js';
+import { llmRecoveryUiSchema } from '../../features/ui-schema/llm-recovery-ui-schema.js';
+import { llmMaxIterationsUiField, llmPanelUiSchema, } from '../../features/ui-schema/llm-panel-ui-schema.js';
+import { parseLlmRolePreset, resolveEffectiveSkillId, } from '../../features/llm-role-preset.js';
+import { DEFAULT_PATH_CHOICE_MAX_ITERATIONS, PATH_CHOICE_MAX_ITERATIONS_CAP, normalizeMaxIterations, } from '../../features/prompt/normalize-max-iterations.js';
+import { normalizeLlmRecoveryPolicy } from '../../features/llm-loop/normalize-llm-recovery-policy.js';
+import { normalizeCompactionConfig } from '../../features/openai/normalize-compaction-params.js';
+import { REVIEW_ACCEPT_TOOL, REVIEW_FEEDBACK_TOOL, } from '../../features/path-choice/control-tools.js';
+import { runPathChoiceToolLoop, } from '../../features/path-choice/run-reactive-path-choice-loop.js';
+import { getRunHostServices } from '../../features/run-host-services.js';
+const FORCED_TOOL_SYSTEM = [
+    'You are an adversarial Critique node — not the author of the assignment.',
+    `Finish by calling exactly one control tool: ${REVIEW_ACCEPT_TOOL} or ${REVIEW_FEEDBACK_TOOL}.`,
+    'Do not complete or rewrite the original assignment yourself.',
+    'Your job is to attack the packet: contradictions, overclaim, unsafe assumptions, missing evidence, scope creep.',
+    'You may call optional inventory tools first when they help investigate.',
+    'Do not write free-form accept/reject essays.',
+    `Call ${REVIEW_FEEDBACK_TOOL} with concrete findings when the packet is not yet defensible.`,
+    `Call ${REVIEW_ACCEPT_TOOL} only when further attack is non-blocking — agreed enough to stop critiquing.`,
+].join(' ');
+const requireChatConfig = (providerId, model) => {
+    if (providerId.trim().length === 0) {
+        throw new Error('Provider is required for Critique chat');
+    }
+    if (model.trim().length === 0) {
+        throw new Error('Model is required for Critique chat');
+    }
+};
+const buildEffectiveCritiqueSystem = (input) => {
+    const merged = buildEffectiveSystemPrompt(input);
+    const parts = [FORCED_TOOL_SYSTEM];
+    if (merged.trim().length > 0) {
+        parts.push(merged);
+    }
+    return parts.join('\n\n---\n\n');
+};
+const buildUserContent = (assignment, packet) => [
+    '## Original assignment',
+    assignment.trim().length > 0 ? assignment : '(empty assignment)',
+    '',
+    '## Packet to attack',
+    packet.trim().length > 0 ? packet : '(empty packet)',
+].join('\n');
+const buildRevisedPacketUserContent = (packet) => [
+    '## Revised packet to attack',
+    packet.trim().length > 0 ? packet : '(empty packet)',
+].join('\n');
+const hasUserMessage = (history) => history.some((message) => message.role === 'user');
+const runCritiqueTurn = (context, packet, history) => {
+    const factory = context.factory;
+    if (factory === undefined) {
+        return new Observable((subscriber) => {
+            subscriber.error(new Error('Critique chat is only available during server workflow runs'));
+        });
+    }
+    requireChatConfig(context.providerId, context.model);
+    const userContent = hasUserMessage(history)
+        ? buildRevisedPacketUserContent(packet)
+        : buildUserContent(context.assignment, packet);
+    const messages = [
+        ...history,
+        { role: 'user', content: userContent },
+    ];
+    return runPathChoiceToolLoop({
+        factory,
+        providerId: context.providerId,
+        model: context.model,
+        messages,
+        maxIterations: context.maxIterations,
+        tools: context.tools,
+        compaction: context.compaction,
+        recovery: context.recovery,
+        steerControl$: context.steerControl$,
+        toolCtx: context.toolCtx,
+    }).pipe(map((chunk) => {
+        if (chunk.kind === 'accept') {
+            return {
+                kind: 'accept',
+                notes: chunk.notes,
+                result: packet,
+            };
+        }
+        return chunk;
+    }));
+};
+/**
+ * Adversarial Critique: path choice via the same Review-private control tools
+ * (`accept` / `feedback`). First input is the original assignment; second is
+ * the packet under attack. Optional inventory / MCP / Sub-Agents may run first.
+ *
+ * Session history uses the shared {@link createLlmSessionCycle$} (ADR-016):
+ * init = assignment / system / inventory; turn driver = `packet`.
+ */
+export const critiqueNode = defineLlmNode({
+    type: 'common-critique',
+    displayName: 'Critique',
+    category: 'AI',
+    description: 'Adversarial Critique: first input is the original assignment/topic; second is the packet to attack. Finish with accept (agreed enough) or feedback (findings). Requires native tool / function calling. Optional wired tools / MCP / Sub-Agents may run via harness first.',
+    uiSchema: [
+        ...llmPanelUiSchema.filter((item) => item.field !== 'maxIterations'),
+        llmMaxIterationsUiField(DEFAULT_PATH_CHOICE_MAX_ITERATIONS, PATH_CHOICE_MAX_ITERATIONS_CAP),
+        ...llmCompactionUiSchema,
+        ...llmRecoveryUiSchema,
+    ],
+    bind(ctx, { makeInput, configureOutput, combineInputs }, inventory) {
+        const { tools, steerControl } = inventory;
+        const assignment = makeInput('assignment', {
+            name: 'assignment',
+            wireType: 'string',
+            inline: 'text-multiline',
+            required: true,
+        });
+        const packet = makeInput('packet', {
+            name: 'packet',
+            wireType: 'string',
+            inline: 'text-multiline',
+            required: true,
+        });
+        const systemPrompt = makeInput('systemPrompt', {
+            name: 'systemPrompt',
+            wireType: 'string',
+            inline: 'text-multiline',
+            defaultValue: '',
+        });
+        // Init peers only — packet is the session turn driver (ADR-016).
+        const context$ = combineInputs([assignment, systemPrompt, tools, ctx], ([assignmentValue, systemPromptValue, toolList, ec]) => {
+            const rolePreset = parseLlmRolePreset(ec.params.rolePreset);
+            const skillId = resolveEffectiveSkillId(rolePreset, ec.params.skillId);
+            const hostServices = getRunHostServices(ec);
+            const skillMarkdown = hostServices?.skillMarkdown ?? '';
+            const agentsMarkdown = hostServices?.agentsMarkdown ?? '';
+            return {
+                assignment: String(assignmentValue ?? ''),
+                ...resolveChatProviderModel(ec.params, hostServices),
+                skillId,
+                skillMarkdown,
+                effectiveSystemPrompt: buildEffectiveCritiqueSystem({
+                    rolePreset,
+                    systemPromptInput: String(systemPromptValue ?? ''),
+                    agentsMarkdown,
+                    skillMarkdown,
+                }),
+                factory: hostServices?.createChatCompletionStream,
+                maxIterations: normalizeMaxIterations(ec.params.maxIterations, {
+                    fallback: DEFAULT_PATH_CHOICE_MAX_ITERATIONS,
+                    maxCap: PATH_CHOICE_MAX_ITERATIONS_CAP,
+                }),
+                maxFeedbackTurns: normalizeMaxFeedbackTurns(ec.params.maxFeedbackTurns),
+                ...(hostServices?.requestPermission !== undefined
+                    ? { requestPermission: hostServices.requestPermission }
+                    : {}),
+                compaction: normalizeCompactionConfig(ec.params),
+                recovery: normalizeLlmRecoveryPolicy(ec.params),
+                steerControl$: steerControl.value$.pipe(filter(isSteerControlPayload)),
+                tools: collectAgentToolHandles({
+                    toolHandles: ec.toolHandles,
+                    toolsPort: toolList,
+                }),
+                toolCtx: {
+                    projectDir: ec.projectDir,
+                    runId: ec.runId,
+                    ...(hostServices?.authorize !== undefined
+                        ? { authorize: hostServices.authorize }
+                        : {}),
+                    ...(hostServices?.denyPaths !== undefined
+                        ? { denyPaths: hostServices.denyPaths }
+                        : {}),
+                    ...(hostServices?.allowedHosts !== undefined
+                        ? { allowedHosts: hostServices.allowedHosts }
+                        : {}),
+                },
+            };
+        });
+        const cycle$ = createLlmSessionCycle$(context$, packet.value$, (context) => ({
+            history: [
+                {
+                    role: 'system',
+                    content: context.effectiveSystemPrompt,
+                },
+            ],
+            trackAssistantHistory: false,
+            appendUserFeedbackToHistory: false,
+            session: undefined,
+        }), (context, turnPayload, history) => runCritiqueTurn(context, String(turnPayload ?? ''), history), { primeTurn0: false });
+        const reasoning$ = cycle$.pipeValue(demuxByKind('reasoning', (chunk) => chunk
+            .text));
+        const draftResponse$ = cycle$.pipeValue(demuxByKind('draftResponse', (chunk) => chunk
+            .text));
+        const toolLog$ = cycle$.pipeValue(demuxByKind('toolLog', (chunk) => chunk.text));
+        const recovery$ = cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
+            const notice = chunk;
+            return toLlmRecoveryPortValue(notice);
+        }));
+        const response$ = cycle$.pipeValue(demuxByKind('accept', (chunk) => chunk
+            .result));
+        const feedback$ = cycle$.pipeValue(demuxByKind('feedback', (chunk) => chunk
+            .notes));
+        return {
+            inputs: [assignment, packet, systemPrompt],
+            outputs: [
+                configureOutput('reasoning', reasoning$, {
+                    wireType: 'string',
+                    feed: { role: 'reasoning', streaming: true },
+                }),
+                configureOutput('draftResponse', draftResponse$, {
+                    wireType: 'string',
+                    feed: { role: 'draft', streaming: true },
+                }),
+                configureOutput('response', response$, {
+                    wireType: 'string',
+                    feed: { role: 'result' },
+                }),
+                configureOutput('feedback', feedback$, {
+                    wireType: 'string',
+                    feed: { role: 'result' },
+                }),
+            ],
+            inventoryOutputs: { toolLog$, recovery$ },
+        };
+    },
+});