@pi-unipi/background-tasks 2.6.1

package/src/__tests__/scripted-provider/fusion-reason.test.ts

@@ -0,0 +1,310 @@
+import { afterEach, describe, it, type TestContext } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+  type AgentSession,
+} from '@earendil-works/pi-coding-agent';
+import { parseJsonText } from '../../types.js';
+import { installFusionFakePi } from '../helpers/fusion-fake-pi.js';
+import { isolatedTestEnv } from '../helpers/normalize.js';
+
+const backgroundTasksExtensionPath = resolve('extensions/background-tasks.ts');
+const scriptedProviderPath = resolve('tests/scripted-provider/scripted-provider-extension.ts');
+const roots: string[] = [];
+const savedEnv = new Map<string, string | undefined>();
+const envKeys = [
+  'PATH',
+  'PI_CODING_AGENT_DIR',
+  'UNIPI_BG_SCRIPTED_SCENARIO',
+  'UNIPI_BG_SCRIPTED_EVENTS',
+  'UNIPI_BG_SCRIPTED_API_KEY',
+] as const;
+
+type JsonRecord = Record<string, unknown>;
+
+interface ProviderEvent extends JsonRecord {
+  callCount?: number;
+  summaries?: string[];
+}
+
+interface Harness {
+  session: AgentSession;
+  eventsPath: string;
+  fakeLogPath: string;
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function rememberEnv(): void {
+  if (savedEnv.size > 0) return;
+  for (const key of envKeys) savedEnv.set(key, process.env[key]);
+}
+
+function restoreEnvValue(key: string, value: string | undefined): void {
+  if (value === undefined) {
+    Reflect.deleteProperty(process.env, key);
+    return;
+  }
+  process.env[key] = value;
+}
+
+function restoreEnv(): void {
+  for (const key of envKeys) restoreEnvValue(key, savedEnv.get(key));
+  savedEnv.clear();
+}
+
+function stringArray(value: unknown): string[] {
+  assert.ok(Array.isArray(value), 'value must be an array');
+  return value.map((entry) => {
+    if (typeof entry !== 'string') throw new Error('entry must be a string');
+    return entry;
+  });
+}
+
+function parseProviderEvent(line: string): ProviderEvent {
+  const parsed = parseJsonText(line);
+  assert.ok(isRecord(parsed), 'provider event must be an object');
+  const event: ProviderEvent = { ...parsed };
+  if (parsed['summaries'] !== undefined) event.summaries = stringArray(parsed['summaries']);
+  if (typeof parsed['callCount'] === 'number') event.callCount = parsed['callCount'];
+  return event;
+}
+
+async function providerEvents(path: string): Promise<ProviderEvent[]> {
+  if (!existsSync(path)) return [];
+  const raw = await readFile(path, 'utf8');
+  return raw.trim() ? raw.trim().split('\n').map(parseProviderEvent) : [];
+}
+
+async function fakeCallCount(path: string): Promise<number> {
+  if (!existsSync(path)) return 0;
+  const raw = await readFile(path, 'utf8');
+  return raw.trim() ? raw.trim().split('\n').length : 0;
+}
+
+async function fakeStages(path: string): Promise<string[]> {
+  if (!existsSync(path)) return [];
+  const raw = await readFile(path, 'utf8');
+  if (!raw.trim()) return [];
+  return raw
+    .trim()
+    .split('\n')
+    .map((line) => {
+      const parsed = parseJsonText(line);
+      assert.ok(isRecord(parsed), 'fake invocation must be an object');
+      const stage = parsed['stage'];
+      if (typeof stage !== 'string') throw new Error('fake invocation stage must be a string');
+      return stage;
+    });
+}
+
+function assistantTexts(session: AgentSession): string[] {
+  return session.sessionManager.getEntries().flatMap((entry) => {
+    if (!isRecord(entry) || !isRecord(entry['message']) || entry['message']['role'] !== 'assistant')
+      return [];
+    const content = entry['message']['content'];
+    if (!Array.isArray(content)) return [];
+    return content.flatMap((part) =>
+      isRecord(part) && part['type'] === 'text' && typeof part['text'] === 'string'
+        ? [part['text']]
+        : [],
+    );
+  });
+}
+
+function toolResults(session: AgentSession, toolName: string): JsonRecord[] {
+  return session.sessionManager.getEntries().flatMap((entry) => {
+    if (!isRecord(entry) || !isRecord(entry['message'])) return [];
+    const message = entry['message'];
+    if (message['role'] === 'toolResult' && message['toolName'] === toolName) return [message];
+    return [];
+  });
+}
+
+async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  label: string,
+  timeoutMs = 8000,
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error(`Timed out waiting for ${label}`);
+}
+
+async function harness(): Promise<Harness> {
+  rememberEnv();
+  const root = await mkdtemp(join(tmpdir(), 'pi-bg-fusion-scripted-'));
+  roots.push(root);
+  const cwd = join(root, 'project');
+  const agentDir = join(root, 'agent');
+  const eventsPath = join(root, 'provider-events.jsonl');
+  await mkdir(cwd, { recursive: true });
+  await mkdir(agentDir, { recursive: true });
+  const fake = await installFusionFakePi(root, {
+    mergedText: 'Scripted fused answer.',
+    invalidFirstEvaluation: true,
+  });
+  Object.assign(process.env, isolatedTestEnv, {
+    PATH: fake.env['PATH'],
+    PI_CODING_AGENT_DIR: agentDir,
+    UNIPI_BG_SCRIPTED_SCENARIO: 'fusion-reason',
+    UNIPI_BG_SCRIPTED_EVENTS: eventsPath,
+    UNIPI_BG_SCRIPTED_API_KEY: 'scripted-api-key',
+    NPM_CONFIG_CACHE: join(tmpdir(), 'pi-npm-cache'),
+  });
+  const settingsManager = SettingsManager.inMemory({
+    defaultProvider: 'pi-bg-scripted',
+    defaultModel: 'scripted-model',
+  });
+  const loader = new DefaultResourceLoader({
+    cwd,
+    agentDir,
+    settingsManager,
+    additionalExtensionPaths: [scriptedProviderPath, backgroundTasksExtensionPath],
+    noExtensions: true,
+    noSkills: true,
+    noPromptTemplates: true,
+    noContextFiles: true,
+    noThemes: true,
+  });
+  await loader.reload();
+  const authStorage = AuthStorage.create(join(agentDir, 'auth.json'));
+  const modelRegistry = ModelRegistry.create(authStorage);
+  const { session } = await createAgentSession({
+    cwd,
+    agentDir,
+    resourceLoader: loader,
+    sessionManager: SessionManager.inMemory(cwd),
+    settingsManager,
+    authStorage,
+    modelRegistry,
+    noTools: 'builtin',
+  });
+  const model = modelRegistry.find('pi-bg-scripted', 'scripted-model');
+  assert.ok(model, 'scripted model should be registered');
+  await session.setModel(model);
+  await session.extensionRunner.emit({ type: 'session_start', reason: 'startup' });
+  return { session, eventsPath, fakeLogPath: fake.logPath };
+}
+
+async function disposeHarness(h: Harness): Promise<void> {
+  try {
+    await h.session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' });
+  } finally {
+    h.session.dispose();
+  }
+}
+
+afterEach(async () => {
+  for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
+  restoreEnv();
+});
+
+void describe('scripted provider fusion_reason integration', { concurrency: false }, () => {
+  void it(
+    'lets the parent launch Fusion, avoid polling, and consume the verified bg_result after wake',
+    { timeout: 15_000 },
+    async (t: TestContext) => {
+      // This case intercepts the Pi child by placing a fake `pi` on PATH. That
+      // cannot work on win32, where production deliberately resolves the Pi
+      // package and launches it through Node rather than consulting PATH, and
+      // the extension layer exposes no launch seam to redirect it. The same
+      // constraint host-gates the equivalent cases in tests/sdk/fusion-sdk.test.ts.
+      // Fusion orchestration itself stays covered on Windows by the injected
+      // childRunner cases in tests/unit/fusion-orchestrator.test.ts.
+      if (process.platform === 'win32') {
+        t.skip(
+          'fake Pi PATH interception is not applicable on win32 because production resolves the Pi package instead of PATH by design',
+        );
+        return;
+      }
+      const h = await harness();
+      try {
+        await h.session.prompt('Use fusion for this scripted task.');
+        await waitFor(
+          async () => (await providerEvents(h.eventsPath)).length >= 4,
+          'fourth parent provider call after background completion and retrieval',
+          15_000,
+        );
+        await h.session.agent.waitForIdle();
+        assert.equal(await fakeCallCount(h.fakeLogPath), 6);
+        assert.deepEqual(
+          (await fakeStages(h.fakeLogPath)).sort(),
+          [
+            'candidate',
+            'candidate',
+            'candidate',
+            'evaluation',
+            'evaluation-repair',
+            'merge',
+          ].sort(),
+        );
+
+        const events = await providerEvents(h.eventsPath);
+        assert.equal(events.length, 4);
+        assert.match((events[0]?.summaries ?? []).join('\n'), /user:Use fusion/);
+        assert.match(
+          (events[1]?.summaries ?? []).join('\n'),
+          /toolResult:fusion_reason:Started fusion reason in the background/,
+        );
+        assert.doesNotMatch(
+          (events[1]?.summaries ?? []).join('\n'),
+          /toolResult:bg_status|toolResult:bg_logs/,
+        );
+        assert.match(
+          (events[2]?.summaries ?? []).join('\n'),
+          /background-task-notification|<task-id>reason-/,
+        );
+        assert.match(
+          (events[3]?.summaries ?? []).join('\n'),
+          /toolResult:bg_result:.*Scripted fused answer/s,
+        );
+        assert.ok(
+          assistantTexts(h.session).some((text) =>
+            text.includes('Parent observed verified Fusion result'),
+          ),
+        );
+
+        const launchResults = toolResults(h.session, 'fusion_reason');
+        assert.equal(launchResults.length, 1);
+        const launchResult = launchResults[0];
+        assert.ok(launchResult, 'Fusion launch result should be persisted');
+        const launchDetails = launchResult['details'];
+        assert.ok(isRecord(launchDetails));
+        assert.equal(launchDetails['schema_version'], 'pi-background-tasks.fusion-launch.v1');
+        assert.equal(Reflect.get(launchResult, 'usage'), undefined);
+
+        const retrievedResults = toolResults(h.session, 'bg_result');
+        assert.equal(retrievedResults.length, 1);
+        const retrieved = retrievedResults[0];
+        assert.ok(retrieved);
+        const content = retrieved['content'];
+        assert.ok(Array.isArray(content));
+        assert.match(
+          String(isRecord(content[0]) ? content[0]['text'] : ''),
+          /Scripted fused answer/,
+        );
+        const details = retrieved['details'];
+        assert.ok(isRecord(details));
+        assert.equal(details['schema_version'], 'pi-background-tasks.fusion-result-view.v1');
+        assert.equal(isRecord(details) ? details['usage_delivered'] : undefined, true);
+      } finally {
+        await disposeHarness(h);
+      }
+    },
+  );
+});

