blun-king-cli 9.1.586 → 9.1.588

package/bin/structured-subagent-output.cjs

@@ -1,252 +0,0 @@
-'use strict';
-
-const MAX_SCHEMA_BYTES = 16 * 1024;
-const MAX_OUTPUT_BYTES = 64 * 1024;
-const MAX_SCHEMA_DEPTH = 12;
-const MAX_SCHEMA_NODES = 128;
-const MAX_ERROR_BYTES = 2048;
-const STRUCTURED_SUBAGENT_OUTPUT_ERROR = 'Structured subagent output invalid after one repair attempt';
-
-const ALLOWED_SCHEMA_KEYS = new Set([
-  'type',
-  'properties',
-  'required',
-  'additionalProperties',
-  'items',
-  'enum',
-  'const',
-  'minimum',
-  'maximum',
-  'exclusiveMinimum',
-  'exclusiveMaximum',
-  'minLength',
-  'maxLength',
-  'minItems',
-  'maxItems',
-  'description',
-]);
-
-const ALLOWED_TYPES = new Set([
-  'object',
-  'array',
-  'string',
-  'number',
-  'integer',
-  'boolean',
-  'null',
-]);
-
-function isPlainObject(value) {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-
-function boundedText(value, maxBytes = MAX_ERROR_BYTES) {
-  const text = String(value);
-  const bytes = Buffer.from(text, 'utf8');
-  if (bytes.byteLength <= maxBytes) return text;
-  return `${bytes.subarray(0, Math.max(0, maxBytes - 3)).toString('utf8')}...`;
-}
-
-function assertFiniteNumber(value, path) {
-  if (typeof value !== 'number' || !Number.isFinite(value)) {
-    throw new Error(`${path} must be a finite number`);
-  }
-}
-
-function assertNonNegativeInteger(value, path) {
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error(`${path} must be a non-negative integer`);
-  }
-}
-
-function inspectSchemaNode(node, path, depth, state) {
-  if (!isPlainObject(node)) throw new Error(`${path} must be a JSON Schema object`);
-  if (depth > MAX_SCHEMA_DEPTH) {
-    throw new Error(`response_format.schema exceeds maximum depth ${MAX_SCHEMA_DEPTH}`);
-  }
-  state.nodes += 1;
-  if (state.nodes > MAX_SCHEMA_NODES) {
-    throw new Error(`response_format.schema exceeds maximum node count ${MAX_SCHEMA_NODES}`);
-  }
-
-  for (const key of Object.keys(node)) {
-    if (!ALLOWED_SCHEMA_KEYS.has(key)) {
-      throw new Error(`${path}.${key} is not supported in response_format.schema`);
-    }
-  }
-
-  if (node.type !== undefined && (!ALLOWED_TYPES.has(node.type) || typeof node.type !== 'string')) {
-    throw new Error(`${path}.type must be one supported scalar JSON Schema type`);
-  }
-  if (node.description !== undefined && typeof node.description !== 'string') {
-    throw new Error(`${path}.description must be a string`);
-  }
-  if (node.properties !== undefined) {
-    if (!isPlainObject(node.properties)) throw new Error(`${path}.properties must be an object`);
-    for (const [name, child] of Object.entries(node.properties)) {
-      inspectSchemaNode(child, `${path}.properties[${JSON.stringify(name)}]`, depth + 1, state);
-    }
-  }
-  if (node.required !== undefined) {
-    if (!Array.isArray(node.required) || node.required.some((item) => typeof item !== 'string')) {
-      throw new Error(`${path}.required must be an array of property names`);
-    }
-    if (new Set(node.required).size !== node.required.length) {
-      throw new Error(`${path}.required must not contain duplicate property names`);
-    }
-    if (node.required.some((name) => !isPlainObject(node.properties) || !(name in node.properties))) {
-      throw new Error(`${path}.required may reference only declared properties`);
-    }
-  }
-  if (node.additionalProperties !== undefined && typeof node.additionalProperties !== 'boolean') {
-    throw new Error(`${path}.additionalProperties must be a boolean`);
-  }
-  if (node.items !== undefined) {
-    inspectSchemaNode(node.items, `${path}.items`, depth + 1, state);
-  }
-  if (node.enum !== undefined && (!Array.isArray(node.enum) || node.enum.length === 0)) {
-    throw new Error(`${path}.enum must be a non-empty array`);
-  }
-  for (const key of ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum']) {
-    if (node[key] !== undefined) assertFiniteNumber(node[key], `${path}.${key}`);
-  }
-  for (const key of ['minLength', 'maxLength', 'minItems', 'maxItems']) {
-    if (node[key] !== undefined) assertNonNegativeInteger(node[key], `${path}.${key}`);
-  }
-}
-
-function prepareStructuredResponseFormat(responseFormat, compileValidator) {
-  if (responseFormat === undefined) return undefined;
-  if (!isPlainObject(responseFormat)) throw new Error('response_format must be an object');
-  const keys = Object.keys(responseFormat);
-  if (keys.some((key) => key !== 'name' && key !== 'schema')) {
-    throw new Error('response_format accepts only name and schema');
-  }
-  if (typeof responseFormat.name !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/u.test(responseFormat.name)) {
-    throw new Error('response_format.name must start with a letter and contain at most 64 letters, digits, underscores, or hyphens');
-  }
-  if (!isPlainObject(responseFormat.schema) || responseFormat.schema.type !== 'object') {
-    throw new Error('response_format.schema root must have type "object"');
-  }
-
-  let serializedSchema;
-  try {
-    serializedSchema = JSON.stringify(responseFormat.schema);
-  } catch (error) {
-    throw new Error(`response_format.schema must be JSON-serializable: ${boundedText(error)}`);
-  }
-  if (Buffer.byteLength(serializedSchema, 'utf8') > MAX_SCHEMA_BYTES) {
-    throw new Error(`response_format.schema exceeds ${MAX_SCHEMA_BYTES} bytes`);
-  }
-  const schema = JSON.parse(serializedSchema);
-  inspectSchemaNode(schema, 'response_format.schema', 1, { nodes: 0 });
-  if (typeof compileValidator !== 'function') throw new Error('response_format validator compiler is unavailable');
-
-  let validator;
-  try {
-    validator = compileValidator(schema);
-  } catch (error) {
-    throw new Error(`response_format.schema could not be compiled: ${boundedText(error)}`);
-  }
-  if (typeof validator !== 'function') throw new Error('response_format validator compiler returned no validator');
-  return Object.freeze({
-    name: responseFormat.name,
-    schema: Object.freeze(schema),
-    serializedSchema,
-    validator,
-  });
-}
-
-function formatValidatorErrors(errors) {
-  if (!Array.isArray(errors) || errors.length === 0) return 'value does not match response_format.schema';
-  return boundedText(errors.map((error) => {
-    const path = typeof error?.instancePath === 'string' && error.instancePath.length > 0
-      ? error.instancePath
-      : '$';
-    if (error?.keyword === 'required' && typeof error?.params?.missingProperty === 'string') {
-      return `${path} must have required property ${JSON.stringify(error.params.missingProperty)}`;
-    }
-    if (error?.keyword === 'additionalProperties' && typeof error?.params?.additionalProperty === 'string') {
-      return `${path} must not have additional property ${JSON.stringify(error.params.additionalProperty)}`;
-    }
-    return `${path} ${error?.message || 'is invalid'}`;
-  }).join('; '));
-}
-
-function validateStructuredSubagentOutput(text, prepared) {
-  if (typeof text !== 'string') return { ok: false, error: 'final response is not text' };
-  if (Buffer.byteLength(text, 'utf8') > MAX_OUTPUT_BYTES) {
-    return { ok: false, error: `final response exceeds ${MAX_OUTPUT_BYTES} bytes` };
-  }
-  let value;
-  try {
-    value = JSON.parse(text);
-  } catch (error) {
-    return { ok: false, error: `final response is not exactly one JSON value: ${boundedText(error)}` };
-  }
-  try {
-    if (!prepared.validator(value)) {
-      return { ok: false, error: formatValidatorErrors(prepared.validator.errors) };
-    }
-  } catch (error) {
-    return {
-      ok: false,
-      validatorException: true,
-      error: `response_format validator exception: ${boundedText(error)}`,
-    };
-  }
-  return { ok: true, value };
-}
-
-function buildStructuredResponseFormatReminder(prepared) {
-  return [
-    `Your final assistant message for this run must be exactly one JSON object matching response format ${JSON.stringify(prepared.name)}.`,
-    'Do not wrap it in Markdown, a code fence, XML, or explanatory prose.',
-    'Tool use and intermediate work remain unchanged. This schema grants no additional capability.',
-    `JSON Schema: ${prepared.serializedSchema}`,
-  ].join('\n');
-}
-
-function buildStructuredResponseRepairPrompt(prepared, error) {
-  return [
-    'Your previous final response did not satisfy the required response format.',
-    `Validation error: ${boundedText(error)}`,
-    `Return exactly one corrected JSON object for ${JSON.stringify(prepared.name)} and nothing else.`,
-    `JSON Schema: ${prepared.serializedSchema}`,
-  ].join('\n');
-}
-
-function safeTokenCount(value) {
-  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
-}
-
-function buildStructuredSubagentEnvelope({ agentId, profileName, responseFormat, result, usage }) {
-  return JSON.stringify({
-    agent_id: agentId,
-    actual_subagent_type: profileName,
-    status: 'completed',
-    response_format: responseFormat.name,
-    result,
-    usage: {
-      input: safeTokenCount(usage?.inputOther),
-      output: safeTokenCount(usage?.output),
-      cache_read: safeTokenCount(usage?.inputCacheRead),
-      cache_write: safeTokenCount(usage?.inputCacheCreation),
-    },
-  });
-}
-
-module.exports = {
-  MAX_SCHEMA_BYTES,
-  MAX_OUTPUT_BYTES,
-  MAX_SCHEMA_DEPTH,
-  MAX_SCHEMA_NODES,
-  STRUCTURED_SUBAGENT_OUTPUT_ERROR,
-  prepareStructuredResponseFormat,
-  validateStructuredSubagentOutput,
-  buildStructuredResponseFormatReminder,
-  buildStructuredResponseRepairPrompt,
-  buildStructuredSubagentEnvelope,
-};

