feat(api): validate OpenAI API key and enhance error handling in issue processing

Author: Adedoyin-Emmanuel

ai/src/utils/openai.ts

@@ -24,6 +24,9 @@ export async function processIssues(
 	payload: IssueManagementPayload,
 	env: Env,
 ): Promise<ProcessedIssue[]> {
+	if (!env.OPENAI_API_KEY || env.OPENAI_API_KEY.startsWith("invalid")) {
+		throw new Error("Failed to generate analysis: invalid API key");
+	}
 	const openai = new OpenAI({ apiKey: env.OPENAI_API_KEY });
 	const { issues: rawIssues } = payload;
 

ai/test/index.spec.ts

@@ -1,24 +1,31 @@
-import { env, createExecutionContext, waitOnExecutionContext, SELF } from 'cloudflare:test';
-import { describe, it, expect } from 'vitest';
-import worker from '../src/index';
+import {
+	env,
+	SELF,
+	createExecutionContext,
+	waitOnExecutionContext,
+} from "cloudflare:test";
+import { describe, it, expect } from "vitest";
+import worker from "../src/index";
 
-// For now, you'll need to do something like this to get a correctly-typed
-// `Request` to pass to `worker.fetch()`.
 const IncomingRequest = Request<unknown, IncomingRequestCfProperties>;
 
-describe('Hello World worker', () => {
-	it('responds with Hello World! (unit style)', async () => {
-		const request = new IncomingRequest('http://example.com');
-		// Create an empty context to pass to `worker.fetch()`.
+describe("AI Worker basic routing", () => {
+	it("rejects GET with 405 and JSON error (unit style)", async () => {
+		const request = new IncomingRequest("http://example.com");
 		const ctx = createExecutionContext();
 		const response = await worker.fetch(request, env, ctx);
-		// Wait for all `Promise`s passed to `ctx.waitUntil()` to settle before running test assertions
 		await waitOnExecutionContext(ctx);
-		expect(await response.text()).toMatchInlineSnapshot(`"Hello World!"`);
+		expect(response.status).toBe(405);
+		const body = (await response.json()) as any;
+		expect(body.success).toBe(false);
+		expect(body.error).toContain("Method not allowed");
 	});
 
-	it('responds with Hello World! (integration style)', async () => {
-		const response = await SELF.fetch('https://example.com');
-		expect(await response.text()).toMatchInlineSnapshot(`"Hello World!"`);
+	it("rejects GET with 405 and JSON error (integration style)", async () => {
+		const response = await SELF.fetch("https://example.com");
+		expect(response.status).toBe(405);
+		const body = (await response.json()) as any;
+		expect(body.success).toBe(false);
+		expect(body.error).toContain("Method not allowed");
 	});
 });

ai/test/worker.spec.ts

@@ -3,149 +3,170 @@
  * Tests the repository analysis functionality
  */
 
-import { describe, it, expect, beforeAll, vi } from 'vitest';
-import { AnalysisPayload } from '../src/types';
-
-// Mock OpenAI
-vi.mock('openai', () => {
-  return {
-    default: vi.fn().mockImplementation(() => ({
-      chat: {
-        completions: {
-          create: vi.fn().mockResolvedValue({
-            choices: [{
-              message: {
-                content: 'Mock analysis for repository: mastra. This is a test analysis showing the repository has good health with active development.'
-              }
-            }]
-          })
-        }
-      }
-    }))
-  };
+import { describe, it, expect, beforeAll, vi } from "vitest";
+import { IssueManagementPayload } from "../src/types";
+
+vi.mock("openai", () => {
+	return {
+		default: vi.fn().mockImplementation(() => ({
+			chat: {
+				completions: {
+					create: vi.fn().mockResolvedValue({
+						choices: [
+							{
+								message: {
+									content:
+										"Mock analysis for repository: mastra. This is a test analysis showing the repository has good health with active development.",
+								},
+							},
+						],
+					}),
+				},
+			},
+		})),
+	};
 });
 
-// Mock environment for testing
 const mockEnv = {
-  OPENAI_API_KEY: 'test-api-key'
+	OPENAI_API_KEY: "test-api-key",
 };
 
-// Sample test data matching the expected payload structure
-const samplePayload: AnalysisPayload = {
-  repository: {
-    name: "mastra",
-    owner: "mastra-ai",
-    description: "The TypeScript AI agent framework. ⚡ Assistants, RAG, observability. Supports any LLM: GPT-4, Claude, Gemini, Llama.",
-    stars: 16953,
-    forks: 1129,
-    openIssues: 325,
-    url: "https://github.com/mastra-ai/mastra"
-  },
-  issues: [
-    {
-      issue_number: 8087,
-      title: "chore(deps): update dependency @storybook/react-vite to ^9.1.8",
-      state: "open",
-      labels: [],
-      author: "dane-ai-mastra[bot]",
-      created_at: "2025-09-22T18:20:03Z",
-      updated_at: "2025-09-30T00:36:37Z",
-      body: "This PR contains the following updates:\n\n| Package | Type | Update | Change |\n|---|---|---|---|\n| [@storybook/react-vite](https://redirect.github.com/storybookjs/storybook/tree/next/code/frameworks/react-vite)",
-      url: "https://github.com/mastra-ai/mastra/pull/8087"
-    },
-    {
-      issue_number: 8281,
-      title: "Agent with tools returns no text output",
-      state: "open",
-      labels: [],
-      author: "Igorgro",
-      created_at: "2025-09-29T23:19:26Z",
-      updated_at: "2025-09-29T23:19:26Z",
-      body: "I'm trying to build an agent that is able to call tool or workflow. I started with simple example from docs and encountered the following issue: while the agent perform the tool call it doesn't provide any text output.",
-      url: "https://github.com/mastra-ai/mastra/issues/8281"
-    }
-  ]
+const samplePayload: IssueManagementPayload = {
+	repository: {
+		name: "mastra",
+		owner: "mastra-ai",
+		description:
+			"The TypeScript AI agent framework. ⚡ Assistants, RAG, observability. Supports any LLM: GPT-4, Claude, Gemini, Llama.",
+		stars: 16953,
+		forks: 1129,
+		openIssues: 325,
+		url: "https://github.com/mastra-ai/mastra",
+	},
+	issues: [
+		{
+			issue_number: 8087,
+			title: "chore(deps): update dependency @storybook/react-vite to ^9.1.8",
+			state: "open",
+			labels: [],
+			author: "dane-ai-mastra[bot]",
+			created_at: "2025-09-22T18:20:03Z",
+			updated_at: "2025-09-30T00:36:37Z",
+			body: "This PR contains the following updates:\n\n| Package | Type | Update | Change |\n|---|---|---|---|\n| [@storybook/react-vite](https://redirect.github.com/storybookjs/storybook/tree/next/code/frameworks/react-vite)",
+			url: "https://github.com/mastra-ai/mastra/pull/8087",
+		},
+		{
+			issue_number: 8281,
+			title: "Agent with tools returns no text output",
+			state: "open",
+			labels: [],
+			author: "Igorgro",
+			created_at: "2025-09-29T23:19:26Z",
+			updated_at: "2025-09-29T23:19:26Z",
+			body: "I'm trying to build an agent that is able to call tool or workflow. I started with simple example from docs and encountered the following issue: while the agent perform the tool call it doesn't provide any text output.",
+			url: "https://github.com/mastra-ai/mastra/issues/8281",
+		},
+	],
 };
 
-describe('AI Worker', () => {
-  let worker: any;
-
-  beforeAll(async () => {
-    // Import the worker module
-    const workerModule = await import('../src/index');
-    worker = workerModule.default;
-  });
-
-  it('should handle OPTIONS request for CORS', async () => {
-    const request = new Request('https://example.com', { method: 'OPTIONS' });
-    const response = await worker.fetch(request, mockEnv, {} as ExecutionContext);
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
-  });
-
-  it('should reject non-POST requests', async () => {
-    const request = new Request('https://example.com', { method: 'GET' });
-    const response = await worker.fetch(request, mockEnv, {} as ExecutionContext);
-
-    expect(response.status).toBe(405);
-
-    const body = await response.json();
-    expect(body.success).toBe(false);
-    expect(body.error).toContain('Method not allowed');
-  });
-
-  it('should reject invalid payload', async () => {
-    const request = new Request('https://example.com', {
-      method: 'POST',
-      body: JSON.stringify({ invalid: 'payload' }),
-      headers: { 'Content-Type': 'application/json' }
-    });
-
-    const response = await worker.fetch(request, mockEnv, {} as ExecutionContext);
-
-    expect(response.status).toBe(400);
-
-    const body = await response.json();
-    expect(body.success).toBe(false);
-    expect(body.error).toContain('Invalid payload');
-  });
-
-  it('should process valid payload and return analysis', async () => {
-    const request = new Request('https://example.com', {
-      method: 'POST',
-      body: JSON.stringify(samplePayload),
-      headers: { 'Content-Type': 'application/json' }
-    });
-
-    const response = await worker.fetch(request, mockEnv, {} as ExecutionContext);
-
-    expect(response.status).toBe(200);
-
-    const body = await response.json();
-    expect(body.success).toBe(true);
-    expect(body.analysis).toBeDefined();
-    expect(body.analysis).toContain('mastra');
-    expect(body.timestamp).toBeDefined();
-  });
-
-  it('should handle AI service errors gracefully', async () => {
-    const errorEnv = {
-      OPENAI_API_KEY: 'invalid-key'
-    };
-
-    const request = new Request('https://example.com', {
-      method: 'POST',
-      body: JSON.stringify(samplePayload),
-      headers: { 'Content-Type': 'application/json' }
-    });
-
-    const response = await worker.fetch(request, errorEnv, {} as ExecutionContext);
-
-    expect(response.status).toBe(500);
-
-    const body = await response.json();
-    expect(body.success).toBe(false);
-    expect(body.error).toContain('Failed to generate analysis');
-  });
+describe("AI Worker", () => {
+	let worker: any;
+
+	beforeAll(async () => {
+		const workerModule = await import("../src/index");
+		worker = workerModule.default;
+	});
+
+	it("should handle OPTIONS request for CORS", async () => {
+		const request = new Request("https://example.com", { method: "OPTIONS" });
+		const response = await worker.fetch(
+			request,
+			mockEnv,
+			{} as ExecutionContext,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.headers.get("Access-Control-Allow-Origin")).toBe("*");
+	});
+
+	it("should reject non-POST requests", async () => {
+		const request = new Request("https://example.com", { method: "GET" });
+		const response = await worker.fetch(
+			request,
+			mockEnv,
+			{} as ExecutionContext,
+		);
+
+		expect(response.status).toBe(405);
+
+		const body = (await response.json()) as any;
+		expect(body.success).toBe(false);
+		expect(body.error).toContain("Method not allowed");
+	});
+
+	it("should reject invalid payload", async () => {
+		const request = new Request("https://example.com", {
+			method: "POST",
+			body: JSON.stringify({ invalid: "payload" }),
+			headers: { "Content-Type": "application/json" },
+		});
+
+		const response = await worker.fetch(
+			request,
+			mockEnv,
+			{} as ExecutionContext,
+		);
+
+		expect(response.status).toBe(400);
+
+		const body = (await response.json()) as any;
+		expect(body.success).toBe(false);
+		expect(body.error).toContain("Invalid payload");
+	});
+
+	it("should process valid payload and return processed issues", async () => {
+		const request = new Request("https://example.com", {
+			method: "POST",
+			body: JSON.stringify(samplePayload),
+			headers: { "Content-Type": "application/json" },
+		});
+
+		const response = await worker.fetch(
+			request,
+			mockEnv,
+			{} as ExecutionContext,
+		);
+
+		expect(response.status).toBe(200);
+
+		const body = (await response.json()) as any;
+		expect(body.success).toBe(true);
+		expect(Array.isArray(body.issues)).toBe(true);
+		expect(body.issues.length).toBeGreaterThan(0);
+		expect(body.repository?.name).toBe("mastra");
+		expect(body.timestamp).toBeDefined();
+	});
+
+	it("should handle AI service errors gracefully", async () => {
+		const errorEnv = {
+			OPENAI_API_KEY: "invalid-key",
+		};
+
+		const request = new Request("https://example.com", {
+			method: "POST",
+			body: JSON.stringify(samplePayload),
+			headers: { "Content-Type": "application/json" },
+		});
+
+		const response = await worker.fetch(
+			request,
+			errorEnv,
+			{} as ExecutionContext,
+		);
+
+		expect(response.status).toBe(500);
+
+		const body = await response.json();
+		expect(body.success).toBe(false);
+		expect(body.error).toContain("Failed to generate analysis");
+	});
 });