package/src/__tests__/scripted-provider/fusion-runtime-guard.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer, type Server } from 'node:http';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import {
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+} from '@earendil-works/pi-coding-agent';
+import { isolatedTestEnv } from '../helpers/normalize.js';
+import { RUNTIME_GUARD_MODEL, RUNTIME_GUARD_PROVIDER } from './runtime-guard-provider.js';
+
+const providerPath = resolve('tests/scripted-provider/runtime-guard-provider.ts');
+const governorPath = resolve('tests/scripted-provider/runtime-guard-probe.ts');
+const roots: string[] = [];
+const servers: Server[] = [];
+
+function restoreEnvValue(key: string, value: string | undefined): void {
+  if (value === undefined) delete process.env[key];
+  else process.env[key] = value;
+}
+
+async function listen(server: Server): Promise<number> {
+  await new Promise<void>((resolveListen, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', reject);
+      resolveListen();
+    });
+  });
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  return address.port;
+}
+
+async function close(server: Server): Promise<void> {
+  await new Promise<void>((resolveClose, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolveClose();
+    });
+  });
+}
+
+afterEach(async () => {
+  for (const server of servers.splice(0)) await close(server);
+  for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
+});
+
+void describe('Fusion final provider-request guard contract', { concurrency: false }, () => {
+  void it(
+    'observes the final transformed payload and aborts before network transport',
+    { timeout: 20_000 },
+    async () => {
+      let httpRequests = 0;
+      const server = createServer((_request, response) => {
+        httpRequests += 1;
+        response.writeHead(500, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ error: { message: 'the guard failed to block transport' } }));
+      });
+      servers.push(server);
+      const port = await listen(server);
+
+      const root = await mkdtemp(join(tmpdir(), 'pi-bg-fusion-runtime-guard-'));
+      roots.push(root);
+      const cwd = join(root, 'project');
+      const agentDir = join(root, 'agent');
+      const logPath = join(root, 'guard.jsonl');
+      await mkdir(cwd, { recursive: true });
+      await mkdir(agentDir, { recursive: true });
+      await writeFile(logPath, '', 'utf8');
+
+      const previous = {
+        baseUrl: process.env['UNIPI_BG_RUNTIME_GUARD_BASE_URL'],
+        log: process.env['UNIPI_BG_RUNTIME_GUARD_LOG'],
+        apiKey: process.env['UNIPI_BG_RUNTIME_GUARD_API_KEY'],
+      };
+      const codexToken = [
+        Buffer.from('{}', 'utf8').toString('base64url'),
+        Buffer.from(
+          JSON.stringify({
+            'https://api.openai.com/auth': { chatgpt_account_id: 'runtime-guard-test-account' },
+          }),
+          'utf8',
+        ).toString('base64url'),
+        'test-signature',
+      ].join('.');
+      Object.assign(process.env, isolatedTestEnv, {
+        UNIPI_BG_RUNTIME_GUARD_BASE_URL: `http://127.0.0.1:${String(port)}/v1`,
+        UNIPI_BG_RUNTIME_GUARD_LOG: logPath,
+        UNIPI_BG_RUNTIME_GUARD_API_KEY: codexToken,
+      });
+
+      let session: Awaited<ReturnType<typeof createAgentSession>>['session'] | undefined;
+      try {
+        const settingsManager = SettingsManager.inMemory({
+          defaultProvider: RUNTIME_GUARD_PROVIDER,
+          defaultModel: RUNTIME_GUARD_MODEL,
+        });
+        const loader = new DefaultResourceLoader({
+          cwd,
+          agentDir,
+          settingsManager,
+          // The provider mutator must load before the governor.
+          additionalExtensionPaths: [providerPath, governorPath],
+          noExtensions: true,
+          noSkills: true,
+          noPromptTemplates: true,
+          noContextFiles: true,
+          noThemes: true,
+        });
+        await loader.reload();
+        const authStorage = AuthStorage.create(join(agentDir, 'auth.json'));
+        const registry = ModelRegistry.create(authStorage);
+        ({ session } = await createAgentSession({
+          cwd,
+          agentDir,
+          resourceLoader: loader,
+          sessionManager: SessionManager.inMemory(cwd),
+          settingsManager,
+          authStorage,
+          modelRegistry: registry,
+          noTools: 'builtin',
+        }));
+        const model = registry.find(RUNTIME_GUARD_PROVIDER, RUNTIME_GUARD_MODEL);
+        assert.ok(model);
+        await session.setModel(model);
+        await session.prompt('prove the final request guard blocks transport');
+        await session.agent.waitForIdle();
+
+        const rows = (await readFile(logPath, 'utf8'))
+          .trim()
+          .split('\n')
+          .filter(Boolean)
+          .map((line) => JSON.parse(line) as Record<string, unknown>);
+        assert.deepEqual(
+          rows.map((row) => row['hook']),
+          ['mutator', 'governor'],
+          `provider-request handlers must run exactly once in extension load order; session=${JSON.stringify(session.sessionManager.getEntries())}`,
+        );
+        assert.equal(rows[1]?.['marker_seen'], true, 'the governor must observe prior transforms');
+        assert.equal(rows[1]?.['provider'], RUNTIME_GUARD_PROVIDER);
+        assert.equal(rows[1]?.['model'], RUNTIME_GUARD_MODEL);
+        assert.equal(typeof rows[1]?.['payload_bytes'], 'number');
+        assert.match(String(rows[1]?.['payload_sha256']), /^[0-9a-f]{64}$/);
+        assert.equal(httpRequests, 0, 'ctx.abort() must prevent the HTTP request from being sent');
+      } finally {
+        if (session) {
+          await session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' });
+          session.dispose();
+        }
+        restoreEnvValue('UNIPI_BG_RUNTIME_GUARD_BASE_URL', previous.baseUrl);
+        restoreEnvValue('UNIPI_BG_RUNTIME_GUARD_LOG', previous.log);
+        restoreEnvValue('UNIPI_BG_RUNTIME_GUARD_API_KEY', previous.apiKey);
+      }
+    },
+  );
+});

