@positronic/cloudflare 0.0.2

package/test-project/tests/api.test.ts

@@ -0,0 +1,1005 @@
+import {
+  env,
+  createExecutionContext,
+  waitOnExecutionContext,
+} from 'cloudflare:test';
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import worker from '../src/index';
+import { BRAIN_EVENTS, STATUS } from '@positronic/core';
+import type {
+  BrainEvent,
+  BrainStartEvent,
+  BrainCompleteEvent,
+  StepStatusEvent,
+  StepCompletedEvent,
+  StepStartedEvent,
+} from '@positronic/core';
+import type { BrainRunnerDO } from '../../src/brain-runner-do.js';
+import type { MonitorDO } from '../../src/monitor-do.js';
+import type { ScheduleDO } from '../../src/schedule-do.js';
+
+interface TestEnv {
+  BRAIN_RUNNER_DO: DurableObjectNamespace<BrainRunnerDO>;
+  MONITOR_DO: DurableObjectNamespace<MonitorDO>;
+  SCHEDULE_DO: DurableObjectNamespace<ScheduleDO>;
+  DB: D1Database;
+  RESOURCES_BUCKET: R2Bucket;
+}
+
+describe('Hono API Tests', () => {
+  // Helper to parse SSE data field
+  function parseSseEvent(text: string): any | null {
+    const lines = text.trim().split('\n');
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        try {
+          const jsonData = line.substring(6); // Length of "data: "
+          const parsed = JSON.parse(jsonData);
+          return parsed;
+        } catch (e) {
+          console.error(
+            '[TEST_SSE_PARSE] Failed to parse SSE data:',
+            line.substring(6),
+            e
+          );
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+
+  // Helper function to read the entire SSE stream and collect events
+  async function readSseStream(
+    stream: ReadableStream<Uint8Array>
+  ): Promise<BrainEvent[]> {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const events: BrainEvent[] = [];
+
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        // Process any remaining buffer content
+        if (buffer.trim().length > 0) {
+          const event = parseSseEvent(buffer);
+          if (event) {
+            events.push(event);
+          }
+        }
+        break; // Exit loop when stream is done
+      }
+
+      const decodedChunk = decoder.decode(value, { stream: true });
+      buffer += decodedChunk;
+      // Process buffer line by line, looking for complete messages (ending in \n\n)
+      let eventEndIndex;
+      while ((eventEndIndex = buffer.indexOf('\n\n')) !== -1) {
+        const message = buffer.substring(0, eventEndIndex);
+        buffer = buffer.substring(eventEndIndex + 2); // Consume message + \n\n
+        if (message.startsWith('data:')) {
+          const event = parseSseEvent(message);
+          if (event) {
+            events.push(event);
+            if (event.type === BRAIN_EVENTS.COMPLETE) {
+              reader.cancel(`Received terminal event: ${event.type}`);
+              return events;
+            }
+            if (event.type === BRAIN_EVENTS.ERROR) {
+              console.error(
+                'Received BRAIN_EVENTS.ERROR. Event details:',
+                event
+              );
+              reader.cancel(`Received terminal event: ${event.type}`);
+              throw new Error(
+                `Received terminal event: ${
+                  event.type
+                }. Details: ${JSON.stringify(event)}`
+              );
+            }
+          }
+        }
+      }
+    }
+    return events;
+  }
+
+  it('POST /brains/runs without brainName should return 400', async () => {
+    const testEnv = env as TestEnv;
+
+    const request = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({}), // Empty body, check for missing brainName
+    });
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    await waitOnExecutionContext(context);
+
+    expect(response.status).toBe(400);
+    const responseBody = await response.json();
+    expect(responseBody).toEqual({
+      error: 'Missing brainName in request body',
+    });
+  });
+
+  it('POST /brains/runs with non-existent brain should return 404', async () => {
+    const testEnv = env as TestEnv;
+    const request = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ brainName: 'non-existent-brain' }),
+    });
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    await waitOnExecutionContext(context);
+    expect(response.status).toBe(404);
+    const responseBody = await response.json();
+    expect(responseBody).toEqual({
+      error: "Brain 'non-existent-brain' not found",
+    });
+  });
+
+  it('Create and watch a brain run', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'basic-brain';
+
+    // --- Create the brain run ---
+    const request = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ brainName }),
+    });
+    const context = createExecutionContext();
+    const response = await worker.fetch(request, testEnv, context);
+    expect(response.status).toBe(201);
+    const responseBody = await response.json<{ brainRunId: string }>();
+    const brainRunId = responseBody.brainRunId;
+    await waitOnExecutionContext(context);
+
+    // --- Watch the brain run via SSE ---
+    const watchUrl = `http://example.com/brains/runs/${brainRunId}/watch`;
+    const watchRequest = new Request(watchUrl);
+    const watchContext = createExecutionContext();
+    const watchResponse = await worker.fetch(
+      watchRequest,
+      testEnv,
+      watchContext
+    );
+
+    expect(watchResponse.status).toBe(200);
+    expect(watchResponse.headers.get('Content-Type')).toContain(
+      'text/event-stream'
+    );
+    if (!watchResponse.body) {
+      throw new Error('Watch response body is null');
+    }
+
+    // --- Read all events from the SSE stream ---
+    const allEvents = await readSseStream(watchResponse.body);
+
+    // --- Assertions on the collected events ---
+    // Check for start event
+    const startEvent = allEvents.find(
+      (e): e is BrainStartEvent => e.type === BRAIN_EVENTS.START
+    );
+    expect(startEvent).toBeDefined();
+    expect(startEvent?.brainTitle).toBe(brainName);
+    expect(startEvent?.status).toBe(STATUS.RUNNING);
+
+    // Check for complete event
+    const completeEvent = allEvents.find(
+      (e): e is BrainCompleteEvent => e.type === BRAIN_EVENTS.COMPLETE
+    );
+    expect(completeEvent).toBeDefined();
+    expect(completeEvent?.status).toBe(STATUS.COMPLETE);
+
+    // Check the final step status event
+    const stepStatusEvents = allEvents.filter(
+      (e): e is StepStatusEvent => e.type === BRAIN_EVENTS.STEP_STATUS
+    );
+    expect(stepStatusEvents.length).toBeGreaterThan(0);
+    const lastStepStatusEvent = stepStatusEvents[stepStatusEvents.length - 1];
+    expect(
+      lastStepStatusEvent.steps.every(
+        (step: any) => step.status === STATUS.COMPLETE
+      )
+    ).toBe(true);
+
+    // Check for specific step completion if needed (depends on basic-brain structure)
+    const stepCompleteEvents = allEvents.filter(
+      (e): e is StepCompletedEvent => e.type === BRAIN_EVENTS.STEP_COMPLETE
+    );
+    expect(stepCompleteEvents.length).toBeGreaterThanOrEqual(1); // Assuming basic-brain has at least one step
+
+    await waitOnExecutionContext(watchContext);
+  });
+
+  it('Create and watch a delayed brain run', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'delayed-brain';
+
+    // Create the brain run
+    const createRequest = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ brainName }),
+    });
+    const createContext = createExecutionContext();
+    const createResponse = await worker.fetch(
+      createRequest,
+      testEnv,
+      createContext
+    );
+    expect(createResponse.status).toBe(201);
+    const createResponseBody = await createResponse.json<{
+      brainRunId: string;
+    }>();
+    const brainRunId = createResponseBody.brainRunId;
+    await waitOnExecutionContext(createContext);
+
+    // Watch the brain run via SSE
+    const watchUrl = `http://example.com/brains/runs/${brainRunId}/watch`;
+    const watchRequest = new Request(watchUrl);
+    const watchContext = createExecutionContext();
+    const watchResponse = await worker.fetch(
+      watchRequest,
+      testEnv,
+      watchContext
+    );
+
+    expect(watchResponse.status).toBe(200);
+    expect(watchResponse.headers.get('Content-Type')).toContain(
+      'text/event-stream'
+    );
+    if (!watchResponse.body) {
+      throw new Error('Watch response body is null');
+    }
+
+    // --- Read all events from the SSE stream ---
+    const allEvents = await readSseStream(watchResponse.body);
+
+    // --- Assertions on the collected events ---
+    // Check for start event
+    const startEvent = allEvents.find(
+      (e): e is BrainStartEvent => e.type === BRAIN_EVENTS.START
+    );
+    expect(startEvent).toBeDefined();
+    expect(startEvent?.brainTitle).toBe(brainName);
+    expect(startEvent?.status).toBe(STATUS.RUNNING);
+
+    // Check for step start/complete events for the delayed step
+    const delayStepStart = allEvents.find(
+      (e): e is StepStartedEvent =>
+        e.type === BRAIN_EVENTS.STEP_START && e.stepTitle === 'Start Delay'
+    );
+    expect(delayStepStart).toBeDefined();
+    const delayStepComplete = allEvents.find(
+      (e): e is StepCompletedEvent =>
+        e.type === BRAIN_EVENTS.STEP_COMPLETE && e.stepTitle === 'Start Delay'
+    );
+    expect(delayStepComplete).toBeDefined();
+
+    // Check for the final complete event
+    const completeEvent = allEvents.find(
+      (e): e is BrainCompleteEvent => e.type === BRAIN_EVENTS.COMPLETE
+    );
+    expect(completeEvent).toBeDefined();
+    expect(completeEvent?.status).toBe(STATUS.COMPLETE);
+
+    // Check the final step status event shows completion
+    const stepStatusEvents = allEvents.filter(
+      (e): e is StepStatusEvent => e.type === BRAIN_EVENTS.STEP_STATUS
+    );
+    expect(stepStatusEvents.length).toBeGreaterThan(0);
+    const lastStepStatusEvent = stepStatusEvents[stepStatusEvents.length - 1];
+    expect(
+      lastStepStatusEvent.steps.every(
+        (step: any) => step.status === STATUS.COMPLETE
+      )
+    ).toBe(true);
+
+    await waitOnExecutionContext(watchContext);
+  });
+
+  it('Asserts brainRunId is present in SSE events', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'basic-brain';
+
+    // Create brain run
+    const createRequest = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ brainName }),
+    });
+    const createContext = createExecutionContext();
+    const createResponse = await worker.fetch(
+      createRequest,
+      testEnv,
+      createContext
+    );
+    const createResponseBody = await createResponse.json<{
+      brainRunId: string;
+    }>();
+    const expectedBrainRunId = createResponseBody.brainRunId;
+    await waitOnExecutionContext(createContext);
+
+    // Watch brain run
+    const watchUrl = `http://example.com/brains/runs/${expectedBrainRunId}/watch`;
+    const watchRequest = new Request(watchUrl);
+    const watchContext = createExecutionContext();
+    const watchResponse = await worker.fetch(
+      watchRequest,
+      testEnv,
+      watchContext
+    );
+
+    // Get first event from stream
+    const reader = watchResponse.body?.getReader();
+    if (!reader) throw new Error('Watch response body is null');
+
+    const { value } = await reader.read();
+    const chunk = new TextDecoder().decode(value);
+    const event = parseSseEvent(chunk);
+
+    // Cleanup
+    reader.cancel();
+    await waitOnExecutionContext(watchContext);
+
+    // Assert
+    expect(event.brainRunId).toBeDefined();
+    expect(event.brainRunId).toBe(expectedBrainRunId);
+  });
+
+  it('Monitor receives brain events (checking brain run)', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'basic-brain';
+
+    // Start the brain run
+    const createRequest = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ brainName }),
+    });
+    const createContext = createExecutionContext();
+    const createResponse = await worker.fetch(
+      createRequest,
+      testEnv,
+      createContext
+    );
+    const { brainRunId } = await createResponse.json<{ brainRunId: string }>();
+    await waitOnExecutionContext(createContext);
+
+    // Watch the brain run via SSE until completion
+    const watchUrl = `http://example.com/brains/runs/${brainRunId}/watch`;
+    const watchRequest = new Request(watchUrl);
+    const watchContext = createExecutionContext();
+    const watchResponse = await worker.fetch(
+      watchRequest,
+      testEnv,
+      watchContext
+    );
+    await readSseStream(watchResponse.body!);
+    await waitOnExecutionContext(watchContext);
+
+    // Get the monitor singleton instance
+    const monitorId = testEnv.MONITOR_DO.idFromName('singleton');
+    const monitorStub = testEnv.MONITOR_DO.get(monitorId);
+    const lastEvent = await monitorStub.getLastEvent(brainRunId);
+
+    // The last event should be a brain complete event
+    expect(lastEvent).toBeDefined();
+    expect(lastEvent.type).toBe(BRAIN_EVENTS.COMPLETE);
+    expect(lastEvent.status).toBe(STATUS.COMPLETE);
+  });
+
+  it('Watches brain run as it runs', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'basic-brain';
+
+    // Run the brain run twice
+    for (let i = 0; i < 2; i++) {
+      // Start the brain run
+      const createRequest = new Request('http://example.com/brains/runs', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ brainName }),
+      });
+      const createContext = createExecutionContext();
+      const createResponse = await worker.fetch(
+        createRequest,
+        testEnv,
+        createContext
+      );
+      const { brainRunId } = await createResponse.json<{
+        brainRunId: string;
+      }>();
+
+      // Watch the brain run via SSE until completion
+      const watchUrl = `http://example.com/brains/runs/${brainRunId}/watch`;
+      const watchRequest = new Request(watchUrl);
+      const watchContext = createExecutionContext();
+      const watchResponse = await worker.fetch(
+        watchRequest,
+        testEnv,
+        watchContext
+      );
+      await readSseStream(watchResponse.body!);
+      await waitOnExecutionContext(watchContext);
+      await waitOnExecutionContext(createContext);
+    }
+
+    // Get brain run history
+    const historyRequest = new Request(
+      `http://example.com/brains/${brainName}/history?limit=5`
+    );
+    const historyContext = createExecutionContext();
+    const historyResponse = await worker.fetch(
+      historyRequest,
+      testEnv,
+      historyContext
+    );
+    await waitOnExecutionContext(historyContext);
+
+    expect(historyResponse.status).toBe(200);
+    const history = await historyResponse.json<{
+      runs: Array<{
+        brainRunId: string;
+        brainTitle: string;
+        brainDescription: string | null;
+        type: string;
+        status: string;
+        options: string;
+        error: string | null;
+        createdAt: number;
+        startedAt: number | null;
+        completedAt: number | null;
+      }>;
+    }>();
+    expect(history.runs.length).toBe(2);
+
+    // Verify each run has the expected properties
+    for (const run of history.runs) {
+      expect(run).toHaveProperty('brainRunId');
+      expect(run).toHaveProperty('brainTitle');
+      expect(run).toHaveProperty('brainDescription');
+      expect(run).toHaveProperty('type');
+      expect(run).toHaveProperty('status');
+      expect(run).toHaveProperty('options');
+      expect(run).toHaveProperty('error');
+      expect(run).toHaveProperty('createdAt');
+      expect(run).toHaveProperty('startedAt');
+      expect(run).toHaveProperty('completedAt');
+      expect(run.status).toBe(STATUS.COMPLETE);
+      expect(run.brainTitle).toBe(brainName);
+    }
+
+    // Verify runs are ordered by createdAt descending
+    const timestamps = history.runs.map(
+      (run: { createdAt: number }) => run.createdAt
+    );
+    expect(timestamps).toEqual([...timestamps].sort((a, b) => b - a));
+  });
+
+  it('Watch endpoint streams running brains', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'delayed-brain';
+    const brainRuns: string[] = [];
+
+    // Start 3 delayed brains
+    for (let i = 0; i < 3; i++) {
+      const createRequest = new Request('http://example.com/brains/runs', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ brainName }),
+      });
+      const createContext = createExecutionContext();
+      const createResponse = await worker.fetch(
+        createRequest,
+        testEnv,
+        createContext
+      );
+      const { brainRunId } = await createResponse.json<{
+        brainRunId: string;
+      }>();
+      brainRuns.push(brainRunId);
+      await waitOnExecutionContext(createContext);
+    }
+
+    // Connect to watch endpoint
+    const watchRequest = new Request('http://example.com/brains/watch');
+    const watchContext = createExecutionContext();
+    const watchResponse = await worker.fetch(
+      watchRequest,
+      testEnv,
+      watchContext
+    );
+    expect(watchResponse.status).toBe(200);
+    expect(watchResponse.headers.get('Content-Type')).toContain(
+      'text/event-stream'
+    );
+
+    if (!watchResponse.body) {
+      throw new Error('Watch response body is null');
+    }
+
+    // Read the SSE stream
+    const events: any[] = [];
+    const reader = watchResponse.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    // Helper to process SSE messages
+    const processBuffer = () => {
+      const messages = buffer.split('\n\n');
+      buffer = messages.pop() || ''; // Keep the incomplete message in the buffer
+
+      for (const message of messages) {
+        if (message.startsWith('data: ')) {
+          const data = JSON.parse(message.slice(6));
+          events.push(data);
+        }
+      }
+    };
+
+    // Read for a while to capture brain completions
+    const startTime = Date.now();
+    const TIMEOUT = 5000; // 5 seconds should be enough for our test brains
+
+    try {
+      while (Date.now() - startTime < TIMEOUT) {
+        const { value, done } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        processBuffer();
+
+        // If we've seen all brains complete, we can stop early
+        const lastEvent = events[events.length - 1];
+        if (lastEvent?.runningBrains?.length === 0) {
+          break;
+        }
+      }
+    } finally {
+      reader.cancel();
+    }
+
+    // Verify the events
+    expect(events.length).toBeGreaterThan(0);
+
+    // First event should show all brains running
+    const initialState = events[0];
+    expect(initialState.runningBrains).toBeDefined();
+    expect(initialState.runningBrains.length).toBe(3);
+    expect(
+      initialState.runningBrains.every((w: any) => w.status === STATUS.RUNNING)
+    ).toBe(true);
+
+    // Last event should show no running brains
+    const finalState = events[events.length - 1];
+    expect(finalState.runningBrains).toBeDefined();
+    expect(finalState.runningBrains.length).toBe(0);
+
+    await waitOnExecutionContext(watchContext);
+  });
+
+  it('Loads resources from the resource manifest', async () => {
+    const testEnv = env as TestEnv;
+    const brainName = 'resource-brain';
+
+    // First, set up test resources in R2
+    // Create testResource
+    await testEnv.RESOURCES_BUCKET.put(
+      'testResource.txt',
+      'This is a test resource',
+      {
+        customMetadata: {
+          type: 'text',
+          path: 'testResource.txt',
+        },
+      }
+    );
+
+    // Create testResourceBinary
+    await testEnv.RESOURCES_BUCKET.put(
+      'testResourceBinary.bin',
+      'This is a test resource binary',
+      {
+        customMetadata: {
+          type: 'binary',
+          path: 'testResourceBinary.bin',
+        },
+      }
+    );
+
+    // Create nested resource
+    await testEnv.RESOURCES_BUCKET.put(
+      'nestedResource/testNestedResource.txt',
+      'This is a test resource',
+      {
+        customMetadata: {
+          type: 'text',
+          path: 'nestedResource/testNestedResource.txt',
+        },
+      }
+    );
+
+    const createRequest = new Request('http://example.com/brains/runs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ brainName }),
+    });
+    const createContext = createExecutionContext();
+    const createResponse = await worker.fetch(
+      createRequest,
+      testEnv,
+      createContext
+    );
+    const { brainRunId } = await createResponse.json<{
+      brainRunId: string;
+    }>();
+    await waitOnExecutionContext(createContext);
+
+    // Watch the brain run via SSE until completion
+    const watchUrl = `http://example.com/brains/runs/${brainRunId}/watch`;
+    const watchRequest = new Request(watchUrl);
+    const watchContext = createExecutionContext();
+    const watchResponse = await worker.fetch(
+      watchRequest,
+      testEnv,
+      watchContext
+    );
+    expect(watchResponse.status).toBe(200); // Ensure watch connection is OK
+    if (!watchResponse.body) {
+      throw new Error('Watch response body is null');
+    }
+
+    // --- Read all events from the SSE stream ---
+    const allEvents = await readSseStream(watchResponse.body);
+    await waitOnExecutionContext(watchContext); // Wait for SSE stream processing and DOs to settle
+
+    // --- Assertions on the collected events ---
+
+    // Check for overall brain completion
+    const completeEvent = allEvents.find(
+      (e): e is BrainCompleteEvent => e.type === BRAIN_EVENTS.COMPLETE
+    );
+    expect(completeEvent).toBeDefined();
+    expect(completeEvent?.status).toBe(STATUS.COMPLETE);
+
+    // Find the step completion events
+    const stepCompleteEvents = allEvents.filter(
+      (e): e is StepCompletedEvent => e.type === BRAIN_EVENTS.STEP_COMPLETE
+    );
+
+    const loadTextStepCompleteEvent = stepCompleteEvents.find(
+      (e) => e.stepTitle === 'Load text resource'
+    );
+    expect(loadTextStepCompleteEvent).toBeDefined();
+    expect(loadTextStepCompleteEvent?.patch).toBeDefined();
+
+    const loadBinaryStepCompleteEvent = stepCompleteEvents.find(
+      (e) => e.stepTitle === 'Load binary resource'
+    );
+    expect(loadBinaryStepCompleteEvent).toBeDefined();
+    expect(loadBinaryStepCompleteEvent?.patch).toBeDefined();
+
+    // Expected resource content from packages/cloudflare/test-project/src/runner.ts
+    const expectedTextContent = 'This is a test resource';
+    const expectedBinaryContentRaw = 'This is a test resource binary';
+    const expectedBinaryContentBase64 = Buffer.from(
+      expectedBinaryContentRaw
+    ).toString('base64');
+
+    // Verify the patch from 'Load text resource' step
+    // This patch is relative to the state *before* this step
+    const textPatch = loadTextStepCompleteEvent!.patch;
+    const addTextOp = textPatch.find(
+      (op) => op.op === 'add' && op.path === '/text'
+    );
+    expect(addTextOp).toBeDefined();
+    expect(addTextOp?.value).toBe(expectedTextContent);
+
+    // Verify the patch from 'Load binary resource' step
+    // This patch is relative to the state *after* 'Load text resource' step
+    const binaryPatch = loadBinaryStepCompleteEvent!.patch;
+    const addBufferOp = binaryPatch.find(
+      (op) => op.op === 'add' && op.path === '/buffer'
+    );
+    expect(addBufferOp).toBeDefined();
+    expect(addBufferOp?.value).toBe(expectedBinaryContentBase64);
+
+    // Verify the patch from 'Load nested resource' step
+    const loadNestedStepCompleteEvent = stepCompleteEvents.find(
+      (e) => e.stepTitle === 'Load nested resource'
+    );
+    expect(loadNestedStepCompleteEvent).toBeDefined();
+    expect(loadNestedStepCompleteEvent?.patch).toBeDefined();
+    const nestedTextPatch = loadNestedStepCompleteEvent!.patch;
+    const addNestedTextOp = nestedTextPatch.find(
+      (op) => op.op === 'add' && op.path === '/nestedText'
+    );
+    expect(addNestedTextOp).toBeDefined();
+    // The mock loader will return 'This is a test resource' for any text request.
+    expect(addNestedTextOp?.value).toBe(expectedTextContent);
+
+    // Check that the steps themselves are marked as completed in the final status
+    const stepStatusEvents = allEvents.filter(
+      (e): e is StepStatusEvent => e.type === BRAIN_EVENTS.STEP_STATUS
+    );
+    expect(stepStatusEvents.length).toBeGreaterThan(0);
+    const lastStepStatusEvent = stepStatusEvents[stepStatusEvents.length - 1];
+
+    expect(lastStepStatusEvent.steps.length).toBe(3); // resource-brain has 3 steps
+    const textStepFinalStatus = lastStepStatusEvent.steps.find(
+      (s) => s.title === 'Load text resource'
+    );
+    const binaryStepFinalStatus = lastStepStatusEvent.steps.find(
+      (s) => s.title === 'Load binary resource'
+    );
+    const nestedStepFinalStatus = lastStepStatusEvent.steps.find(
+      (s) => s.title === 'Load nested resource'
+    );
+
+    expect(textStepFinalStatus?.status).toBe(STATUS.COMPLETE);
+    expect(binaryStepFinalStatus?.status).toBe(STATUS.COMPLETE);
+    expect(nestedStepFinalStatus?.status).toBe(STATUS.COMPLETE);
+
+    // Clean up test resources
+    await testEnv.RESOURCES_BUCKET.delete('testResource.txt');
+    await testEnv.RESOURCES_BUCKET.delete('testResourceBinary.bin');
+    await testEnv.RESOURCES_BUCKET.delete(
+      'nestedResource/testNestedResource.txt'
+    );
+  });
+
+  describe('Brain Schedules API Tests', () => {
+    it('POST /brains/schedules creates a new schedule', async () => {
+      const testEnv = env as TestEnv;
+      const brainName = 'basic-brain';
+      const cronExpression = '0 3 * * *'; // Daily at 3am
+
+      const request = new Request('http://example.com/brains/schedules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ brainName, cronExpression }),
+      });
+      const context = createExecutionContext();
+      const response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+
+      expect(response.status).toBe(201);
+      const responseBody = await response.json<{
+        id: string;
+        brainName: string;
+        cronExpression: string;
+        enabled: boolean;
+        createdAt: number;
+      }>();
+
+      expect(responseBody.id).toBeDefined();
+      expect(responseBody.brainName).toBe(brainName);
+      expect(responseBody.cronExpression).toBe(cronExpression);
+      expect(responseBody.enabled).toBe(true);
+      expect(responseBody.createdAt).toBeDefined();
+    });
+
+    it('GET /brains/schedules lists all schedules', async () => {
+      const testEnv = env as TestEnv;
+
+      // Create a few schedules first
+      for (let i = 0; i < 3; i++) {
+        const request = new Request('http://example.com/brains/schedules', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            brainName: `brain-${i}`,
+            cronExpression: `${i} * * * *`,
+          }),
+        });
+        const context = createExecutionContext();
+        await worker.fetch(request, testEnv, context);
+        await waitOnExecutionContext(context);
+      }
+
+      // List schedules
+      const listRequest = new Request('http://example.com/brains/schedules');
+      const listContext = createExecutionContext();
+      const listResponse = await worker.fetch(
+        listRequest,
+        testEnv,
+        listContext
+      );
+      await waitOnExecutionContext(listContext);
+
+      expect(listResponse.status).toBe(200);
+      const responseBody = await listResponse.json<{
+        schedules: Array<{
+          id: string;
+          brainName: string;
+          cronExpression: string;
+          enabled: boolean;
+          createdAt: number;
+        }>;
+        count: number;
+      }>();
+
+      expect(responseBody.schedules).toBeInstanceOf(Array);
+      expect(responseBody.count).toBeGreaterThanOrEqual(3);
+    });
+
+    it('DELETE /brains/schedules/:scheduleId deletes a schedule', async () => {
+      const testEnv = env as TestEnv;
+
+      // Create a schedule
+      const createRequest = new Request('http://example.com/brains/schedules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          brainName: 'delete-brain',
+          cronExpression: '0 0 * * *',
+        }),
+      });
+      const createContext = createExecutionContext();
+      const createResponse = await worker.fetch(
+        createRequest,
+        testEnv,
+        createContext
+      );
+      const { id } = await createResponse.json<{ id: string }>();
+      await waitOnExecutionContext(createContext);
+
+      // Delete the schedule
+      const deleteRequest = new Request(
+        `http://example.com/brains/schedules/${id}`,
+        {
+          method: 'DELETE',
+        }
+      );
+      const deleteContext = createExecutionContext();
+      const deleteResponse = await worker.fetch(
+        deleteRequest,
+        testEnv,
+        deleteContext
+      );
+      await waitOnExecutionContext(deleteContext);
+
+      expect(deleteResponse.status).toBe(204);
+
+      // Verify it's deleted
+      const getRequest = new Request(
+        `http://example.com/brains/schedules/${id}`
+      );
+      const getContext = createExecutionContext();
+      const getResponse = await worker.fetch(getRequest, testEnv, getContext);
+      await waitOnExecutionContext(getContext);
+
+      expect(getResponse.status).toBe(404);
+    });
+
+    it('GET /brains/schedules/runs lists scheduled run history', async () => {
+      const testEnv = env as TestEnv;
+
+      const request = new Request('http://example.com/brains/schedules/runs');
+      const context = createExecutionContext();
+      const response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+
+      expect(response.status).toBe(200);
+      const responseBody = await response.json<{
+        runs: Array<{
+          id: number;
+          scheduleId: string;
+          brainRunId?: string;
+          status: 'triggered' | 'failed';
+          ranAt: number;
+        }>;
+        count: number;
+      }>();
+
+      expect(responseBody.runs).toBeInstanceOf(Array);
+      expect(typeof responseBody.count).toBe('number');
+    });
+
+    it('GET /brains/schedules/runs with scheduleId filter', async () => {
+      const testEnv = env as TestEnv;
+      const scheduleId = 'test-schedule-123';
+
+      const request = new Request(
+        `http://example.com/brains/schedules/runs?scheduleId=${scheduleId}`
+      );
+      const context = createExecutionContext();
+      const response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+
+      expect(response.status).toBe(200);
+      const responseBody = await response.json<{
+        runs: Array<{
+          id: number;
+          scheduleId: string;
+          brainRunId?: string;
+          status: 'triggered' | 'failed';
+          ranAt: number;
+        }>;
+        count: number;
+      }>();
+
+      // All runs should belong to the specified schedule
+      for (const run of responseBody.runs) {
+        expect(run.scheduleId).toBe(scheduleId);
+      }
+    });
+
+    it('POST /brains/schedules validates cron expression', async () => {
+      const testEnv = env as TestEnv;
+
+      const request = new Request('http://example.com/brains/schedules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          brainName: 'invalid-cron-brain',
+          cronExpression: 'invalid cron',
+        }),
+      });
+      const context = createExecutionContext();
+      const response = await worker.fetch(request, testEnv, context);
+      await waitOnExecutionContext(context);
+
+      expect(response.status).toBe(400);
+      const error = (await response.json()) as { error: string };
+      expect(error.error).toContain('Invalid cron expression');
+    });
+
+    it('POST /brains/schedules allows multiple schedules per brain', async () => {
+      const testEnv = env as TestEnv;
+      const brainName = 'multi-schedule-brain';
+
+      // Create first schedule
+      const request1 = new Request('http://example.com/brains/schedules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          brainName,
+          cronExpression: '0 9 * * *', // 9am daily
+        }),
+      });
+      const context1 = createExecutionContext();
+      const response1 = await worker.fetch(request1, testEnv, context1);
+      await waitOnExecutionContext(context1);
+      expect(response1.status).toBe(201);
+
+      // Create second schedule for same brain
+      const request2 = new Request('http://example.com/brains/schedules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          brainName,
+          cronExpression: '0 17 * * *', // 5pm daily
+        }),
+      });
+      const context2 = createExecutionContext();
+      const response2 = await worker.fetch(request2, testEnv, context2);
+      await waitOnExecutionContext(context2);
+      expect(response2.status).toBe(201);
+
+      // Verify both schedules exist
+      const listRequest = new Request('http://example.com/brains/schedules');
+      const listContext = createExecutionContext();
+      const listResponse = await worker.fetch(
+        listRequest,
+        testEnv,
+        listContext
+      );
+      await waitOnExecutionContext(listContext);
+
+      const { schedules } = await listResponse.json<{
+        schedules: Array<{ brainName: string }>;
+      }>();
+
+      const multiSchedules = schedules.filter((s) => s.brainName === brainName);
+      expect(multiSchedules.length).toBe(2);
+    });
+  });
+});