langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/ai/features/openai/llm-context-compaction.js

@@ -0,0 +1,326 @@
+import { isContextLengthExceededError } from './context-length-error.js';
+const SUMMARY_PREFIX = '## Compacted conversation context\n';
+export const SUMMARY_SYSTEM_PROMPT = [
+    'Summarize the following conversation history for continuity.',
+    'Preserve requirements, decisions, unfinished tasks, tool outcomes,',
+    'and exact constraints. Be dense and factual. Do not invent content.',
+].join(' ');
+const estimateApproxTokens = (value) => {
+    try {
+        return Math.ceil(JSON.stringify(value).length / 4);
+    }
+    catch {
+        return Math.ceil(String(value).length / 4);
+    }
+};
+export const estimateMessagesTokens = (messages) => estimateApproxTokens(messages);
+export const estimateToolsTokens = (tools) => (tools.length === 0 ? 0 : estimateApproxTokens(tools));
+export const estimateRequestTokens = (messages, tools) => estimateMessagesTokens(messages) + estimateToolsTokens(tools);
+const effectiveInputBudget = (contextSize) => Math.floor(contextSize * 0.8);
+const summarySlotTokens = (inputBudget) => Math.min(4096, Math.max(256, Math.floor(inputBudget * 0.15)));
+const truncateToApproxTokens = (text, maxTokens) => {
+    const maxChars = Math.max(0, maxTokens * 4);
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return text.slice(text.length - maxChars);
+};
+const splitLeadingSystem = (messages) => {
+    let end = 0;
+    while (end < messages.length && messages[end]?.role === 'system') {
+        end += 1;
+    }
+    return {
+        system: messages.slice(0, end),
+        rest: messages.slice(end),
+    };
+};
+const findLastUserIndex = (messages) => {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        if (messages[i]?.role === 'user') {
+            return i;
+        }
+    }
+    return -1;
+};
+const toBlocks = (messages) => {
+    const blocks = [];
+    const lastUserIndex = findLastUserIndex(messages);
+    let i = 0;
+    while (i < messages.length) {
+        const message = messages[i];
+        if (message === undefined) {
+            break;
+        }
+        if (message.role === 'tool') {
+            return {
+                ok: false,
+                message: 'Cannot compact history: orphan tool message without a preceding assistant tool_calls block',
+            };
+        }
+        if (message.role === 'assistant' &&
+            message.tool_calls !== undefined &&
+            message.tool_calls.length > 0) {
+            const callIds = new Set(message.tool_calls.map((call) => call.id));
+            const group = [message];
+            let j = i + 1;
+            while (j < messages.length) {
+                const next = messages[j];
+                if (next === undefined || next.role !== 'tool') {
+                    break;
+                }
+                if (!callIds.has(next.tool_call_id)) {
+                    return {
+                        ok: false,
+                        message: `Cannot compact history: tool message id ${next.tool_call_id} is not part of the preceding assistant tool_calls`,
+                    };
+                }
+                group.push(next);
+                callIds.delete(next.tool_call_id);
+                j += 1;
+            }
+            if (callIds.size > 0) {
+                return {
+                    ok: false,
+                    message: 'Cannot compact history: incomplete assistant tool_calls / tool result block',
+                };
+            }
+            const isNewest = j === messages.length;
+            blocks.push({
+                messages: group,
+                isProtected: isNewest,
+            });
+            i = j;
+            continue;
+        }
+        blocks.push({
+            messages: [message],
+            isProtected: i === lastUserIndex || i === messages.length - 1,
+        });
+        i += 1;
+    }
+    if (blocks.length > 0) {
+        const last = blocks[blocks.length - 1];
+        if (last !== undefined && !last.isProtected) {
+            blocks[blocks.length - 1] = { ...last, isProtected: true };
+        }
+    }
+    return { ok: true, blocks };
+};
+const flattenBlocks = (blocks) => blocks.flatMap((block) => block.messages);
+const serializeMessagesForSummary = (messages) => messages
+    .map((message) => {
+    if (message.role === 'tool') {
+        return `[tool ${message.tool_call_id}]\n${message.content}`;
+    }
+    if (message.role === 'assistant' &&
+        message.tool_calls !== undefined &&
+        message.tool_calls.length > 0) {
+        const calls = message.tool_calls
+            .map((call) => `${call.name}(${call.arguments}) id=${call.id}`)
+            .join('; ');
+        return `[assistant tool_calls]\n${message.content}\n${calls}`;
+    }
+    return `[${message.role}]\n${message.content}`;
+})
+    .join('\n\n');
+const collectDoneText = async (stream) => {
+    let text = '';
+    for await (const chunk of stream) {
+        if (chunk.kind === 'draft' && typeof chunk.text === 'string') {
+            text += chunk.text;
+        }
+        else if (chunk.kind === 'done' && typeof chunk.text === 'string') {
+            text = chunk.text.length > 0 ? chunk.text : text;
+        }
+    }
+    return text.trim();
+};
+const summarizeRange = async (args) => {
+    let sourceBudget = args.sourceBudgetTokens;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (args.signal !== undefined && args.signal.aborted) {
+            return {
+                ok: false,
+                message: 'Compaction aborted',
+                aborted: true,
+            };
+        }
+        const serialized = truncateToApproxTokens(serializeMessagesForSummary(args.source), sourceBudget);
+        try {
+            const stream = await args.factory({
+                providerId: args.providerId,
+                model: args.model,
+                messages: [
+                    { role: 'system', content: SUMMARY_SYSTEM_PROMPT },
+                    { role: 'user', content: serialized },
+                ],
+                ...(args.signal !== undefined ? { signal: args.signal } : {}),
+            });
+            const content = await collectDoneText(stream);
+            if (content.length === 0) {
+                return {
+                    ok: false,
+                    message: 'Compaction summary returned empty text',
+                };
+            }
+            return { ok: true, content };
+        }
+        catch (error) {
+            if (args.signal !== undefined && args.signal.aborted) {
+                return {
+                    ok: false,
+                    message: 'Compaction aborted',
+                    aborted: true,
+                };
+            }
+            if (isContextLengthExceededError(error)) {
+                sourceBudget = Math.max(256, Math.floor(sourceBudget / 2));
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                message: `Compaction summary failed: ${message}`,
+            };
+        }
+    }
+    return {
+        ok: false,
+        message: 'Compaction summary failed after repeated context-length errors',
+    };
+};
+const findRemovableRange = (blocks) => {
+    let start = -1;
+    for (let i = 0; i < blocks.length; i += 1) {
+        if (!blocks[i].isProtected) {
+            start = i;
+            break;
+        }
+    }
+    if (start < 0) {
+        return undefined;
+    }
+    let end = start;
+    while (end + 1 < blocks.length && !blocks[end + 1].isProtected) {
+        end += 1;
+    }
+    return { start, end };
+};
+const buildSummaryMessage = (content, slotTokens) => ({
+    role: 'user',
+    content: `${SUMMARY_PREFIX}${truncateToApproxTokens(content, slotTokens)}`,
+});
+/**
+ * LLM-summary compaction: replace contiguous unprotected message blocks with
+ * a summary user message while preserving leading system + last user + newest
+ * block and full assistant/tool groups.
+ */
+export const compactMessagesWithSummary = async (args) => {
+    const beforeTokens = estimateRequestTokens(args.messages, args.tools);
+    if (beforeTokens <= args.targetTokens) {
+        return {
+            ok: true,
+            messages: args.messages,
+            beforeTokens,
+            afterTokens: beforeTokens,
+        };
+    }
+    const { system, rest } = splitLeadingSystem(args.messages);
+    const blocked = toBlocks(rest);
+    if (!blocked.ok) {
+        return blocked;
+    }
+    let blocks = [...blocked.blocks];
+    const toolsTokens = estimateToolsTokens(args.tools);
+    const slot = summarySlotTokens(args.targetTokens);
+    const requiredTokens = estimateMessagesTokens([
+        ...system,
+        ...(findLastUserIndex(rest) >= 0
+            ? [rest[findLastUserIndex(rest)]]
+            : []),
+    ]) +
+        toolsTokens +
+        slot;
+    if (requiredTokens > args.targetTokens) {
+        return {
+            ok: false,
+            message: `Cannot compact history: required system/user/tools already need ~${requiredTokens} approx tokens (budget ${args.targetTokens})`,
+        };
+    }
+    let workingMessages = args.messages;
+    let passes = 0;
+    while (estimateRequestTokens(workingMessages, args.tools) >
+        args.targetTokens &&
+        passes < 2) {
+        if (args.signal !== undefined && args.signal.aborted) {
+            return { ok: false, message: 'Compaction aborted' };
+        }
+        const range = findRemovableRange(blocks);
+        if (range === undefined) {
+            return {
+                ok: false,
+                message: 'Cannot compact history: no removable message blocks left under the protected prefix/suffix',
+            };
+        }
+        const source = flattenBlocks(blocks.slice(range.start, range.end + 1));
+        const remainingBudget = Math.max(256, args.targetTokens -
+            toolsTokens -
+            estimateMessagesTokens([
+                ...system,
+                ...flattenBlocks(blocks.slice(0, range.start)),
+                ...flattenBlocks(blocks.slice(range.end + 1)),
+            ]) -
+            slot);
+        const summary = await summarizeRange({
+            factory: args.factory,
+            providerId: args.providerId,
+            model: args.model,
+            ...(args.signal !== undefined ? { signal: args.signal } : {}),
+            source,
+            sourceBudgetTokens: remainingBudget,
+        });
+        if (!summary.ok) {
+            return {
+                ok: false,
+                message: summary.message,
+            };
+        }
+        const summaryMessage = buildSummaryMessage(summary.content, slot);
+        blocks = [
+            ...blocks.slice(0, range.start),
+            {
+                messages: [summaryMessage],
+                isProtected: true,
+            },
+            ...blocks.slice(range.end + 1),
+        ];
+        workingMessages = [...system, ...flattenBlocks(blocks)];
+        passes += 1;
+    }
+    const afterTokens = estimateRequestTokens(workingMessages, args.tools);
+    if (afterTokens > args.targetTokens) {
+        return {
+            ok: false,
+            message: `Cannot compact history below ~${args.targetTokens} approx tokens (still ~${afterTokens})`,
+        };
+    }
+    return {
+        ok: true,
+        messages: workingMessages,
+        beforeTokens,
+        afterTokens,
+    };
+};
+export const resolveProactiveTargetTokens = (config) => {
+    if (config.contextSize <= 0) {
+        return undefined;
+    }
+    return effectiveInputBudget(config.contextSize);
+};
+export const resolveForceTargetTokens = (config, currentInputEstimate) => {
+    if (config.contextSize > 0) {
+        return Math.min(effectiveInputBudget(config.contextSize), Math.max(256, Math.floor(currentInputEstimate * 0.5)));
+    }
+    return Math.max(256, Math.floor(currentInputEstimate * 0.5));
+};

