langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/ai/features/path-choice/run-reactive-path-choice-loop.js

@@ -0,0 +1,106 @@
+import { buildSpawnSubagentChatTool, parseToolArgs, previewToolLogText, toChatToolDefinitions, } from '../../../tools/inventory-tool-round.js';
+import { DISABLED_COMPACTION_CONFIG } from '../openai/normalize-compaction-params.js';
+import { DEFAULT_LLM_RECOVERY_POLICY, } from '../llm-loop/llm-loop-types.js';
+import { runLlmLoop, } from '../llm-loop/run-llm-loop.js';
+import { findControlToolCall, isReviewControlToolName, notesFromControlToolArgs, REVIEW_CHAT_TOOLS, REVIEW_TOOL_REMINDER, } from './control-tools.js';
+const PATH_CHOICE_POLICY = {
+    decideCompletion: ({ state, text, toolCalls }) => {
+        // Pre-tool base — never mid-scan committedMessages (orphan tool_calls).
+        const base = state.roundCheckpoint;
+        const control = findControlToolCall(toolCalls);
+        if (control !== undefined) {
+            const notes = notesFromControlToolArgs(parseToolArgs(control.call.arguments));
+            const messages = [
+                ...base,
+                {
+                    role: 'assistant',
+                    content: text,
+                    tool_calls: [control.call],
+                },
+                {
+                    role: 'tool',
+                    tool_call_id: control.call.id,
+                    content: notes,
+                },
+            ];
+            return {
+                kind: 'complete',
+                chunks: [
+                    { kind: 'historySync', messages },
+                    {
+                        kind: 'toolLog',
+                        text: `→ ${control.call.name}(${previewToolLogText(control.call.arguments)})`,
+                    },
+                    control.kind === 'accept'
+                        ? { kind: 'accept', notes }
+                        : { kind: 'feedback', notes },
+                ],
+            };
+        }
+        const inventoryCalls = toolCalls.filter((call) => !isReviewControlToolName(call.name));
+        if (inventoryCalls.length > 0) {
+            return { kind: 'run-tools', calls: inventoryCalls };
+        }
+        const assistantContent = text.trim().length > 0
+            ? text
+            : '(no text; missing accept/feedback tool call)';
+        return {
+            kind: 'continue',
+            messages: [
+                ...base,
+                { role: 'assistant', content: assistantContent },
+                { role: 'user', content: REVIEW_TOOL_REMINDER },
+            ],
+            chunks: [
+                { kind: 'reminder', text: REVIEW_TOOL_REMINDER },
+                {
+                    kind: 'toolLog',
+                    text: `⚠ ${REVIEW_TOOL_REMINDER}`,
+                },
+            ],
+        };
+    },
+    toolNotAllowedText: (toolName) => `Tool «${toolName}» is not in the Review tools allowlist.`,
+    maxIterationsFailure: (maxIterations) => ({
+        kind: 'fail',
+        failure: {
+            kind: 'protocol',
+            message: `Review failed after ${maxIterations} completions ` +
+                'without accept or feedback (forced tool use).',
+            recoverable: false,
+        },
+    }),
+};
+export const runPathChoiceToolLoop = (args) => {
+    const inventory = args.tools ?? [];
+    const subagentRegistrations = args.subagentRegistrations ?? [];
+    return runLlmLoop({
+        factory: args.factory,
+        providerId: args.providerId,
+        model: args.model,
+        messages: args.messages,
+        maxIterations: args.maxIterations,
+        inventoryTools: inventory,
+        chatTools: [
+            ...REVIEW_CHAT_TOOLS,
+            ...toChatToolDefinitions(inventory),
+            ...(subagentRegistrations.length > 0
+                ? [buildSpawnSubagentChatTool(subagentRegistrations)]
+                : []),
+        ],
+        compaction: args.compaction ?? DISABLED_COMPACTION_CONFIG,
+        recovery: args.recovery ?? DEFAULT_LLM_RECOVERY_POLICY,
+        policy: PATH_CHOICE_POLICY,
+        subagentRegistrations,
+        ...(args.harness !== undefined ? { harness: args.harness } : {}),
+        ...(args.toolCtx !== undefined ? { toolCtx: args.toolCtx } : {}),
+        ...(args.steerControl$ !== undefined
+            ? { steerControl$: args.steerControl$ }
+            : {}),
+        ...(args.waitForSubagentResult !== undefined
+            ? {
+                waitForSubagentResult: args.waitForSubagentResult,
+            }
+            : {}),
+    });
+};

