blun-king-cli 9.1.536 → 9.1.561

package/scripts/programmatic-tool-runtime.test.mjs

@@ -1,365 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { createProgrammaticToolRuntime } from '../bin/programmatic-tool-runtime.mjs';
-
-test('runs deterministic transforms and returns bounded state', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [],
-    invokeTool: async () => assert.fail('no tool call expected'),
-  });
-
-  const outcome = await runtime.run({
-    code: 'state.total = [3, 1, 2].sort().reduce((a, b) => a + b, 0); return state.total;',
-    state: {},
-  });
-
-  assert.equal(outcome.result, 6);
-  assert.deepEqual(outcome.state, { total: 6 });
-  assert.equal(outcome.callCount, 0);
-});
-
-test('exposes only explicitly allowed tools through one host invocation boundary', async () => {
-  const calls = [];
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'lookup_record', alias: 'lookupRecord' }],
-    invokeTool: async (call) => {
-      calls.push(call);
-      return { id: call.args.id, label: `record-${call.args.id}` };
-    },
-  });
-
-  const outcome = await runtime.run({
-    code: 'return tools.lookupRecord({ id: 7 });',
-    state: {},
-  });
-
-  assert.deepEqual(outcome.result, { id: 7, label: 'record-7' });
-  assert.equal(calls.length, 1);
-  assert.equal(calls[0].name, 'lookup_record');
-  assert.deepEqual(calls[0].args, { id: 7 });
-  assert.match(calls[0].callId, /^ptc_lookup_record_/u);
-});
-
-test('does not expose host filesystem, network, process, clock, or dynamic eval', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [],
-    invokeTool: async () => assert.fail('no tool call expected'),
-  });
-
-  const outcome = await runtime.run({
-    code: `return {
-      process: typeof process,
-      require: typeof require,
-      fetch: typeof fetch,
-      date: typeof Date,
-      performance: typeof performance,
-      eval: typeof eval,
-      fn: typeof Function,
-    };`,
-    state: {},
-  });
-
-  assert.deepEqual(outcome.result, {
-    process: 'undefined',
-    require: 'undefined',
-    fetch: 'undefined',
-    date: 'undefined',
-    performance: 'undefined',
-    eval: 'undefined',
-    fn: 'undefined',
-  });
-});
-
-test('rejects unknown or invalid tool aliases before execution', () => {
-  assert.throws(
-    () => createProgrammaticToolRuntime({
-      allowedTools: [{ name: 'Read', alias: 'bad-alias' }],
-      invokeTool: async () => ({}),
-    }),
-    /valid JavaScript identifier/u,
-  );
-
-  assert.throws(
-    () => createProgrammaticToolRuntime({
-      allowedTools: [
-        { name: 'Read', alias: 'read' },
-        { name: 'OtherRead', alias: 'read' },
-      ],
-      invokeTool: async () => ({}),
-    }),
-    /duplicate tool alias/u,
-  );
-});
-
-test('fails closed when the program exceeds the tool-call limit', async () => {
-  let calls = 0;
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'counter', alias: 'counter' }],
-    invokeTool: async () => ++calls,
-    limits: { maxToolCalls: 2 },
-  });
-
-  await assert.rejects(
-    runtime.run({
-      code: 'tools.counter({}); tools.counter({}); tools.counter({}); return 3;',
-      state: {},
-    }),
-    /tool-call limit of 2/u,
-  );
-  assert.equal(calls, 2);
-});
-
-test('interrupts non-terminating code at the execution deadline', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [],
-    invokeTool: async () => assert.fail('no tool call expected'),
-    limits: { guestExecutionMs: 40, timeoutMs: 1_000 },
-  });
-
-  await assert.rejects(
-    runtime.run({ code: 'while (true) {}', state: {} }),
-    /execution deadline/u,
-  );
-});
-
-test('does not charge host waiting time against the guest execution budget', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'slow', alias: 'slow' }],
-    invokeTool: async ({ args }) => {
-      await new Promise((resolve) => setTimeout(resolve, 75));
-      return args.value;
-    },
-    limits: { guestExecutionMs: 30, timeoutMs: 250 },
-  });
-
-  const outcome = await runtime.run({
-    code: 'const value = tools.slow({ value: 8 }); return value + 1;',
-    state: {},
-  });
-
-  assert.equal(outcome.result, 9);
-});
-
-test('interrupts a pending host call at the wall deadline', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'wait', alias: 'wait' }],
-    invokeTool: async () => new Promise(() => {}),
-    limits: { guestExecutionMs: 1_000, timeoutMs: 40 },
-  });
-
-  await assert.rejects(
-    runtime.run({ code: 'return tools.wait({});', state: {} }),
-    /execution deadline exceeded/u,
-  );
-});
-
-test('rejects oversized result and state payloads', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [],
-    invokeTool: async () => assert.fail('no tool call expected'),
-    limits: { maxOutputChars: 32, maxStateChars: 32 },
-  });
-
-  await assert.rejects(
-    runtime.run({ code: 'return "x".repeat(100);', state: {} }),
-    /result exceeds 32 characters/u,
-  );
-  await assert.rejects(
-    runtime.run({ code: 'state.value = "x".repeat(100); return 1;', state: {} }),
-    /state exceeds 32 characters/u,
-  );
-});
-
-test('emits observable start, nested tool, and completion events', async () => {
-  const events = [];
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'echo', alias: 'echo' }],
-    invokeTool: async ({ args }) => args,
-    onEvent: (event) => events.push(event),
-  });
-
-  await runtime.run({ code: 'return tools.echo({ value: 9 });', state: {} });
-
-  assert.deepEqual(events.map((event) => event.type), [
-    'interpreter.started',
-    'interpreter.tool_call',
-    'interpreter.tool_result',
-    'interpreter.completed',
-  ]);
-  assert.equal(events[1].toolName, 'echo');
-  assert.equal(events[2].isError, false);
-});
-
-test('rejects a tool failure without hiding it from observability', async () => {
-  const events = [];
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'fail', alias: 'fail' }],
-    invokeTool: async () => {
-      throw new Error('approval denied');
-    },
-    onEvent: (event) => events.push(event),
-  });
-
-  await assert.rejects(
-    runtime.run({ code: 'return tools.fail({});', state: {} }),
-    /approval denied/u,
-  );
-  assert.deepEqual(events.map((event) => event.type), [
-    'interpreter.started',
-    'interpreter.tool_call',
-    'interpreter.tool_result',
-    'interpreter.failed',
-  ]);
-  assert.equal(events[2].isError, true);
-});
-
-test('preserves an external abort reason while cancelling a pending host call', async () => {
-  const controller = new AbortController();
-  let hostSignal;
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'wait', alias: 'wait' }],
-    invokeTool: ({ signal }) => {
-      hostSignal = signal;
-      return new Promise(() => {});
-    },
-    limits: { timeoutMs: 1_000 },
-  });
-
-  const running = runtime.run({
-    code: 'return tools.wait({});',
-    state: {},
-    signal: controller.signal,
-  });
-  setTimeout(() => controller.abort(new Error('operator cancelled')), 10);
-
-  await assert.rejects(running, /operator cancelled/u);
-  assert.equal(hostSignal.aborted, true);
-});
-
-test('rejects oversized and cyclic tool results at the host boundary', async () => {
-  const oversized = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'large', alias: 'large' }],
-    invokeTool: async () => ({ value: 'x'.repeat(100) }),
-    limits: { maxToolResultChars: 32 },
-  });
-  await assert.rejects(
-    oversized.run({ code: 'return tools.large({});', state: {} }),
-    /tool result exceeds 32 characters/u,
-  );
-
-  const cyclic = {};
-  cyclic.self = cyclic;
-  const nonJson = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'cyclic', alias: 'cyclic' }],
-    invokeTool: async () => cyclic,
-  });
-  await assert.rejects(
-    nonJson.run({ code: 'return tools.cyclic({});', state: {} }),
-    /tool cyclic result is not JSON serializable/u,
-  );
-});
-
-test('rejects oversized code, initial state, and tool arguments before crossing limits', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'echo', alias: 'echo' }],
-    invokeTool: async ({ args }) => args,
-    limits: {
-      maxCodeChars: 24,
-      maxStateChars: 24,
-      maxToolArgumentChars: 24,
-    },
-  });
-
-  await assert.rejects(
-    runtime.run({ code: 'return "0123456789012345678901234";', state: {} }),
-    /program exceeds 24 characters/u,
-  );
-  await assert.rejects(
-    runtime.run({ code: 'return 1;', state: { value: 'x'.repeat(30) } }),
-    /state exceeds 24 characters/u,
-  );
-  await assert.rejects(
-    runtime.run({ code: 'return tools.echo({value:"xxxxxxxxxxxxxxxxxxxxxxxx"});', state: {} }),
-    /program exceeds 24 characters/u,
-  );
-
-  const argumentRuntime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'echo', alias: 'echo' }],
-    invokeTool: async ({ args }) => args,
-    limits: { maxToolArgumentChars: 24 },
-  });
-  await assert.rejects(
-    argumentRuntime.run({ code: 'return tools.echo({ value: "x".repeat(30) });', state: {} }),
-    /tool arguments exceed 24 characters/u,
-  );
-});
-
-test('does not leave the private host bridge reachable from guest code', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'echo', alias: 'echo' }],
-    invokeTool: async ({ args }) => args,
-  });
-
-  const outcome = await runtime.run({
-    code: `return {
-      direct: typeof globalThis.__blun_ptc_0,
-      leakedKeys: Object.keys(globalThis).filter((key) => key.startsWith('__blun_ptc_')),
-      normalCall: tools.echo({ value: 4 }),
-    };`,
-    state: {},
-  });
-
-  assert.deepEqual(outcome.result, {
-    direct: 'undefined',
-    leakedKeys: [],
-    normalCall: { value: 4 },
-  });
-});
-
-test('continues only through an explicit JSON state snapshot', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [],
-    invokeTool: async () => assert.fail('no tool call expected'),
-  });
-
-  const first = await runtime.run({
-    code: 'state.count = (state.count ?? 0) + 1; return state.count;',
-    state: {},
-  });
-  const second = await runtime.run({
-    code: 'state.count += 1; return state.count;',
-    state: first.state,
-  });
-
-  assert.deepEqual(first, { result: 1, state: { count: 1 }, callCount: 0 });
-  assert.deepEqual(second, { result: 2, state: { count: 2 }, callCount: 0 });
-});
-
-test('enforces the guest memory ceiling', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [],
-    invokeTool: async () => assert.fail('no tool call expected'),
-    limits: { memoryBytes: 1024 * 1024, timeoutMs: 1_000 },
-  });
-
-  await assert.rejects(
-    runtime.run({ code: 'return "x".repeat(10_000_000);', state: {} }),
-    /memory|allocation|null/iu,
-  );
-});
-
-test('releases isolated contexts across repeated async tool runs', async () => {
-  const runtime = createProgrammaticToolRuntime({
-    allowedTools: [{ name: 'increment', alias: 'increment' }],
-    invokeTool: async ({ args }) => args.value + 1,
-  });
-
-  for (let index = 0; index < 20; index += 1) {
-    const outcome = await runtime.run({
-      code: `return tools.increment({ value: ${index} });`,
-      state: {},
-    });
-    assert.equal(outcome.result, index + 1);
-  }
-});

