langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/ai/review/node.d.ts

@@ -121,6 +121,88 @@ export declare const reviewNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }];
     readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
     readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [...({
@@ -229,6 +311,88 @@ export declare const reviewNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }], import("@langflower/node-sdk/llm").LlmExecutionCaps>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
     readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
     readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [...({
@@ -337,6 +501,88 @@ export declare const reviewNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }], import("@langflower/node-sdk/llm").LlmExecutionCaps>;
     readonly paletteSecondary?: true;
     readonly description?: string;

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

@@ -1,5 +1,5 @@
 import { filter, map, Observable } from 'rxjs';
-import { defineLlmNode, isSteerControlPayload, } from '@langflower/node-sdk/llm';
+import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
 import { collectAgentToolHandles } from '../../tools/collect-agent-tool-handles.js';
 import { buildEffectiveSystemPrompt } from '../build-effective-system-prompt.js';
 import { resolveChatProviderModel } from '../resolve-chat-provider-model.js';
@@ -208,7 +208,7 @@ export const reviewNode = defineLlmNode({
         const toolLog$ = cycle$.pipeValue(demuxByKind('toolLog', (chunk) => chunk.text));
         const recovery$ = cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
             const notice = chunk;
-            return { code: notice.code, text: notice.text };
+            return toLlmRecoveryPortValue(notice);
         }));
         const response$ = cycle$.pipeValue(demuxByKind('accept', (chunk) => chunk.result));
         const feedback$ = cycle$.pipeValue(demuxByKind('feedback', (chunk) => chunk.notes));

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

@@ -128,6 +128,88 @@ export declare const subAgentNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }];
     readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
     readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [{
@@ -251,6 +333,88 @@ export declare const subAgentNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }], import("@langflower/node-sdk/llm").LlmExecutionCaps>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
     readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
     readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [{
@@ -374,6 +538,88 @@ export declare const subAgentNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }], import("@langflower/node-sdk/llm").LlmExecutionCaps>;
     readonly paletteSecondary?: true;
     readonly description?: string;

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

@@ -1,4 +1,4 @@
-import { defineLlmNode, isSteerControlPayload } from '@langflower/node-sdk/llm';
+import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
 import { concat, EMPTY, filter, mergeMap, Observable, of, } from 'rxjs';
 import { llmPanelUiSchema } from '../llm-panel-ui-schema.js';
 import { llmCompactionUiSchema } from '../llm-compaction-ui-schema.js';
@@ -261,7 +261,7 @@ export const subAgentNode = defineLlmNode({
         const toolLog$ = cycle$.pipeValue(demuxByKind('toolLog', (chunk) => chunk.text));
         const recovery$ = cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
             const notice = chunk;
-            return { code: notice.code, text: notice.text };
+            return toLlmRecoveryPortValue(notice);
         }));
         const response$ = cycle$.pipeValue(demuxByKind('response', (chunk) => chunk
             .text));

package/vendor/common-nodes/dist/catalog.js

@@ -1,11 +1,11 @@
-import { fakeLlmNode } from './ai/fake-llm/node.js';
-import { openAiLlmNode } from './ai/openai-llm/node.js';
+import { fakeLlmNode } from './ai/nodes/fake-llm/node.js';
+import { openAiLlmNode } from './ai/nodes/openai-llm/node.js';
 import { mcpHttpNode } from './mcp/mcp-http/node.js';
 import { mcpStdioNode } from './mcp/mcp-stdio/node.js';
 import { chatInputNode } from './hitl/chat-input/node.js';
-import { reviewNode } from './ai/review/node.js';
-import { critiqueNode } from './ai/critique/node.js';
-import { subAgentNode } from './ai/sub-agent/node.js';
+import { reviewNode } from './ai/nodes/review/node.js';
+import { critiqueNode } from './ai/nodes/critique/node.js';
+import { subAgentNode } from './ai/nodes/sub-agent/node.js';
 import { checkpointNode } from './flow/checkpoint/node.js';
 import { delayNode } from './flow/delay/node.js';
 import { loopNode } from './flow/loop/node.js';