package/vendor/common-nodes/dist/ai/features/openai/normalize-compaction-params.d.ts

@@ -0,0 +1,14 @@
+export type LlmCompactionConfig = {
+    /**
+     * Approx input token budget. `0` disables proactive compaction.
+     * Invalid values coerce to the Inspector default `200000`.
+     */
+    readonly contextSize: number;
+    /** Retry once after a typed context-length error by force-compacting. */
+    readonly compactOnError: boolean;
+};
+export declare const DEFAULT_CONTEXT_SIZE = 200000;
+export declare const DISABLED_COMPACTION_CONFIG: LlmCompactionConfig;
+export declare const normalizeContextSize: (value: unknown) => number;
+export declare const normalizeCompactOnError: (value: unknown) => boolean;
+export declare const normalizeCompactionConfig: (params: Readonly<Record<string, unknown>>) => LlmCompactionConfig;

package/vendor/common-nodes/dist/ai/features/openai/normalize-compaction-params.js

@@ -0,0 +1,21 @@
+export const DEFAULT_CONTEXT_SIZE = 200000;
+const MAX_CONTEXT_SIZE = 1_000_000;
+export const DISABLED_COMPACTION_CONFIG = {
+    contextSize: 0,
+    compactOnError: false,
+};
+export const normalizeContextSize = (value) => {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n)) {
+        return DEFAULT_CONTEXT_SIZE;
+    }
+    if (n <= 0) {
+        return 0;
+    }
+    return Math.min(MAX_CONTEXT_SIZE, Math.floor(n));
+};
+export const normalizeCompactOnError = (value) => value === true;
+export const normalizeCompactionConfig = (params) => ({
+    contextSize: normalizeContextSize(params['contextSize']),
+    compactOnError: normalizeCompactOnError(params['compactOnError']),
+});

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