package/scripts/structured-subagent-output.test.cjs

@@ -1,170 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const test = require('node:test');
-const {
-  MAX_SCHEMA_BYTES,
-  MAX_SCHEMA_DEPTH,
-  MAX_SCHEMA_NODES,
-  prepareStructuredResponseFormat,
-  validateStructuredSubagentOutput,
-  buildStructuredResponseFormatReminder,
-  buildStructuredResponseRepairPrompt,
-  buildStructuredSubagentEnvelope,
-} = require('../bin/structured-subagent-output.cjs');
-
-const reviewFormat = {
-  name: 'review_result',
-  schema: {
-    type: 'object',
-    properties: {
-      status: { type: 'string', enum: ['pass', 'fail'] },
-      findings: { type: 'array', items: { type: 'string' }, maxItems: 20 },
-    },
-    required: ['status', 'findings'],
-    additionalProperties: false,
-  },
-};
-
-function compileReviewValidator(schema) {
-  assert.deepEqual(schema, reviewFormat.schema);
-  const validator = (value) => {
-    const errors = [];
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-      errors.push({ instancePath: '', message: 'must be object' });
-    } else {
-      for (const required of schema.required) {
-        if (!(required in value)) errors.push({ keyword: 'required', instancePath: '', params: { missingProperty: required } });
-      }
-      for (const key of Object.keys(value)) {
-        if (!(key in schema.properties)) errors.push({ keyword: 'additionalProperties', instancePath: '', params: { additionalProperty: key } });
-      }
-      if ('status' in value && !schema.properties.status.enum.includes(value.status)) {
-        errors.push({ instancePath: '/status', message: 'must be equal to one of the allowed values' });
-      }
-      if ('findings' in value && (!Array.isArray(value.findings) || value.findings.some((item) => typeof item !== 'string'))) {
-        errors.push({ instancePath: '/findings', message: 'must be an array of strings' });
-      }
-    }
-    validator.errors = errors;
-    return errors.length === 0;
-  };
-  validator.errors = [];
-  return validator;
-}
-
-test('valid output returns parsed object and deterministic envelope', () => {
-  const prepared = prepareStructuredResponseFormat(reviewFormat, compileReviewValidator);
-  const validation = validateStructuredSubagentOutput('{"status":"pass","findings":[]}', prepared);
-  assert.equal(validation.ok, true);
-  assert.deepEqual(validation.value, { status: 'pass', findings: [] });
-  assert.equal(buildStructuredSubagentEnvelope({
-    agentId: 'agent-1',
-    profileName: 'coder',
-    responseFormat: prepared,
-    result: validation.value,
-    usage: { inputOther: 7, output: 5, inputCacheRead: 3, inputCacheCreation: 2 },
-  }), '{"agent_id":"agent-1","actual_subagent_type":"coder","status":"completed","response_format":"review_result","result":{"status":"pass","findings":[]},"usage":{"input":7,"output":5,"cache_read":3,"cache_write":2}}');
-});
-
-test('invalid JSON, leading prose, and fenced JSON fail exact parsing', () => {
-  const prepared = prepareStructuredResponseFormat(reviewFormat, compileReviewValidator);
-  for (const text of [
-    '{bad',
-    'Here is the result: {"status":"pass","findings":[]}',
-    '```json\n{"status":"pass","findings":[]}\n```',
-  ]) {
-    const result = validateStructuredSubagentOutput(text, prepared);
-    assert.equal(result.ok, false);
-    assert.match(result.error, /not exactly one JSON value/u);
-  }
-});
-
-test('validator errors are concrete and bounded', () => {
-  const prepared = prepareStructuredResponseFormat(reviewFormat, compileReviewValidator);
-  const missing = validateStructuredSubagentOutput('{"status":"pass"}', prepared);
-  assert.equal(missing.ok, false);
-  assert.match(missing.error, /required property "findings"/u);
-  const extra = validateStructuredSubagentOutput('{"status":"pass","findings":[],"extra":1}', prepared);
-  assert.equal(extra.ok, false);
-  assert.match(extra.error, /additional property "extra"/u);
-});
-
-test('validator exceptions fail closed and remain distinguishable', () => {
-  const prepared = prepareStructuredResponseFormat(reviewFormat, () => () => {
-    throw new Error('compiler runtime exploded');
-  });
-  const result = validateStructuredSubagentOutput('{"status":"pass","findings":[]}', prepared);
-  assert.equal(result.ok, false);
-  assert.equal(result.validatorException, true);
-  assert.match(result.error, /validator exception/u);
-});
-
-test('reminder and repair prompt carry only the bounded schema contract', () => {
-  const prepared = prepareStructuredResponseFormat(reviewFormat, compileReviewValidator);
-  const reminder = buildStructuredResponseFormatReminder(prepared);
-  assert.match(reminder, /exactly one JSON object/u);
-  assert.match(reminder, /grants no additional capability/u);
-  assert.match(reminder, /review_result/u);
-  const repair = buildStructuredResponseRepairPrompt(prepared, 'missing findings');
-  assert.match(repair, /missing findings/u);
-  assert.match(repair, /nothing else/u);
-});
-
-test('malformed and unsupported schemas fail before compilation', () => {
-  let compileCalls = 0;
-  const compile = () => {
-    compileCalls += 1;
-    return () => true;
-  };
-  const rejected = [
-    { name: 'x', schema: { type: 'array', items: { type: 'string' } } },
-    { name: 'x', schema: { type: 'object', $ref: 'https://example.test/schema.json' } },
-    { name: 'x', schema: { type: 'object', properties: { value: { type: 'string', pattern: '.*' } } } },
-    { name: 'bad name', schema: { type: 'object' } },
-  ];
-  for (const responseFormat of rejected) {
-    assert.throws(() => prepareStructuredResponseFormat(responseFormat, compile));
-  }
-  assert.equal(compileCalls, 0);
-});
-
-test('oversized schema fails before compilation', () => {
-  const huge = {
-    name: 'huge',
-    schema: { type: 'object', description: 'x'.repeat(MAX_SCHEMA_BYTES) },
-  };
-  assert.throws(() => prepareStructuredResponseFormat(huge, () => assert.fail('must not compile')), /exceeds/u);
-});
-
-test('deep schema fails before compilation', () => {
-  let node = { type: 'string' };
-  for (let index = 0; index < MAX_SCHEMA_DEPTH; index += 1) {
-    node = { type: 'array', items: node };
-  }
-  assert.throws(() => prepareStructuredResponseFormat({
-    name: 'deep',
-    schema: { type: 'object', properties: { value: node } },
-  }, () => assert.fail('must not compile')), /maximum depth/u);
-});
-
-test('node-heavy schema fails before compilation', () => {
-  const properties = {};
-  for (let index = 0; index < MAX_SCHEMA_NODES; index += 1) properties[`p${index}`] = { type: 'string' };
-  assert.throws(() => prepareStructuredResponseFormat({
-    name: 'wide',
-    schema: { type: 'object', properties },
-  }, () => assert.fail('must not compile')), /maximum node count/u);
-});
-
-test('validator is compiled exactly once and schema is cloned', () => {
-  let compileCalls = 0;
-  const input = structuredClone(reviewFormat);
-  const prepared = prepareStructuredResponseFormat(input, (schema) => {
-    compileCalls += 1;
-    return compileReviewValidator(schema);
-  });
-  input.schema.properties.status.enum.push('later');
-  assert.equal(compileCalls, 1);
-  assert.deepEqual(prepared.schema.properties.status.enum, ['pass', 'fail']);
-});