langflower 0.0.7 → 0.0.9

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

@@ -46,6 +46,8 @@ export type CreateChatCompletionStreamArgs = {
     readonly messages: readonly ChatCompletionMessage[];
     readonly tools?: readonly ChatCompletionToolDefinition[];
     readonly signal?: ChatCompletionAbortSignal;
+    readonly frequency_penalty?: number;
+    readonly presence_penalty?: number;
 };
 /** OpenAI-compatible chat stream factory (credentials resolved server-side). */
 export type CreateChatCompletionStream = (args: CreateChatCompletionStreamArgs) => Promise<AsyncIterable<ChatCompletionStreamChunk>>;

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

@@ -116,6 +116,88 @@ export declare const critiqueNode: {
         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 [...({
@@ -224,6 +306,88 @@ export declare const critiqueNode: {
         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 [...({
@@ -332,6 +496,88 @@ export declare const critiqueNode: {
         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/critique/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';
@@ -206,7 +206,7 @@ export const critiqueNode = 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));

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

@@ -102,6 +102,88 @@ export declare const fakeLlmNode: {
         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 field: "tokenDelayMs";
         readonly type: "number";
@@ -205,6 +287,88 @@ export declare const fakeLlmNode: {
         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 field: "tokenDelayMs";
         readonly type: "number";
@@ -308,6 +472,88 @@ export declare const fakeLlmNode: {
         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 field: "tokenDelayMs";
         readonly type: "number";

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

@@ -0,0 +1,53 @@
+export type ChatCompletionAbortSignal = {
+    readonly aborted: boolean;
+};
+export type ChatCompletionToolCall = {
+    readonly id: string;
+    readonly name: string;
+    /** JSON object string (OpenAI-compatible). */
+    readonly arguments: string;
+};
+export type ChatCompletionMessage = {
+    readonly role: 'system' | 'user';
+    readonly content: string;
+} | {
+    readonly role: 'assistant';
+    readonly content: string;
+    readonly tool_calls?: readonly ChatCompletionToolCall[];
+} | {
+    readonly role: 'tool';
+    readonly content: string;
+    readonly tool_call_id: string;
+};
+export type ChatCompletionToolDefinition = {
+    readonly type: 'function';
+    readonly function: {
+        readonly name: string;
+        readonly description?: string;
+        readonly parameters?: object;
+    };
+};
+export type ChatCompletionFinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'unknown';
+export type ChatCompletionStreamChunk = {
+    readonly kind: 'reasoning';
+    readonly text: string;
+} | {
+    readonly kind: 'draft';
+    readonly text: string;
+} | {
+    readonly kind: 'done';
+    readonly text: string;
+    readonly tool_calls?: readonly ChatCompletionToolCall[];
+    readonly finishReason?: ChatCompletionFinishReason;
+};
+export type CreateChatCompletionStreamArgs = {
+    readonly providerId: string;
+    readonly model: string;
+    readonly messages: readonly ChatCompletionMessage[];
+    readonly tools?: readonly ChatCompletionToolDefinition[];
+    readonly signal?: ChatCompletionAbortSignal;
+    readonly frequency_penalty?: number;
+    readonly presence_penalty?: number;
+};
+/** OpenAI-compatible chat stream factory (credentials resolved server-side). */
+export type CreateChatCompletionStream = (args: CreateChatCompletionStreamArgs) => Promise<AsyncIterable<ChatCompletionStreamChunk>>;

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

@@ -0,0 +1 @@
+export {};

package/vendor/common-nodes/dist/ai/features/llm-loop/autokick-recovery.d.ts

@@ -0,0 +1,13 @@
+export declare const autokickBackoffMs: (attempt: number, baseMs: number, maxMs: number) => number;
+export declare const clampChatPenalty: (value: number) => number;
+export declare const autokickPenalties: (attempt: number, delta: {
+    readonly frequency: number;
+    readonly presence: number;
+}) => {
+    readonly frequency: number;
+    readonly presence: number;
+};
+export declare const autokickKickUserTurn: (content: string) => {
+    readonly role: "user";
+    readonly content: string;
+};

package/vendor/common-nodes/dist/ai/features/llm-loop/autokick-recovery.js

@@ -0,0 +1,17 @@
+export const autokickBackoffMs = (attempt, baseMs, maxMs) => {
+    const safeAttempt = Math.max(1, attempt);
+    const delay = baseMs * 2 ** (safeAttempt - 1);
+    return Math.min(delay, maxMs);
+};
+export const clampChatPenalty = (value) => Math.min(2, Math.max(-2, value));
+export const autokickPenalties = (attempt, delta) => {
+    const safeAttempt = Math.max(1, attempt);
+    return {
+        frequency: clampChatPenalty(delta.frequency * safeAttempt),
+        presence: clampChatPenalty(delta.presence * safeAttempt),
+    };
+};
+export const autokickKickUserTurn = (content) => ({
+    role: 'user',
+    content,
+});

package/vendor/common-nodes/dist/ai/features/llm-loop/classify-llm-failure.d.ts

@@ -0,0 +1,2 @@
+import type { LlmFailure } from './llm-loop-types.js';
+export declare const classifyLlmFailure: (error: unknown) => LlmFailure;