@@ -33,6 +33,7 @@ import { extractLinksNode } from './crawl/extract-links/node.js';
 import { fetchUrlNode } from './crawl/fetch-url/node.js';
 import { savePageNode } from './crawl/save-page/node.js';
 import { memoryToolsNode } from './memory/memory-tools/node.js';
+import { langflowerToolsNode } from './langflower-tools/node.js';
 const COMMON_REACTIVE_NODES = [
     booleanNode,
     numberNode,
@@ -64,6 +65,7 @@ const COMMON_REACTIVE_NODES = [
     compareNode,
     switchNode,
     memoryToolsNode,
+    langflowerToolsNode,
     fetchUrlNode,
     extractLinksNode,
     savePageNode,

package/vendor/common-nodes/dist/compile-custom-nodes/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Emits `compile_custom_nodes` for agent inventory. The handler calls the
+ * server-injected compile hook (same composer as Custom → Update).
+ */
+export declare const compileCustomNodesNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};
+//# sourceMappingURL=node.d.ts.map

package/vendor/common-nodes/dist/compile-custom-nodes/node.js

@@ -0,0 +1,45 @@
+import { defineToolRegistrations } from '@langflower/node-sdk';
+import { getRunHostServices, } from '../ai/features/run-host-services.js';
+const MISSING_HOOK_TEXT = '{ ok: false }\ncompile_custom_nodes unavailable (no server hook)';
+const formatCompileCustomNodesResult = (result) => {
+    const lines = [`status: ${result.status}`];
+    if (result.nodeTypes.length > 0) {
+        lines.push(`nodeTypes: ${result.nodeTypes.join(', ')}`);
+    }
+    if (result.errors.length > 0) {
+        lines.push('errors:');
+        for (const error of result.errors) {
+            lines.push(`- ${error.packageName}: ${error.message}`);
+        }
+    }
+    return lines.join('\n');
+};
+/**
+ * Emits `compile_custom_nodes` for agent inventory. The handler calls the
+ * server-injected compile hook (same composer as Custom → Update).
+ */
+export const compileCustomNodesNode = defineToolRegistrations({
+    type: 'common-compile-custom-nodes',
+    displayName: 'Compile Custom Nodes',
+    category: 'Tools',
+    description: 'Emits compile_custom_nodes so an agent can recompile project custom packs (same path as Custom → Update).',
+    tools: [
+        {
+            toolId: 'compile_custom_nodes',
+            description: 'Recompile `.langflower/nodes/` packs, hot-swap live custom instances, and refresh the Custom palette. No arguments. Pack failures also write COMPILATION_ERRORS.md.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                additionalProperties: false,
+            },
+            handler: async (_args, ctx) => {
+                const compile = getRunHostServices(ctx)?.compileCustomNodes;
+                if (compile === undefined) {
+                    return MISSING_HOOK_TEXT;
+                }
+                return formatCompileCustomNodesResult(await compile());
+            },
+        },
+    ],
+});
+//# sourceMappingURL=node.js.map

package/vendor/common-nodes/dist/crawl/crawl/node.js

@@ -3,7 +3,7 @@ import { createCrawlContext } from '@langflower/tools/create-crawl-context';
 import { createWebFetch } from '@langflower/tools/create-web-fetch';
 import { runBfsCrawl } from '@langflower/tools/run-bfs-crawl';
 import { from, mergeMap, throwError } from 'rxjs';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 const normalizeLimit = (value, fallback, max) => {
     const n = Number(value);
     if (!Number.isFinite(n) || n < 0) {

package/vendor/common-nodes/dist/crawl/fetch-url/node.js

@@ -2,7 +2,7 @@ import { defineReactiveNode } from '@langflower/node-sdk';
 import { createWebFetch } from '@langflower/tools/create-web-fetch';
 import { from, map, mergeMap, throwError } from 'rxjs';
 import { htmlToText } from '@langflower/tools/html';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 /**
  * HTTP GET a URL via server `ctx.harness.webFetch` (SSRF guards), then extract
  * plain text from HTML.