langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/ai/features/llm-role-preset.d.ts

@@ -0,0 +1,69 @@
+/** Instance role preset — one LLM node type, many configured roles. */
+export type LlmRolePreset = 'custom' | 'plan' | 'coder' | 'explorer';
+export type ToolPermissionDecision = 'allow' | 'ask' | 'deny';
+/** Per-tool coarse decision on the LLM node (`params.toolPermissions`). */
+export type ToolPermissionsMap = Readonly<Record<string, ToolPermissionDecision>>;
+export type LlmRolePresetDefaults = {
+    readonly systemPrompt: string;
+    readonly skillId: string;
+    /** Visible Inspector table materialization for this preset. */
+    readonly toolPermissions: ToolPermissionsMap;
+};
+export declare const LLM_ROLE_PRESET_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";
+}];
+/**
+ * Harness builtin ids — twin of `@langflower/tools` `BUILTIN_TOOL_IDS` and
+ * shared `HARNESS_BUILTIN_TOOL_OPTIONS`. Kept local so UI can import this
+ * module without bundling Node builtins from tools.
+ */
+export declare const HARNESS_BUILTIN_TOOL_IDS: readonly ["read", "glob", "grep", "edit", "write", "create", "delete", "bash"];
+export declare const PLAN_AGENT_SYSTEM_PROMPT: string;
+export declare const CODER_AGENT_SYSTEM_PROMPT: string;
+export declare const LLM_ROLE_PRESET_DEFAULTS: Readonly<Record<LlmRolePreset, LlmRolePresetDefaults>>;
+export declare const parseLlmRolePreset: (value: unknown) => LlmRolePreset;
+export declare const resolveEffectiveSkillId: (rolePreset: LlmRolePreset, skillIdParam: unknown) => string;
+/** Parse `params.toolPermissions` into a validated map (empty if unset). */
+export declare const parseToolPermissions: (value: unknown) => ToolPermissionsMap;
+/**
+ * Migrate legacy `enabledToolIds` allowlist → coarse toolPermissions.
+ * Listed → allow (bash/delete → ask); unlisted builtins → deny.
+ */
+export declare const migrateEnabledToolIdsToPermissions: (enabledToolIds: readonly string[]) => ToolPermissionsMap;
+/**
+ * Resolve node toolPermissions: explicit map, else migrate enabledToolIds,
+ * else preset defaults for the current role.
+ */
+export declare const resolveEffectiveToolPermissions: (rolePreset: LlmRolePreset, toolPermissionsParam: unknown, enabledToolIdsParam?: unknown) => ToolPermissionsMap;
+/** Inventory ids whose decision is not deny. */
+export declare const toolPermissionsToEnabledIds: (toolPermissions: ToolPermissionsMap) => readonly string[];
+/**
+ * Params patch when the author selects a role preset in the Inspector.
+ *
+ * - Writes `rolePreset` + materializes `toolPermissions`.
+ * - Removes legacy `enabledToolIds`.
+ * - Does **not** touch `skillId` / `systemPrompt`.
+ */
+export declare const paramsAfterRolePresetApply: (currentParams: Readonly<Record<string, unknown>>, rolePreset: LlmRolePreset) => Readonly<Record<string, unknown>>;
+/**
+ * Project permission layer shape — structural twin of tools PermissionConfig
+ * (UI must not import `@langflower/tools`).
+ */
+export type ProjectPermissionConfig = Readonly<Record<string, ToolPermissionDecision | Readonly<Record<string, ToolPermissionDecision>>>>;
+/** Coarse floor for Inspector (parity with tools `toolFloorDecision`). */
+export declare const toolFloorDecisionForUi: (config: ProjectPermissionConfig | undefined, toolId: string) => ToolPermissionDecision;
+export declare const validNodePermissionOptionsForUi: (floor: ToolPermissionDecision) => readonly ToolPermissionDecision[];
+export declare const clampToolPermissionForUi: (floor: ToolPermissionDecision, node: ToolPermissionDecision) => ToolPermissionDecision;
+export declare const isHarnessToolAlwaysDenied: (config: ProjectPermissionConfig | undefined, toolId: string) => boolean;
+/** Opt-in: newly wired tool ids default to allow when missing. */
+export declare const mergeToolPermissionsOnNewWires: (toolPermissions: ToolPermissionsMap, wiredToolIds: readonly string[]) => ToolPermissionsMap;

