blun-king-cli 9.1.526 → 9.1.536

package/scripts/check-structured-subagent-output-regression.js

@@ -0,0 +1,331 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const root = join(__dirname, '..');
+const bundlePath = join(root, 'blun.mjs');
+
+function extractBetween(source, startNeedle, endNeedle) {
+  const start = source.indexOf(startNeedle);
+  assert.notEqual(start, -1, `missing source start: ${startNeedle}`);
+  const end = source.indexOf(endNeedle, start + startNeedle.length);
+  assert.notEqual(end, -1, `missing source end: ${endNeedle}`);
+  return source.slice(start, end);
+}
+
+function assertBundleContract(source) {
+  assert.match(source, /response_format: object\(\{/u, 'Agent input must expose response_format');
+  assert.match(
+    source,
+    /prepareStructuredResponseFormat\(args\.response_format, compileToolArgsValidator\)/u,
+    'response_format must reuse BLUN AJV compilation',
+  );
+  const preparationIndex = source.indexOf('prepareStructuredResponseFormat(args.response_format, compileToolArgsValidator)');
+  const launchIndex = source.indexOf('await this.subagentHost.spawn({', preparationIndex);
+  assert.ok(preparationIndex >= 0 && launchIndex > preparationIndex, 'schema compilation must precede child creation');
+  assert.match(source, /response_format is supported for foreground Agent runs only/u, 'structured background runs must be rejected');
+  assert.match(
+    source,
+    /const runInBackground = responseFormat === void 0 \? resolvedRunMode\.runInBackground : false/u,
+    'structured output must select a foreground run',
+  );
+  assert.match(
+    source,
+    /appendSystemReminder\(buildStructuredResponseFormatReminder\(options\.responseFormat\)/u,
+    'the schema reminder must remain child-local',
+  );
+  assert.match(
+    source,
+    /completeStructuredSubagentResult\(child, childId, profileName, options\.responseFormat, options\.signal\)/u,
+    'structured completion must validate before returning',
+  );
+  assert.match(
+    source,
+    /buildStructuredResponseRepairPrompt\(responseFormat, validation\.error\)[\s\S]{0,500}completeChildTurnWithMaxTokensHandoff\(child, signal\)/u,
+    'one repair turn must use the normal child completion path',
+  );
+  assert.match(
+    source,
+    /signal\.throwIfAborted\(\);[\s\S]{0,180}buildStructuredResponseRepairPrompt/u,
+    'cancellation must be checked before repair',
+  );
+  assert.match(source, /responseFormat: this\.responseFormat/u, 'timeout continuation must preserve the response format');
+  assert.match(
+    source,
+    /responseFormat === void 0 \? formatForegroundAgentSuccess\(handle, output\) : output/u,
+    'validated structured output must not be wrapped in free-form text',
+  );
+  assert.match(
+    source,
+    /message\.includes\(STRUCTURED_SUBAGENT_OUTPUT_ERROR\)/u,
+    'a second invalid response must preserve the resume hint',
+  );
+  const swarmRegion = extractBetween(
+    source,
+    '//#region ../../packages/agent-core/src/tools/builtin/collaboration/agent-swarm.ts',
+    '//#region ../../packages/agent-core/src/tools/builtin/collaboration/ask-user.md?raw',
+  );
+  assert.doesNotMatch(swarmRegion, /response_format/u, 'AgentSwarm must not silently accept response_format');
+}
+
+function buildAgentToolClass(source) {
+  const assignment = extractBetween(source, 'AgentTool = class {', '\n\t};\n\tUSER_INTERRUPTED_SUBAGENT_MESSAGE');
+  const classSource = `${assignment.slice('AgentTool = '.length)}\n\t}`;
+  return Function(
+    'AgentToolInputSchema',
+    'toInputJsonSchema',
+    'buildSubagentDescriptions',
+    'agent_default',
+    'agent_background_enabled_default',
+    'agent_background_disabled_default',
+    'resolveSubagentRunMode',
+    'ToolAccesses',
+    'matchesGlobRuleSubject',
+    'prepareStructuredResponseFormat',
+    'compileToolArgsValidator',
+    'BACKGROUND_AGENT_UNAVAILABLE',
+    'formatForegroundAgentSuccess',
+    'formatForegroundAgentFailure',
+    'USER_INTERRUPTED_SUBAGENT_MESSAGE',
+    'launchErrorMessage',
+    `"use strict"; return (${classSource});`,
+  )(
+    {},
+    () => ({}),
+    () => '',
+    'agent',
+    'background enabled',
+    'background disabled',
+    ({ allowBackground }) => ({ runInBackground: allowBackground === true }),
+    { none: () => ({}) },
+    () => true,
+    require('../bin/structured-subagent-output.cjs').prepareStructuredResponseFormat,
+    () => () => true,
+    'background unavailable',
+    (handle, result) => [
+      `agent_id: ${handle.agentId}`,
+      `actual_subagent_type: ${handle.profileName}`,
+      'status: completed',
+      '',
+      '[summary]',
+      result,
+    ].join('\n'),
+    () => 'failed',
+    'interrupted',
+    (error) => String(error),
+  );
+}
+
+async function exerciseBundledAgentTool(source) {
+  const AgentTool = buildAgentToolClass(source);
+  const backgroundManager = {
+    getTask: () => ({ status: 'completed' }),
+    readOutput: async () => 'free text',
+  };
+  const tool = new AgentTool({}, backgroundManager, {}, { allowBackground: true });
+  const unstructured = await tool.resolveExecution({ prompt: 'x', description: 'free' });
+  assert.equal(unstructured.display.background, true);
+  const structuredArgs = {
+    prompt: 'x',
+    description: 'structured',
+    response_format: { name: 'answer', schema: { type: 'object' } },
+  };
+  const structured = await tool.resolveExecution(structuredArgs);
+  assert.equal(structured.display.background, false);
+
+  const handle = { agentId: 'agent-1', profileName: 'coder' };
+  assert.equal(
+    (await tool.formatForegroundResult('task-1', handle, undefined)).output,
+    'agent_id: agent-1\nactual_subagent_type: coder\nstatus: completed\n\n[summary]\nfree text',
+    'free-form output must remain byte-compatible',
+  );
+  backgroundManager.readOutput = async () => '{"status":"completed"}';
+  assert.equal(
+    (await tool.formatForegroundResult('task-2', handle, {})).output,
+    '{"status":"completed"}',
+    'structured output must remain canonical JSON without a text wrapper',
+  );
+
+  let spawned = false;
+  tool.subagentHost = { spawn: async () => { spawned = true; throw new Error('must not spawn'); } };
+  const invalid = await tool.execution({
+    ...structuredArgs,
+    response_format: { name: 'answer', schema: { type: 'array' } },
+  }, { toolCallId: 'call-1', signal: new AbortController().signal });
+  assert.equal(invalid.isError, true);
+  assert.match(invalid.output, /Invalid response_format/u);
+  assert.equal(spawned, false, 'invalid schema must fail before child creation');
+
+  const background = await tool.execution({ ...structuredArgs, run_in_background: true }, {
+    toolCallId: 'call-2',
+    signal: new AbortController().signal,
+  });
+  assert.equal(background.isError, true);
+  assert.match(background.output, /foreground Agent runs only/u);
+  assert.equal(spawned, false);
+}
+
+async function exerciseBundledRepairFlow(source) {
+  const functionSource = extractBetween(
+    source,
+    'async function completeStructuredSubagentResult(',
+    'function shouldSuppressQueuedAttemptFailureEvent(',
+  );
+  const runtime = require('../bin/structured-subagent-output.cjs');
+  let currentText = '';
+  let completionCalls = 0;
+  const completeStructuredSubagentResult = Function(
+    'validateStructuredSubagentOutput',
+    'buildStructuredResponseRepairPrompt',
+    'SUBAGENT_PROMPT_ORIGIN',
+    'completeChildTurnWithMaxTokensHandoff',
+    'lastAssistantText',
+    'STRUCTURED_SUBAGENT_OUTPUT_ERROR',
+    `"use strict"; ${functionSource}; return completeStructuredSubagentResult;`,
+  )(
+    runtime.validateStructuredSubagentOutput,
+    runtime.buildStructuredResponseRepairPrompt,
+    { kind: 'system_trigger', name: 'subagent' },
+    async () => { completionCalls += 1; },
+    () => currentText,
+    runtime.STRUCTURED_SUBAGENT_OUTPUT_ERROR,
+  );
+
+  const prepared = runtime.prepareStructuredResponseFormat({
+    name: 'answer',
+    schema: {
+      type: 'object',
+      properties: { value: { type: 'string' } },
+      required: ['value'],
+      additionalProperties: false,
+    },
+  }, () => {
+    const validator = (value) => {
+      const ok = value !== null && typeof value === 'object' && !Array.isArray(value)
+        && typeof value.value === 'string' && Object.keys(value).length === 1;
+      validator.errors = ok ? [] : [{ keyword: 'required', instancePath: '', params: { missingProperty: 'value' } }];
+      return ok;
+    };
+    return validator;
+  });
+
+  const prompts = [];
+  const child = { turn: { prompt: (parts) => {
+    prompts.push(parts[0].text);
+    currentText = '{"value":"repaired"}';
+    return 'turn-2';
+  } } };
+  currentText = '{"wrong":true}';
+  const repaired = await completeStructuredSubagentResult(
+    child,
+    'agent-2',
+    'coder',
+    prepared,
+    new AbortController().signal,
+  );
+  assert.deepEqual(repaired, { value: 'repaired' });
+  assert.equal(prompts.length, 1);
+  assert.equal(completionCalls, 1);
+
+  currentText = '{"wrong":true}';
+  child.turn.prompt = (parts) => {
+    prompts.push(parts[0].text);
+    currentText = '{"still_wrong":true}';
+    return 'turn-3';
+  };
+  await assert.rejects(
+    completeStructuredSubagentResult(child, 'agent-3', 'coder', prepared, new AbortController().signal),
+    /Structured subagent output invalid after one repair attempt[\s\S]*Resume with Agent/u,
+  );
+
+  const controller = new AbortController();
+  controller.abort(new Error('cancelled'));
+  currentText = '{"wrong":true}';
+  const promptCountBeforeCancel = prompts.length;
+  await assert.rejects(
+    completeStructuredSubagentResult(child, 'agent-4', 'coder', prepared, controller.signal),
+    /cancelled/u,
+  );
+  assert.equal(prompts.length, promptCountBeforeCancel, 'cancellation must prevent the repair turn');
+}
+
+function exerciseBundledStructuredFailure(source) {
+  const functionSource = extractBetween(
+    source,
+    'function formatForegroundAgentFailure(',
+    'function launchErrorMessage(',
+  );
+  const runtime = require('../bin/structured-subagent-output.cjs');
+  const formatForegroundAgentFailure = Function(
+    'SUBAGENT_MAX_TOKENS_ERROR',
+    'STRUCTURED_SUBAGENT_OUTPUT_ERROR',
+    `"use strict"; ${functionSource}; return formatForegroundAgentFailure;`,
+  )('SUBAGENT_MAX_TOKENS', runtime.STRUCTURED_SUBAGENT_OUTPUT_ERROR);
+  const output = formatForegroundAgentFailure(
+    { agentId: 'agent-failed', profileName: 'coder' },
+    `${runtime.STRUCTURED_SUBAGENT_OUTPUT_ERROR}: missing value`,
+    false,
+  );
+  assert.match(output, /agent_id: agent-failed/u);
+  assert.match(output, /actual_subagent_type: coder/u);
+  assert.match(output, /missing value/u);
+  assert.match(output, /resume_hint: Continue with Agent\(resume="agent-failed"/u);
+}
+
+async function main() {
+  const suite = spawnSync(process.execPath, ['--test', join(__dirname, 'structured-subagent-output.test.cjs')], {
+    stdio: 'inherit',
+  });
+  assert.equal(suite.status, 0, 'structured subagent helper tests must pass');
+  const source = readFileSync(bundlePath, 'utf8');
+  assertBundleContract(source);
+  await exerciseBundledAgentTool(source);
+  await exerciseBundledRepairFlow(source);
+  exerciseBundledStructuredFailure(source);
+
+  assert.throws(
+    () => assertBundleContract(source.replace(
+      'prepareStructuredResponseFormat(args.response_format, compileToolArgsValidator)',
+      'prepareStructuredResponseFormat(args.response_format, () => () => true)',
+    )),
+    /reuse BLUN AJV/u,
+  );
+  assert.throws(
+    () => assertBundleContract(source.replace(
+      'const runInBackground = responseFormat === void 0 ? resolvedRunMode.runInBackground : false',
+      'const runInBackground = resolvedRunMode.runInBackground',
+    )),
+    /foreground run/u,
+  );
+  assert.throws(
+    () => {
+      const region = extractBetween(
+        source,
+        'async function completeStructuredSubagentResult(',
+        'function shouldSuppressQueuedAttemptFailureEvent(',
+      );
+      const mutatedRegion = region.replace(
+        /\t\tsignal\.throwIfAborted\(\);\r?\n(?=\t\tif \(child\.turn\.prompt)/u,
+        '',
+      );
+      assertBundleContract(source.replace(region, mutatedRegion));
+    },
+    /cancellation/u,
+  );
+  assert.throws(
+    () => assertBundleContract(source.replace(
+      'responseFormat === void 0 ? formatForegroundAgentSuccess(handle, output) : output',
+      'formatForegroundAgentSuccess(handle, output)',
+    )),
+    /free-form text/u,
+  );
+  process.stdout.write('structured subagent output regression: ok\n');
+}
+
+main().catch((error) => {
+  console.error(error.stack || error);
+  process.exitCode = 1;
+});

package/scripts/check-telegram-direct-work-resume-regression.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const packageRoot = path.resolve(process.env.BLUN_PACKAGE_ROOT || path.join(__dirname, '..'));
+const {
+  createDirectReplyTurnStop,
+  directMessageAllowsWorkContinuation,
+  directMessageStartsOrResumesWork,
+  directTelegramPayloadText,
+} = require(path.join(packageRoot, 'bin', 'telegram-direct-focus-policy.cjs'));
+
+const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
+const direct = (payload) => [
+  'A private Telegram DM has priority over background, group, and loop work.',
+  '<channel priority="direct" source="telegram" chat_id="1605241602">',
+  payload,
+  '</channel>',
+].join('\n');
+
+const status = direct('Wie weit bist du?');
+assert.equal(directTelegramPayloadText(status), 'Wie weit bist du?');
+assert.equal(directMessageAllowsWorkContinuation(status), true);
+assert.equal(directMessageStartsOrResumesWork(status), false);
+const statusStop = createDirectReplyTurnStop(status);
+assert.equal(statusStop.noteToolResult('mcp__plugin-telegram_telegram__reply', false), true);
+assert.equal(statusStop.shouldStop(), true, 'standalone DM chat should stop after its reply');
+
+for (const payload of [
+  'Auftrag: Lies die SPEC und baue die Datei.',
+  'Feuer frei',
+  'Bitte weiterarbeiten und danach melden.',
+]) {
+  const input = direct(payload);
+  assert.equal(directMessageAllowsWorkContinuation(input), true, payload);
+  assert.equal(directMessageStartsOrResumesWork(input), true, payload);
+  const stop = createDirectReplyTurnStop(input);
+  stop.noteToolResult('mcp__plugin-telegram_telegram__reply', false);
+  assert.equal(stop.shouldStop(), false, `work DM must continue after reply: ${payload}`);
+}
+
+const pause = direct('Bitte stop, warte auf mein Zeichen.');
+assert.equal(directMessageAllowsWorkContinuation(pause), false);
+assert.equal(directMessageStartsOrResumesWork(pause), false);
+
+assert.match(bundle, /let directSteerContinuationPending = false;/u);
+assert.match(bundle, /pendingSteers\.some\(\(steer\) => directMessageAllowsWorkContinuation/u);
+assert.match(bundle, /name: "telegram_direct_work_resume"/u);
+assert.match(bundle, /perform the next unfinished action now\./u);
+
+console.log('telegram-direct-work-resume-regression PASS');