@hearsay-tools/squawk 0.0.0-stage → 0.17.0-pr3058.5683

package/scripts/mock-claude-model-refusal.mjs

@@ -0,0 +1,76 @@
+// Native Claude stream-json fixtures, with independent per-input retry counts.
+const attempts = new Map();
+const model = 'claude-test-model';
+
+function initEvent(mode, selected) {
+  return { type: 'system', subtype: 'init', ...(mode === 'missing-session' ? {} : { session_id: mode === 'changed-session' ? 'other-session' : mode === 'empty-session' ? '' : 'model-refusal-session' }),
+    ...(mode === 'missing-model' ? {} : { model: mode === 'empty-model' ? '' : selected }) };
+}
+
+function completes(mode, count) {
+  return mode === 'seed' || mode === 'queued-seed' || (mode === 'once' && count > 1) || mode === 'later';
+}
+
+function completeStart(text, uuid, emit, replay) {
+  replay(uuid, text);
+  emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: `Completed ${text}` }] } });
+}
+
+function completeResult(text, uuid) {
+  return { type: 'result', subtype: 'success', result: `Completed ${text}`,
+    usage: { input_tokens: 10, output_tokens: 5 }, user_message_uuids: [uuid], queued_turn_count: 0 };
+}
+
+function refusalMessage(mode, selected) {
+  const refused = mode === 'wrong-model' ? 'claude-wrong-model' : selected;
+  let message = `There's an issue with the selected model (${refused}). It may not exist or you may not have access to it. Run --model to pick a different model.`;
+  if (mode === 'auth') message = 'Failed to authenticate. API Error: 401 OAuth access token has been revoked.';
+  if (mode === 'limit') message = 'API Error: Request rejected (429) · All credentials are cooling down. Please try again later.';
+  return message;
+}
+
+function refusalFrames(mode, emit, message) {
+  if (mode.startsWith('system-')) emit({ type: 'system', subtype: mode.slice(7).replaceAll('-', '_'), task_id: 'already-started' });
+  if (mode === 'tool-progress') emit({ type: 'tool_progress', tool_use_id: 'already-started', tool_name: 'Bash', elapsed_time_seconds: 1 });
+  if (mode === 'work') emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id: 'already-ran', name: 'Bash', input: { command: 'touch result' } }] } });
+  if (mode === 'prose') emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'I already changed the file.' }] } });
+  if (mode === 'assistant-usage') emit({ type: 'assistant', message: { role: 'assistant', content: [], usage: { input_tokens: 1, output_tokens: 0 } } });
+  // Both real diagnostic sources: the visible assistant frame and is_error result.
+  emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: message }] } });
+}
+
+function refusalUsage(mode) {
+  const usage = { input_tokens: mode === 'used' ? 1 : 0, output_tokens: 0,
+    service_tier: 'standard', cache_read_input_tokens: mode === 'cached' ? 1 : 0 };
+  if (mode === 'missing-count') delete usage.output_tokens;
+  if (mode === 'invalid-count') usage.input_tokens = -1;
+  return usage;
+}
+
+function refusalResult(mode, selected, message, uuid) {
+  return { type: 'result', subtype: 'success', is_error: true, result: message,
+    modelUsage: { [selected]: { inputTokens: mode === 'model-tokens' ? 1 : 0,
+      outputTokens: 0, costUSD: mode === 'model-cost' ? 0.01 : mode === 'model-invalid' ? null : 0,
+      contextWindow: 200000, maxOutputTokens: 64000 } },
+    ...(mode === 'missing-usage' ? {} : { usage: refusalUsage(mode) }),
+    ...(mode === 'paid' ? { total_cost_usd: 0.01 } : { total_cost_usd: 0 }),
+    user_message_uuids: [uuid], queued_turn_count: 0 };
+}
+
+export async function modelRefusalReply(text, uuid, emit, replay) {
+  const mode = text.split(':')[2];
+  const count = (attempts.get(text) ?? 0) + 1;
+  attempts.set(text, count);
+  const selected = mode === 'changed' ? 'claude-other-model' : model;
+  emit(initEvent(mode, selected));
+  if (completes(mode, count)) {
+    completeStart(text, uuid, emit, replay);
+    // Leave the final model call complete while another stdin line queues.
+    if (mode === 'queued-seed') await new Promise(resolve => setTimeout(resolve, 250));
+    emit(completeResult(text, uuid));
+    return;
+  }
+  const message = refusalMessage(mode, selected);
+  refusalFrames(mode, emit, message);
+  emit(refusalResult(mode, selected, message, uuid));
+}

package/scripts/mock-claude-subagents.mjs