package/vendor/common-nodes/dist/ai/features/prompt/build-effective-system-prompt.d.ts

@@ -0,0 +1,9 @@
+import { type LlmRolePreset } from '../llm-role-preset.js';
+export type BuildEffectiveSystemPromptInput = {
+    readonly rolePreset: LlmRolePreset;
+    readonly systemPromptInput: string;
+    readonly agentsMarkdown: string;
+    readonly skillMarkdown: string;
+};
+/** Merges panel/input system text with optional AGENTS.md + skill markdown (no FS). */
+export declare const buildEffectiveSystemPrompt: (input: BuildEffectiveSystemPromptInput) => string;

package/vendor/common-nodes/dist/ai/features/prompt/build-effective-system-prompt.js

@@ -0,0 +1,21 @@
+import { LLM_ROLE_PRESET_DEFAULTS, } from '../llm-role-preset.js';
+/** Merges panel/input system text with optional AGENTS.md + skill markdown (no FS). */
+export const buildEffectiveSystemPrompt = (input) => {
+    const preset = LLM_ROLE_PRESET_DEFAULTS[input.rolePreset];
+    const base = input.systemPromptInput.trim() !== ''
+        ? input.systemPromptInput.trim()
+        : preset.systemPrompt.trim();
+    const parts = [];
+    if (base !== '') {
+        parts.push(base);
+    }
+    const agents = input.agentsMarkdown.trim();
+    if (agents !== '') {
+        parts.push(agents);
+    }
+    const skill = input.skillMarkdown.trim();
+    if (skill !== '') {
+        parts.push(skill);
+    }
+    return parts.join('\n\n---\n\n');
+};

package/vendor/common-nodes/dist/ai/features/prompt/normalize-max-iterations.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Normalize Inspector / param `maxIterations`.
+ * `0` = unlimited; invalid / negative → `fallback`; positive → floor + `maxCap`.
+ */
+export declare const normalizeMaxIterations: (value: unknown, options: {
+    readonly fallback: number;
+    readonly maxCap: number;
+}) => number;
+/** Soft upper bound only — Inspector lets users raise freely. */
+export declare const AGENT_MAX_ITERATIONS_CAP: number;
+export declare const PATH_CHOICE_MAX_ITERATIONS_CAP: number;
+export declare const DEFAULT_AGENT_MAX_ITERATIONS = 100;
+export declare const DEFAULT_PATH_CHOICE_MAX_ITERATIONS = 5;

package/vendor/common-nodes/dist/ai/features/prompt/normalize-max-iterations.js

@@ -0,0 +1,23 @@
+/**
+ * Normalize Inspector / param `maxIterations`.
+ * `0` = unlimited; invalid / negative → `fallback`; positive → floor + `maxCap`.
+ */
+export const normalizeMaxIterations = (value, options) => {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n) || n < 0) {
+        return options.fallback;
+    }
+    if (n === 0) {
+        return 0;
+    }
+    const floored = Math.floor(n);
+    if (floored < 1) {
+        return options.fallback;
+    }
+    return Math.min(options.maxCap, floored);
+};
+/** Soft upper bound only — Inspector lets users raise freely. */
+export const AGENT_MAX_ITERATIONS_CAP = Number.MAX_SAFE_INTEGER;
+export const PATH_CHOICE_MAX_ITERATIONS_CAP = Number.MAX_SAFE_INTEGER;
+export const DEFAULT_AGENT_MAX_ITERATIONS = 100;
+export const DEFAULT_PATH_CHOICE_MAX_ITERATIONS = 5;

package/vendor/common-nodes/dist/ai/features/prompt/resolve-chat-provider-model.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolve chat provider/model from node params with optional host default
+ * (`LangflowerConfig.model` parsed into {@link RunHostServices.defaultChat}).
+ */
+import type { RunHostServices } from '../run-host-services.js';
+export type ResolvedChatProviderModel = {
+    readonly providerId: string;
+    readonly model: string;
+};
+export declare const resolveChatProviderModel: (params: Readonly<Record<string, unknown>>, host: RunHostServices | undefined) => ResolvedChatProviderModel;

package/vendor/common-nodes/dist/ai/features/prompt/resolve-chat-provider-model.js

@@ -0,0 +1,8 @@
+export const resolveChatProviderModel = (params, host) => {
+    const fromParamsProvider = String(params['providerId'] ?? '').trim();
+    const fromParamsModel = String(params['model'] ?? '').trim();
+    return {
+        providerId: fromParamsProvider || host?.defaultChat?.providerId || '',
+        model: fromParamsModel || host?.defaultChat?.model || '',
+    };
+};

