fix(provider): address code review issues for in-memory platform

- Move platform creation outside retry loop to prevent resource accumulation
- Implement no-op BlobStore methods to avoid runtime TypeErrors
- Use crypto.randomUUID() for agentId and runId to prevent collisions
- Add explicit type annotations to store interfaces for type safety

Author: dh-ohi-yusuke

src/platform.ts

@@ -1,39 +1,45 @@
 import { createAgentPlatform, InMemoryRunEventNotifier } from "@cursor/sdk";
+import type { AgentRunStore, AgentCheckpointStore, RunEventStore, CreateAgentInput } from "@cursor/sdk";
+import crypto from "node:crypto";
 
 /**
  * Creates a minimal, in-memory platform for @cursor/sdk to avoid
  * the native sqlite3 dependency which causes issues in CLI environments.
  */
 export async function getInMemoryPlatform() {
-  const noopStore: any = {
+  const noopStore: AgentRunStore = {
     getAgent: async () => null,
-    createAgent: async (input: any) => ({
-      agent: { agentId: input.agentId || "default" },
-      run: { runId: "initial-run" },
+    createAgent: async (input: CreateAgentInput) => ({
+      agent: { agentId: input.agentId || `agent-${crypto.randomUUID()}` },
+      run: { runId: `run-${crypto.randomUUID()}` },
     }),
     listAgents: async () => ({ items: [] }),
     getRun: async () => null,
     listRuns: async () => ({ items: [] }),
     markRunStarting: async () => {},
     markRunTerminal: async () => {},
-    createFollowUpRun: async () => ({ runId: "follow-up" }),
+    createFollowUpRun: async () => ({ runId: `run-${crypto.randomUUID()}` }),
     archiveAgent: async () => {},
     unarchiveAgent: async () => {},
     deleteAgent: async () => {},
     patchCheckpoint: async () => {},
     cancelRun: async () => {},
   };
 
-  const noopCheckpointStore: any = {
+  const noopCheckpointStore: AgentCheckpointStore = {
     loadLatest: async () => null,
     saveCheckpoint: async () => "cp-ref",
-    getBlobStore: async () => ({}),
+    getBlobStore: async () => ({
+      get: async () => null,
+      put: async () => {},
+      delete: async () => {},
+    }),
     getFullConversation: async () => ({ turns: [] }),
     deleteAgent: async () => {},
   };
 
-  const noopEventStore: any = {
-    appendRunEvent: async () => ({ runId: "run", offset: 0 }),
+  const noopEventStore: RunEventStore = {
+    appendRunEvent: async () => ({ runId: `run-${crypto.randomUUID()}`, offset: 0 }),
     listRunEvents: async () => ({ items: [] }),
     deleteRunEvents: async () => {},
   };

src/provider.ts

@@ -324,13 +324,13 @@ async function performAgentCreationAttempt(deps: {
   Agent: { create: (opts: AgentCreateOpts) => Promise<unknown> };
   apiKey: string;
   modelId: string;
+  platform: any;
   log: Logger;
   attempt: number;
 }): Promise<{ agent: SDKAgent } | { error: unknown; canRetry: boolean; delay: number }> {
-  const { Agent, apiKey, modelId, log, attempt } = deps;
+  const { Agent, apiKey, modelId, platform, log, attempt } = deps;
   try {
     log.debug("cursor-provider: calling Agent.create", { modelId, attempt });
-    const platform = await getInMemoryPlatform();
     const agent = (await Agent.create({
       apiKey,
       model: { id: modelId },
@@ -354,9 +354,15 @@ async function performAgentCreationAttempt(deps: {
 async function createAgentWithRetry(deps: { apiKey: string; modelId: string; log: Logger }): Promise<SDKAgent> {
   const { Agent } = await import("@cursor/sdk");
   const { log } = deps;
+  const platform = await getInMemoryPlatform();
 
   for (let attempt = 1; attempt <= 3; attempt++) {
-    const result = await performAgentCreationAttempt({ Agent: Agent as unknown as { create: (opts: AgentCreateOpts) => Promise<unknown> }, ...deps, attempt });
+    const result = await performAgentCreationAttempt({
+      Agent: Agent as unknown as { create: (opts: AgentCreateOpts) => Promise<unknown> },
+      ...deps,
+      platform,
+      attempt,
+    });
 
     if ("agent" in result) return result.agent;
     if (!result.canRetry) {