langflower 0.0.2 → 0.0.4

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

@@ -25,7 +25,7 @@ export const llmProviderModelSkillUiSchema = [
 export const llmMaxIterationsUiField = (defaultValue, maxCap) => ({
     field: 'maxIterations',
     type: 'number',
-    label: 'Tool-loop max iterations (0 = unlimited)',
+    label: 'Tool-loop max iterations per feedback turn (0 = unlimited)',
     default: defaultValue,
     min: 0,
     max: maxCap,
@@ -48,9 +48,9 @@ export const llmPanelUiSchema = [
         default: false,
     },
     {
-        field: 'enabledToolIds',
-        type: 'tool-id-list',
-        label: 'Enabled tools',
+        field: 'toolPermissions',
+        type: 'tool-permission-table',
+        label: 'Tool permissions',
         optionsSource: 'node.wiredTools',
     },
     {
@@ -70,4 +70,3 @@ export const llmPanelUiSchema = [
         step: 1,
     },
 ];
-//# sourceMappingURL=llm-panel-ui-schema.js.map

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

@@ -29,4 +29,3 @@ export declare const llmRecoveryUiSchema: readonly [{
     readonly max: 32;
     readonly step: 1;
 }];
-//# sourceMappingURL=llm-recovery-ui-schema.d.ts.map

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

@@ -34,4 +34,3 @@ export const llmRecoveryUiSchema = [
         step: 1,
     },
 ];
-//# sourceMappingURL=llm-recovery-ui-schema.js.map

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

@@ -1,24 +1,13 @@
 /** Instance role preset — one LLM node type, many configured roles. */
 export type LlmRolePreset = 'custom' | 'plan' | 'coder' | 'explorer';
-export type RolePermissionDecision = 'allow' | 'ask' | 'deny';
-/** Per-tool rules: pattern → decision, or a single decision for `*`. */
-export type RolePermissionToolConfig = RolePermissionDecision | Readonly<Record<string, RolePermissionDecision>>;
-/**
- * Role permission posture — same shape as project `permission` in
- * `langflower.jsonc`. Applied as a per-tool overlay in
- * `buildExecutionContext` (see merge rules in LLM_NODES.md).
- */
-export type RolePermissionPosture = Readonly<Record<string, RolePermissionToolConfig>>;
+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;
-    /**
-     * Author-time allowlist for the internal loop.
-     * `undefined` = all builtins + wired (custom / no budget).
-     */
-    readonly enabledToolIds: readonly string[] | undefined;
-    /** Runtime permission overlay for this role (empty = project/defaults only). */
-    readonly permission: RolePermissionPosture;
+    /** Visible Inspector table materialization for this preset. */
+    readonly toolPermissions: ToolPermissionsMap;
 };
 export declare const LLM_ROLE_PRESET_OPTIONS: readonly [{
     readonly value: "custom";
@@ -44,25 +33,37 @@ 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;
 /**
- * Resolve author-time tool allowlist for the internal loop.
- *
- * Merge rules:
- * - Explicit `enabledToolIds` array (including `[]`) always wins.
- * - When unset, use the current role preset defaults (`custom` → all tools).
+ * Migrate legacy `enabledToolIds` allowlist → coarse toolPermissions.
+ * Listed → allow (bash/delete → ask); unlisted builtins → deny.
  */
-export declare const resolveEffectiveEnabledToolIds: (rolePreset: LlmRolePreset, enabledToolIdsParam: unknown) => readonly string[] | undefined;
-/** Permission posture for the current role (empty object for custom). */
-export declare const resolveRolePermissionPosture: (rolePreset: LlmRolePreset) => RolePermissionPosture;
+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 `enabledToolIds` from preset defaults so the multiselect
- *   reflects the budget; `custom` omits the key (all tools).
- * - Does **not** touch `skillId` / `systemPrompt` / other fields — those keep
- *   their existing resolve-at-runtime or explicit override behaviour.
- * - Subsequent edits to `enabledToolIds` stick until the next preset apply.
+ * - 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>>;
-//# sourceMappingURL=llm-role-preset.d.ts.map
+/**
+ * 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/llm-role-preset.js

@@ -1,3 +1,4 @@
+/** Instance role preset — one LLM node type, many configured roles. */
 export const LLM_ROLE_PRESET_OPTIONS = [
     { value: 'custom', title: 'Custom' },
     { value: 'plan', title: 'Plan' },
@@ -46,80 +47,52 @@ const EXPLORER_AGENT_SYSTEM_PROMPT = [
     '',
     'Cite URLs. Separate facts from inference.',
 ].join('\n');
-/** Plan: read-heavy + docs/md writes; no bash / code edit / delete. */
-const PLAN_ENABLED_TOOL_IDS = [
-    'read',
-    'glob',
-    'grep',
-    'write',
-    'create',
-];
-const PLAN_PERMISSION = {
+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',
-    // Separate globs — matcher has no `{a,b}` brace expansion.
-    write: {
-        '**/*.md': 'ask',
-        '**/*.mdx': 'ask',
-        'docs/**': 'ask',
-        '*': 'deny',
-    },
-    create: {
-        '**/*.md': 'ask',
-        '**/*.mdx': 'ask',
-        'docs/**': 'ask',
-        '*': 'deny',
-    },
-};
-/** Coder: full harness set; bash ask (overlays project default deny). */
-const CODER_ENABLED_TOOL_IDS = [...HARNESS_BUILTIN_TOOL_IDS];
-const CODER_PERMISSION = {
-    bash: 'ask',
 };
-/** Explorer: read + md notes; no grep/edit/bash/delete. */
-const EXPLORER_ENABLED_TOOL_IDS = ['read', 'write', 'create'];
-const EXPLORER_PERMISSION = {
+const EXPLORER_TOOL_PERMISSIONS = {
+    ...allAllow(),
+    read: 'allow',
+    write: 'ask',
+    create: 'ask',
     glob: 'deny',
     grep: 'deny',
     edit: 'deny',
     delete: 'deny',
     bash: 'deny',
-    write: {
-        '**/*.md': 'ask',
-        '**/*.mdx': 'ask',
-        '*': 'deny',
-    },
-    create: {
-        '**/*.md': 'ask',
-        '**/*.mdx': 'ask',
-        '*': 'deny',
-    },
 };
 export const LLM_ROLE_PRESET_DEFAULTS = {
     custom: {
         systemPrompt: '',
         skillId: '',
-        enabledToolIds: undefined,
-        permission: {},
+        toolPermissions: CUSTOM_TOOL_PERMISSIONS,
     },
     plan: {
         systemPrompt: PLAN_AGENT_SYSTEM_PROMPT,
         skillId: 'plan',
-        enabledToolIds: PLAN_ENABLED_TOOL_IDS,
-        permission: PLAN_PERMISSION,
+        toolPermissions: PLAN_TOOL_PERMISSIONS,
     },
     coder: {
         systemPrompt: CODER_AGENT_SYSTEM_PROMPT,
         skillId: 'coder',
-        enabledToolIds: CODER_ENABLED_TOOL_IDS,
-        permission: CODER_PERMISSION,
+        toolPermissions: CODER_TOOL_PERMISSIONS,
     },
     explorer: {
         systemPrompt: EXPLORER_AGENT_SYSTEM_PROMPT,
         skillId: 'explorer',
-        enabledToolIds: EXPLORER_ENABLED_TOOL_IDS,
-        permission: EXPLORER_PERMISSION,
+        toolPermissions: EXPLORER_TOOL_PERMISSIONS,
     },
 };
 export const parseLlmRolePreset = (value) => {
@@ -135,44 +108,158 @@ export const resolveEffectiveSkillId = (rolePreset, skillIdParam) => {
     }
     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);
+};
 /**
- * Resolve author-time tool allowlist for the internal loop.
- *
- * Merge rules:
- * - Explicit `enabledToolIds` array (including `[]`) always wins.
- * - When unset, use the current role preset defaults (`custom` → all tools).
+ * Migrate legacy `enabledToolIds` allowlist → coarse toolPermissions.
+ * Listed → allow (bash/delete → ask); unlisted builtins → deny.
  */
-export const resolveEffectiveEnabledToolIds = (rolePreset, enabledToolIdsParam) => {
+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 enabledToolIdsParam.map(String);
+        return migrateEnabledToolIdsToPermissions(enabledToolIdsParam.map(String));
     }
-    return LLM_ROLE_PRESET_DEFAULTS[rolePreset].enabledToolIds;
+    return LLM_ROLE_PRESET_DEFAULTS[rolePreset].toolPermissions;
 };
-/** Permission posture for the current role (empty object for custom). */
-export const resolveRolePermissionPosture = (rolePreset) => LLM_ROLE_PRESET_DEFAULTS[rolePreset].permission;
+/** 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 `enabledToolIds` from preset defaults so the multiselect
- *   reflects the budget; `custom` omits the key (all tools).
- * - Does **not** touch `skillId` / `systemPrompt` / other fields — those keep
- *   their existing resolve-at-runtime or explicit override behaviour.
- * - Subsequent edits to `enabledToolIds` stick until the next preset apply.
+ * - Writes `rolePreset` + materializes `toolPermissions`.
+ * - Removes legacy `enabledToolIds`.
+ * - Does **not** touch `skillId` / `systemPrompt`.
  */
 export const paramsAfterRolePresetApply = (currentParams, rolePreset) => {
-    const { enabledToolIds: _previous, ...rest } = currentParams;
+    const { enabledToolIds: _legacy, toolPermissions: _previous, ...rest } = currentParams;
     const defaults = LLM_ROLE_PRESET_DEFAULTS[rolePreset];
-    if (defaults.enabledToolIds === undefined) {
-        return {
-            ...rest,
-            rolePreset,
-        };
-    }
     return {
         ...rest,
         rolePreset,
-        enabledToolIds: [...defaults.enabledToolIds],
+        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;
 };
-//# sourceMappingURL=llm-role-preset.js.map

package/vendor/common-nodes/dist/ai/llm-session/run-session-machine.d.ts

@@ -1,4 +1,5 @@
 import type { ChatCompletionMessage } from '../chat-completion-stream.js';
+import type { PermissionAskRequest } from '@langflower/tools/permission';
 import { type Observable } from 'rxjs';
 export type LlmSessionPreparation<Session> = {
     readonly history: readonly ChatCompletionMessage[];
@@ -6,13 +7,15 @@ export type LlmSessionPreparation<Session> = {
     readonly appendUserFeedbackToHistory: boolean;
     readonly session: Session;
 };
+type LlmSessionContext = {
+    readonly maxFeedbackTurns: number;
+    readonly requestPermission?: (request: PermissionAskRequest) => Promise<'allow' | 'deny'>;
+};
 /**
  * Sequential session fold. Each turn is an inner Observable reduced into the
  * accumulator; concurrency 1 queues feedback while a turn is streaming.
  */
-export declare const runLlmSessionMachine: <Context extends {
-    readonly maxFeedbackTurns: number;
-}, Session, Chunk extends {
+export declare const runLlmSessionMachine: <Context extends LlmSessionContext, Session, Chunk extends {
     readonly kind: string;
 }>(context: Context, turn$: Observable<unknown>, preparation: LlmSessionPreparation<Session>, runTurn: (context: Context, turnPayload: unknown, history: readonly ChatCompletionMessage[], session: Session) => Observable<Chunk>, primeTurn0: boolean) => Observable<Chunk>;
-//# sourceMappingURL=run-session-machine.d.ts.map
+export {};

package/vendor/common-nodes/dist/ai/llm-session/run-session-machine.js

@@ -1,4 +1,4 @@
-import { EMPTY, concat, filter, map, mergeScan, of, scan, startWith, throwError, } from 'rxjs';
+import { EMPTY, concat, filter, from, map, mergeScan, of, scan, startWith, switchMap, throwError, } from 'rxjs';
 const isBlankTurn = (raw) => raw === null ||
     raw === undefined ||
     (typeof raw === 'string' && raw.trim().length === 0);
@@ -38,6 +38,31 @@ const reduceChunk = (state, chunk) => {
     }
     return { ...state, emitted: chunk };
 };
+const acceptFeedbackTurn = (context, state, raw, runTurn, feedbackTurns) => {
+    const history = state.preparation.appendUserFeedbackToHistory
+        ? [
+            ...state.history,
+            { role: 'user', content: String(raw ?? '') },
+        ]
+        : state.history;
+    const next = {
+        ...state,
+        history,
+        feedbackTurns,
+        emitted: undefined,
+    };
+    return runTurn(context, raw, next.history, next.preparation.session).pipe(scan((accumulator, chunk) => reduceChunk(accumulator, chunk), next));
+};
+const denyMaxFeedbackTurns = (state, maxFeedbackTurns) => {
+    const message = `Stopped: maxFeedbackTurns ` + `(${maxFeedbackTurns}) reached`;
+    return concat(of({
+        ...state,
+        emitted: {
+            kind: 'toolLog',
+            text: `⚠ ${message}`,
+        },
+    }), throwError(() => message));
+};
 const runTurnFromState = (context, state, raw, primeTurn0, runTurn) => {
     if (!state.turn0Done) {
         if (!primeTurn0 && isBlankTurn(raw)) {
@@ -51,29 +76,31 @@ const runTurnFromState = (context, state, raw, primeTurn0, runTurn) => {
     }
     if (context.maxFeedbackTurns > 0 &&
         state.feedbackTurns >= context.maxFeedbackTurns) {
-        const message = `Stopped: maxFeedbackTurns ` +
-            `(${context.maxFeedbackTurns}) reached`;
+        const ask = context.requestPermission;
+        if (ask === undefined) {
+            return denyMaxFeedbackTurns(state, context.maxFeedbackTurns);
+        }
+        const waitingText = `⚠ Max feedback turns (${context.maxFeedbackTurns}) reached. ` +
+            'Allow to continue for another budget, or Deny to stop.';
         return concat(of({
             ...state,
             emitted: {
                 kind: 'toolLog',
-                text: `⚠ ${message}`,
+                text: waitingText,
             },
-        }), throwError(() => message));
+        }), from(ask({
+            toolId: 'agent.maxFeedbackTurns',
+            detail: String(context.maxFeedbackTurns),
+            summary: `Max feedback turns (${context.maxFeedbackTurns}) ` +
+                'reached. Allow to continue?',
+        })).pipe(switchMap((decision) => {
+            if (decision !== 'allow') {
+                return denyMaxFeedbackTurns(state, context.maxFeedbackTurns);
+            }
+            return acceptFeedbackTurn(context, state, raw, runTurn, 1);
+        })));
     }
-    const history = state.preparation.appendUserFeedbackToHistory
-        ? [
-            ...state.history,
-            { role: 'user', content: String(raw ?? '') },
-        ]
-        : state.history;
-    const next = {
-        ...state,
-        history,
-        feedbackTurns: state.feedbackTurns + 1,
-        emitted: undefined,
-    };
-    return runTurn(context, raw, next.history, next.preparation.session).pipe(scan((accumulator, chunk) => reduceChunk(accumulator, chunk), next));
+    return acceptFeedbackTurn(context, state, raw, runTurn, state.feedbackTurns + 1);
 };
 /**
  * Sequential session fold. Each turn is an inner Observable reduced into the
@@ -89,4 +116,3 @@ export const runLlmSessionMachine = (context, turn$, preparation, runTurn, prime
     const turns$ = primeTurn0 ? turn$.pipe(startWith('')) : turn$;
     return turns$.pipe(mergeScan((state, raw) => runTurnFromState(context, state, raw, primeTurn0, runTurn), initial, 1), filter((state) => state.emitted !== undefined), map((state) => state.emitted));
 };
-//# sourceMappingURL=run-session-machine.js.map

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

@@ -1,5 +1,6 @@
 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, SteerControlPayload } from '@langflower/node-sdk/llm';
 import type { PortMeta } from '@langflower/node-sdk';
@@ -25,6 +26,11 @@ export type LlmAgentInventoryContext = {
     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}. */
@@ -61,6 +67,10 @@ type StandardLlmAgentChunk = {
 } | {
     readonly kind: 'toolLog';
     readonly text: string;
+} | {
+    readonly kind: 'recoveryNotice';
+    readonly code: 'retry' | 'suspended';
+    readonly text: string;
 } | {
     readonly kind: 'response';
     readonly text: string;
@@ -106,6 +116,7 @@ export declare const demuxByKind: <Out>(kind: string, project: (chunk: {
  */
 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>;
@@ -126,15 +137,14 @@ type BindLlmAgentSessionOptions<Context extends LlmAgentInventoryContext, Chunk
  */
 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, ({
-        readonly wireType: string;
-    } | {
-        readonly inferTypeFrom: import("@langflower/node-sdk").InputParams<unknown> | StatefulObservable<unknown, unknown, PortMeta>;
-    }) & import("@langflower/node-sdk").OutputParams & PortMeta>[];
+    outputs: StatefulObservable<string, unknown, import("@langflower/node-sdk").OutputParams & PortMeta>[];
     inventoryOutputs: {
         toolLog$: StatefulObservable<string, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
+        recovery$: StatefulObservable<{
+            code: "suspended" | "retry";
+            text: string;
+        }, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
         subagent$: StatefulObservable<SubAgentSpawnPayload, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
     };
 };
 export {};
-//# sourceMappingURL=llm-session-shell.d.ts.map

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

@@ -77,6 +77,9 @@ const assembleLlmAgentInventoryContext = (prompt, toolList, subagentList, mcpLis
             maxCap: AGENT_MAX_ITERATIONS_CAP,
         }),
         maxFeedbackTurns: normalizeMaxFeedbackTurns(ec.params.maxFeedbackTurns),
+        ...(hostServices?.requestPermission !== undefined
+            ? { requestPermission: hostServices.requestPermission }
+            : {}),
         compaction: normalizeCompactionConfig(ec.params),
         recovery: normalizeLlmRecoveryPolicy(ec.params),
     };
@@ -94,6 +97,13 @@ 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 {
+            code: notice.code,
+            text: notice.text,
+        };
+    })),
     response$: cycle$.pipeValue(demuxByKind('response', (chunk) => asKind(chunk).text)),
     subagent$: cycle$.pipeValue(demuxByKind('subagentSpawn', (chunk) => asKind(chunk).payload)),
 });
