@cyanautomation/kaseki-agent 1.4.1

package/src/middleware/job-lookup.test.ts

@@ -0,0 +1,113 @@
+import { Request, Response } from 'express';
+import { jobLookupMiddleware } from './job-lookup';
+import { JobScheduler } from '../job-scheduler';
+import { Job } from '../kaseki-api-types';
+
+// Mock Job object
+const mockJob: Job = {
+  id: 'run-123',
+  status: 'running',
+  createdAt: new Date(),
+  startedAt: new Date(),
+  completedAt: undefined,
+  resultDir: '/results/run-123',
+  correlationId: 'corr-456',
+  requestId: 'req-789',
+  exitCode: undefined,
+  failureClass: undefined,
+  error: undefined,
+  webhookConfig: undefined,
+  finalized: false,
+  request: {
+    repoUrl: 'https://github.com/org/repo',
+    ref: 'main',
+    taskPrompt: 'Fix the bug',
+  },
+};
+
+describe('jobLookupMiddleware', () => {
+  let mockScheduler: jest.Mocked<JobScheduler>;
+  let mockReq: Partial<Request>;
+  let mockRes: Partial<Response>;
+  let nextCalled: boolean;
+
+  beforeEach(() => {
+    // Create a mock scheduler
+    mockScheduler = {
+      getJob: jest.fn(),
+    } as unknown as jest.Mocked<JobScheduler>;
+
+    // Create mock request and response
+    mockReq = {
+      params: { id: 'run-123' },
+    };
+
+    mockRes = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis(),
+    };
+
+    nextCalled = false;
+  });
+
+  const next = (): void => {
+    nextCalled = true;
+  };
+
+  it('should attach job to request when found', () => {
+    mockScheduler.getJob.mockReturnValue(mockJob);
+
+    const middleware = jobLookupMiddleware(mockScheduler);
+    middleware(mockReq as Request, mockRes as Response, next);
+
+    expect(mockScheduler.getJob).toHaveBeenCalledWith('run-123');
+    expect(mockReq.job).toBe(mockJob);
+    expect(nextCalled).toBe(true);
+  });
+
+  it('should return 404 when job not found', () => {
+    mockScheduler.getJob.mockReturnValue(undefined);
+
+    const middleware = jobLookupMiddleware(mockScheduler);
+    middleware(mockReq as Request, mockRes as Response, next);
+
+    expect(mockScheduler.getJob).toHaveBeenCalledWith('run-123');
+    expect(mockRes.status).toHaveBeenCalledWith(404);
+    expect(nextCalled).toBe(false);
+  });
+
+  it('should return 400 when job ID is missing', () => {
+    mockReq.params = {};
+
+    const middleware = jobLookupMiddleware(mockScheduler);
+    middleware(mockReq as Request, mockRes as Response, next);
+
+    expect(mockRes.status).toHaveBeenCalledWith(400);
+    expect(nextCalled).toBe(false);
+  });
+
+  it('should not call scheduler.getJob when job ID is missing', () => {
+    mockReq.params = {};
+
+    const middleware = jobLookupMiddleware(mockScheduler);
+    middleware(mockReq as Request, mockRes as Response, next);
+
+    expect(mockScheduler.getJob).not.toHaveBeenCalled();
+  });
+
+  it('should return proper error response format for 404', () => {
+    mockScheduler.getJob.mockReturnValue(undefined);
+
+    const middleware = jobLookupMiddleware(mockScheduler);
+    middleware(mockReq as Request, mockRes as Response, next);
+
+    // Verify that json() was called with the correct error format
+    const callArgs = (mockRes.json as jest.Mock).mock.calls[0][0];
+    expect(callArgs).toEqual({
+      type: 'https://api.kaseki.local/errors#not-found',
+      title: 'Not Found',
+      status: 404,
+      detail: 'Run not found: run-123',
+    });
+  });
+});

package/src/middleware/job-lookup.ts

