Fix MCP lint boundary casts

Author: RhysSullivan

apps/cloud/src/mcp/session-durable-object.ts

@@ -109,6 +109,8 @@ interface McpModelResumeStub {
   ) => Promise<McpSessionModelResumeResult>;
 }
 
+const toMcpModelResumeStub = (stub: unknown): McpModelResumeStub => stub as McpModelResumeStub;
+
 class OrganizationNotFoundError extends Data.TaggedError("OrganizationNotFoundError")<{
   readonly organizationId: string;
 }> {}
@@ -211,10 +213,10 @@ export class McpSessionDOSqlite extends McpAgentSessionDOBase<Env, CloudSessionD
   ): Effect.Effect<McpSessionModelResumeResult, unknown> {
     return Effect.tryPromise({
       try: () =>
-        (
+        toMcpModelResumeStub(
           env.MCP_SESSION.get(
             env.MCP_SESSION.idFromName(mcpSessionDurableObjectName(owner.sessionId)),
-          ) as unknown as McpModelResumeStub
+          ),
         ).resumeExecutionForModel(executionId, identity, response),
       catch: (cause) => new McpModelResumeForwardError({ cause }),
     });

apps/host-cloudflare/src/mcp/session-durable-object.ts

@@ -55,6 +55,8 @@ interface McpModelResumeStub {
   ) => Promise<McpSessionModelResumeResult>;
 }
 
+const toMcpModelResumeStub = (stub: unknown): McpModelResumeStub => stub as McpModelResumeStub;
+
 class McpModelResumeForwardError extends Data.TaggedError("McpModelResumeForwardError")<{
   readonly cause: unknown;
 }> {}
@@ -84,10 +86,10 @@ export class McpSessionDO extends McpAgentSessionDOBase<CloudflareEnv, CfSession
   ): Effect.Effect<McpSessionModelResumeResult, unknown> {
     return Effect.tryPromise({
       try: () =>
-        (
+        toMcpModelResumeStub(
           this.cfEnv.MCP_SESSION.get(
             this.cfEnv.MCP_SESSION.idFromName(mcpSessionDurableObjectName(owner.sessionId)),
-          ) as unknown as McpModelResumeStub
+          ),
         ).resumeExecutionForModel(executionId, identity, response),
       catch: (cause) => new McpModelResumeForwardError({ cause }),
     });

packages/hosts/cloudflare/src/mcp/agent-session-model-resume.test.ts

@@ -67,20 +67,80 @@ vi.mock("agents/mcp", () => ({
   },
 }));
 
