@shipfox/client-workflows 15.0.0 → 17.0.0

package/src/hooks/api/annotations.ts

@@ -0,0 +1,240 @@
+import {
+  type AnnotationStyleDto,
+  annotationSummaryResponseSchema,
+  readAnnotationsResponseSchema,
+} from '@shipfox/annotations-dto';
+import {checkedApiRequest} from '@shipfox/client-api';
+import {
+  infiniteQueryOptions,
+  queryOptions,
+  useInfiniteQuery,
+  useQuery,
+} from '@tanstack/react-query';
+import type {RunAnnotationSummary} from '#core/run-annotation.js';
+
+const ANNOTATIONS_PAGE_SIZE = 100;
+const ANNOTATIONS_REFRESH_INTERVAL_MS = 5_000;
+
+export interface WorkflowRunAnnotation {
+  id: string;
+  jobId: string;
+  jobExecutionId: string;
+  originStepId: string;
+  originStepAttempt: number;
+  context: string;
+  style: AnnotationStyleDto;
+  sequence: number;
+  body: string;
+}
+
+export interface WorkflowRunAnnotationsPage {
+  annotations: WorkflowRunAnnotation[];
+  hasMore: boolean;
+  nextCursor: string | null;
+}
+
+export const workflowRunAnnotationsQueryKeys = {
+  all: ['workflow-run-annotations'] as const,
+  list: (workflowRunId: string, attempt: number, jobExecutionId?: string) =>
+    [
+      ...workflowRunAnnotationsQueryKeys.all,
+      'list',
+      workflowRunId,
+      attempt,
+      jobExecutionId ?? null,
+    ] as const,
+  summary: (workflowRunId: string, attempt: number, jobExecutionId?: string) =>
+    [
+      ...workflowRunAnnotationsQueryKeys.all,
+      'summary',
+      workflowRunId,
+      attempt,
+      jobExecutionId ?? null,
+    ] as const,
+};
+
+function annotationParams({
+  workflowRunId,
+  attempt,
+  jobExecutionId,
+  cursor,
+}: {
+  workflowRunId: string;
+  attempt: number;
+  jobExecutionId?: string | undefined;
+  cursor?: string | null | undefined;
+}): URLSearchParams {
+  const params = new URLSearchParams({
+    workflow_run_id: workflowRunId,
+    attempt: String(attempt),
+    limit: String(ANNOTATIONS_PAGE_SIZE),
+  });
+  if (jobExecutionId) params.set('job_execution_id', jobExecutionId);
+  if (cursor) params.set('cursor', cursor);
+  return params;
+}
+
+async function getWorkflowRunAnnotationsPage({
+  workflowRunId,
+  attempt,
+  jobExecutionId,
+  cursor,
+  signal,
+}: {
+  workflowRunId: string;
+  attempt: number;
+  jobExecutionId?: string | undefined;
+  cursor?: string | null | undefined;
+  signal?: AbortSignal;
+}): Promise<WorkflowRunAnnotationsPage> {
+  const response = await checkedApiRequest(
+    readAnnotationsResponseSchema,
+    `/annotations?${annotationParams({workflowRunId, attempt, jobExecutionId, cursor}).toString()}`,
+    {signal},
+  );
+  return {
+    annotations: response.annotations.map(toWorkflowRunAnnotation),
+    hasMore: response.has_more,
+    nextCursor: response.next_cursor,
+  };
+}
+
+async function getWorkflowRunAnnotationSummary({
+  workflowRunId,
+  attempt,
+  jobExecutionId,
+  signal,
+}: {
+  workflowRunId: string;
+  attempt: number;
+  jobExecutionId?: string | undefined;
+  signal?: AbortSignal;
+}): Promise<RunAnnotationSummary> {
+  const params = annotationParams({workflowRunId, attempt, jobExecutionId});
+  params.delete('limit');
+  const response = await checkedApiRequest(
+    annotationSummaryResponseSchema,
+    `/annotations/summary?${params.toString()}`,
+    {signal},
+  );
+  return {
+    total: response.total,
+    error: response.error,
+    warning: response.warning,
+    info: response.info,
+    success: response.success,
+    truncated: false,
+    stepCounts: response.step_counts.map((step) => ({
+      stepId: step.origin_step_id,
+      attempt: step.origin_step_attempt,
+      total: step.total,
+    })),
+  };
+}
+
+export function workflowRunAnnotationsQueryOptions(
+  workflowRunId: string | undefined,
+  attempt: number | undefined,
+  jobExecutionId?: string | undefined,
+  options?: {enabled?: boolean | undefined; polling?: boolean | undefined},
+) {
+  const enabled = Boolean(workflowRunId) && attempt !== undefined && (options?.enabled ?? true);
+  const polling = options?.polling ?? true;
+  return infiniteQueryOptions({
+    queryKey:
+      workflowRunId && attempt !== undefined
+        ? workflowRunAnnotationsQueryKeys.list(workflowRunId, attempt, jobExecutionId)
+        : ([...workflowRunAnnotationsQueryKeys.all, 'list'] as const),
+    enabled,
+    initialPageParam: null as string | null,
+    queryFn: ({pageParam, signal}) =>
+      getWorkflowRunAnnotationsPage({
+        workflowRunId: workflowRunId ?? '',
+        attempt: attempt ?? 0,
+        ...(jobExecutionId ? {jobExecutionId} : {}),
+        cursor: pageParam,
+        signal,
+      }),
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+    staleTime: 2_000,
+    refetchInterval:
+      enabled && polling
+        ? (query) => {
+            const pages = query.state.data?.pages;
+            return pages && pages.length > 1 ? false : ANNOTATIONS_REFRESH_INTERVAL_MS;
+          }
+        : false,
+  });
+}
+
+export function useWorkflowRunAnnotationsQuery(
+  workflowRunId: string | undefined,
+  attempt: number | undefined,
+  jobExecutionId?: string | undefined,
+  options?: {enabled?: boolean | undefined; polling?: boolean | undefined},
+) {
+  return useInfiniteQuery(
+    workflowRunAnnotationsQueryOptions(workflowRunId, attempt, jobExecutionId, options),
+  );
+}
+
+export function workflowRunAnnotationSummaryQueryOptions(
+  workflowRunId: string | undefined,
+  attempt: number | undefined,
+  jobExecutionId?: string | undefined,
+  options?: {enabled?: boolean | undefined; polling?: boolean | undefined},
+) {
+  const enabled = Boolean(workflowRunId) && attempt !== undefined && (options?.enabled ?? true);
+  const polling = options?.polling ?? true;
+  return queryOptions({
+    queryKey:
+      workflowRunId && attempt !== undefined
+        ? workflowRunAnnotationsQueryKeys.summary(workflowRunId, attempt, jobExecutionId)
+        : ([...workflowRunAnnotationsQueryKeys.all, 'summary'] as const),
+    enabled,
+    queryFn: ({signal}) =>
+      getWorkflowRunAnnotationSummary({
+        workflowRunId: workflowRunId ?? '',
+        attempt: attempt ?? 0,
+        ...(jobExecutionId ? {jobExecutionId} : {}),
+        signal,
+      }),
+    staleTime: 2_000,
+    refetchInterval: enabled && polling ? ANNOTATIONS_REFRESH_INTERVAL_MS : false,
+  });
+}
+
+export function useWorkflowRunAnnotationSummaryQuery(
+  workflowRunId: string | undefined,
+  attempt: number | undefined,
+  jobExecutionId?: string | undefined,
+  options?: {enabled?: boolean | undefined; polling?: boolean | undefined},
+) {
+  return useQuery(
+    workflowRunAnnotationSummaryQueryOptions(workflowRunId, attempt, jobExecutionId, options),
+  );
+}
+
+export function flattenWorkflowRunAnnotations(
+  data: {pages: readonly WorkflowRunAnnotationsPage[]} | undefined,
+): WorkflowRunAnnotation[] {
+  return data?.pages.flatMap((page) => page.annotations) ?? [];
+}
+
+function toWorkflowRunAnnotation(
+  annotation: Awaited<
+    ReturnType<typeof readAnnotationsResponseSchema.parse>
+  >['annotations'][number],
+): WorkflowRunAnnotation {
+  return {
+    id: annotation.id,
+    jobId: annotation.job_id,
+    jobExecutionId: annotation.job_execution_id,
+    originStepId: annotation.origin_step_id,
+    originStepAttempt: annotation.origin_step_attempt,
+    context: annotation.context,
+    style: annotation.style,
+    sequence: annotation.sequence,
+    body: annotation.body,
+  };
+}

