blun-king-cli 9.1.527 → 9.1.550

package/bin/structured-agent-swarm-output.cjs

@@ -0,0 +1,325 @@
+'use strict';
+
+const MAX_STRUCTURED_SWARM_OUTPUT_BYTES = 256 * 1024;
+const MAX_STRUCTURED_SWARM_FALLBACK_BYTES = 64 * 1024;
+const MAX_STRUCTURED_SWARM_RESULTS = 128;
+const MAX_PROFILE_BYTES = 64;
+const MAX_ERROR_CHARS = 512;
+const RESUME_HINT = 'Resume this agent through AgentSwarm.resume_agent_ids.';
+
+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 byteLength(value) {
+  return Buffer.byteLength(value, 'utf8');
+}
+
+function validBoundedString(value, maxBytes) {
+  return typeof value === 'string' && value.length > 0 && byteLength(value) <= maxBytes;
+}
+
+function safeUsage(value) {
+  if (!isPlainObject(value)) return null;
+  const keys = ['input', 'output', 'cache_read', 'cache_write'];
+  if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) return null;
+  if (!keys.every((key) => Number.isSafeInteger(value[key]) && value[key] >= 0)) return null;
+  return {
+    input: value.input,
+    output: value.output,
+    cache_read: value.cache_read,
+    cache_write: value.cache_write,
+  };
+}
+
+function boundedError(value) {
+  const text = String(value ?? 'unknown error').replace(/[\r\n\t]+/gu, ' ').trim();
+  return text.length > MAX_ERROR_CHARS ? `${text.slice(0, MAX_ERROR_CHARS - 3)}...` : text;
+}
+
+function parseStructuredChildEnvelope(raw, expected) {
+  if (typeof raw !== 'string') return { ok: false, error: 'child envelope is not a JSON string' };
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return { ok: false, error: 'child envelope is not exactly one JSON object' };
+  }
+  if (!isPlainObject(value)) return { ok: false, error: 'child envelope is not an object' };
+  const keys = ['agent_id', 'actual_subagent_type', 'status', 'response_format', 'result', 'usage'];
+  if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) {
+    return { ok: false, error: 'child envelope shape mismatch' };
+  }
+  if (value.agent_id !== expected.agentId) return { ok: false, error: 'agent_id mismatch' };
+  if (value.actual_subagent_type !== expected.profileName) return { ok: false, error: 'actual_subagent_type mismatch' };
+  if (!validBoundedString(value.actual_subagent_type, MAX_PROFILE_BYTES)) {
+    return { ok: false, error: 'actual_subagent_type exceeds 64 UTF-8 bytes' };
+  }
+  if (value.status !== 'completed') return { ok: false, error: 'child status mismatch' };
+  if (value.response_format !== expected.responseFormat.name) return { ok: false, error: 'response_format mismatch' };
+  const usage = safeUsage(value.usage);
+  if (usage === null) return { ok: false, error: 'child usage shape mismatch' };
+  try {
+    if (expected.responseFormat.validator(value.result) !== true) {
+      return { ok: false, error: 'child result failed response_format validation' };
+    }
+  } catch {
+    return { ok: false, error: 'child result validator failed closed' };
+  }
+  return {
+    ok: true,
+    value: {
+      agentId: value.agent_id,
+      profileName: value.actual_subagent_type,
+      result: value.result,
+      usage,
+    },
+  };
+}
+
+function baseEntry(input, outcome, profileName) {
+  const entry = {
+    index: input.spec.index,
+    mode: input.spec.kind,
+  };
+  if (input.spec.item !== undefined) entry.item = input.spec.item;
+  if (input.agentId !== undefined) entry.agent_id = input.agentId;
+  if (profileName !== undefined) entry.actual_subagent_type = profileName;
+  entry.outcome = outcome;
+  return entry;
+}
+
+function failureEntry(input, error, profileName) {
+  const entry = baseEntry(input, 'failed', profileName);
+  entry.error = `Structured swarm item failed: ${boundedError(error)}`;
+  if (input.agentId !== undefined) entry.resume_hint = RESUME_HINT;
+  return entry;
+}
+
+function normalizeResult(input, responseFormat) {
+  const profileName = validBoundedString(input.profileName, MAX_PROFILE_BYTES) ? input.profileName : undefined;
+  if (input.status !== 'completed') {
+    const outcome = input.status === 'aborted' ? 'aborted' : 'failed';
+    const entry = baseEntry(input, outcome, profileName);
+    entry.error = boundedError(input.error);
+    if (input.agentId !== undefined) entry.resume_hint = RESUME_HINT;
+    return entry;
+  }
+  if (profileName === undefined) return failureEntry(input, 'authoritative profile is unavailable or invalid');
+  const parsed = parseStructuredChildEnvelope(input.result, {
+    agentId: input.agentId,
+    profileName,
+    responseFormat,
+  });
+  if (!parsed.ok) return failureEntry(input, parsed.error, profileName);
+  const entry = baseEntry(input, 'completed', parsed.value.profileName);
+  entry.result = parsed.value.result;
+  entry.usage = parsed.value.usage;
+  return entry;
+}
+
+function summaryFor(results) {
+  return {
+    completed: results.filter((entry) => entry.outcome === 'completed').length,
+    failed: results.filter((entry) => entry.outcome === 'failed').length,
+    aborted: results.filter((entry) => entry.outcome === 'aborted').length,
+  };
+}
+
+function aggregateStatus(summary) {
+  if (summary.completed === summary.completed + summary.failed + summary.aborted) return 'completed';
+  if (summary.completed === 0) return 'failed';
+  return 'partial';
+}
+
+function metadataOnlyEntry(entry) {
+  const result = {
+    index: entry.index,
+    mode: entry.mode,
+  };
+  if (entry.agent_id !== undefined) result.agent_id = entry.agent_id;
+  if (entry.actual_subagent_type !== undefined) result.actual_subagent_type = entry.actual_subagent_type;
+  result.outcome = entry.outcome;
+  result.result_omitted = true;
+  return result;
+}
+
+function minimalOverflowEnvelope(responseFormat, summary) {
+  return {
+    status: 'failed',
+    error_code: 'structured_swarm_output_limit_exceeded',
+    response_format: responseFormat.name,
+    summary,
+    results_omitted: true,
+  };
+}
+
+function validateInputs(inputs) {
+  if (inputs.length === 0) throw new Error('structured swarm requires at least one result');
+  if (inputs.length > MAX_STRUCTURED_SWARM_RESULTS) {
+    throw new Error(`structured swarm supports at most ${String(MAX_STRUCTURED_SWARM_RESULTS)} results`);
+  }
+  const indexes = inputs.map((input) => input?.spec?.index);
+  const expected = Array.from({ length: inputs.length }, (_, index) => index + 1);
+  const ordered = [...indexes].sort((left, right) => left - right);
+  if (!ordered.every((value, index) => Number.isInteger(value) && value === expected[index])) {
+    throw new Error('structured swarm indexes must be unique contiguous integers starting at 1');
+  }
+  if (!inputs.every((input) => input.spec.kind === 'spawn' || input.spec.kind === 'resume')) {
+    throw new Error('structured swarm mode must be spawn or resume');
+  }
+}
+
+function renderStructuredSwarmResultsWithLimits(inputs, responseFormat, limits) {
+  if (!Array.isArray(inputs)) throw new TypeError('structured swarm results must be an array');
+  if (!responseFormat || typeof responseFormat.name !== 'string' || typeof responseFormat.validator !== 'function') {
+    throw new TypeError('prepared response format is required');
+  }
+  validateInputs(inputs);
+  const maxOutputBytes = limits?.maxOutputBytes ?? MAX_STRUCTURED_SWARM_OUTPUT_BYTES;
+  const maxFallbackBytes = limits?.maxFallbackBytes ?? MAX_STRUCTURED_SWARM_FALLBACK_BYTES;
+  const results = inputs.map((input) => normalizeResult(input, responseFormat)).sort((left, right) => left.index - right.index);
+  const summary = summaryFor(results);
+  const full = JSON.stringify({
+    status: aggregateStatus(summary),
+    response_format: responseFormat.name,
+    summary,
+    results,
+  });
+  if (byteLength(full) <= maxOutputBytes) return full;
+
+  const fallback = JSON.stringify({
+    status: 'failed',
+    error_code: 'structured_swarm_output_limit_exceeded',
+    response_format: responseFormat.name,
+    summary,
+    results: results.map(metadataOnlyEntry),
+  });
+  if (byteLength(fallback) <= maxFallbackBytes) return fallback;
+  return JSON.stringify(minimalOverflowEnvelope(responseFormat, summary));
+}
+
+function renderStructuredSwarmResults(inputs, responseFormat) {
+  return renderStructuredSwarmResultsWithLimits(inputs, responseFormat, undefined);
+}
+
+function safeSummary(value) {
+  if (!isPlainObject(value)) return null;
+  const keys = ['completed', 'failed', 'aborted'];
+  if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) return null;
+  if (!keys.every((key) => Number.isSafeInteger(value[key]) && value[key] >= 0)) return null;
+  return {
+    completed: value.completed,
+    failed: value.failed,
+    aborted: value.aborted,
+  };
+}
+
+function parseStructuredDisplayEntry(entry) {
+  if (!isPlainObject(entry)) return null;
+  if (!Number.isSafeInteger(entry.index) || entry.index < 1) return null;
+  if (entry.mode !== 'spawn' && entry.mode !== 'resume') return null;
+  if (entry.outcome !== 'completed' && entry.outcome !== 'failed' && entry.outcome !== 'aborted') return null;
+
+  const resultOmitted = entry.result_omitted === true;
+  if (Object.hasOwn(entry, 'result_omitted') && !resultOmitted) return null;
+  if (resultOmitted && (Object.hasOwn(entry, 'result') || Object.hasOwn(entry, 'error'))) return null;
+  if (!resultOmitted && entry.outcome === 'completed' && !Object.hasOwn(entry, 'result')) return null;
+  if (!resultOmitted && entry.outcome !== 'completed' && typeof entry.error !== 'string') return null;
+
+  return {
+    index: entry.index,
+    status: entry.outcome,
+    completedText: entry.outcome === 'completed' && !resultOmitted
+      ? JSON.stringify(entry.result)
+      : undefined,
+    failureText: entry.outcome !== 'completed' && !resultOmitted
+      ? boundedError(entry.error)
+      : undefined,
+  };
+}
+
+function parseStructuredSwarmDisplay(output) {
+  if (typeof output !== 'string') return { recognized: false };
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    return { recognized: false };
+  }
+  if (!isPlainObject(value)) return { recognized: false };
+  if (!validBoundedString(value.response_format, MAX_STRUCTURED_SWARM_FALLBACK_BYTES)) {
+    return { recognized: false };
+  }
+  if (value.status !== 'completed' && value.status !== 'partial' && value.status !== 'failed') {
+    return { recognized: false };
+  }
+
+  const summary = safeSummary(value.summary);
+  if (summary === null) return { recognized: false };
+  const summaryTotal = summary.completed + summary.failed + summary.aborted;
+  if (summaryTotal < 1 || summaryTotal > MAX_STRUCTURED_SWARM_RESULTS) return { recognized: false };
+  const overflow = value.error_code === 'structured_swarm_output_limit_exceeded';
+  if (Object.hasOwn(value, 'error_code') && !overflow) return { recognized: false };
+  if (overflow && value.status !== 'failed') return { recognized: false };
+
+  if (value.results_omitted === true) {
+    const allowedKeys = ['status', 'error_code', 'response_format', 'summary', 'results_omitted'];
+    if (!overflow || Object.hasOwn(value, 'results') || Object.keys(value).some((key) => !allowedKeys.includes(key))) {
+      return { recognized: false };
+    }
+    return {
+      recognized: true,
+      aggregateFailed: true,
+      summary,
+      statuses: [],
+    };
+  }
+
+  if (Object.hasOwn(value, 'results_omitted') || !Array.isArray(value.results)) return { recognized: false };
+  const allowedKeys = overflow
+    ? ['status', 'error_code', 'response_format', 'summary', 'results']
+    : ['status', 'response_format', 'summary', 'results'];
+  if (Object.keys(value).some((key) => !allowedKeys.includes(key))) return { recognized: false };
+  if (value.results.length === 0 || value.results.length > MAX_STRUCTURED_SWARM_RESULTS) return { recognized: false };
+
+  const statuses = value.results.map(parseStructuredDisplayEntry);
+  if (statuses.some((entry) => entry === null)) return { recognized: false };
+  statuses.sort((left, right) => left.index - right.index);
+  if (!statuses.every((entry, index) => entry.index === index + 1)) return { recognized: false };
+
+  const actualSummary = {
+    completed: statuses.filter((entry) => entry.status === 'completed').length,
+    failed: statuses.filter((entry) => entry.status === 'failed').length,
+    aborted: statuses.filter((entry) => entry.status === 'aborted').length,
+  };
+  if (!Object.keys(actualSummary).every((key) => actualSummary[key] === summary[key])) return { recognized: false };
+  if (!overflow && aggregateStatus(summary) !== value.status) return { recognized: false };
+  if (!overflow && value.results.some((entry) => entry.result_omitted === true)) return { recognized: false };
+  if (overflow && !value.results.every((entry) => entry.result_omitted === true)) return { recognized: false };
+
+  return {
+    recognized: true,
+    aggregateFailed: overflow,
+    summary,
+    statuses,
+  };
+}
+
+function structuredSwarmToolResult(output) {
+  const parsed = parseStructuredSwarmDisplay(output);
+  return parsed.recognized && parsed.aggregateFailed ? { output, isError: true } : { output };
+}
+
+module.exports = {
+  MAX_STRUCTURED_SWARM_OUTPUT_BYTES,
+  MAX_STRUCTURED_SWARM_FALLBACK_BYTES,
+  MAX_STRUCTURED_SWARM_RESULTS,
+  parseStructuredChildEnvelope,
+  parseStructuredSwarmDisplay,
+  renderStructuredSwarmResults,
+  renderStructuredSwarmResultsWithLimits,
+  structuredSwarmToolResult,
+};

package/bin/structured-subagent-output.cjs

@@ -0,0 +1,252 @@
+'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,
+};