package/vendor/common-nodes/dist/ai/features/llm-role-preset.js

@@ -0,0 +1,265 @@
+/** Instance role preset — one LLM node type, many configured roles. */
+export const LLM_ROLE_PRESET_OPTIONS = [
+    { value: 'custom', title: 'Custom' },
+    { value: 'plan', title: 'Plan' },
+    { value: 'coder', title: 'Coder' },
+    { value: 'explorer', title: 'Explorer' },
+];
+/**
+ * Harness builtin ids — twin of `@langflower/tools` `BUILTIN_TOOL_IDS` and
+ * shared `HARNESS_BUILTIN_TOOL_OPTIONS`. Kept local so UI can import this
+ * module without bundling Node builtins from tools.
+ */
+export const HARNESS_BUILTIN_TOOL_IDS = [
+    'read',
+    'glob',
+    'grep',
+    'edit',
+    'write',
+    'create',
+    'delete',
+    'bash',
+];
+export const PLAN_AGENT_SYSTEM_PROMPT = [
+    'You are the Plan agent in a Langflower workflow.',
+    '',
+    "Understand the user's goal, explore the codebase read-only, and produce a clear",
+    'implementation plan. Do not modify source code or non-documentation files.',
+    '',
+    'Write plans in Markdown with sections: Goal, Context, Steps, Risks, Open questions.',
+    '',
+    'When requirements are ambiguous, use ask_user before finalizing the plan.',
+].join('\n');
+export const CODER_AGENT_SYSTEM_PROMPT = [
+    'You are the Coder agent in a Langflower workflow.',
+    '',
+    'Implement the requested changes in the project repository. Make minimal, correct',
+    'edits. Prefer precise file edits over large rewrites.',
+    '',
+    'When tests are available, run them to verify your work. Summarize what you changed',
+    'in your final response.',
+].join('\n');
+const EXPLORER_AGENT_SYSTEM_PROMPT = [
+    'You are the Explorer agent in a Langflower workflow.',
+    '',
+    'Research the topic using web_fetch. Synthesize findings into clear Markdown notes.',
+    'Do not modify application source code—only *.md research notes.',
+    '',
+    'Cite URLs. Separate facts from inference.',
+].join('\n');
+const allAllow = () => Object.fromEntries(HARNESS_BUILTIN_TOOL_IDS.map((id) => [id, 'allow']));
+const CUSTOM_TOOL_PERMISSIONS = allAllow();
+const CODER_TOOL_PERMISSIONS = {
+    ...allAllow(),
+    bash: 'ask',
+    delete: 'ask',
+};
+const PLAN_TOOL_PERMISSIONS = {
+    ...allAllow(),
+    write: 'ask',
+    create: 'ask',
+    edit: 'deny',
+    delete: 'deny',
+    bash: 'deny',
+};
+const EXPLORER_TOOL_PERMISSIONS = {
+    ...allAllow(),
+    read: 'allow',
+    write: 'ask',
+    create: 'ask',
+    glob: 'deny',
+    grep: 'deny',
+    edit: 'deny',
+    delete: 'deny',
+    bash: 'deny',
+};
+export const LLM_ROLE_PRESET_DEFAULTS = {
+    custom: {
+        systemPrompt: '',
+        skillId: '',
+        toolPermissions: CUSTOM_TOOL_PERMISSIONS,
+    },
+    plan: {
+        systemPrompt: PLAN_AGENT_SYSTEM_PROMPT,
+        skillId: 'plan',
+        toolPermissions: PLAN_TOOL_PERMISSIONS,
+    },
+    coder: {
+        systemPrompt: CODER_AGENT_SYSTEM_PROMPT,
+        skillId: 'coder',
+        toolPermissions: CODER_TOOL_PERMISSIONS,
+    },
+    explorer: {
+        systemPrompt: EXPLORER_AGENT_SYSTEM_PROMPT,
+        skillId: 'explorer',
+        toolPermissions: EXPLORER_TOOL_PERMISSIONS,
+    },
+};
+export const parseLlmRolePreset = (value) => {
+    if (value === 'plan' || value === 'coder' || value === 'explorer') {
+        return value;
+    }
+    return 'custom';
+};
+export const resolveEffectiveSkillId = (rolePreset, skillIdParam) => {
+    const explicit = typeof skillIdParam === 'string' ? skillIdParam.trim() : '';
+    if (explicit !== '') {
+        return explicit;
+    }
+    return LLM_ROLE_PRESET_DEFAULTS[rolePreset].skillId;
+};
+const isToolPermissionDecision = (value) => value === 'allow' || value === 'ask' || value === 'deny';
+/** Parse `params.toolPermissions` into a validated map (empty if unset). */
+export const parseToolPermissions = (value) => {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    const entries = Object.entries(value).filter((entry) => isToolPermissionDecision(entry[1]));
+    return Object.fromEntries(entries);
+};
+/**
+ * Migrate legacy `enabledToolIds` allowlist → coarse toolPermissions.
+ * Listed → allow (bash/delete → ask); unlisted builtins → deny.
+ */
+export const migrateEnabledToolIdsToPermissions = (enabledToolIds) => {
+    const allowed = new Set(enabledToolIds);
+    const next = {};
+    for (const id of HARNESS_BUILTIN_TOOL_IDS) {
+        if (!allowed.has(id)) {
+            next[id] = 'deny';
+            continue;
+        }
+        next[id] = id === 'bash' || id === 'delete' ? 'ask' : 'allow';
+    }
+    for (const id of enabledToolIds) {
+        if (!(id in next)) {
+            next[id] = 'allow';
+        }
+    }
+    return next;
+};
+/**
+ * Resolve node toolPermissions: explicit map, else migrate enabledToolIds,
+ * else preset defaults for the current role.
+ */
+export const resolveEffectiveToolPermissions = (rolePreset, toolPermissionsParam, enabledToolIdsParam) => {
+    const parsed = parseToolPermissions(toolPermissionsParam);
+    if (Object.keys(parsed).length > 0) {
+        return parsed;
+    }
+    if (Array.isArray(enabledToolIdsParam)) {
+        return migrateEnabledToolIdsToPermissions(enabledToolIdsParam.map(String));
+    }
+    return LLM_ROLE_PRESET_DEFAULTS[rolePreset].toolPermissions;
+};
+/** Inventory ids whose decision is not deny. */
+export const toolPermissionsToEnabledIds = (toolPermissions) => Object.entries(toolPermissions)
+    .filter(([, decision]) => decision !== 'deny')
+    .map(([toolId]) => toolId);
+/**
+ * Params patch when the author selects a role preset in the Inspector.
+ *
+ * - Writes `rolePreset` + materializes `toolPermissions`.
+ * - Removes legacy `enabledToolIds`.
+ * - Does **not** touch `skillId` / `systemPrompt`.
+ */
+export const paramsAfterRolePresetApply = (currentParams, rolePreset) => {
+    const { enabledToolIds: _legacy, toolPermissions: _previous, ...rest } = currentParams;
+    const defaults = LLM_ROLE_PRESET_DEFAULTS[rolePreset];
+    return {
+        ...rest,
+        rolePreset,
+        toolPermissions: { ...defaults.toolPermissions },
+    };
+};
+/** Defaults twin of `@langflower/tools` `DEFAULT_PERMISSION_CONFIG` (allow-all). */
+const DEFAULT_HARNESS_PERMISSION = {
+    read: { '*': 'allow' },
+    glob: { '*': 'allow' },
+    grep: { '*': 'allow' },
+    edit: { '*': 'allow' },
+    write: { '*': 'allow' },
+    create: { '*': 'allow' },
+    delete: { '*': 'allow' },
+    bash: { '*': 'allow' },
+};
+const DECISION_RANK = {
+    deny: 3,
+    ask: 2,
+    allow: 1,
+};
+const rulesForTool = (config, toolId) => {
+    const raw = config[toolId] ?? DEFAULT_HARNESS_PERMISSION[toolId];
+    if (raw === undefined) {
+        return { '*': 'allow' };
+    }
+    if (isToolPermissionDecision(raw)) {
+        return { '*': raw };
+    }
+    const entries = Object.entries(raw).filter((entry) => isToolPermissionDecision(entry[1]));
+    if (entries.length === 0) {
+        return { '*': 'deny' };
+    }
+    return Object.fromEntries(entries);
+};
+/** Coarse floor for Inspector (parity with tools `toolFloorDecision`). */
+export const toolFloorDecisionForUi = (config, toolId) => {
+    const merged = {
+        ...DEFAULT_HARNESS_PERMISSION,
+        ...(config ?? {}),
+    };
+    if (merged[toolId] === undefined &&
+        DEFAULT_HARNESS_PERMISSION[toolId] === undefined) {
+        return 'allow';
+    }
+    const rules = rulesForTool(merged, toolId);
+    const star = rules['*'];
+    if (star !== undefined && Object.keys(rules).length === 1) {
+        return star;
+    }
+    const decisions = Object.values(rules);
+    if (decisions.some((decision) => decision === 'allow')) {
+        return 'allow';
+    }
+    if (decisions.some((decision) => decision === 'ask')) {
+        return 'ask';
+    }
+    return 'deny';
+};
+export const validNodePermissionOptionsForUi = (floor) => {
+    if (floor === 'deny') {
+        return [];
+    }
+    if (floor === 'ask') {
+        return ['deny', 'ask'];
+    }
+    return ['deny', 'ask', 'allow'];
+};
+export const clampToolPermissionForUi = (floor, node) => DECISION_RANK[floor] >= DECISION_RANK[node] ? floor : node;
+export const isHarnessToolAlwaysDenied = (config, toolId) => {
+    const merged = {
+        ...DEFAULT_HARNESS_PERMISSION,
+        ...(config ?? {}),
+    };
+    if (merged[toolId] === undefined &&
+        DEFAULT_HARNESS_PERMISSION[toolId] === undefined) {
+        return false;
+    }
+    const decisions = Object.values(rulesForTool(merged, toolId));
+    return (decisions.length > 0 &&
+        decisions.every((decision) => decision === 'deny'));
+};
+/** Opt-in: newly wired tool ids default to allow when missing. */
+export const mergeToolPermissionsOnNewWires = (toolPermissions, wiredToolIds) => {
+    const next = {
+        ...toolPermissions,
+    };
+    let changed = false;
+    for (const id of wiredToolIds) {
+        if (next[id] === undefined) {
+            next[id] = 'allow';
+            changed = true;
+        }
+    }
+    return changed ? next : toolPermissions;
+};