package/src/hooks/api/run-annotation-mapper.ts

@@ -0,0 +1,30 @@
+import type {AnnotationDto, ReadAnnotationsResponseDto} from '@shipfox/annotations-dto';
+import type {RunAnnotationRecord} from '#core/run-annotation.js';
+
+export interface RunAnnotationPage {
+  annotations: RunAnnotationRecord[];
+  hasMore: boolean;
+  nextCursor: string | null;
+}
+
+export function toRunAnnotation(dto: AnnotationDto): RunAnnotationRecord {
+  return {
+    id: dto.id,
+    jobId: dto.job_id,
+    jobExecutionId: dto.job_execution_id,
+    originStepId: dto.origin_step_id,
+    originStepAttempt: dto.origin_step_attempt,
+    context: dto.context,
+    style: dto.style,
+    sequence: dto.sequence,
+    body: dto.body,
+  };
+}
+
+export function toRunAnnotationPage(response: ReadAnnotationsResponseDto): RunAnnotationPage {
+  return {
+    annotations: response.annotations.map(toRunAnnotation),
+    hasMore: response.has_more,
+    nextCursor: response.next_cursor,
+  };
+}

package/src/hooks/api/run-annotations.ts

@@ -0,0 +1,137 @@
+import {READ_ANNOTATIONS_MAX_LIMIT, readAnnotationsResponseSchema} from '@shipfox/annotations-dto';
+import {checkedApiRequest} from '@shipfox/client-api';
+import {
+  type InfiniteData,
+  infiniteQueryOptions,
+  type UseInfiniteQueryOptions,
+  useInfiniteQuery,
+} from '@tanstack/react-query';
+import {useMemo} from 'react';
+import {
+  type RunAnnotationRecord,
+  type RunAnnotationSummary,
+  summarizeRunAnnotations,
+} from '#core/run-annotation.js';
+import {type RunAnnotationPage, toRunAnnotationPage} from './run-annotation-mapper.js';
+
+/** Matches the run detail poll, so annotations and run state never disagree by more than a tick. */
+const ACTIVE_POLL_MS = 4_000;
+
+export const runAnnotationsQueryKeys = {
+  all: ['run-annotations'] as const,
+  list: (workflowRunId: string, runAttempt?: number | undefined) =>
+    [...runAnnotationsQueryKeys.all, 'list', workflowRunId, runAttempt ?? null] as const,
+};
+
+type RunAnnotationsQueryKey =
+  | ReturnType<typeof runAnnotationsQueryKeys.list>
+  | readonly ['run-annotations', 'list'];
+
+type RunAnnotationsQueryOptions = UseInfiniteQueryOptions<
+  RunAnnotationPage,
+  Error,
+  InfiniteData<RunAnnotationPage, string | undefined>,
+  RunAnnotationsQueryKey,
+  string | undefined
+>;
+
+async function listRunAnnotations({
+  workflowRunId,
+  runAttempt,
+  cursor,
+  signal,
+}: {
+  workflowRunId: string;
+  runAttempt: number;
+  cursor?: string | undefined;
+  signal?: AbortSignal;
+}): Promise<RunAnnotationPage> {
+  const params = new URLSearchParams({
+    workflow_run_id: workflowRunId,
+    attempt: String(runAttempt),
+    limit: String(READ_ANNOTATIONS_MAX_LIMIT),
+  });
+  if (cursor) params.set('cursor', cursor);
+
+  return toRunAnnotationPage(
+    await checkedApiRequest(readAnnotationsResponseSchema, `/annotations?${params.toString()}`, {
+      signal,
+    }),
+  );
+}
+
+export interface RunAnnotationsQueryInput {
+  workflowRunId: string | undefined;
+  runAttempt: number | undefined;
+  /** Poll while the run attempt is non-terminal, then settle. */
+  live?: boolean | undefined;
+}
+
+export function runAnnotationsQueryOptions({
+  workflowRunId,
+  runAttempt,
+  live = false,
+}: RunAnnotationsQueryInput): RunAnnotationsQueryOptions {
+  const enabled = Boolean(workflowRunId) && runAttempt !== undefined;
+
+  // Polling stops once the reader has paged past the first page: the cursor bounding page 2 was
+  // computed from page 1's last row, so a refetch that shifts that boundary can drop a range of
+  // annotations into a between-pages gap.
+  return infiniteQueryOptions({
+    queryKey: workflowRunId
+      ? runAnnotationsQueryKeys.list(workflowRunId, runAttempt)
+      : ([...runAnnotationsQueryKeys.all, 'list'] as const),
+    enabled,
+    initialPageParam: undefined as string | undefined,
+    queryFn: ({pageParam, signal}) =>
+      listRunAnnotations({
+        workflowRunId: workflowRunId ?? '',
+        runAttempt: runAttempt ?? 1,
+        cursor: pageParam,
+        signal,
+      }),
+    getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+    staleTime: 2_000,
+    refetchOnWindowFocus: true,
+    refetchInterval: (query) => {
+      if (!live) return false;
+      const pages = query.state.data?.pages;
+      return pages && pages.length > 1 ? false : ACTIVE_POLL_MS;
+    },
+    refetchIntervalInBackground: false,
+  });
+}
+
+export interface RunAnnotationsQueryResult {
+  query: ReturnType<
+    typeof useInfiniteQuery<
+      RunAnnotationPage,
+      Error,
+      InfiniteData<RunAnnotationPage, string | undefined>,
+      RunAnnotationsQueryKey,
+      string | undefined
+    >
+  >;
+  /** `undefined` until the first page resolves, so counts never render a speculative zero. */
+  annotations: RunAnnotationRecord[] | undefined;
+  summary: RunAnnotationSummary | undefined;
+}
+
+export function useRunAnnotationsQuery(input: RunAnnotationsQueryInput): RunAnnotationsQueryResult {
+  const query = useInfiniteQuery(runAnnotationsQueryOptions(input));
+  const pages = query.data?.pages;
+
+  const annotations = useMemo(
+    () => (pages ? pages.flatMap((page) => page.annotations) : undefined),
+    [pages],
+  );
+  const summary = useMemo(
+    () =>
+      annotations
+        ? summarizeRunAnnotations(annotations, {truncated: pages?.at(-1)?.hasMore ?? false})
+        : undefined,
+    [annotations, pages],
+  );
+
+  return {query, annotations, summary};
+}