@@ -0,0 +1,30 @@
+import type { ChatCompletionMessage, ChatCompletionStreamChunk, ChatCompletionToolDefinition, CreateChatCompletionStream } from '../chat-completion-stream.js';
+import type { LlmCompactionConfig } from './normalize-compaction-params.js';
+export type PreparedChatCompletion = {
+    readonly ok: true;
+    readonly messages: readonly ChatCompletionMessage[];
+    readonly stream: AsyncIterable<ChatCompletionStreamChunk>;
+    readonly compaction?: {
+        readonly reason: 'proactive' | 'context-error';
+        readonly beforeTokens: number;
+        readonly afterTokens: number;
+    };
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
+/**
+ * Proactive + compact-on-error gate before consuming a chat stream.
+ * Context retries happen only at create-stream time (pre reasoning/draft).
+ */
+export declare const prepareChatCompletion: (args: {
+    readonly factory: CreateChatCompletionStream;
+    readonly providerId: string;
+    readonly model: string;
+    readonly messages: readonly ChatCompletionMessage[];
+    readonly tools?: readonly ChatCompletionToolDefinition[];
+    readonly signal?: AbortSignal;
+    readonly compaction?: LlmCompactionConfig;
+    readonly frequency_penalty?: number;
+    readonly presence_penalty?: number;
+}) => Promise<PreparedChatCompletion>;

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

@@ -0,0 +1,132 @@
+import { classifyContextLengthError, isContextLengthExceededError, } from './context-length-error.js';
+import { compactMessagesWithSummary, estimateRequestTokens, resolveForceTargetTokens, resolveProactiveTargetTokens, } from './llm-context-compaction.js';
+import { DISABLED_COMPACTION_CONFIG } from './normalize-compaction-params.js';
+const createMainStream = async (args) => args.factory({
+    providerId: args.providerId,
+    model: args.model,
+    messages: args.messages,
+    ...(args.tools.length > 0 ? { tools: args.tools } : {}),
+    ...(args.signal !== undefined ? { signal: args.signal } : {}),
+    ...(args.frequency_penalty !== undefined
+        ? { frequency_penalty: args.frequency_penalty }
+        : {}),
+    ...(args.presence_penalty !== undefined
+        ? { presence_penalty: args.presence_penalty }
+        : {}),
+});
+/**
+ * Proactive + compact-on-error gate before consuming a chat stream.
+ * Context retries happen only at create-stream time (pre reasoning/draft).
+ */
+export const prepareChatCompletion = async (args) => {
+    const tools = args.tools ?? [];
+    const config = args.compaction ?? DISABLED_COMPACTION_CONFIG;
+    let messages = args.messages;
+    let compaction;
+    const proactiveTarget = resolveProactiveTargetTokens(config);
+    if (proactiveTarget !== undefined &&
+        estimateRequestTokens(messages, tools) > proactiveTarget) {
+        const compacted = await compactMessagesWithSummary({
+            factory: args.factory,
+            providerId: args.providerId,
+            model: args.model,
+            messages,
+            tools,
+            targetTokens: proactiveTarget,
+            ...(args.signal !== undefined ? { signal: args.signal } : {}),
+        });
+        if (!compacted.ok) {
+            return { ok: false, error: new Error(compacted.message) };
+        }
+        if (compacted.afterTokens < compacted.beforeTokens) {
+            messages = compacted.messages;
+            compaction = {
+                reason: 'proactive',
+                beforeTokens: compacted.beforeTokens,
+                afterTokens: compacted.afterTokens,
+            };
+        }
+    }
+    try {
+        const stream = await createMainStream({
+            factory: args.factory,
+            providerId: args.providerId,
+            model: args.model,
+            messages,
+            tools,
+            ...(args.signal !== undefined ? { signal: args.signal } : {}),
+            ...(args.frequency_penalty !== undefined
+                ? { frequency_penalty: args.frequency_penalty }
+                : {}),
+            ...(args.presence_penalty !== undefined
+                ? { presence_penalty: args.presence_penalty }
+                : {}),
+        });
+        return {
+            ok: true,
+            messages,
+            stream,
+            ...(compaction !== undefined ? { compaction } : {}),
+        };
+    }
+    catch (error) {
+        if (args.signal !== undefined && args.signal.aborted) {
+            return { ok: false, error };
+        }
+        const contextError = classifyContextLengthError(error) ??
+            (isContextLengthExceededError(error) ? error : undefined);
+        if (contextError === undefined || !config.compactOnError) {
+            return {
+                ok: false,
+                error: contextError ?? error,
+            };
+        }
+        const forceTarget = resolveForceTargetTokens(config, estimateRequestTokens(messages, tools));
+        const compacted = await compactMessagesWithSummary({
+            factory: args.factory,
+            providerId: args.providerId,
+            model: args.model,
+            messages,
+            tools,
+            targetTokens: forceTarget,
+            ...(args.signal !== undefined ? { signal: args.signal } : {}),
+        });
+        if (!compacted.ok) {
+            return { ok: false, error: new Error(compacted.message) };
+        }
+        messages = compacted.messages;
+        compaction = {
+            reason: 'context-error',
+            beforeTokens: compacted.beforeTokens,
+            afterTokens: compacted.afterTokens,
+        };
+        try {
+            const stream = await createMainStream({
+                factory: args.factory,
+                providerId: args.providerId,
+                model: args.model,
+                messages,
+                tools,
+                ...(args.signal !== undefined ? { signal: args.signal } : {}),
+                ...(args.frequency_penalty !== undefined
+                    ? { frequency_penalty: args.frequency_penalty }
+                    : {}),
+                ...(args.presence_penalty !== undefined
+                    ? { presence_penalty: args.presence_penalty }
+                    : {}),
+            });
+            return {
+                ok: true,
+                messages,
+                stream,
+                compaction,
+            };
+        }
+        catch (retryError) {
+            return {
+                ok: false,
+                error: classifyContextLengthError(retryError) ?? retryError,
+            };
+        }
+    }
+};

package/vendor/common-nodes/dist/ai/features/path-choice/control-tools.d.ts

@@ -0,0 +1,20 @@
+import type { ChatCompletionToolCall, ChatCompletionToolDefinition } from '../chat-completion-stream.js';
+/**
+ * Path-choice control tools (accept / feedback). Must not be merged into shared
+ * inventory or harness allowlists. Import only from `ai/nodes/review/` and
+ * `ai/nodes/critique/`.
+ */
+export declare const REVIEW_ACCEPT_TOOL = "accept";
+export declare const REVIEW_FEEDBACK_TOOL = "feedback";
+export declare const REVIEW_TOOL_REMINDER = "You must finish by calling exactly one control tool: accept or feedback. Free-form text answers are not valid. Call accept to approve the artifact, or feedback with notes to send it back for revision.";
+/** Chat tool definitions injected only into path-choice completion calls. */
+export declare const REVIEW_CHAT_TOOLS: readonly ChatCompletionToolDefinition[];
+export declare const notesFromControlToolArgs: (args: Readonly<Record<string, unknown>>) => string;
+export declare const findControlToolCall: (toolCalls: readonly ChatCompletionToolCall[]) => {
+    readonly kind: "accept";
+    readonly call: ChatCompletionToolCall;
+} | {
+    readonly kind: "feedback";
+    readonly call: ChatCompletionToolCall;
+} | undefined;
+export declare const isReviewControlToolName: (name: string) => boolean;

package/vendor/common-nodes/dist/ai/features/path-choice/control-tools.js

@@ -0,0 +1,70 @@
+/**
+ * Path-choice control tools (accept / feedback). Must not be merged into shared
+ * inventory or harness allowlists. Import only from `ai/nodes/review/` and
+ * `ai/nodes/critique/`.
+ */
+export const REVIEW_ACCEPT_TOOL = 'accept';
+export const REVIEW_FEEDBACK_TOOL = 'feedback';
+export const REVIEW_TOOL_REMINDER = 'You must finish by calling exactly one control tool: accept or feedback. Free-form text answers are not valid. Call accept to approve the artifact, or feedback with notes to send it back for revision.';
+/** Chat tool definitions injected only into path-choice completion calls. */
+export const REVIEW_CHAT_TOOLS = [
+    {
+        type: 'function',
+        function: {
+            name: REVIEW_ACCEPT_TOOL,
+            description: 'REQUIRED path when the artifact meets the task criteria. Call this tool to accept — never write a free-form approval. Optional notes may summarize why it passes. Exactly one of accept or feedback must be called to finish.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    notes: {
+                        type: 'string',
+                        description: 'Optional short acceptance notes',
+                    },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: REVIEW_FEEDBACK_TOOL,
+            description: 'REQUIRED path when the artifact fails the task criteria. Call this tool with concrete revision notes — never write a free-form reject essay. Exactly one of accept or feedback must be called to finish.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    notes: {
+                        type: 'string',
+                        description: 'Required revision notes for the upstream agent',
+                    },
+                },
+                required: ['notes'],
+            },
+        },
+    },
+];
+export const notesFromControlToolArgs = (args) => {
+    const notes = args.notes;
+    if (typeof notes === 'string') {
+        return notes;
+    }
+    const feedback = args.feedback;
+    if (typeof feedback === 'string') {
+        return feedback;
+    }
+    if (typeof args.__raw === 'string') {
+        return args.__raw;
+    }
+    return '';
+};
+export const findControlToolCall = (toolCalls) => {
+    for (const call of toolCalls) {
+        if (call.name === REVIEW_ACCEPT_TOOL) {
+            return { kind: 'accept', call };
+        }
+        if (call.name === REVIEW_FEEDBACK_TOOL) {
+            return { kind: 'feedback', call };
+        }
+    }
+    return undefined;
+};
+export const isReviewControlToolName = (name) => name === REVIEW_ACCEPT_TOOL || name === REVIEW_FEEDBACK_TOOL;

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