@@ -142,6 +152,7 @@ export const bindLlmAgentSession = (ctx, helpers, inventory, options) => {
     const feedback = makeInput('feedback', {
         name: 'feedback',
         wireType: 'string',
+        multi: 'merge',
         defaultValue: '',
     });
     // 2. inventory context$
@@ -157,7 +168,7 @@ export const bindLlmAgentSession = (ctx, helpers, inventory, options) => {
         ? undefined
         : String(turnFeedback ?? ''), history, subagentResult.value$, session), { primeTurn0: true });
     // 4. demux
-    const { reasoning$, draftResponse$, toolLog$, response$, subagent$ } = demuxLlmAgentPorts(cycle$);
+    const { reasoning$, draftResponse$, toolLog$, recovery$, response$, subagent$, } = demuxLlmAgentPorts(cycle$);
     // 5. outputs
     return {
         inputs: [userPrompt, systemPrompt, feedback],
@@ -175,7 +186,6 @@ export const bindLlmAgentSession = (ctx, helpers, inventory, options) => {
                 feed: { role: 'result' },
             }),
         ],
-        inventoryOutputs: { toolLog$, subagent$ },
+        inventoryOutputs: { toolLog$, recovery$, subagent$ },
     };
 };
-//# sourceMappingURL=llm-session-shell.js.map

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