package/vendor/common-nodes/dist/ai/features/run-host-services.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Server/runtime-only bag attached via {@link runHostServicesSymbol}.
+ * Not part of public ExecutionContext — specialized LLM wiring closes over
+ * this, not author Caps.
+ */
+import type { ToolHandle } from '@langflower/node-sdk';
+import type { ToolInvokeCall } from '@langflower/tools/create-project-harness';
+import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
+import type { PermissionAskRequest } from '@langflower/tools/permission';
+import type { CreateChatCompletionStream } from './chat-completion-stream.js';
+export declare const runHostServicesSymbol: unique symbol;
+export type LangflowerBusRequest = (intent: string, payload: unknown) => Promise<unknown>;
+export type RunHostServices = {
+    readonly createChatCompletionStream?: CreateChatCompletionStream;
+    readonly skillMarkdown?: string;
+    readonly agentsMarkdown?: string;
+    /**
+     * Parsed effective `LangflowerConfig.model` (`providerId/modelId`).
+     * Empty node `providerId` / `model` params fall back to these at run time.
+     */
+    readonly defaultChat?: {
+        readonly providerId: string;
+        readonly model: string;
+    };
+    readonly authorize?: (call: ToolInvokeCall) => Promise<'allow' | 'deny'>;
+    /**
+     * Direct HITL ask (tool gates + agent limit continue). Bypasses permission
+     * config / grant cache — always surfaces `runner.permission.ask`.
+     */
+    readonly requestPermission?: (request: PermissionAskRequest) => Promise<'allow' | 'deny'>;
+    readonly denyPaths?: readonly string[];
+    readonly allowedHosts?: readonly string[];
+    /**
+     * In-process bus RPC for Langflower Tools only (compile / later editor
+     * intents). Missing on LLM and other catalog nodes.
+     */
+    readonly requestLangflowerBus?: LangflowerBusRequest;
+    /**
+     * Read current editor source `tools` outputs for this agent (post-swap).
+     * Missing outside a Langflower server run.
+     */
+    readonly getLiveWiredTools?: (agentNodeId: string) => readonly ToolHandle[];
+};
+export declare const attachRunHostServices: <T extends object>(ctx: T, services: RunHostServices) => T;
+export declare const getRunHostServices: (ctx: object) => RunHostServices | undefined;
+/**
+ * LLM `toolCtx`: identity + permission/path fields only.
+ * Does **not** attach {@link RunHostServices} — bus RPC and live inventory
+ * stay on the tools / LLM node ExecutionContext, not on agent invoke ctx.
+ */
+export declare const buildAgentToolCtx: (identity: {
+    readonly projectDir: string;
+    readonly runId: string;
+}, hostServices: RunHostServices | undefined) => ToolHandlerContext;

package/vendor/common-nodes/dist/ai/features/run-host-services.js

@@ -0,0 +1,29 @@
+export const runHostServicesSymbol = Symbol('langflower.runHostServices');
+export const attachRunHostServices = (ctx, services) => Object.assign(ctx, {
+    [runHostServicesSymbol]: services,
+});
+export const getRunHostServices = (ctx) => {
+    const bag = ctx[runHostServicesSymbol];
+    if (bag === undefined || typeof bag !== 'object' || bag === null) {
+        return undefined;
+    }
+    return bag;
+};
+/**
+ * LLM `toolCtx`: identity + permission/path fields only.
+ * Does **not** attach {@link RunHostServices} — bus RPC and live inventory
+ * stay on the tools / LLM node ExecutionContext, not on agent invoke ctx.
+ */
+export const buildAgentToolCtx = (identity, hostServices) => ({
+    projectDir: identity.projectDir,
+    runId: identity.runId,
+    ...(hostServices?.authorize !== undefined
+        ? { authorize: hostServices.authorize }
+        : {}),
+    ...(hostServices?.denyPaths !== undefined
+        ? { denyPaths: hostServices.denyPaths }
+        : {}),
+    ...(hostServices?.allowedHosts !== undefined
+        ? { allowedHosts: hostServices.allowedHosts }
+        : {}),
+});

package/vendor/common-nodes/dist/ai/features/scripted-chat-completion-stream.d.ts