@@ -0,0 +1,35 @@
+import type { ToolHandle } from '@langflower/node-sdk';
+import type { SteerControlPayload } from '@langflower/node-sdk/llm';
+import type { Harness } from '@langflower/tools/create-project-harness';
+import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
+import type { Observable } from 'rxjs';
+import type { ChatCompletionMessage, CreateChatCompletionStream } from '../chat-completion-stream.js';
+import type { SubAgentRegistration } from '../sub-agent-protocol.js';
+import type { LlmCompactionConfig } from '../openai/normalize-compaction-params.js';
+import { type LlmRecoveryPolicy } from '../llm-loop/llm-loop-types.js';
+import { type SharedLlmLoopChunk } from '../llm-loop/run-llm-loop.js';
+export type ReviewLoopChunk = SharedLlmLoopChunk | {
+    readonly kind: 'reminder';
+    readonly text: string;
+} | {
+    readonly kind: 'accept';
+    readonly notes: string;
+} | {
+    readonly kind: 'feedback';
+    readonly notes: string;
+};
+export declare const runPathChoiceToolLoop: (args: {
+    readonly factory: CreateChatCompletionStream;
+    readonly providerId: string;
+    readonly model: string;
+    readonly messages: readonly ChatCompletionMessage[];
+    readonly maxIterations: number;
+    readonly tools?: readonly ToolHandle[];
+    readonly harness?: Harness;
+    readonly toolCtx?: ToolHandlerContext;
+    readonly subagentRegistrations?: readonly SubAgentRegistration[];
+    readonly compaction?: LlmCompactionConfig;
+    readonly recovery?: LlmRecoveryPolicy;
+    readonly steerControl$?: Observable<SteerControlPayload>;
+    readonly waitForSubagentResult?: (callId: string, signal: AbortSignal) => Promise<string>;
+}) => Observable<ReviewLoopChunk>;