@@ -8,6 +8,5 @@ export declare const normalizeMaxIterations: (value: unknown, options: {
 }) => number;
 export declare const AGENT_MAX_ITERATIONS_CAP = 64;
 export declare const PATH_CHOICE_MAX_ITERATIONS_CAP = 32;
-export declare const DEFAULT_AGENT_MAX_ITERATIONS = 8;
+export declare const DEFAULT_AGENT_MAX_ITERATIONS = 64;
 export declare const DEFAULT_PATH_CHOICE_MAX_ITERATIONS = 5;
-//# sourceMappingURL=normalize-max-iterations.d.ts.map

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

@@ -18,6 +18,5 @@ export const normalizeMaxIterations = (value, options) => {
 };
 export const AGENT_MAX_ITERATIONS_CAP = 64;
 export const PATH_CHOICE_MAX_ITERATIONS_CAP = 32;
-export const DEFAULT_AGENT_MAX_ITERATIONS = 8;
+export const DEFAULT_AGENT_MAX_ITERATIONS = 64;
 export const DEFAULT_PATH_CHOICE_MAX_ITERATIONS = 5;
-//# sourceMappingURL=normalize-max-iterations.js.map

package/vendor/common-nodes/dist/ai/openai/context-length-error.d.ts

@@ -12,4 +12,3 @@ export declare const isContextLengthExceededError: (error: unknown) => error is
  * Structured fields win; narrow message fallback covers LM Studio / vLLM.
  */
 export declare const classifyContextLengthError: (error: unknown) => ContextLengthExceededError | undefined;
-//# sourceMappingURL=context-length-error.d.ts.map