package/src/__tests__/scripted-provider/hook-contract-provider.ts

@@ -0,0 +1,179 @@
+import { appendFileSync } from 'node:fs';
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import {
+  createAssistantMessageEventStream,
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Context,
+  type Message,
+  type Model,
+  type TextContent,
+  type ToolCall,
+} from '@earendil-works/pi-ai';
+
+/**
+ * Deterministic provider used only by the Pi hook-contract characterisation
+ * gate. It records the exact LLM context it was handed for every call so the
+ * test can prove whether a `context` handler's returned messages actually reach
+ * the provider, and whether a call was dispatched at all.
+ */
+const PROVIDER = 'pi-bg-hook-contract';
+const MODEL_ID = 'hook-contract-model';
+const API = 'pi-bg-hook-contract-api';
+
+const USAGE = {
+  input: 7,
+  output: 3,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 10,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+type JsonObject = Record<PropertyKey, unknown>;
+
+interface ScriptedToolCall extends Omit<ToolCall, 'arguments'> {
+  arguments: JsonObject;
+}
+
+type ScriptedBlock = TextContent | ScriptedToolCall;
+
+interface ScriptedAssistantMessage extends Omit<AssistantMessage, 'content' | 'stopReason'> {
+  content: ScriptedBlock[];
+  stopReason: 'stop' | 'toolUse';
+}
+
+function record(event: JsonObject): void {
+  const path = process.env['UNIPI_BG_HOOK_PROBE_LOG'];
+  if (!path) return;
+  appendFileSync(path, `${JSON.stringify(event)}\n`, 'utf8');
+}
+
+function messageText(message: Message): string {
+  if (typeof message.content === 'string') return message.content;
+  if (!Array.isArray(message.content)) return '';
+  return message.content.map((part) => ('text' in part ? part.text : `<${part.type}>`)).join('');
+}
+
+function assistant(
+  content: ScriptedBlock[],
+  stopReason: 'stop' | 'toolUse',
+): ScriptedAssistantMessage {
+  return {
+    role: 'assistant',
+    content,
+    api: API,
+    provider: PROVIDER,
+    model: MODEL_ID,
+    usage: USAGE,
+    stopReason,
+    timestamp: Date.now(),
+  };
+}
+
+function pushMessage(stream: AssistantMessageEventStream, message: ScriptedAssistantMessage): void {
+  const partial: AssistantMessage = { ...message, content: [] };
+  stream.push({ type: 'start', partial: { ...partial } });
+  message.content.forEach((block, contentIndex) => {
+    if (block.type === 'text') {
+      const partialText: TextContent = { type: 'text', text: '' };
+      partial.content = [...partial.content, partialText];
+      stream.push({ type: 'text_start', contentIndex, partial: { ...partial } });
+      partialText.text = block.text;
+      stream.push({ type: 'text_delta', contentIndex, delta: block.text, partial: { ...partial } });
+      stream.push({ type: 'text_end', contentIndex, content: block.text, partial: { ...partial } });
+      return;
+    }
+    const partialToolCall: ToolCall = {
+      type: 'toolCall',
+      id: block.id,
+      name: block.name,
+      arguments: {},
+    };
+    partial.content = [...partial.content, partialToolCall];
+    stream.push({ type: 'toolcall_start', contentIndex, partial: { ...partial } });
+    stream.push({
+      type: 'toolcall_delta',
+      contentIndex,
+      delta: JSON.stringify(block.arguments),
+      partial: { ...partial },
+    });
+    partialToolCall.arguments = block.arguments;
+    stream.push({ type: 'toolcall_end', contentIndex, toolCall: block, partial: { ...partial } });
+  });
+  stream.push({ type: 'done', reason: message.stopReason, message });
+  stream.end(message);
+}
+
+const ProbeEchoParams = {
+  type: 'object',
+  properties: { value: { type: 'string' } },
+  required: ['value'],
+  additionalProperties: false,
+} as const;
+
+export default function hookContractProviderExtension(pi: ExtensionAPI): void {
+  let providerCalls = 0;
+
+  pi.registerTool<typeof ProbeEchoParams, { value: string }>({
+    name: 'probe_echo',
+    label: 'Probe Echo',
+    description: 'Hook-contract characterisation echo tool.',
+    parameters: ProbeEchoParams,
+    execute(_toolCallId, input) {
+      return Promise.resolve({
+        content: [{ type: 'text' as const, text: `ORIGINAL_TOOL_PAYLOAD:${input.value}` }],
+        details: { value: input.value },
+      });
+    },
+  });
+
+  pi.registerProvider(PROVIDER, {
+    name: 'Pi Background Tasks Hook Contract Provider',
+    baseUrl: 'http://localhost:0',
+    apiKey: 'UNIPI_BG_HOOK_CONTRACT_API_KEY',
+    api: API,
+    models: [
+      {
+        id: MODEL_ID,
+        name: 'Hook Contract Model',
+        reasoning: false,
+        input: ['text'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 200_000,
+        maxTokens: 4096,
+      },
+    ],
+    streamSimple(
+      _model: Model<Api>,
+      context: Context,
+      options?: { signal?: AbortSignal | undefined },
+    ): AssistantMessageEventStream {
+      providerCalls += 1;
+      record({
+        hook: 'provider_call',
+        providerCalls,
+        // Records whether Pi handed this call an already-aborted signal. A
+        // conforming provider must not send the request in that state.
+        signalAborted: options?.signal?.aborted === true,
+        roles: context.messages.map((message) => message.role),
+        texts: context.messages.map(messageText),
+      });
+      const stream = createAssistantMessageEventStream();
+      const wantsTool = providerCalls === 1 && process.env['UNIPI_BG_HOOK_PROBE_TOOL'] === '1';
+      queueMicrotask(() => {
+        pushMessage(
+          stream,
+          wantsTool
+            ? assistant(
+                [{ type: 'toolCall', id: 'probe-call-1', name: 'probe_echo', arguments: { value: 'seed' } }],
+                'toolUse',
+              )
+            : assistant([{ type: 'text', text: `probe answer ${String(providerCalls)}` }], 'stop'),
+        );
+      });
+      return stream;
+    },
+  });
+}

package/src/__tests__/scripted-provider/hook-probe-a.ts

@@ -0,0 +1,3 @@
+import { createHookProbeExtension } from './hook-probe-extension.js';
+
+export default createHookProbeExtension('probe-a');

package/src/__tests__/scripted-provider/hook-probe-b.ts

@@ -0,0 +1,3 @@
+import { createHookProbeExtension } from './hook-probe-extension.js';
+
+export default createHookProbeExtension('probe-b');