@@ -0,0 +1,17 @@
+import type { CreateChatCompletionStream } from './chat-completion-stream.js';
+type ScriptedToolCall = {
+    readonly name: string;
+    readonly arguments?: unknown;
+};
+export type ScriptedTurn = {
+    readonly toolCalls: readonly ScriptedToolCall[];
+} | {
+    readonly text: string;
+};
+export declare const parseScriptedTurns: (value: unknown) => readonly ScriptedTurn[] | undefined;
+/**
+ * Deterministic `CreateChatCompletionStream` for CI / demos. Cursor advances
+ * across calls so multi-turn scripts keep working in one session.
+ */
+export declare const createScriptedFactory: (turns: readonly ScriptedTurn[]) => CreateChatCompletionStream;
+export {};

package/vendor/common-nodes/dist/ai/features/scripted-chat-completion-stream.js

@@ -0,0 +1,61 @@
+export const parseScriptedTurns = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const turns = [];
+    for (const item of value) {
+        if (item === null || typeof item !== 'object') {
+            continue;
+        }
+        const record = item;
+        if (Array.isArray(record.toolCalls)) {
+            const toolCalls = record.toolCalls
+                .filter((call) => call !== null &&
+                typeof call === 'object' &&
+                typeof call.name === 'string')
+                .map((call) => ({
+                name: call.name,
+                ...(call.arguments !== undefined
+                    ? { arguments: call.arguments }
+                    : {}),
+            }));
+            turns.push({ toolCalls });
+            continue;
+        }
+        if (typeof record.text === 'string') {
+            turns.push({ text: record.text });
+        }
+    }
+    return turns.length > 0 ? turns : undefined;
+};
+/**
+ * Deterministic `CreateChatCompletionStream` for CI / demos. Cursor advances
+ * across calls so multi-turn scripts keep working in one session.
+ */
+export const createScriptedFactory = (turns) => {
+    let index = 0;
+    return async () => {
+        const turn = turns[index] ?? { text: '' };
+        index += 1;
+        return (async function* () {
+            if ('toolCalls' in turn) {
+                yield {
+                    kind: 'done',
+                    text: '',
+                    tool_calls: turn.toolCalls.map((call, callIndex) => ({
+                        id: `script_${index}_${callIndex}`,
+                        name: call.name,
+                        arguments: typeof call.arguments === 'string'
+                            ? call.arguments
+                            : JSON.stringify(call.arguments ?? {}),
+                    })),
+                };
+                return;
+            }
+            if (turn.text.length > 0) {
+                yield { kind: 'draft', text: turn.text };
+            }
+            yield { kind: 'done', text: turn.text };
+        })();
+    };
+};