package/src/hooks/api/step-attempt-detail.ts

@@ -0,0 +1,67 @@
+import {stepAttemptDetailResponseSchema} from '@shipfox/api-workflows-dto';
+import {checkedApiRequest} from '@shipfox/client-api';
+import {queryOptions, type UseQueryOptions, useQuery} from '@tanstack/react-query';
+import type {StepAttemptDetail} from '#core/workflow-run.js';
+import {toStepAttemptDetail} from './workflow-run-mapper.js';
+
+export const stepAttemptDetailQueryKeys = {
+  all: ['workflow-step-attempt-details'] as const,
+  detail: (stepId: string, attempt: number) =>
+    [...stepAttemptDetailQueryKeys.all, stepId, attempt] as const,
+};
+
+type StepAttemptDetailQueryKey =
+  | ReturnType<typeof stepAttemptDetailQueryKeys.detail>
+  | readonly ['workflow-step-attempt-details'];
+
+type StepAttemptDetailQueryOptions = UseQueryOptions<
+  StepAttemptDetail,
+  Error,
+  StepAttemptDetail,
+  StepAttemptDetailQueryKey
+>;
+
+async function getStepAttemptDetail({
+  stepId,
+  attempt,
+  signal,
+}: {
+  stepId: string;
+  attempt: number;
+  signal?: AbortSignal;
+}): Promise<StepAttemptDetail> {
+  const response = await checkedApiRequest(
+    stepAttemptDetailResponseSchema,
+    `/workflows/runs/steps/${stepId}/attempts/${attempt}`,
+    {signal},
+  );
+  return toStepAttemptDetail(response);
+}
+
+export function stepAttemptDetailQueryOptions(
+  stepId: string | undefined,
+  attempt: number | undefined,
+): StepAttemptDetailQueryOptions {
+  return queryOptions({
+    queryKey:
+      stepId && attempt !== undefined
+        ? stepAttemptDetailQueryKeys.detail(stepId, attempt)
+        : ([...stepAttemptDetailQueryKeys.all] as const),
+    enabled: Boolean(stepId) && attempt !== undefined,
+    queryFn: ({signal}) =>
+      getStepAttemptDetail({stepId: stepId ?? '', attempt: attempt ?? 0, signal}),
+    staleTime: Infinity,
+  });
+}
+
+export function useStepAttemptDetailQuery(
+  stepId: string | undefined,
+  attempt: number | undefined,
+  options?: {enabled?: boolean | undefined},
+) {
+  return useQuery({
+    ...stepAttemptDetailQueryOptions(stepId, attempt),
+    ...options,
+    enabled: Boolean(stepId) && attempt !== undefined && (options?.enabled ?? true),
+  });
+}