@@ -0,0 +1,54 @@
+// `mock:subagent-background` (hearsay-tools/cezarion#2431, hearsay-tools/cezarion#1512): a
+// backgrounded native Agent that outlives the parent's turn. Frame shapes follow
+// src/core/__fixtures__/claude/background-agent.ndjson, reconstructed from a live CLI 2.1.303
+// transcript. Prompt tokens:
+// - `parity-release=<path>` (required): the child's end waits until this file exists;
+// - `subagents=<n>`: spawn n children, abg01…abg0n, whose notifications follow in order;
+// - `subagent-status=completed|failed|stopped`: each notification's status (default completed);
+// - `subagent-duplicate`: send each notification twice;
+// - `subagent-resume`: after the notifications, run an unprompted parent turn (system/init,
+//   parent text, result) with no stdin line; `subagent-resume-done` ends that turn with CEZ:DONE.
+// - `mock:monitoring` / `mock:done`: the parking turn's text ends with that marker.
+// The parking turn returns at once, so stdin lines written while the children run are answered.
+export async function replyWithBackgroundSubagents(userText, { emit, afterParityPark }) {
+  const count = Math.max(1, Number(/\bsubagents=(\d+)/.exec(userText)?.[1] ?? 1));
+  const status = /\bsubagent-status=(completed|failed|stopped)\b/.exec(userText)?.[1] ?? 'completed';
+  const children = Array.from({ length: count }, (_, index) => {
+    const n = String(index + 1).padStart(2, '0');
+    return { toolUseId: `toolu_bg_${n}`, taskId: `abg${n}` };
+  });
+  const parent = { parent_tool_use_id: null };
+  for (const { toolUseId, taskId } of children) {
+    const description = `Background research ${taskId}`;
+    emit({ type: 'assistant', ...parent, message: { role: 'assistant', content: [{ type: 'tool_use', id: toolUseId, name: 'Agent',
+      input: { description, prompt: 'Trace the park path and report.', subagent_type: 'general-purpose', run_in_background: true } }] } });
+    emit({ type: 'system', subtype: 'task_started', task_id: taskId, tool_use_id: toolUseId, description,
+      subagent_type: 'general-purpose', is_backgrounded: true, task_type: 'local_agent' });
+    emit({ type: 'user', ...parent, message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: toolUseId, content: [{ type: 'text',
+      text: `Async agent launched successfully.\nagentId: ${taskId}\nThe agent is working in the background. You will be notified automatically when it completes.` }] }] },
+      tool_use_result: { isAsync: true, status: 'async_launched', agentId: taskId, description, outputFile: `/tmp/tasks/${taskId}.output`, canReadOutputFile: true } });
+  }
+  const marker = userText.includes('mock:monitoring') ? '\n\nCEZ:MONITORING' : userText.includes('mock:done') ? '\n\nCEZ:DONE' : '';
+  const parked = `Started ${count === 1 ? 'a background agent' : `${count} background agents`}; I will continue when ${count === 1 ? 'it reports' : 'they report'}.${marker}`;
+  emit({ type: 'assistant', ...parent, message: { role: 'assistant', content: [{ type: 'text', text: parked }] } });
+  emit({ type: 'result', subtype: 'success', is_error: false, result: parked, usage: { input_tokens: 10, output_tokens: 5 } });
+  void (async () => {
+    await afterParityPark(userText);
+    for (const { toolUseId, taskId } of children) {
+      emit({ type: 'assistant', parent_tool_use_id: toolUseId, agent_id: taskId,
+        message: { role: 'assistant', content: [{ type: 'text', text: `Background child ${taskId} is working.` }] } });
+      const notification = { type: 'system', subtype: 'task_notification', task_id: taskId, tool_use_id: toolUseId, status,
+        output_file: `/tmp/tasks/${taskId}.output`, summary: `Agent "Background research ${taskId}" ${status === 'completed' ? 'finished' : status}` };
+      emit(notification);
+      if (userText.includes('subagent-duplicate')) emit(notification);
+    }
+    if (!userText.includes('subagent-resume')) return;
+    const resumed = `The background ${count === 1 ? 'agent' : 'agents'} reported ${status}.${userText.includes('subagent-resume-done') ? '\n\nCEZ:DONE' : ''}`;
+    emit({ type: 'system', subtype: 'init' });
+    emit({ type: 'assistant', ...parent, message: { role: 'assistant', content: [{ type: 'text', text: resumed }] } });
+    emit({ type: 'result', subtype: 'success', is_error: false, result: resumed, usage: { input_tokens: 10, output_tokens: 5 } });
+  })().catch((error) => {
+    process.stderr.write(`mock-claude-subagents: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}