@@ -0,0 +1,45 @@
+import { Request, Response, NextFunction } from 'express';
+import { JobScheduler } from '../job-scheduler';
+import { Job } from '../kaseki-api-types';
+import { sendErrorResponse } from '../utils/response-helpers';
+
+/**
+ * Extend Express Request to include the job from middleware.
+ */
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Express {
+    interface Request {
+      job?: Job;
+    }
+  }
+}
+
+/**
+ * Middleware that looks up a job by ID and attaches it to the request.
+ * If the job is not found, responds with a 404 error.
+ *
+ * Usage:
+ * ```typescript
+ * router.get('/runs/:id/status', jobLookupMiddleware(scheduler), (req, res) => {
+ *   const job = req.job!; // guaranteed to exist
+ *   // ...
+ * });
+ * ```
+ */
+export function jobLookupMiddleware(scheduler: JobScheduler) {
+  return (req: Request, res: Response, next: NextFunction): void => {
+    const jobId = req.params.id;
+    if (!jobId) {
+      return sendErrorResponse(res, 400, 'Bad Request', 'Job ID is required');
+    }
+
+    const job = scheduler.getJob(jobId);
+    if (!job) {
+      return sendErrorResponse(res, 404, 'Not Found', `Run not found: ${jobId}`);
+    }
+
+    req.job = job;
+    next();
+  };
+}

package/src/pi-event-filter.test.ts

@@ -0,0 +1,183 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+jest.setTimeout(20000);
+
+interface RunResult {
+  exitCode: number | null;
+  lines: string[];
+  summary: any;
+}
+
+async function runFilter(inputLines: string[]): Promise<RunResult> {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-event-filter-fast-'));
+  const inputPath = path.join(tmpDir, 'in.jsonl');
+  const outputPath = path.join(tmpDir, 'out.jsonl');
+  const summaryPath = path.join(tmpDir, 'summary.json');
+
+  try {
+    fs.writeFileSync(inputPath, `${inputLines.join('\n')}\n`, 'utf8');
+
+    let stderrOutput = '';
+    const tsxBin = path.join(__dirname, '..', 'node_modules', '.bin', 'tsx');
+    const child = spawn(tsxBin, [
+      path.join(__dirname, 'pi-event-filter.ts'),
+      inputPath,
+      outputPath,
+      summaryPath,
+    ]);
+
+    if (child.stderr) {
+      child.stderr.on('data', (data: Buffer) => {
+        stderrOutput += data.toString();
+      });
+    }
+
+    const exitCode = await new Promise<number | null>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('close', resolve);
+    });
+
+    if (exitCode !== 0 && stderrOutput) {
+      console.error(`pi-event-filter stderr (exit ${exitCode}):`, stderrOutput);
+    }
+
+    const output = fs.existsSync(outputPath)
+      ? fs.readFileSync(outputPath, 'utf8').trim()
+      : '';
+    const lines = output ? output.split('\n') : [];
+    const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+
+    return { exitCode, lines, summary };
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+describe('pi-event-filter fast correctness tests', () => {
+  test('filters a tiny JSONL fixture and writes representative summary', async () => {
+    const fixture = [
+      JSON.stringify({
+        type: 'tool_execution_start',
+        timestamp: '2026-01-01T00:00:00.000Z',
+        message: { model: 'small-model', api: 'small-api' },
+        assistantMessageEvent: {
+          type: 'thinking_delta',
+          partial: { content: [{ type: 'thinking', text: 'hidden' }] },
+        },
+      }),
+      JSON.stringify({
+        type: 'tool_execution_end',
+        timestamp: '2026-01-01T00:00:01.000Z',
+        message: {
+          model: 'small-model',
+          api: 'small-api',
+          content: [
+            { type: 'thinking', text: 'remove-me' },
+            { type: 'output_text', text: 'keep-me' },
+          ],
+        },
+        assistantMessageEvent: {
+          type: 'output_delta',
+          partial: {
+            content: [
+              { type: 'thinking', text: 'remove-me-too' },
+              { type: 'output_text', text: 'visible' },
+            ],
+          },
+        },
+      }),
+    ];
+
+    const result = await runFilter(fixture);
+    expect(result.exitCode).toBe(0);
+    expect(result.lines).toHaveLength(1);
+
+    const kept = JSON.parse(result.lines[0]);
+    expect(kept.message.content).toEqual([{ type: 'output_text', text: 'keep-me' }]);
+    expect(kept.assistantMessageEvent.partial.content).toEqual([
+      { type: 'output_text', text: 'visible' },
+    ]);
+    expect(result.summary).toMatchObject({
+      selected_model: 'small-model',
+      selected_api: 'small-api',
+      invalid_json_lines: 0,
+      tool_start_count: 1,
+      tool_end_count: 1,
+      first_event_at: '2026-01-01T00:00:00.000Z',
+      last_event_at: '2026-01-01T00:00:01.000Z',
+      event_counts: {
+        tool_execution_start: 1,
+        tool_execution_end: 1,
+      },
+      assistant_event_counts: {
+        thinking_delta: 1,
+        output_delta: 1,
+      },
+    });
+  });
+
+  test('computes summary counts and preferred model/api from medium fixture', async () => {
+    const fixture = [
+      JSON.stringify({
+        type: 'tool_execution_start',
+        timestamp: '2026-01-01T00:00:01.000Z',
+        message: { model: 'model-a', api: 'api-a' },
+        assistantMessageEvent: { type: 'output_delta', partial: { model: 'model-a', api: 'api-a' } },
+      }),
+      JSON.stringify({
+        type: 'tool_execution_end',
+        timestamp: '2026-01-01T00:00:03.000Z',
+        message: { model: 'model-b', api: 'api-b' },
+        assistantMessageEvent: { type: 'output_delta', partial: { model: 'model-b', api: 'api-b' } },
+      }),
+      JSON.stringify({
+        type: 'tool_execution_start',
+        timestamp: '2026-01-01T00:00:02.000Z',
+        message: { model: 'model-a', api: 'api-a' },
+        assistantMessageEvent: { type: 'thinking_delta', partial: { model: 'model-a', api: 'api-a' } },
+      }),
+      JSON.stringify({
+        type: 'other_event',
+        timestamp: '2026-01-01T00:00:04.000Z',
+        message: { model: 'model-c', api: 'api-c' },
+        assistantMessageEvent: { type: 'output_delta', partial: { model: 'model-c', api: 'api-c' } },
+      }),
+    ];
+
+    const result = await runFilter(fixture);
+    expect(result.exitCode).toBe(0);
+    expect(result.lines).toHaveLength(3);
+    expect(result.summary.tool_start_count).toBe(2);
+    expect(result.summary.tool_end_count).toBe(1);
+    expect(result.summary.event_counts.tool_execution_start).toBe(2);
+    expect(result.summary.event_counts.tool_execution_end).toBe(1);
+    expect(result.summary.event_counts.other_event).toBe(1);
+    expect(result.summary.assistant_event_counts.output_delta).toBe(3);
+    expect(result.summary.assistant_event_counts.thinking_delta).toBe(1);
+    expect(result.summary.selected_model).toBe('model-a');
+    expect(result.summary.selected_api).toBe('api-a');
+    expect(result.summary.first_event_at).toBe('2026-01-01T00:00:01.000Z');
+    expect(result.summary.last_event_at).toBe('2026-01-01T00:00:04.000Z');
+  });
+
+  test('counts and skips invalid JSON lines', async () => {
+    const fixture = [
+      '{"type":"tool_execution_start","timestamp":"2026-01-01T00:00:01.000Z","message":{"model":"x","api":"y"}}',
+      '{this-is-invalid-json}',
+      JSON.stringify({
+        type: 'tool_execution_end',
+        timestamp: '2026-01-01T00:00:02.000Z',
+        message: { model: 'x', api: 'y' },
+        assistantMessageEvent: { type: 'output_delta' },
+      }),
+    ];
+
+    const result = await runFilter(fixture);
+    expect(result.exitCode).toBe(0);
+    expect(result.lines).toHaveLength(2);
+    expect(result.summary.invalid_json_lines).toBe(1);
+  });
+});