package/vendor/common-nodes/dist/ai/features/llm-session/llm-session-shell.d.ts

@@ -0,0 +1,148 @@
+import type { ToolHandle, configureOutput, makeInput } from '@langflower/node-sdk';
+import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
+import type { PermissionAskRequest } from '@langflower/tools/permission';
+import type { ChatCompletionMessage } from '../chat-completion-stream.js';
+import { type LlmInventoryInputs, type LlmRecoveryNotice, type SteerControlPayload } from '@langflower/node-sdk/llm';
+import type { PortMeta } from '@langflower/node-sdk';
+import type { combineStatefulObservables, StatefulObservable } from '@rx-evo/stateful-observable';
+import { type Observable, type OperatorFunction } from 'rxjs';
+import { type LlmRolePreset } from '../llm-role-preset.js';
+import { type SubAgentRegistration, type SubAgentSpawnPayload } from '../sub-agent-protocol.js';
+import type { LlmCompactionConfig } from '../openai/normalize-compaction-params.js';
+import type { LlmRecoveryPolicy } from '../llm-loop/llm-loop-types.js';
+/** Shared inventory + panel fields assembled for OpenAI / Fake agent binds. */
+export type LlmAgentInventoryContext = {
+    readonly prompt: string;
+    readonly tools: readonly ToolHandle[];
+    readonly getTools?: () => readonly ToolHandle[];
+    readonly subagentRegistrations: readonly SubAgentRegistration[];
+    readonly providerId: string;
+    readonly model: string;
+    readonly skillId: string;
+    readonly rolePreset: LlmRolePreset;
+    readonly effectiveSystemPrompt: string;
+    readonly skillMarkdown: string;
+    readonly agentsMarkdown: string;
+    readonly toolCtx: ToolHandlerContext;
+    readonly maxIterations: number;
+    /** Cap on feedback turns after turn 0; 0 = unlimited (Soft↔Hard guardrail). */
+    readonly maxFeedbackTurns: number;
+    /**
+     * HITL continue asks for storm caps (`agent.maxIterations` /
+     * `agent.maxFeedbackTurns`). Missing → Deny (prior stop behavior).
+     */
+    readonly requestPermission?: (request: PermissionAskRequest) => Promise<'allow' | 'deny'>;
+    readonly compaction: LlmCompactionConfig;
+    readonly recovery: LlmRecoveryPolicy;
+    /** ADR-032 soft Pause / Steer — set in {@link bindLlmAgentSession}. */
+    readonly steerControl$?: Observable<SteerControlPayload>;
+};
+/**
+ * Prep for the shared LLM session cycle (ADR-016). All LLM nodes MUST use
+ * {@link createLlmSessionCycle$} — per-node cold-start history is forbidden.
+ */
+export type LlmFeedbackSessionPrep<Session = undefined> = {
+    readonly history: readonly ChatCompletionMessage[];
+    /** Append `{ role: assistant, content }` when a `response` chunk arrives. */
+    readonly trackAssistantHistory: boolean;
+    /** Append turn payload as `{ role: user }` before feedback turns (>0). */
+    readonly appendUserFeedbackToHistory: boolean;
+    readonly session: Session;
+};
+export type LlmSessionCycleOptions = {
+    /**
+     * When true (default, Soft↔Hard / openai-llm), prime turn 0 with
+     * `startWith('')` and call `runTurn` with `turnPayload === undefined`.
+     * When false (Critique `packet` / Review `result`), the first non-empty
+     * turn$ value is turn 0's payload — no empty prime.
+     */
+    readonly primeTurn0?: boolean;
+};
+/** Standard agent cycle chunk kinds demuxed to OpenAI / Fake ports. */
+type StandardLlmAgentChunk = {
+    readonly kind: 'reasoning';
+    readonly text: string;
+} | {
+    readonly kind: 'draftResponse';
+    readonly text: string;
+} | {
+    readonly kind: 'toolLog';
+    readonly text: string;
+} | ({
+    readonly kind: 'recoveryNotice';
+} & LlmRecoveryNotice) | {
+    readonly kind: 'response';
+    readonly text: string;
+} | {
+    readonly kind: 'historySync';
+    readonly messages: readonly ChatCompletionMessage[];
+} | {
+    readonly kind: 'subagentSpawn';
+    readonly payload: SubAgentSpawnPayload;
+};
+type LlmAgentEcSlice = {
+    readonly projectDir: string;
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly params: Readonly<Record<string, unknown>>;
+    readonly toolHandles?: readonly ToolHandle[];
+    readonly mcpHandles?: readonly import('@langflower/node-sdk/mcp').McpHandle[];
+};
+type ReactiveBindHelpers = {
+    readonly makeInput: typeof makeInput;
+    readonly configureOutput: typeof configureOutput;
+    readonly combineInputs: typeof combineStatefulObservables;
+};
+/** 0 = unlimited; positive = max feedback turns after turn 0. */
+export declare const normalizeMaxFeedbackTurns: (value: unknown) => number;
+export declare const appendToolInventory: (systemPrompt: string, tools: readonly ToolHandle[]) => string;
+/**
+ * RxJS operator: filter session chunks by `kind` and project the payload.
+ * Use inside `pipeValue` — do not wrap as `(cycle$) => cycle$.pipeValue(...)`.
+ *
+ * `@rx-evo` wraps values in `NoInfer`, which breaks `Extract` type guards —
+ * callers narrow with a cast inside `project`.
+ */
+export declare const demuxByKind: <Out>(kind: string, project: (chunk: {
+    readonly kind: string;
+}) => Out) => OperatorFunction<{
+    readonly kind: string;
+}, Out>;
+/**
+ * Shared LLM session cycle (ADR-016): init context recreates the session;
+ * turn$ drives turn 0 + later turns with accumulated `messages[]`.
+ *
+ * All LLM nodes (openai / fake / critique / review / future) MUST use this —
+ * do not invent per-node cold-start `switchMap` history.
+ */
+export declare const createLlmSessionCycle$: <Context extends {
+    readonly maxFeedbackTurns: number;
+    readonly requestPermission?: (request: PermissionAskRequest) => Promise<"allow" | "deny">;
+}, Chunk extends {
+    readonly kind: string;
+}, Session, Deps, Meta>(context$: StatefulObservable<Context, Deps, Meta>, turn$: Observable<unknown>, prepareSession: (context: Context) => LlmFeedbackSessionPrep<Session>, runTurn: (context: Context, turnPayload: unknown, history: readonly ChatCompletionMessage[], session: Session) => Observable<Chunk>, options?: LlmSessionCycleOptions) => StatefulObservable<Chunk, Deps, Meta>;
+type BindLlmAgentSessionOptions<Context extends LlmAgentInventoryContext, Chunk extends StandardLlmAgentChunk, Session> = {
+    readonly extendContext: (base: LlmAgentInventoryContext, ec: LlmAgentEcSlice) => Context;
+    readonly prepareSession: (context: Context) => LlmFeedbackSessionPrep<Session>;
+    readonly runTurn: (context: Context, feedback: string | undefined, history: readonly ChatCompletionMessage[], subagentResult$: Observable<unknown>, session: Session) => Observable<Chunk>;
+};
+/**
+ * Composer entry for OpenAI / Fake agent binds.
+ *
+ * Order:
+ * 1. make role inputs (userPrompt / systemPrompt / feedback)
+ * 2. assemble inventory context$ (+ provider extend)
+ * 3. ADR-016 feedback cycle$
+ * 4. demux chunk ports
+ * 5. configure standard outputs
+ */
+export declare const bindLlmAgentSession: <Context extends LlmAgentInventoryContext, Chunk extends StandardLlmAgentChunk, Session = undefined>(ctx: StatefulObservable<LlmAgentEcSlice, unknown, PortMeta>, helpers: ReactiveBindHelpers, inventory: LlmInventoryInputs, options: BindLlmAgentSessionOptions<Context, Chunk, Session>) => {
+    inputs: import("@rx-evo/stateful-observable").StatefulConnection<string, unknown, import("@langflower/node-sdk").InputPortMeta<string>>[];
+    outputs: StatefulObservable<string, unknown, import("@langflower/node-sdk").OutputParams & PortMeta>[];
+    inventoryOutputs: {
+        toolLog$: StatefulObservable<string, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
+        recovery$: StatefulObservable<LlmRecoveryNotice, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
+        subagent$: StatefulObservable<SubAgentSpawnPayload, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
+    };
+};
+export {};