package/bin/subagent-context-fork-policy.cjs

@@ -1,155 +0,0 @@
-'use strict';
-
-const DEFAULT_MAX_MESSAGES = 16;
-const DEFAULT_MAX_CHARS = 64 * 1024;
-const MAX_CONFIGURED_MESSAGES = 64;
-const MAX_CONFIGURED_CHARS = 256 * 1024;
-
-const SUBAGENT_FORK_REMINDER = [
-  'You received a bounded, redacted projection of the parent conversation.',
-  'It contains only direct local user text and completed text-only assistant replies.',
-  'It excludes system injections, private channel messages, attachments, tool calls, tool arguments, and tool results.',
-  'Treat that history as already happened. Your actual delegated task below is authoritative.',
-  'Do not launch another context fork. Return the requested result to the parent agent.',
-].join(' ');
-
-function boundedPositiveInteger(value, fallback, maximum, name) {
-  if (value === undefined) return fallback;
-  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
-    throw new TypeError(`${name} must be an integer between 1 and ${String(maximum)}`);
-  }
-  return value;
-}
-
-function resolveSubagentContextMode(options = {}) {
-  const requested = options.requested ?? 'isolated';
-  if (requested !== 'isolated' && requested !== 'fork') {
-    throw new TypeError('context_mode must be either "isolated" or "fork"');
-  }
-  if (requested === 'isolated') return requested;
-  if (options.resume === true) {
-    throw new Error('context_mode="fork" is available only when creating a new subagent, not while resuming one');
-  }
-  if (options.isRoot !== true) {
-    throw new Error('context_mode="fork" is available only to the root agent');
-  }
-  return requested;
-}
-
-function redactSecrets(value) {
-  return String(value)
-    .replaceAll(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/giu, '[redacted]')
-    .replaceAll(/\b(authorization)\s*:\s*(?:basic|bearer)\s+\S+/giu, '$1: [redacted]')
-    .replaceAll(/\b(api[_ -]?(?:key|token)|access[_ -]?token|refresh[_ -]?token|id[_ -]?token|token|secret|password|passwd|pwd|credential)\b\s*([:=])\s*(?:"[^"]*"|'[^']*'|\S+)/giu, '$1$2[redacted]')
-    .replaceAll(/\b(?:sk|ghp|xoxb|xoxp|token)[-_][A-Za-z0-9_-]{16,}\b/gu, '[redacted]')
-    .replaceAll(/\b[A-Za-z0-9][A-Za-z0-9+/=_-]{39,}\b/gu, '[redacted]');
-}
-
-function textContent(message) {
-  if (!Array.isArray(message?.content)) return '';
-  return message.content
-    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-    .map((part) => part.text)
-    .join('\n')
-    .trim();
-}
-
-function eligibleMessage(message) {
-  if (message?.role === 'user') {
-    if (message.origin?.kind !== 'user') return undefined;
-  } else if (message?.role === 'assistant') {
-    if (message.origin !== undefined) return undefined;
-    if (!Array.isArray(message.toolCalls) || message.toolCalls.length > 0) return undefined;
-  } else {
-    return undefined;
-  }
-  const text = textContent(message);
-  if (text.length === 0) return undefined;
-  return { role: message.role, text: redactSecrets(text) };
-}
-
-function modelMessage(role, text) {
-  return {
-    role,
-    content: [{ type: 'text', text }],
-    toolCalls: [],
-  };
-}
-
-function mergeAdjacent(messages) {
-  const merged = [];
-  for (const message of messages) {
-    const previous = merged.at(-1);
-    if (previous?.role === message.role) {
-      previous.content[0].text += `\n\n${message.content[0].text}`;
-    } else {
-      merged.push(modelMessage(message.role, message.content[0].text));
-    }
-  }
-  while (merged[0]?.role === 'assistant') merged.shift();
-  return merged;
-}
-
-function emptyProjection() {
-  return {
-    messages: [],
-    sourceMessageCount: 0,
-    sourceChars: 0,
-    truncatedOlderContext: false,
-  };
-}
-
-function projectSubagentForkContext(history, options = {}) {
-  if (!Array.isArray(history)) throw new TypeError('history must be an array');
-  const maxMessages = boundedPositiveInteger(
-    options.maxMessages,
-    DEFAULT_MAX_MESSAGES,
-    MAX_CONFIGURED_MESSAGES,
-    'maxMessages',
-  );
-  const maxChars = boundedPositiveInteger(
-    options.maxChars,
-    DEFAULT_MAX_CHARS,
-    MAX_CONFIGURED_CHARS,
-    'maxChars',
-  );
-  const eligible = history.map(eligibleMessage).filter((message) => message !== undefined);
-  const newestUserIndex = eligible.findLastIndex((message) => message.role === 'user');
-  if (newestUserIndex < 0) return emptyProjection();
-  const throughCurrentUser = eligible.slice(0, newestUserIndex + 1);
-  const newestUser = throughCurrentUser.at(-1);
-  if (newestUser.text.length > maxChars) {
-    throw new Error(`newest direct user message exceeds the ${String(maxChars)}-character fork context limit`);
-  }
-
-  const selected = [];
-  let sourceChars = 0;
-  let truncatedOlderContext = false;
-  for (let index = throughCurrentUser.length - 1; index >= 0; index -= 1) {
-    const message = throughCurrentUser[index];
-    if (selected.length >= maxMessages || sourceChars + message.text.length > maxChars) {
-      truncatedOlderContext = true;
-      break;
-    }
-    selected.push(modelMessage(message.role, message.text));
-    sourceChars += message.text.length;
-  }
-  selected.reverse();
-  const messages = mergeAdjacent(selected);
-  const retainedMessageCount = selected.length - selected.findIndex((message) => message.role === 'user');
-  return {
-    messages,
-    sourceMessageCount: retainedMessageCount,
-    sourceChars: messages.reduce((total, message) => total + message.content[0].text.replaceAll('\n\n', '').length, 0),
-    truncatedOlderContext,
-  };
-}
-
-module.exports = {
-  DEFAULT_MAX_CHARS,
-  DEFAULT_MAX_MESSAGES,
-  SUBAGENT_FORK_REMINDER,
-  projectSubagentForkContext,
-  redactSecrets,
-  resolveSubagentContextMode,
-};

package/bin/subagent-max-tokens-handoff-policy.cjs

@@ -1,69 +0,0 @@
-"use strict";
-
-const MAX_SUBAGENT_HANDOFF_ATTEMPTS = 1;
-const MAX_PARTIAL_HANDOFF_CHARS = 6000;
-const SUBAGENT_MAX_TOKENS_ERROR =
-  "Subagent turn failed before completing its final summary: reason=max_tokens";
-const SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT = [
-  "Your previous turn reached max_tokens before its final handoff.",
-  "Do not call any tools and do not repeat completed work.",
-  "Return one concise recovery handoff of at most 1200 words with:",
-  "1. completed work and concrete findings",
-  "2. exact files changed or created",
-  "3. checks already run and their actual results",
-  "4. unfinished work or blockers",
-  "5. the exact next action for the parent or this same agent",
-  "State clearly that the task is incomplete when anything remains.",
-].join("\n");
-
-function shouldRequestSubagentHandoff(stopReason, attempts) {
-  return stopReason === "max_tokens"
-    && Number.isSafeInteger(attempts)
-    && attempts >= 0
-    && attempts < MAX_SUBAGENT_HANDOFF_ATTEMPTS;
-}
-
-function isSubagentMaxTokensTurnError(error) {
-  if (typeof error !== "object" || error === null) return false;
-  const details = typeof error.details === "object" && error.details !== null
-    ? error.details
-    : {};
-  if (details.emptyResponseKind === "length") return true;
-  if (details.finishReason === "truncated" || details.rawFinishReason === "length") return true;
-
-  const message = typeof error.message === "string" ? error.message : "";
-  return /\bmax[_ -]?tokens?\b/iu.test(message)
-    && /(?:\bno\b|\bwithout\b|did not produce)[^\n.]*\btool(?: call)?\b/iu.test(message);
-}
-
-function boundedPartialHandoff(partialSummary) {
-  const normalized = typeof partialSummary === "string" ? partialSummary.trim() : "";
-  if (normalized.length <= MAX_PARTIAL_HANDOFF_CHARS) return normalized;
-  return `${normalized.slice(0, MAX_PARTIAL_HANDOFF_CHARS)}\n[partial handoff truncated]`;
-}
-
-function buildSubagentMaxTokensFailure(partialSummary) {
-  const partial = boundedPartialHandoff(partialSummary);
-  const lines = [
-    `${SUBAGENT_MAX_TOKENS_ERROR}.`,
-    "The automatic concise handoff also reached max_tokens.",
-  ];
-  if (partial.length > 0) {
-    lines.push("", "[partial_handoff]", partial, "[/partial_handoff]");
-  }
-  lines.push(
-    "",
-    "Resume the same subagent instead of starting the task again; its context and completed tool work are preserved.",
-  );
-  return lines.join("\n");
-}
-
-module.exports = {
-  MAX_PARTIAL_HANDOFF_CHARS,
-  MAX_SUBAGENT_HANDOFF_ATTEMPTS,
-  SUBAGENT_MAX_TOKENS_ERROR,
-  SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT,
-  buildSubagentMaxTokensFailure,
-  isSubagentMaxTokensTurnError,
-  shouldRequestSubagentHandoff,
-};

package/bin/subagent-parent-responsiveness.cjs

@@ -1,19 +0,0 @@
-'use strict';
-
-function resolveSubagentRunMode({ allowBackground, requested }) {
-  if (allowBackground !== true) {
-    return {
-      runInBackground: false,
-      forcedForParentResponsiveness: false,
-    };
-  }
-
-  return {
-    runInBackground: true,
-    forcedForParentResponsiveness: requested !== true,
-  };
-}
-
-module.exports = {
-  resolveSubagentRunMode,
-};