-class FakeStorage {
+class FakeStorage implements DurableObjectStorage {
   private readonly values = new Map<string, unknown>();
+  readonly sql = {} as DurableObjectStorage["sql"];
+  readonly kv = {} as DurableObjectStorage["kv"];
   alarmAt: number | null = null;
 
-  async get<T>(key: string): Promise<T | undefined> {
-    return this.values.get(key) as T | undefined;
+  async get<T>(key: string): Promise<T | undefined>;
+  async get<T>(keys: string[]): Promise<Map<string, T>>;
+  async get<T>(keyOrKeys: string | string[]): Promise<T | undefined | Map<string, T>> {
+    if (Array.isArray(keyOrKeys)) {
+      return new Map(keyOrKeys.map((key) => [key, this.values.get(key) as T]));
+    }
+    return this.values.get(keyOrKeys) as T | undefined;
+  }
+
+  async put<T>(key: string, value: T): Promise<void>;
+  async put<T>(entries: Record<string, T> | Map<string, T>): Promise<void>;
+  async put<T>(
+    keyOrEntries: string | Record<string, T> | Map<string, T>,
+    value?: T,
+  ): Promise<void> {
+    if (typeof keyOrEntries === "string") {
+      this.values.set(keyOrEntries, value);
+      return;
+    }
+    const entries =
+      keyOrEntries instanceof Map ? keyOrEntries.entries() : Object.entries(keyOrEntries);
+    for (const [key, entry] of entries) this.values.set(key, entry);
+  }
+
+  async delete(key: string): Promise<boolean>;
+  async delete(keys: string[]): Promise<number>;
+  async delete(keyOrKeys: string | string[]): Promise<boolean | number> {
+    if (!Array.isArray(keyOrKeys)) return this.values.delete(keyOrKeys);
+    let deleted = 0;
+    for (const key of keyOrKeys) {
+      if (this.values.delete(key)) deleted += 1;
+    }
+    return deleted;
+  }
+
+  async list<T = unknown>(): Promise<Map<string, T>> {
+    return new Map([...this.values.entries()].map(([key, value]) => [key, value as T]));
+  }
+
+  async deleteAll(): Promise<void> {
+    this.values.clear();
+    this.alarmAt = null;
+  }
+
+  transaction<T>(_closure: (txn: DurableObjectTransaction) => Promise<T>): Promise<T> {
+    return Promise.resolve(undefined as T);
+  }
+
+  transactionSync<T>(_closure: () => T): T {
+    return undefined as T;
+  }
+
+  async sync(): Promise<void> {}
+
+  async getAlarm(): Promise<number | null> {
+    return this.alarmAt;
+  }
+
+  async getCurrentBookmark(): Promise<string> {
+    return "test-bookmark";
   }
 
-  async put<T>(key: string, value: T): Promise<void> {
-    this.values.set(key, value);
+  async getBookmarkForTime(_timestamp: number | Date): Promise<string> {
+    return "test-bookmark";
   }
 
-  async delete(key: string): Promise<boolean> {
-    return this.values.delete(key);
+  onNextSessionRestoreBookmark(_bookmark: string): Promise<string> {
+    return Promise.resolve("test-bookmark");
   }
 
   async setAlarm(scheduledTime: number | Date): Promise<void> {
@@ -92,18 +152,21 @@ class FakeStorage {
   }
 }
 
-class FakeDurableObjectState {
+class FakeDurableObjectState implements DurableObjectState {
   readonly storage = new FakeStorage();
   readonly id: DurableObjectId;
+  readonly props: unknown = undefined;
+  readonly facets = {} as DurableObjectState["facets"];
   readonly ctx = this;
   private waitUntilPromises: Promise<unknown>[] = [];
 
   constructor(name: string) {
-    this.id = {
+    const id: Pick<DurableObjectId, "equals" | "name" | "toString"> = {
       equals: (other: DurableObjectId) => other.toString() === name,
       name,
       toString: () => name,
-    } as unknown as DurableObjectId;
+    };
+    this.id = id as DurableObjectId;
   }
 
   waitUntil(promise: Promise<unknown>): void {
@@ -120,6 +183,34 @@ class FakeDurableObjectState {
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T> {
     return callback();
   }
+
+  acceptWebSocket(_ws: WebSocket, _tags?: string[]): void {}
+
+  getWebSockets(_tag?: string): WebSocket[] {
+    return [];
+  }
+
+  getTags(_ws: WebSocket): string[] {
+    return [];
+  }
+
+  setWebSocketAutoResponse(_pair?: WebSocketRequestResponsePair): void {}
+
+  getWebSocketAutoResponse(): WebSocketRequestResponsePair | null {
+    return null;
+  }
+
+  getWebSocketAutoResponseTimestamp(_ws: WebSocket): Date | null {
+    return null;
+  }
+
+  setHibernatableWebSocketEventTimeout(_timeoutMs?: number): void {}
+
+  getHibernatableWebSocketEventTimeout(): number | null {
+    return null;
+  }
+
+  abort(_reason?: string): void {}
 }
 
 class InMemoryExecutionOwnerDirectoryNamespace implements McpExecutionOwnerDirectoryNamespace<string> {
@@ -134,7 +225,7 @@ class InMemoryExecutionOwnerDirectoryNamespace implements McpExecutionOwnerDirec
     if (!directory) {
       directory = new McpExecutionOwnerDirectoryDO({
         storage: new FakeStorage(),
-      } as unknown as DurableObjectState);
+      });
       this.directories.set(id, directory);
     }
     return directory;
@@ -200,13 +291,6 @@ type PendingApprovalLeaseSnapshot = {
   readonly timeout: ReturnType<typeof setTimeout> | null;
 };
 
-type PrivateRuntimeState = {
-  engine: ExecutionEngine<Cause.YieldableError> | null;
-  dbHandle: TestDbHandle | null;
-  initialized: boolean;
-  pendingApprovalLeases: Map<string, PendingApprovalLeaseSnapshot>;
-};
-
 class HarnessSession extends McpAgentSessionDOBase<Cloudflare.Env, TestDbHandle> {
   private readonly meta: SessionMeta;
   private readonly fakeState: FakeDurableObjectState;
@@ -227,7 +311,7 @@ class HarnessSession extends McpAgentSessionDOBase<Cloudflare.Env, TestDbHandle>
     readonly forwardModelResumeToOwner?: HarnessSession["modelResumeForward"];
   }) {
     const state = new FakeDurableObjectState(input.sessionId);
-    super(state as unknown as DurableObjectState, {} as Cloudflare.Env);
+    super(state, {} as Cloudflare.Env);
     this.fakeState = state;
     this.meta = input.meta ?? sessionMeta();
     this.directory = mcpExecutionOwnerDirectoryFromNamespace(input.directoryNamespace);
@@ -269,10 +353,9 @@ class HarnessSession extends McpAgentSessionDOBase<Cloudflare.Env, TestDbHandle>
   }
 
   protected override buildMcpServer(): Effect.Effect<BuiltMcpServer> {
-    const runtime = this.runtimeState();
     return Effect.succeed({
       mcpServer: new McpServer({ name: "test", version: "1.0.0" }),
-      engine: runtime.engine!,
+      engine: this["engine"]!,
     });
   }
 
@@ -298,32 +381,25 @@ class HarnessSession extends McpAgentSessionDOBase<Cloudflare.Env, TestDbHandle>
     executionId: string,
     response: ResumeResponse,
   ): Promise<McpSessionModelResumeResult | null> {
-    const local = await Effect.runPromise(
-      this.runtimeState().engine!.resume(executionId, response),
-    );
+    const local = await Effect.runPromise(this["engine"]!.resume(executionId, response));
     if (local) return { status: "result", result: formatMcpExecutionOutcome(local) };
     return Effect.runPromise(this.modelResumeFallback(executionId, response));
   }
 
   pendingLease(executionId: string): PendingApprovalLeaseSnapshot | undefined {
-    return this.runtimeState().pendingApprovalLeases.get(executionId);
+    return this["pendingApprovalLeases"].get(executionId);
   }
 
   pendingLeaseCount(): number {
-    return this.runtimeState().pendingApprovalLeases.size;
+    return this["pendingApprovalLeases"].size;
   }
 
   private installRuntime(engine: ExecutionEngine<Cause.YieldableError>): void {
-    const runtime = this.runtimeState();
-    runtime.engine = engine;
-    runtime.dbHandle = { end: () => undefined };
-    runtime.initialized = true;
+    this["engine"] = engine;
+    this["dbHandle"] = { end: () => undefined };
+    this["initialized"] = true;
     this.server = new McpServer({ name: "test", version: "1.0.0" });
   }
-
-  private runtimeState(): PrivateRuntimeState {
-    return this as unknown as PrivateRuntimeState;
-  }
 }
 
 const makeDirectory = () => {

packages/hosts/cloudflare/src/mcp/execution-owner-directory.test.ts

@@ -34,7 +34,7 @@ const makeDirectory = () => {
   const storage = new FakeStorage();
   const directory = new McpExecutionOwnerDirectoryDO({
     storage,
-  } as unknown as DurableObjectState);
+  });
   return { directory, storage };
 };
 

packages/hosts/cloudflare/src/mcp/execution-owner-directory.ts

@@ -30,6 +30,21 @@ export interface McpExecutionOwnerDirectoryNamespace<Id> {
   readonly get: (id: Id) => unknown;
 }
 
+interface McpExecutionOwnerDirectoryStorage {
+  readonly get: <T>(key: string) => Promise<T | undefined>;
+  readonly put: <T>(key: string, value: T) => Promise<void>;
+  readonly delete: (key: string) => Promise<boolean>;
+  readonly setAlarm: (scheduledTime: number | Date) => Promise<void>;
+  readonly deleteAlarm: () => Promise<void>;
+}
+
+interface McpExecutionOwnerDirectoryState {
+  readonly storage: McpExecutionOwnerDirectoryStorage;
+}
+
+const toMcpExecutionOwnerDirectoryStub = (stub: unknown): McpExecutionOwnerDirectoryStub =>
+  stub as McpExecutionOwnerDirectoryStub;
+
 export const mcpSessionDurableObjectName = (sessionId: string): string =>
   `streamable-http:${sessionId}`;
 
@@ -59,9 +74,9 @@ const isOwnerRecord = (value: unknown): value is McpExecutionOwnerRecord =>
 const expiryMs = (record: McpExecutionOwnerRecord): number => Date.parse(record.expiresAt);
 
 export class McpExecutionOwnerDirectoryDO {
-  private readonly storage: DurableObjectStorage;
+  private readonly storage: McpExecutionOwnerDirectoryStorage;
 
-  constructor(ctx: DurableObjectState) {
+  constructor(ctx: McpExecutionOwnerDirectoryState) {
     this.storage = ctx.storage;
   }
 
@@ -99,7 +114,7 @@ export const mcpExecutionOwnerDirectoryFromNamespace = <Id>(
 ): McpExecutionOwnerDirectory | null => {
   if (!namespace) return null;
   const stubFor = (executionId: string): McpExecutionOwnerDirectoryStub =>
-    namespace.get(namespace.idFromName(executionId)) as unknown as McpExecutionOwnerDirectoryStub;
+    toMcpExecutionOwnerDirectoryStub(namespace.get(namespace.idFromName(executionId)));
   return {
     put: (record) =>
       Effect.tryPromise({

packages/hosts/mcp/src/tool-server.test.ts

@@ -30,6 +30,10 @@ class TestExecutionError extends Data.TaggedError("TestExecutionError")<{
   readonly message: string;
 }> {}
 
+const expectString: (value: unknown) => asserts value is string = (value) => {
+  expect(typeof value).toBe("string");
+};
+
 const makeStubEngine = <E extends Cause.YieldableError = never>(overrides: {
   execute?: ExecutionEngine<E>["execute"];
   executeWithPause?: ExecutionEngine<E>["executeWithPause"];
@@ -1478,10 +1482,10 @@ describe("MCP host server — client without elicitation (pause/resume)", () =>
         });
         const after = Date.now();
         const structured = result.structuredContent as Record<string, unknown>;
-        const expiresAt = structured.expiresAt as string;
+        const expiresAt = structured.expiresAt;
 
         expect(structured.ttlMs).toBe(60_000);
-        expect(typeof expiresAt).toBe("string");
+        expectString(expiresAt);
         const expiresAtMs = Date.parse(expiresAt);
         expect(expiresAtMs).toBeGreaterThanOrEqual(before + 60_000);
         expect(expiresAtMs).toBeLessThanOrEqual(after + 60_000);