@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/reasoning-stop.js

@@ -0,0 +1,292 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+import { armReasoningStopState } from './reasoning-stop-state.js';
+const FLOW_ID = 'reasoning_stop_flow';
+const TOOL_NAME = 'reasoning.stop';
+const VALID_STOP_REASONS = new Set(['completed', 'blocked', 'user_input', 'simple_question', 'plan_mode']);
+function parseToolArguments(toolCall) {
+    if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(toolCall.arguments);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function readText(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const trimmed = value.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return '';
+}
+function readBool(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value === true) {
+            return true;
+        }
+        if (value === false) {
+            return false;
+        }
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true') {
+            return true;
+        }
+        if (normalized === 'false') {
+            return false;
+        }
+    }
+    return undefined;
+}
+function readStopReason(record, keys) {
+    const raw = readText(record, keys).toLowerCase();
+    if (!raw) {
+        return undefined;
+    }
+    return VALID_STOP_REASONS.has(raw) ? raw : undefined;
+}
+function normalizeReasoningStopPayload(args) {
+    const taskGoal = readText(args, ['task_goal', 'taskGoal', 'goal']);
+    if (!taskGoal) {
+        return {
+            ok: false,
+            code: 'TASK_GOAL_REQUIRED',
+            message: 'reasoning.stop requires task_goal.'
+        };
+    }
+    const completed = readBool(args, ['is_completed', 'isCompleted', 'completed']);
+    if (typeof completed !== 'boolean') {
+        return {
+            ok: false,
+            code: 'IS_COMPLETED_REQUIRED',
+            message: 'reasoning.stop requires is_completed(boolean).'
+        };
+    }
+    const stopReason = readStopReason(args, ['stop_reason', 'stopReason', 'reason_type', 'reasonType']);
+    const completionEvidence = readText(args, [
+        'completion_evidence',
+        'completionEvidence',
+        'evidence'
+    ]);
+    const cannotCompleteReason = readText(args, [
+        'cannot_complete_reason',
+        'cannotCompleteReason',
+        'reason'
+    ]);
+    const blockingEvidence = readText(args, [
+        'blocking_evidence',
+        'blockingEvidence',
+        'block_evidence'
+    ]);
+    const attemptsExhausted = readBool(args, [
+        'attempts_exhausted',
+        'attemptsExhausted',
+        'all_attempts_exhausted',
+        'allAttemptsExhausted'
+    ]);
+    const nextStep = readText(args, [
+        'next_step',
+        'nextStep',
+        'next_steps',
+        'nextSteps',
+        'plan_next_step',
+        'next_plan'
+    ]);
+    const userInputRequired = readBool(args, [
+        'user_input_required',
+        'userInputRequired'
+    ]);
+    const userQuestion = readText(args, [
+        'user_question',
+        'userQuestion',
+        'question_for_user',
+        'questionForUser'
+    ]);
+    const learning = readText(args, [
+        'learning',
+        'experience',
+        'insight',
+        'lesson',
+        'lesson_learned'
+    ]);
+    if (completed && !completionEvidence) {
+        return {
+            ok: false,
+            code: 'COMPLETION_EVIDENCE_REQUIRED',
+            message: 'reasoning.stop requires completion_evidence when is_completed=true.'
+        };
+    }
+    if (completed && userInputRequired === true) {
+        return {
+            ok: false,
+            code: 'USER_INPUT_CONFLICT_WITH_COMPLETED',
+            message: 'reasoning.stop cannot set user_input_required=true when is_completed=true.'
+        };
+    }
+    if (!completed && userInputRequired === true) {
+        if (!cannotCompleteReason) {
+            return {
+                ok: false,
+                code: 'CANNOT_COMPLETE_REASON_REQUIRED_FOR_USER_INPUT',
+                message: 'reasoning.stop requires cannot_complete_reason when user_input_required=true.'
+            };
+        }
+        if (!userQuestion) {
+            return {
+                ok: false,
+                code: 'USER_QUESTION_REQUIRED',
+                message: 'reasoning.stop requires user_question when user_input_required=true.'
+            };
+        }
+    }
+    if (!completed && userInputRequired !== true && !cannotCompleteReason && !nextStep) {
+        return {
+            ok: false,
+            code: 'NEXT_STEP_OR_CANNOT_COMPLETE_REQUIRED',
+            message: 'reasoning.stop requires next_step or cannot_complete_reason when is_completed=false.'
+        };
+    }
+    if (!completed && cannotCompleteReason && !nextStep && attemptsExhausted !== true) {
+        return {
+            ok: false,
+            code: 'ATTEMPTS_EXHAUSTED_REQUIRED',
+            message: 'reasoning.stop requires attempts_exhausted=true when stopping with cannot_complete_reason.'
+        };
+    }
+    if (!completed && cannotCompleteReason && !nextStep && !blockingEvidence) {
+        return {
+            ok: false,
+            code: 'BLOCKING_EVIDENCE_REQUIRED',
+            message: 'reasoning.stop requires blocking_evidence when stopping with cannot_complete_reason.'
+        };
+    }
+    return {
+        ok: true,
+        payload: {
+            taskGoal,
+            completed,
+            ...(stopReason ? { stopReason } : {}),
+            completionEvidence,
+            cannotCompleteReason,
+            blockingEvidence,
+            ...(typeof attemptsExhausted === 'boolean' ? { attemptsExhausted } : {}),
+            nextStep,
+            ...(typeof userInputRequired === 'boolean' ? { userInputRequired } : {}),
+            userQuestion,
+            ...(learning ? { learning } : {})
+        }
+    };
+}
+function buildSummary(payload) {
+    const lines = [
+        `用户任务目标: ${payload.taskGoal}`,
+        `是否完成: ${payload.completed ? '是' : '否'}`
+    ];
+    if (payload.stopReason) {
+        lines.push(`停止原因: ${payload.stopReason}`);
+    }
+    if (payload.completed) {
+        lines.push(`完成证据: ${payload.completionEvidence}`);
+    }
+    else {
+        if (typeof payload.userInputRequired === 'boolean') {
+            lines.push(`需用户参与: ${payload.userInputRequired ? '是' : '否'}`);
+        }
+        if (payload.userQuestion) {
+            lines.push(`用户问题: ${payload.userQuestion}`);
+        }
+        if (payload.cannotCompleteReason) {
+            if (typeof payload.attemptsExhausted === 'boolean') {
+                lines.push(`已穷尽可行尝试: ${payload.attemptsExhausted ? '是' : '否'}`);
+            }
+            lines.push(`无法完成原因: ${payload.cannotCompleteReason}`);
+            if (payload.blockingEvidence) {
+                lines.push(`阻塞证据: ${payload.blockingEvidence}`);
+            }
+        }
+        if (payload.nextStep) {
+            lines.push(`下一步: ${payload.nextStep}`);
+        }
+    }
+    if (payload.learning) {
+        lines.push(`经验沉淀: ${payload.learning}`);
+    }
+    if (typeof payload.isSimpleQuestion === 'boolean') {
+        lines.push(`是否简单问题: ${payload.isSimpleQuestion ? '是' : '否'}`);
+    }
+    return lines.join('\n');
+}
+function appendToolOutput(base, toolCall, content) {
+    const cloned = cloneJson(base);
+    const existingOutputs = Array.isArray(cloned.tool_outputs)
+        ? cloned.tool_outputs
+        : [];
+    let payloadText = '';
+    try {
+        payloadText = JSON.stringify(content);
+    }
+    catch {
+        payloadText = String(content ?? '');
+    }
+    cloned.tool_outputs = [
+        ...existingOutputs,
+        {
+            tool_call_id: toolCall.id,
+            name: TOOL_NAME,
+            content: payloadText
+        }
+    ];
+    return cloned;
+}
+const handler = async (ctx) => {
+    const toolCall = ctx.toolCall;
+    if (!toolCall || toolCall.name !== TOOL_NAME) {
+        return null;
+    }
+    const parsed = parseToolArguments(toolCall);
+    const normalized = normalizeReasoningStopPayload(parsed);
+    if (normalized.ok === false) {
+        return {
+            flowId: FLOW_ID,
+            finalize: async () => ({
+                chatResponse: appendToolOutput(ctx.base, toolCall, {
+                    ok: false,
+                    code: normalized.code,
+                    message: normalized.message
+                }),
+                execution: {
+                    flowId: FLOW_ID
+                }
+            })
+        };
+    }
+    const summary = buildSummary(normalized.payload);
+    const armed = armReasoningStopState(ctx.adapterContext, summary);
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: appendToolOutput(ctx.base, toolCall, {
+                ok: true,
+                armed,
+                summary
+            }),
+            execution: {
+                flowId: FLOW_ID
+            }
+        })
+    };
+};
+registerServerToolHandler(TOOL_NAME, handler);

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/stop-message-auto/{iflow-followup.d.ts → ai-followup.d.ts}

