explorbot 0.4.1 → 0.4.3

package/src/action.ts

@@ -14,6 +14,7 @@ import { browserErrorMessage, isFatalBrowserError, isNavigationTransitionError }
 import { captureHtmlForSnapshot, htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
 import { Overlay, OverlayPage } from './utils/overlay.js';
+import type { Region } from './utils/region.js';
 import { sleep, waitForPageReadiness } from './utils/page-readiness.ts';
 import { safeFilename } from './utils/strings.ts';
 import { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from './utils/web-sandbox.ts';
@@ -181,7 +182,7 @@ class Action {
         focusedElement,
         iframeURL: frame ? frame.url?.() || 'iframe' : undefined,
       });
-      if (!frame) await this.detectRegionOfInterest(result).catch((err: Error) => debugLog('Region detection failed:', err.message));
+      if (!frame) await this.detectRegion(result).catch((err: Error) => debugLog('Region detection failed:', err.message));
       this.stateManager.updateState(result, codeBlock);
       return result;
     } catch (err) {
@@ -193,36 +194,36 @@ class Action {
     }
   }
 
-  private async detectRegionOfInterest(result: ActionResult): Promise<void> {
+  private async detectRegion(result: ActionResult): Promise<void> {
     const previousState = this.stateManager.getCurrentState();
     if (!previousState) return;
     const previous = ActionResult.fromState(previousState);
-    const previousOverlay = previous.overlay;
+    const previousRegion = previous.overlay;
     const sameUrl = !!previous.url && result.isSameUrl({ url: previous.url });
     const overlayPage = new OverlayPage(this.playwrightHelper.page);
 
-    if (result.overlay.detected && previousOverlay.detected && previousOverlay.root && previousOverlay.type === result.overlay.type && previousOverlay.name === result.overlay.name) {
-      result.overlay = previousOverlay;
+    if (result.overlay.isModal && previousRegion.isModal && previousRegion.root && previousRegion.type === result.overlay.type && previousRegion.name === result.overlay.name) {
+      result.overlay = previousRegion;
       return;
     }
 
     if (!previous.html) return;
 
     if (previous.html === result.html) {
-      if (sameUrl && previousOverlay.present && previousOverlay.xpath && !result.overlay.detected) result.overlay = previousOverlay;
+      if (sameUrl && previousRegion.isOpen && previousRegion.xpath && !result.overlay.isModal) result.overlay = previousRegion;
       return;
     }
 
-    let carried: Overlay | null = null;
-    if (sameUrl && previousOverlay.present && previousOverlay.xpath) {
-      if (await overlayPage.isStillOpen(previousOverlay)) {
-        carried = previousOverlay;
+    let carried: Region | null = null;
+    if (sameUrl && previousRegion.isOpen && previousRegion.xpath) {
+      if (await overlayPage.isStillOpen(previousRegion)) {
+        carried = previousRegion;
       } else {
-        debugLog(`Region closed: ${previousOverlay.name || previousOverlay.type}`);
-        if (!result.overlay.detected) {
-          const parent = previousOverlay.parent;
+        debugLog(`Region closed: ${previousRegion.name || previousRegion.type}`);
+        if (!result.overlay.isModal) {
+          const parent = previousRegion.parent;
           if (parent?.xpath) {
-            const restored = new Overlay(parent);
+            const restored = Overlay.resolve({ overlay: parent });
             if (await overlayPage.isStillOpen(restored)) result.overlay = restored;
           }
           return;
@@ -239,7 +240,7 @@ class Action {
       previousHtml: previous.html,
     });
 
-    if (result.overlay.detected) {
+    if (result.overlay instanceof Overlay) {
       if (detected) result.overlay = result.overlay.withGeometry(detected);
       return;
     }

package/src/ai/fisherman/request-haul.ts

@@ -0,0 +1,36 @@
+import type { RequestResult } from '../../api/request-result.ts';
+import { type RequestStore, isFailedRequest } from '../../api/request-store.ts';
+
+export class RequestHaul {
+  private start: number;
+
+  constructor(private store: RequestStore) {
+    this.start = store.getMadeRequests().length;
+  }
+
+  requests(): RequestResult[] {
+    return this.store.getMadeRequests().slice(this.start);
+  }
+
+  failed(): RequestResult[] {
+    return this.requests().filter(isFailedRequest);
+  }
+
+  successfulWrites(): RequestResult[] {
+    return this.requests().filter((r) => r.isWrite && !r.error && r.status >= 200 && r.status < 400);
+  }
+
+  successfulReads(): RequestResult[] {
+    return this.requests().filter((r) => !r.isWrite && !r.error && r.status >= 200 && r.status < 400);
+  }
+
+  byId(): Map<string, RequestResult> {
+    const map = new Map<string, RequestResult>();
+    for (const request of this.successfulWrites()) {
+      const { id } = request.extractIdAndTitle();
+      if (id === undefined) continue;
+      map.set(String(id), request);
+    }
+    return map;
+  }
+}

package/src/ai/{fisherman-tools.ts → fisherman/tools.ts}

@@ -1,31 +1,36 @@
 import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
-import type { ApiClient } from '../api/api-client.ts';
-import type { RequestResult } from '../api/request-result.ts';
-import type { RequestStore } from '../api/request-store.ts';
-import { extractEndpointDefinition } from '../api/spec-reader.ts';
-import { tag } from '../utils/logger.ts';
-import { RequestMap } from '../utils/request-map.ts';
-import { isDynamicSegment } from '../utils/url-matcher.ts';
-
-export function createFishermanTools(apiClient: ApiClient, requestStore: RequestStore, opts: { spec?: any; baseEndpoint?: string }) {
+import type { ApiClient } from '../../api/api-client.ts';
+import type { RequestResult } from '../../api/request-result.ts';
+import type { RequestStore } from '../../api/request-store.ts';
+import { extractEndpointDefinition } from '../../api/spec-reader.ts';
+import type { Test } from '../../test-plan.ts';
+import { tag } from '../../utils/logger.ts';
+import { isDynamicSegment } from '../../utils/url-matcher.ts';
+import type { Fisherman } from '../fisherman.ts';
+import type { RequestHaul } from './request-haul.ts';
+
+const BODY_PREVIEW_LIMIT = 2000;
+
+export function createFishermanTools(apiClient: ApiClient, requestStore: RequestStore, haul: RequestHaul, opts: { spec?: any; baseEndpoint?: string; readOnly?: boolean }) {
+  const readOnly = opts.readOnly === true;
   let finished = false;
   let result: FishermanResult | null = null;
-  const ledgerStart = requestStore.getMadeRequests().length;
 
-  const runRequests = () => requestStore.getMadeRequests().slice(ledgerStart);
-  const successfulWrites = () => runRequests().filter((r) => r.isWrite && !r.error && r.status >= 200 && r.status < 400);
-  const getResult = () => result ?? synthesizeResult(runRequests(), successfulWrites(), false);
+  let allowedMethods: string[] = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+  if (readOnly) allowedMethods = ['GET'];
+
+  const getResult = () => result ?? synthesizeResult(haul, false, readOnly);
   const isFinished = () => finished;
   const finishFromText = (text?: string) => {
     finished = true;
-    const synthesized = synthesizeResult(runRequests(), successfulWrites(), true);
+    const synthesized = synthesizeResult(haul, true, readOnly);
     if (text && synthesized.success) synthesized.summary = text;
     result = synthesized;
   };
 
-  const tools = {
+  const tools: Record<string, any> = {
     getEndpointSpec: tool({
       description: dedent`
         Get the request specification for an endpoint.
@@ -33,13 +38,14 @@ export function createFishermanTools(apiClient: ApiClient, requestStore: Request
         Call this before making a request to an endpoint you haven't used before.
       `,
       inputSchema: z.object({
-        method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).describe('HTTP method'),
+        method: z.enum(allowedMethods as [string, ...string[]]).describe('HTTP method'),
         path: z.string().describe('Endpoint path, e.g. /suites'),
       }),
       execute: async ({ method, path }) => {
         tag('step').log(`Fisherman: spec lookup ${method} ${path}`);
 
-        const captured = requestStore.findCapturedRequest(method, path);
+        let captured = requestStore.findCapturedRequest(method, path);
+        if (captured && !captured.requestBody && opts.spec && captured.status < 400) captured = undefined;
         if (captured) {
           if (captured.status >= 400) {
             const rejectedCapture = {
@@ -91,7 +97,7 @@ export function createFishermanTools(apiClient: ApiClient, requestStore: Request
         Returns status, plus IDs and names auto-extracted from the response under 'extracted'.
       `,
       inputSchema: z.object({
-        method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).describe('HTTP method'),
+        method: z.enum(allowedMethods as [string, ...string[]]).describe('HTTP method'),
         path: z.string().describe('API path (e.g., /suites, /suites/1)'),
         body: z.any().optional().describe('Request body (JSON object)'),
         queryParams: z.record(z.string(), z.string()).optional().describe('Query parameters'),
@@ -128,11 +134,13 @@ export function createFishermanTools(apiClient: ApiClient, requestStore: Request
 
         const extracted = extractKeyFields(reqResult.responseBody);
         tag('success').log(`Fisherman: ${input.method} ${input.path} > ${statusLine}`);
-        return {
+        const output: Record<string, any> = {
           success: true,
           status: reqResult.status,
           extracted,
         };
+        if (readOnly) output.bodyPreview = reqResult.rawResponseBody.substring(0, BODY_PREVIEW_LIMIT);
+        return output;
       },
     }),
 
@@ -160,32 +168,12 @@ export function createFishermanTools(apiClient: ApiClient, requestStore: Request
           .describe('List of items that could not be created'),
       }),
       execute: async ({ summary, created, failed }) => {
-        const writes = successfulWrites();
-        if (writes.length === 0) {
-          tag('warning').log('Fisherman: finish rejected — no successful write request in this run');
-          return { finished: false, error: 'No successful write request was made in this run, so nothing was created. Keep working, or call stop if the data cannot be prepared.' };
-        }
-
-        const createdRequests = new RequestMap(writes);
-
-        const verified: FishermanResult['created'] = [];
-        for (const item of created) {
-          if (item.id === undefined) {
-            verified.push(item);
-            continue;
-          }
-          const request = createdRequests.get(item.id);
-          if (!request) {
-            tag('warning').log(`Fisherman: dropped unverified created item ${item.type} (id: ${item.id})`);
-            continue;
-          }
-          verified.push({ ...item, request: request.toEndpoint() });
-        }
-        if (verified.length === 0) verified.push(...writes.map(toCreatedItem));
+        const { result: verified, error } = verifyFinish(haul, { summary, created, failed });
+        if (!verified) return { finished: false, error };
 
         tag('success').log(`Fisherman done: ${summary}`);
         finished = true;
-        result = { success: true, summary, created: verified, failed: failed || [] };
+        result = verified;
         return { finished: true };
       },
     }),
@@ -204,15 +192,106 @@ export function createFishermanTools(apiClient: ApiClient, requestStore: Request
     }),
   };
 
+  if (readOnly) {
+    tools.finish = tool({
+      description: 'Report the answer to the question. Call when the requests have shown what exists.',
+      inputSchema: z.object({
+        answer: z.string().describe('What the data shows, quoting the concrete names, titles and ids that were returned'),
+      }),
+      execute: async ({ answer }) => {
+        if (haul.successfulReads().length === 0) {
+          tag('warning').log('Fisherman: finish rejected — no successful request in this run');
+          return { finished: false, error: 'No successful request was made in this run, so nothing was read. Keep working, or call stop if the question cannot be answered.' };
+        }
+
+        tag('success').log(`Fisherman answered: ${answer}`);
+        finished = true;
+        result = { success: true, summary: answer, created: [], failed: [] };
+        return { finished: true };
+      },
+    });
+  }
+
   return { tools, getResult, isFinished, finishFromText };
 }
 
-function synthesizeResult(made: RequestResult[], writes: RequestResult[], declaredDone: boolean): FishermanResult {
-  const failures = made.filter((r) => r.status >= 400 || r.error);
-  let summary = `Stopped before finishing: ${made.length} requests, ${writes.length} successful writes, ${failures.length} failed`;
+export function createAskApiTool(fisherman: Fisherman | null, task: Test) {
+  return {
+    askApi: tool({
+      description: dedent`
+        Ask what data already exists, changing nothing.
+        Ask a question about existing records: which ones are there, what they are called, whether a particular one exists.
+        Use it before precondition() to see whether suitable data is already available, and whenever a step needs the exact name or id of a record that is already there.
+        It never creates, edits or deletes anything — precondition() does that.
+      `,
+      inputSchema: z.object({
+        question: z.string().describe('What to find out about data that already exists'),
+      }),
+      execute: async ({ question }) => {
+        tag('info').log(`Ask API: ${question}`);
+
+        if (!fisherman?.isAvailable()) {
+          return { answered: false, reason: 'No API access is configured, so existing data cannot be queried. Judge from the page instead.' };
+        }
+
+        const result = await fisherman.lookupData(question, task.startUrl, task.sessionName);
+
+        if (!result.success) {
+          tag('warning').log(`Ask API unanswered: ${result.summary}`);
+          return { answered: false, reason: result.summary || 'The API could not answer this question' };
+        }
+
+        task.addNote(`Asked API: ${question} — ${result.summary}`);
+        tag('success').log(`Ask API: ${result.summary}`);
+        return { answered: true, answer: result.summary };
+      },
+    }),
+  };
+}
+
+export function verifyFinish(haul: RequestHaul, input: { summary: string; created: FishermanResult['created']; failed?: FishermanResult['failed'] }): { result: FishermanResult | null; error?: string } {
+  const writes = haul.successfulWrites();
+  if (writes.length === 0) {
+    tag('warning').log('Fisherman: finish rejected — no successful write request in this run');
+    return { result: null, error: 'No successful write request was made in this run, so nothing was created. Keep working, or call stop if the data cannot be prepared.' };
+  }
+
+  const createdRequests = haul.byId();
+
+  const verified: FishermanResult['created'] = [];
+  for (const item of input.created) {
+    if (item.id === undefined) {
+      verified.push(item);
+      continue;
+    }
+    const request = createdRequests.get(String(item.id));
+    if (!request) {
+      tag('warning').log(`Fisherman: dropped unverified created item ${item.type} (id: ${item.id})`);
+      continue;
+    }
+    verified.push({ ...item, request: request.toEndpoint() });
+  }
+  if (verified.length === 0) verified.push(...writes.map(toCreatedItem));
+
+  return { result: { success: true, summary: input.summary, created: verified, failed: input.failed || [] } };
+}
+
+function synthesizeResult(haul: RequestHaul, declaredDone: boolean, readOnly: boolean): FishermanResult {
+  const made = haul.requests();
+  const failures = haul.failed();
+  let succeeded = haul.successfulWrites();
+  let successLabel = 'successful writes';
+  if (readOnly) {
+    succeeded = haul.successfulReads();
+    successLabel = 'successful reads';
+  }
+  let summary = `Stopped before finishing: ${made.length} requests, ${succeeded.length} ${successLabel}, ${failures.length} failed`;
   const lastFailure = failures[failures.length - 1];
   if (lastFailure) summary += `; last failure: ${lastFailure.toSummary()}`;
-  return { success: declaredDone && writes.length > 0, summary, created: writes.map(toCreatedItem), failed: [] };
+
+  const result: FishermanResult = { success: declaredDone && succeeded.length > 0, summary, created: [], failed: [] };
+  if (!readOnly) result.created = succeeded.map(toCreatedItem);
+  return result;
 }
 
 function toCreatedItem(write: RequestResult): FishermanResult['created'][number] {

package/src/ai/fisherman.ts

@@ -1,13 +1,15 @@
 import dedent from 'dedent';
 import type { ApiClient } from '../api/api-client.ts';
-import type { RequestStore } from '../api/request-store.ts';
+import { type EndpointFamily, type RequestStore, isFailedRequest } from '../api/request-store.ts';
 import { listAllEndpoints } from '../api/spec-reader.ts';
 import { createDebug, tag } from '../utils/logger.ts';
 
 const debugLog = createDebug('explorbot:fisherman');
 import { loop } from '../utils/loop.ts';
 import type { Agent } from './agent.ts';
-import { type FishermanResult, createFishermanTools } from './fisherman-tools.ts';
+import type { Conversation } from './conversation.ts';
+import { RequestHaul } from './fisherman/request-haul.ts';
+import { type FishermanResult, createFishermanTools } from './fisherman/tools.ts';
 import type { Provider } from './provider.ts';
 import { dataProtectionRules } from './rules.ts';
 
@@ -72,22 +74,74 @@ export class Fisherman implements Agent {
 
     if (!endpointList) {
       tag('warning').log('Fisherman: no endpoints available');
-      this.mode = 'disabled';
       return { success: false, summary: 'No API endpoints available', created: [], failed: [] };
     }
 
     await this.refreshAuth();
     debugLog(`auth headers: ${Object.keys(this.apiClient.getHeaders()).join(', ')}`);
 
-    const { tools, getResult, isFinished, finishFromText } = createFishermanTools(this.apiClient, this.requestStore, {
+    const haul = new RequestHaul(this.requestStore);
+    const { tools, getResult, isFinished, finishFromText } = createFishermanTools(this.apiClient, this.requestStore, haul, {
       spec: this.spec,
       baseEndpoint: this.baseEndpoint,
     });
-    const ledgerStart = this.requestStore.getMadeRequests().length;
 
     const conversation = this.provider.startConversation(this.buildSystemPrompt(endpointList, Object.keys(tools), scopeUrl), 'fisherman');
     conversation.addUserText(this.buildTaskPrompt(instructions));
 
+    await this.runSession(conversation, tools, { haul, isFinished, finishFromText, label: `fisherman: ${instructions.slice(0, 50)}` });
+
+    const result = getResult();
+    tag('info').log(`Fisherman result: ${result.summary}`);
+    return result;
+  }
+
+  async lookupData(question: string, scopeUrl?: string, sessionName?: string): Promise<FishermanResult> {
+    this.sessionName = sessionName;
+    tag('info').log(`Fisherman [read]: ${question}`);
+
+    await this.ensureReady(scopeUrl);
+
+    if (this.mode === 'disabled') {
+      debugLog('disabled — no data for scope');
+      return { success: false, summary: 'No API data available for this scope', created: [], failed: [] };
+    }
+
+    const endpointList = this.buildEndpointList(scopeUrl, 'read');
+    debugLog(`read endpoints:\n${endpointList || '(none)'}`);
+
+    if (!endpointList) {
+      tag('warning').log('Fisherman: no read endpoints available');
+      return { success: false, summary: 'No read endpoints are known for this scope', created: [], failed: [] };
+    }
+
+    await this.refreshAuth();
+
+    const haul = new RequestHaul(this.requestStore);
+    const { tools, getResult, isFinished, finishFromText } = createFishermanTools(this.apiClient, this.requestStore, haul, {
+      spec: this.spec,
+      baseEndpoint: this.baseEndpoint,
+      readOnly: true,
+    });
+
+    const conversation = this.provider.startConversation(this.buildLookupSystemPrompt(endpointList, Object.keys(tools), scopeUrl), 'fisherman');
+    conversation.addUserText(dedent`
+      Answer this question about data that already exists:
+
+      ${question}
+
+      Make the requests needed to answer it, then call finish with the answer.
+      If the available endpoints cannot answer it, call stop with the reason.
+    `);
+
+    await this.runSession(conversation, tools, { haul, isFinished, finishFromText, label: `fisherman lookup: ${question.slice(0, 50)}` });
+
+    const result = getResult();
+    tag('info').log(`Fisherman answer: ${result.summary}`);
+    return result;
+  }
+
+  private async runSession(conversation: Conversation, tools: Record<string, any>, opts: { haul: RequestHaul; isFinished: () => boolean; finishFromText: (text?: string) => void; label: string }): Promise<void> {
     await loop(
       async ({ stop, iteration }) => {
         debugLog(`iteration ${iteration}`);
@@ -97,19 +151,19 @@ export class Fisherman implements Agent {
         });
         debugLog(`iteration ${iteration} done, text: ${invokeResult?.response?.text?.slice(0, 200) || '(none)'}`);
 
-        if (isFinished()) {
+        if (opts.isFinished()) {
           stop();
           return;
         }
 
         if (!invokeResult?.toolExecutions?.length) {
           debugLog('no tool call in this turn — treating as finish');
-          finishFromText(invokeResult?.response?.text);
+          opts.finishFromText(invokeResult?.response?.text);
           stop();
           return;
         }
 
-        if (this.isStuckOnEndpoint(ledgerStart)) {
+        if (this.isStuckOnEndpoint(opts.haul)) {
           tag('warning').log('Fisherman: repeated failures on the same endpoint — stopping');
           stop();
           return;
@@ -123,7 +177,7 @@ export class Fisherman implements Agent {
       {
         maxAttempts: MAX_ITERATIONS,
         observability: {
-          name: `fisherman: ${instructions.slice(0, 50)}`,
+          name: opts.label,
           agent: 'fisherman',
           sessionId: this.sessionName,
         },
@@ -134,10 +188,6 @@ export class Fisherman implements Agent {
         },
       }
     );
-
-    const result = getResult();
-    tag('info').log(`Fisherman result: ${result.summary}`);
-    return result;
   }
 
   private async detectMode(scopeUrl?: string): Promise<void> {
@@ -177,18 +227,19 @@ export class Fisherman implements Agent {
     }
   }
 
-  private buildEndpointList(scopeUrl?: string): string {
+  private buildEndpointList(scopeUrl?: string, family: EndpointFamily = 'write'): string {
     this.scopeDegraded = false;
     if (this.mode === 'achieve' && this.spec) {
-      const specEndpoints = listAllEndpoints(this.spec, this.baseEndpoint);
+      let specEndpoints = listAllEndpoints(this.spec, this.baseEndpoint);
+      if (family === 'read') specEndpoints = keepReadLines(specEndpoints);
       if (specEndpoints) return specEndpoints;
     }
 
-    const scoped = this.requestStore.toEndpointList(scopeUrl || '/');
+    const scoped = this.requestStore.toEndpointList(scopeUrl || '/', family);
     if (scoped) return scoped;
 
     this.scopeDegraded = true;
-    return this.requestStore.toEndpointList();
+    return this.requestStore.toEndpointList(undefined, family);
   }
 
   private buildSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string {
@@ -228,12 +279,44 @@ export class Fisherman implements Agent {
     `;
   }
 
-  private isStuckOnEndpoint(ledgerStart: number): boolean {
-    const made = this.requestStore.getMadeRequests().slice(ledgerStart);
+  private buildLookupSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string {
+    let scopeBlock = '';
+    if (scopeUrl) {
+      scopeBlock = `\n\nSCOPE: You are answering about ${scopeUrl}.`;
+      if (this.scopeDegraded) scopeBlock += '\nThe endpoint list could not be narrowed to this scope and may include endpoints belonging to other scopes. Prefer the endpoint whose path belongs to this scope.';
+    }
+
+    return dedent`
+      You are Fisherman — reading the API to report what data already exists. You change nothing.
+
+      AVAILABLE ENDPOINTS:
+      ${endpointList}
+      ${scopeBlock}
+
+      AVAILABLE TOOLS:
+      ${toolNames.join(', ')}.
+      Use tool names exactly as listed. Do not invent aliases or combined names.
+      Match each tool input schema exactly. Do not invent parameter names or pass extra fields.
+
+      WORKFLOW:
+      1. Pick the endpoint that lists the kind of item the question is about
+      2. Request it, and when the answer needs a parent resource, request the parent first and use its id
+      3. Call finish with the answer, quoting the concrete names, titles and ids the responses returned
+
+      RULES:
+      - Report only what a response actually returned. Never describe data you did not read
+      - Report an empty collection as empty. An absent item must not be reported as present
+      - Answer the question that was asked and stop. Do not survey unrelated endpoints
+      - Use the response category and error text to correct a failed request. Retry a temporary or server failure once
+    `;
+  }
+
+  private isStuckOnEndpoint(haul: RequestHaul): boolean {
+    const made = haul.requests();
     if (made.length < REPEATED_FAILURE_LIMIT) return false;
     const recent = made.slice(-REPEATED_FAILURE_LIMIT);
     const first = recent[0];
-    return recent.every((r) => (r.status >= 400 || r.error) && r.method === first.method && r.path === first.path);
+    return recent.every((r) => isFailedRequest(r) && r.method === first.method && r.path === first.path);
   }
 
   private buildTaskPrompt(instructions: string): string {
@@ -249,3 +332,10 @@ export class Fisherman implements Agent {
     `;
   }
 }
+
+function keepReadLines(endpointList: string): string {
+  return endpointList
+    .split('\n')
+    .filter((line) => line.startsWith('GET '))
+    .join('\n');
+}