package/vendor/common-nodes/dist/ai/features/llm-session/llm-session-shell.js

@@ -0,0 +1,198 @@
+import { toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
+import { filter, map, pipe, shareReplay, switchMap, } from 'rxjs';
+import { buildEffectiveSystemPrompt } from '../prompt/build-effective-system-prompt.js';
+import { collectAgentToolHandles } from '../../../tools/collect-agent-tool-handles.js';
+import { parseLlmRolePreset, resolveEffectiveSkillId, } from '../llm-role-preset.js';
+import { flattenSubAgentRegistrations, } from '../sub-agent-protocol.js';
+import { normalizeCompactionConfig } from '../openai/normalize-compaction-params.js';
+import { resolveChatProviderModel } from '../prompt/resolve-chat-provider-model.js';
+import { buildAgentToolCtx, getRunHostServices } from '../run-host-services.js';
+import { AGENT_MAX_ITERATIONS_CAP, DEFAULT_AGENT_MAX_ITERATIONS, normalizeMaxIterations as normalizeMaxIterationsParam, } from '../prompt/normalize-max-iterations.js';
+import { normalizeLlmRecoveryPolicy } from '../llm-loop/normalize-llm-recovery-policy.js';
+import { runLlmSessionMachine } from './run-session-machine.js';
+const asPortList = (value) => {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+};
+/**
+ * Close over live editor wired tools when the server hook is present;
+ * otherwise freeze the combineInputs snapshot (unit tests).
+ */
+const createAgentGetTools = (ec, toolList, mcpList) => {
+    const hostServices = getRunHostServices(ec);
+    return () => {
+        const live = hostServices?.getLiveWiredTools?.(ec.nodeId);
+        return collectAgentToolHandles({
+            toolHandles: ec.toolHandles,
+            toolsPort: live === undefined
+                ? toolList
+                : [...asPortList(toolList), ...live],
+            mcpHandles: ec.mcpHandles,
+            mcpPort: mcpList,
+        });
+    };
+};
+const toolLabel = (tool) => tool.name.length > 0 ? tool.name : tool.toolId || 'unknown';
+const formatList = (items, labelOf) => (items.length === 0 ? 'none' : items.map(labelOf).join(', '));
+/** 0 = unlimited; positive = max feedback turns after turn 0. */
+export const normalizeMaxFeedbackTurns = (value) => {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n) || n < 1) {
+        return 0;
+    }
+    return Math.min(AGENT_MAX_ITERATIONS_CAP, Math.floor(n));
+};
+export const appendToolInventory = (systemPrompt, tools) => {
+    if (tools.length === 0) {
+        return systemPrompt;
+    }
+    return [
+        systemPrompt,
+        `Available tools (callable via internal tool loop): ${formatList(tools, toolLabel)}.`,
+    ]
+        .filter((part) => part.trim().length > 0)
+        .join('\n\n');
+};
+/**
+ * Step: merge prompt / inventory / role panel into the shared agent context.
+ */
+const assembleLlmAgentInventoryContext = (prompt, toolList, subagentList, mcpList, systemPromptValue, 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 ?? '';
+    const getTools = createAgentGetTools(ec, toolList, mcpList);
+    return {
+        prompt: String(prompt ?? ''),
+        tools: getTools(),
+        getTools,
+        subagentRegistrations: flattenSubAgentRegistrations(subagentList),
+        ...resolveChatProviderModel(ec.params, hostServices),
+        skillId,
+        rolePreset,
+        skillMarkdown,
+        agentsMarkdown,
+        effectiveSystemPrompt: buildEffectiveSystemPrompt({
+            rolePreset,
+            systemPromptInput: String(systemPromptValue ?? ''),
+            agentsMarkdown,
+            skillMarkdown,
+        }),
+        toolCtx: buildAgentToolCtx({ projectDir: ec.projectDir, runId: ec.runId }, hostServices),
+        maxIterations: normalizeMaxIterationsParam(ec.params.maxIterations, {
+            fallback: DEFAULT_AGENT_MAX_ITERATIONS,
+            maxCap: AGENT_MAX_ITERATIONS_CAP,
+        }),
+        maxFeedbackTurns: normalizeMaxFeedbackTurns(ec.params.maxFeedbackTurns),
+        ...(hostServices?.requestPermission !== undefined
+            ? { requestPermission: hostServices.requestPermission }
+            : {}),
+        compaction: normalizeCompactionConfig(ec.params),
+        recovery: normalizeLlmRecoveryPolicy(ec.params),
+    };
+};
+/**
+ * RxJS operator: filter session chunks by `kind` and project the payload.
+ * Use inside `pipeValue` — do not wrap as `(cycle$) => cycle$.pipeValue(...)`.
+ *
+ * `@rx-evo` wraps values in `NoInfer`, which breaks `Extract` type guards —
+ * callers narrow with a cast inside `project`.
+ */
+export const demuxByKind = (kind, project) => pipe(filter((chunk) => chunk.kind === kind), map(project));
+const asKind = (chunk) => chunk;
+const demuxLlmAgentPorts = (cycle$) => ({
+    reasoning$: cycle$.pipeValue(demuxByKind('reasoning', (chunk) => asKind(chunk).text)),
+    draftResponse$: cycle$.pipeValue(demuxByKind('draftResponse', (chunk) => asKind(chunk).text)),
+    toolLog$: cycle$.pipeValue(demuxByKind('toolLog', (chunk) => asKind(chunk).text)),
+    recovery$: cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
+        const notice = asKind(chunk);
+        return toLlmRecoveryPortValue(notice);
+    })),
+    response$: cycle$.pipeValue(demuxByKind('response', (chunk) => asKind(chunk).text)),
+    subagent$: cycle$.pipeValue(demuxByKind('subagentSpawn', (chunk) => asKind(chunk).payload)),
+});
+/**
+ * Shared LLM session cycle (ADR-016): init context recreates the session;
+ * turn$ drives turn 0 + later turns with accumulated `messages[]`.
+ *
+ * All LLM nodes (openai / fake / critique / review / future) MUST use this —
+ * do not invent per-node cold-start `switchMap` history.
+ */
+export const createLlmSessionCycle$ = (context$, turn$, prepareSession, runTurn, options) => {
+    const primeTurn0 = options?.primeTurn0 ?? true;
+    return context$
+        .pipeValue(switchMap((context) => {
+        const prep = prepareSession(context);
+        return runLlmSessionMachine(context, turn$, prep, runTurn, primeTurn0);
+    }))
+        .pipe(shareReplay({ bufferSize: 1, refCount: true }));
+};
+/**
+ * Composer entry for OpenAI / Fake agent binds.
+ *
+ * Order:
+ * 1. make role inputs (userPrompt / systemPrompt / feedback)
+ * 2. assemble inventory context$ (+ provider extend)
+ * 3. ADR-016 feedback cycle$
+ * 4. demux chunk ports
+ * 5. configure standard outputs
+ */
+export const bindLlmAgentSession = (ctx, helpers, inventory, options) => {
+    const { makeInput, configureOutput, combineInputs } = helpers;
+    const { tools, mcp, subagentRegistration, subagentResult, steerControl } = inventory;
+    // 1. role inputs
+    const userPrompt = makeInput('userPrompt', {
+        name: 'userPrompt',
+        wireType: 'string',
+        inline: 'text-multiline',
+        required: true,
+    });
+    const systemPrompt = makeInput('systemPrompt', {
+        name: 'systemPrompt',
+        wireType: 'string',
+        inline: 'text-multiline',
+        defaultValue: '',
+    });
+    const feedback = makeInput('feedback', {
+        name: 'feedback',
+        wireType: 'string',
+        multi: 'merge',
+        defaultValue: '',
+    });
+    // 2. inventory context$
+    const context$ = combineInputs([userPrompt, tools, subagentRegistration, mcp, systemPrompt, ctx], ([prompt, toolList, subagentList, mcpList, systemPromptValue, ec]) => {
+        const base = assembleLlmAgentInventoryContext(prompt, toolList, subagentList, mcpList, systemPromptValue, ec);
+        return {
+            ...options.extendContext(base, ec),
+            steerControl$: steerControl.value$,
+        };
+    });
+    // 3. feedback cycle$ (ADR-016 Soft↔Hard: primeTurn0)
+    const cycle$ = createLlmSessionCycle$(context$, feedback.value$, options.prepareSession, (context, turnFeedback, history, session) => options.runTurn(context, turnFeedback === undefined
+        ? undefined
+        : String(turnFeedback ?? ''), history, subagentResult.value$, session), { primeTurn0: true });
+    // 4. demux
+    const { reasoning$, draftResponse$, toolLog$, recovery$, response$, subagent$, } = demuxLlmAgentPorts(cycle$);
+    // 5. outputs
+    return {
+        inputs: [userPrompt, systemPrompt, feedback],
+        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' },
+            }),
+        ],
+        inventoryOutputs: { toolLog$, recovery$, subagent$ },
+    };
+};