package/vendor/common-nodes/dist/ai/features/sub-agent-protocol.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Sub-Agent registration / spawn / result wire contracts (ADR-021 L0).
+ * Separate from `ToolHandle` — never part of agent tool inventory.
+ *
+ * Named wire types (not `json`) so RuntimeEditor connection checks reject
+ * unrelated structured payloads. Custom nodes:
+ * `import { SUBAGENT_RESULT_WIRE_TYPE, type SubAgentResultPayload } from
+ * '@langflower/common-nodes/ai/sub-agent-protocol'`.
+ */
+/** Wire type strings owned by `@langflower/node-sdk` (`defineLlmNode`). */
+export { SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from '@langflower/node-sdk/llm';
+type SubAgentSkillAnnounce = {
+    readonly skillId: string;
+    readonly description: string;
+};
+/** On Sub-Agent `registration` out → main `subagentRegistration` in (combine). */
+export type SubAgentRegistration = {
+    readonly targetNodeId: string;
+    readonly name: string;
+    readonly description: string;
+    readonly skills: readonly SubAgentSkillAnnounce[];
+};
+/** Main `subagent` out → Sub-Agent `task` in (fan-out; filter by nodeId). */
+export type SubAgentSpawnPayload = {
+    readonly callId: string;
+    readonly nodeId: string;
+    /** Empty string when the main agent chose no skill. */
+    readonly skillId: string;
+    readonly task: string;
+};
+/** Sub-Agent `result` out → main `subagentResult` in (merge; router by callId). */
+export type SubAgentResultPayload = {
+    readonly callId: string;
+    readonly result: string;
+};
+export declare const isSubAgentSpawnPayload: (value: unknown) => value is SubAgentSpawnPayload;
+export declare const isSubAgentResultPayload: (value: unknown) => value is SubAgentResultPayload;
+/** Flatten multi-wire combine values (single reg or arrays). */
+export declare const flattenSubAgentRegistrations: (wired: unknown) => readonly SubAgentRegistration[];

package/vendor/common-nodes/dist/ai/features/sub-agent-protocol.js

@@ -0,0 +1,43 @@
+/**
+ * Sub-Agent registration / spawn / result wire contracts (ADR-021 L0).
+ * Separate from `ToolHandle` — never part of agent tool inventory.
+ *
+ * Named wire types (not `json`) so RuntimeEditor connection checks reject
+ * unrelated structured payloads. Custom nodes:
+ * `import { SUBAGENT_RESULT_WIRE_TYPE, type SubAgentResultPayload } from
+ * '@langflower/common-nodes/ai/sub-agent-protocol'`.
+ */
+/** Wire type strings owned by `@langflower/node-sdk` (`defineLlmNode`). */
+export { SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from '@langflower/node-sdk/llm';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isSkillAnnounce = (value) => isRecord(value) &&
+    typeof value.skillId === 'string' &&
+    typeof value.description === 'string';
+const isSubAgentRegistration = (value) => isRecord(value) &&
+    typeof value.targetNodeId === 'string' &&
+    typeof value.name === 'string' &&
+    typeof value.description === 'string' &&
+    Array.isArray(value.skills) &&
+    value.skills.every(isSkillAnnounce);
+export const isSubAgentSpawnPayload = (value) => isRecord(value) &&
+    typeof value.callId === 'string' &&
+    typeof value.nodeId === 'string' &&
+    typeof value.skillId === 'string' &&
+    typeof value.task === 'string';
+export const isSubAgentResultPayload = (value) => isRecord(value) &&
+    typeof value.callId === 'string' &&
+    typeof value.result === 'string';
+/** Flatten multi-wire combine values (single reg or arrays). */
+export const flattenSubAgentRegistrations = (wired) => {
+    const root = wired ?? [];
+    const list = Array.isArray(root) ? root : [root];
+    return list.flatMap((item) => {
+        if (Array.isArray(item)) {
+            return item.filter(isSubAgentRegistration);
+        }
+        if (isSubAgentRegistration(item)) {
+            return [item];
+        }
+        return [];
+    });
+};

package/vendor/common-nodes/dist/ai/features/ui-schema/llm-compaction-ui-schema.d.ts

@@ -0,0 +1,14 @@
+/** Shared Inspector fields for OpenAI-compatible chat compaction. */
+export declare const llmCompactionUiSchema: readonly [{
+    readonly field: "contextSize";
+    readonly type: "number";
+    readonly label: "Context size (approx tokens)";
+    readonly default: 200000;
+    readonly min: 0;
+    readonly step: 1;
+}, {
+    readonly field: "compactOnError";
+    readonly type: "boolean";
+    readonly label: "Compact on context error";
+    readonly default: false;
+}];

package/vendor/common-nodes/dist/ai/features/ui-schema/llm-compaction-ui-schema.js

@@ -0,0 +1,18 @@
+import { DEFAULT_CONTEXT_SIZE } from '../openai/normalize-compaction-params.js';
+/** Shared Inspector fields for OpenAI-compatible chat compaction. */
+export const llmCompactionUiSchema = [
+    {
+        field: 'contextSize',
+        type: 'number',
+        label: 'Context size (approx tokens)',
+        default: DEFAULT_CONTEXT_SIZE,
+        min: 0,
+        step: 1,
+    },
+    {
+        field: 'compactOnError',
+        type: 'boolean',
+        label: 'Compact on context error',
+        default: false,
+    },
+];

package/vendor/common-nodes/dist/ai/features/ui-schema/llm-panel-ui-schema.d.ts

@@ -0,0 +1,80 @@
+export declare const llmMaxIterationsUiField: (defaultValue: number, maxCap: number) => {
+    readonly field: "maxIterations";
+    readonly type: "number";
+    readonly label: "Tool-loop max iterations per feedback turn (0 = unlimited)";
+    readonly default: number;
+    readonly min: 0;
+    readonly max: number;
+    readonly step: 1;
+};
+/**
+ * Shared Inspector panel floor for all LLM-family nodes (OpenAI, Fake,
+ * Sub-Agent, Review, Critique). Nodes may expand after this list; they must
+ * not omit these fields.
+ */
+export declare const llmPanelUiSchema: readonly [{
+    readonly field: "rolePreset";
+    readonly type: "select";
+    readonly label: "Role preset";
+    readonly default: "custom";
+    readonly options: readonly [{
+        readonly value: "custom";
+        readonly title: "Custom";
+    }, {
+        readonly value: "plan";
+        readonly title: "Plan";
+    }, {
+        readonly value: "coder";
+        readonly title: "Coder";
+    }, {
+        readonly value: "explorer";
+        readonly title: "Explorer";
+    }];
+}, {
+    readonly field: "providerId";
+    readonly type: "select";
+    readonly label: "Provider";
+    readonly optionsSource: "langflower.providers";
+}, {
+    readonly field: "model";
+    readonly type: "select";
+    readonly label: "Model";
+    readonly optionsSource: "langflower.models";
+    readonly dependsOn: "providerId";
+}, {
+    readonly field: "skillId";
+    readonly type: "select";
+    readonly label: "Skill";
+    readonly optionsSource: "langflower.skills";
+}, {
+    readonly field: "includeAgentsMd";
+    readonly type: "boolean";
+    readonly label: "Include root AGENTS.md";
+    readonly default: false;
+}, {
+    readonly field: "toolPermissions";
+    readonly type: "tool-permission-table";
+    readonly label: "Tool permissions";
+    readonly optionsSource: "node.wiredTools";
+}, {
+    readonly field: "enabledMcpIds";
+    readonly type: "tool-id-list";
+    readonly label: "Enabled MCP";
+    readonly optionsSource: "langflower.mcpServers";
+}, {
+    readonly field: "maxIterations";
+    readonly type: "number";
+    readonly label: "Tool-loop max iterations per feedback turn (0 = unlimited)";
+    readonly default: number;
+    readonly min: 0;
+    readonly max: number;
+    readonly step: 1;
+}, {
+    readonly field: "maxFeedbackTurns";
+    readonly type: "number";
+    readonly label: "Max feedback turns (0 = unlimited)";
+    readonly default: 50;
+    readonly min: 0;
+    readonly max: number;
+    readonly step: 1;
+}];

package/vendor/common-nodes/dist/ai/features/ui-schema/llm-panel-ui-schema.js

@@ -0,0 +1,76 @@
+import { LLM_ROLE_PRESET_OPTIONS } from '../llm-role-preset.js';
+import { AGENT_MAX_ITERATIONS_CAP, DEFAULT_AGENT_MAX_ITERATIONS, } from '../prompt/normalize-max-iterations.js';
+/** Provider / Model / Skill — folded into {@link llmPanelUiSchema}. */
+const llmProviderModelSkillUiSchema = [
+    {
+        field: 'providerId',
+        type: 'select',
+        label: 'Provider',
+        optionsSource: 'langflower.providers',
+    },
+    {
+        field: 'model',
+        type: 'select',
+        label: 'Model',
+        optionsSource: 'langflower.models',
+        dependsOn: 'providerId',
+    },
+    {
+        field: 'skillId',
+        type: 'select',
+        label: 'Skill',
+        optionsSource: 'langflower.skills',
+    },
+];
+export const llmMaxIterationsUiField = (defaultValue, maxCap) => ({
+    field: 'maxIterations',
+    type: 'number',
+    label: 'Tool-loop max iterations per feedback turn (0 = unlimited)',
+    default: defaultValue,
+    min: 0,
+    max: maxCap,
+    step: 1,
+});
+/**
+ * Shared Inspector panel floor for all LLM-family nodes (OpenAI, Fake,
+ * Sub-Agent, Review, Critique). Nodes may expand after this list; they must
+ * not omit these fields.
+ */
+export const llmPanelUiSchema = [
+    {
+        field: 'rolePreset',
+        type: 'select',
+        label: 'Role preset',
+        default: 'custom',
+        options: LLM_ROLE_PRESET_OPTIONS,
+    },
+    ...llmProviderModelSkillUiSchema,
+    {
+        field: 'includeAgentsMd',
+        type: 'boolean',
+        label: 'Include root AGENTS.md',
+        default: false,
+    },
+    {
+        field: 'toolPermissions',
+        type: 'tool-permission-table',
+        label: 'Tool permissions',
+        optionsSource: 'node.wiredTools',
+    },
+    {
+        field: 'enabledMcpIds',
+        type: 'tool-id-list',
+        label: 'Enabled MCP',
+        optionsSource: 'langflower.mcpServers',
+    },
+    llmMaxIterationsUiField(DEFAULT_AGENT_MAX_ITERATIONS, AGENT_MAX_ITERATIONS_CAP),
+    {
+        field: 'maxFeedbackTurns',
+        type: 'number',
+        label: 'Max feedback turns (0 = unlimited)',
+        default: 50,
+        min: 0,
+        max: AGENT_MAX_ITERATIONS_CAP,
+        step: 1,
+    },
+];