package/src/pi-event-filter.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { once } from 'node:events';
+import readline from 'node:readline';
+import { EventCounterAggregator } from './event-aggregator.js';
+import { TimestampTracker } from './timestamp-tracker.js';
+
+interface PiEvent {
+  type?: string;
+  timestamp?: string | number;
+  message?: {
+    model?: string;
+    api?: string;
+    timestamp?: string | number;
+    content?: Array<{ type: string }>;
+  };
+  assistantMessageEvent?: {
+    type?: string;
+    message?: {
+      model?: string;
+      api?: string;
+      timestamp?: string | number;
+      content?: Array<{ type: string }>;
+    };
+    partial?: {
+      model?: string;
+      api?: string;
+      timestamp?: string | number;
+      content?: Array<{ type: string }>;
+    };
+  };
+}
+
+interface EventCountMap {
+  [key: string]: number;
+}
+
+interface Summary {
+  selected_model: string;
+  selected_api: string;
+  event_counts: EventCountMap;
+  assistant_event_counts: EventCountMap;
+  tool_start_count: number;
+  tool_end_count: number;
+  invalid_json_lines: number;
+  first_event_at: string | null;
+  last_event_at: string | null;
+}
+
+const inputPath = process.argv[2] ?? '/tmp/pi-events.raw.jsonl';
+const filteredPath = process.argv[3] ?? '/results/pi-events.jsonl';
+const summaryPath = process.argv[4] ?? '/results/pi-summary.json';
+
+let rssSampler: NodeJS.Timeout | null = null;
+let maxRssBytes = 0;
+
+function startRssSampler(): void {
+  if (process.env.PI_EVENT_FILTER_TRACK_RSS !== '1') return;
+  maxRssBytes = process.memoryUsage().rss;
+  rssSampler = setInterval(() => {
+    maxRssBytes = Math.max(maxRssBytes, process.memoryUsage().rss);
+  }, 25);
+  rssSampler.unref();
+}
+
+function stopRssSampler(): void {
+  if (process.env.PI_EVENT_FILTER_TRACK_RSS !== '1') return;
+  if (rssSampler) {
+    clearInterval(rssSampler);
+    rssSampler = null;
+  }
+  maxRssBytes = Math.max(maxRssBytes, process.memoryUsage().rss);
+  process.stderr.write(`MAX_RSS_BYTES=${maxRssBytes}
+`);
+}
+
+function eventTimestamp(event: PiEvent): string | null {
+  const candidates = [
+    event.timestamp,
+    event.message?.timestamp,
+    event.assistantMessageEvent?.message?.timestamp,
+    event.assistantMessageEvent?.partial?.timestamp,
+  ];
+  for (const value of candidates) {
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+      return new Date(value).toISOString();
+  }
+  return null;
+}
+
+function shouldKeep(event: PiEvent): boolean {
+  const assistantType = event.assistantMessageEvent?.type;
+  if (assistantType?.startsWith('thinking_')) return false;
+  return true;
+}
+
+function sanitize(event: PiEvent): PiEvent {
+  const copy = JSON.parse(JSON.stringify(event)) as PiEvent;
+  if (copy.assistantMessageEvent?.partial?.content) {
+    copy.assistantMessageEvent.partial.content =
+      copy.assistantMessageEvent.partial.content.filter(
+        (part) => part?.type !== 'thinking'
+      );
+  }
+  if (copy.message?.content) {
+    copy.message.content = copy.message.content.filter(
+      (part) => part?.type !== 'thinking'
+    );
+  }
+  return copy;
+}
+
+async function main(): Promise<void> {
+  startRssSampler();
+  const input = fs.createReadStream(inputPath, { encoding: 'utf8' });
+  const output = fs.createWriteStream(filteredPath, { encoding: 'utf8' });
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+
+  const aggregator = new EventCounterAggregator();
+  const tracker = new TimestampTracker();
+  let invalidJsonLines = 0;
+
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    let event: PiEvent;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      invalidJsonLines++;
+      continue;
+    }
+
+    // Record event type
+    aggregator.recordEventType(event.type);
+
+    // Track timestamp
+    const timestamp = eventTimestamp(event);
+    if (timestamp) {
+      tracker.record(timestamp);
+    }
+
+    // Record model and API observations
+    aggregator.recordModelAndApi(event.message);
+    aggregator.recordModelAndApi(event.assistantMessageEvent?.message);
+    aggregator.recordModelAndApi(event.assistantMessageEvent?.partial);
+
+    // Record assistant event type
+    const assistantType = event.assistantMessageEvent?.type;
+    aggregator.recordAssistantEventType(assistantType);
+
+    // Track tool executions
+    if (event.type === 'tool_execution_start') aggregator.recordToolStart();
+    if (event.type === 'tool_execution_end') aggregator.recordToolEnd();
+
+    // Write event if it should be kept
+    if (shouldKeep(event)) {
+      const canContinue = output.write(`${JSON.stringify(sanitize(event))}\n`);
+      if (!canContinue) {
+        await once(output, 'drain');
+      }
+    }
+  }
+
+  await new Promise<void>((resolve) => output.end(resolve));
+
+  // Generate summary
+  const summary: Summary = {
+    ...aggregator.summary(),
+    invalid_json_lines: invalidJsonLines,
+    first_event_at: tracker.firstEpochMs() !== null ? new Date(tracker.firstEpochMs()!).toISOString() : tracker.firstTimestamp(),
+    last_event_at: tracker.lastEpochMs() !== null ? new Date(tracker.lastEpochMs()!).toISOString() : tracker.lastTimestamp(),
+  };
+
+  fs.writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
+  stopRssSampler();
+}
+
+main().catch((error: Error) => {
+  stopRssSampler();
+  console.error(error);
+  process.exit(1);
+});