package/src/hooks/api/workflow-run-mapper.ts

@@ -1,5 +1,7 @@
 import type {
+  EvaluationTraceDto,
   JobListeningDto,
+  StepAttemptDetailResponseDto,
   StepAttemptDto,
   StepGateResultDto,
   WorkflowExecutionEventDto,
@@ -13,6 +15,7 @@ import type {
   WorkflowRunStepDetailDto,
 } from '@shipfox/api-workflows-dto';
 import {
+  type EvaluationTraceEntry,
   Job,
   JobExecution,
   type JobListening,
@@ -139,6 +142,10 @@ export function toJob(dto: WorkflowRunJobDetailDto): Job {
     status: dto.status,
     statusReason: dto.status_reason,
     carriedOver: dto.carried_over,
+    outputs: dto.outputs ?? null,
+    success: dto.success ?? null,
+    runner: dto.runner ?? null,
+    evaluationTrace: toEvaluationTrace(dto.evaluation_trace),
     listening: dto.listening ? toJobListening(dto.listening) : null,
     listenerStatus: dto.listener_status,
     resolutionReason: dto.resolution_reason,
@@ -158,11 +165,14 @@ export function toJobExecution(dto: WorkflowRunJobExecutionDetailDto): JobExecut
     name: dto.name,
     status: dto.status,
     statusReason: dto.status_reason,
+    runner: dto.runner ?? null,
+    outputs: dto.outputs ?? null,
     triggerEvents: (dto.trigger_events ?? []).map(toWorkflowExecutionEvent),
     queuedAt: dto.queued_at ?? null,
     startedAt: dto.started_at ?? null,
     finishedAt: dto.finished_at ?? null,
     timedOutAt: dto.timed_out_at ?? null,
+    evaluationTrace: toEvaluationTrace(dto.evaluation_trace),
     createdAt: dto.created_at,
     updatedAt: dto.updated_at,
     steps: dto.steps.map(toStep),
@@ -179,8 +189,10 @@ export function toStep(dto: WorkflowRunStepDetailDto): Step {
       ? {startLine: dto.source_location.start_line, endLine: dto.source_location.end_line}
       : null,
     status: dto.status,
+    statusReason: dto.status_reason,
     type: dto.type,
     config: dto.config,
+    evaluationTrace: toEvaluationTrace(dto.evaluation_trace),
     agentConfig: toAgentStepConfig(dto),
     error: dto.error
       ? {
@@ -210,6 +222,8 @@ export function toStepAttempt(dto: StepAttemptDto, jobExecutionId: string): Step
     status: dto.status,
     exitCode: dto.exit_code ?? null,
     output: dto.output ?? null,
+    outputs: dto.outputs ?? dto.output ?? null,
+    response: dto.response ?? null,
     error: dto.error ?? null,
     gateResult: toStepGateResult(dto.gate_result),
     restartFeedback: dto.restart_feedback ?? null,
@@ -218,6 +232,16 @@ export function toStepAttempt(dto: StepAttemptDto, jobExecutionId: string): Step
   });
 }
 
+export function toStepAttemptDetail(dto: StepAttemptDetailResponseDto) {
+  return {
+    stepId: dto.step_id,
+    attempt: dto.attempt,
+    authoredConfig: dto.authored_config,
+    config: dto.config,
+    evaluationTrace: toEvaluationTrace(dto.evaluation_trace),
+  };
+}
+
 function toJobListening(dto: JobListeningDto): JobListening {
   return {
     on: dto.on,
@@ -259,6 +283,28 @@ function toStepGateResult(dto: StepGateResultDto): StepGateResult {
   return dto;
 }
 
+function toEvaluationTrace(trace: EvaluationTraceDto | null): EvaluationTraceEntry[] | null {
+  return (
+    trace?.map((entry) =>
+      'dropped' in entry
+        ? entry
+        : {
+            expression: entry.expression,
+            roots: entry.roots,
+            fillTarget: entry.fill_target,
+            evaluatedAt: entry.evaluated_at,
+            field: entry.field,
+            ...(entry.value === undefined ? {} : {value: entry.value}),
+            ...(entry.truncated === undefined ? {} : {truncated: entry.truncated}),
+            ...(entry.expr_truncated === undefined ? {} : {exprTruncated: entry.expr_truncated}),
+            ...(entry.reference === undefined ? {} : {reference: entry.reference}),
+            ...(entry.degraded === undefined ? {} : {degraded: entry.degraded}),
+            ...(entry.env_key === undefined ? {} : {envKey: entry.env_key}),
+          },
+    ) ?? null
+  );
+}
+
 function toAgentStepConfig(dto: WorkflowRunStepDetailDto): Step['agentConfig'] {
   if (dto.type !== 'agent') return null;
   return {

package/src/hooks/api/workflow-runs.test.tsx

@@ -1,3 +1,4 @@
+import type {StepAttemptDetailResponseDto} from '@shipfox/api-workflows-dto';
 import {configureApiClient} from '@shipfox/client-api';
 import {type InfiniteData, QueryClient, QueryClientProvider} from '@tanstack/react-query';
 import {act, cleanup, renderHook, waitFor} from '@testing-library/react';
@@ -11,7 +12,8 @@ import {
   workflowRunDto,
   workflowRunListResponseDto,
 } from '#test/fixtures/workflow-run.js';
-import {toWorkflowRun, toWorkflowRunListPage} from './workflow-run-mapper.js';
+import {useStepAttemptDetailQuery} from './step-attempt-detail.js';
+import {toStepAttemptDetail, toWorkflowRun, toWorkflowRunListPage} from './workflow-run-mapper.js';
 import {
   fireManualWorkflow,
   useCancelWorkflowRunMutation,
@@ -133,6 +135,64 @@ describe('workflow run API hooks', () => {
     expect(cached).toHaveProperty('triggerSource', 'manual');
   });
 
+  test('maps lazy step attempt details to authored and resolved troubleshooting data', () => {
+    const dto: StepAttemptDetailResponseDto = {
+      step_id: '88888888-8888-4888-8888-888888888888',
+      attempt: 2,
+      authored_config: {run: 'echo $' + '{{ inputs.message }}'},
+      config: {run: 'echo hello'},
+      evaluation_trace: [
+        {
+          expression: 'inputs.message',
+          roots: ['inputs.message'],
+          fill_target: 'run',
+          evaluated_at: '2026-08-05T12:00:00.000Z',
+          field: 'run',
+          value: 'hello',
+          degraded: false,
+        },
+      ],
+    };
+
+    expect(toStepAttemptDetail(dto)).toEqual({
+      stepId: dto.step_id,
+      attempt: 2,
+      authoredConfig: dto.authored_config,
+      config: dto.config,
+      evaluationTrace: [
+        {
+          expression: 'inputs.message',
+          roots: ['inputs.message'],
+          fillTarget: 'run',
+          evaluatedAt: '2026-08-05T12:00:00.000Z',
+          field: 'run',
+          value: 'hello',
+          degraded: false,
+        },
+      ],
+    });
+  });
+
+  test('does not fetch step attempt details while the inspector is closed', async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({
+        step_id: '88888888-8888-4888-8888-888888888888',
+        attempt: 1,
+        authored_config: null,
+        config: {},
+        evaluation_trace: null,
+      }),
+    );
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    renderWithQueryClient(() =>
+      useStepAttemptDetailQuery('88888888-8888-4888-8888-888888888888', 1, {enabled: false}),
+    );
+
+    await Promise.resolve();
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
   test('rejects malformed detail responses before they reach the query cache', async () => {
     const fetchImpl = vi.fn(async () => jsonResponse({id: RUN_ID, trigger_source: 'manual'}));
     configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});