@@ -5,7 +5,7 @@ export interface StopMessageAutoResponseSnapshot {
     reasoningText?: string;
     responseExcerpt?: string;
 }
-type StopMessageAutoMessageBackend = 'iflow' | 'codex';
+type StopMessageAutoMessageBackend = 'codex';
 export type StopMessageAiFollowupHistoryEntry = {
     ts?: number;
     round?: number;
@@ -33,13 +33,13 @@ type StopMessageAiFollowupArgs = {
 };
 export declare function renderStopMessageAutoFollowupViaAi(args: StopMessageAiFollowupArgs): string | null;
 export declare function renderStopMessageAutoFollowupViaAiAsync(args: StopMessageAiFollowupArgs): Promise<string | null>;
-export declare function renderStopMessageAutoFollowupViaIflow(args: StopMessageAiFollowupArgs): string | null;
+export declare function renderStopMessageAutoFollowupViaAiFollowup(args: StopMessageAiFollowupArgs): string | null;
 export declare function extractStopMessageAutoResponseSnapshot(base: unknown, adapterContext: unknown): StopMessageAutoResponseSnapshot;
 export declare function extractResponsesOutputText(base: {
     [key: string]: unknown;
 }): string;
 export declare function hasToolLikeOutput(value: unknown): boolean;
-export declare function buildStopMessageAutoMessageIflowPromptForTests(args: StopMessageAiFollowupArgs, backend?: StopMessageAutoMessageBackend): string;
+export declare function buildStopMessageAutoMessagePromptForTests(args: StopMessageAiFollowupArgs, backend?: StopMessageAutoMessageBackend): string;
 export declare function resolveStopMessageAiDoneMarker(value?: string): string;
 export declare function resolveStopMessageAiApprovedMarker(value?: string): string;
 export {};