fix(ptc): hash full tool definitions for cache invalidation

Previously the type cache only hashed tool names, so schema changes
(e.g., updated MCP server, different workspace with same tool names)
wouldn't invalidate cached types. Now hashes names + schemas + descriptions.

Author: ethanndickson

src/node/services/ptc/typeGenerator.test.ts

@@ -1,7 +1,7 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect, beforeEach } from "bun:test";
 import { z } from "zod";
 import type { Tool } from "ai";
-import { generateMuxTypes } from "./typeGenerator";
+import { generateMuxTypes, getCachedMuxTypes, clearTypeCache } from "./typeGenerator";
 
 /**
  * Create a mock tool with the given schema and optional execute function.
@@ -231,3 +231,53 @@ describe("generateMuxTypes", () => {
     expect(types).toContain("declare var console");
   });
 });
+
+describe("getCachedMuxTypes", () => {
+  beforeEach(() => {
+    clearTypeCache();
+  });
+
+  test("invalidates cache when tool schema changes", async () => {
+    const toolV1 = createMockTool(z.object({ name: z.string() }));
+    const toolV2 = createMockTool(z.object({ name: z.string(), age: z.number() }));
+
+    const types1 = await getCachedMuxTypes({ my_tool: toolV1 });
+    expect(types1).toContain("name: string");
+    expect(types1).not.toContain("age");
+
+    // Same tool name, different schema - should regenerate
+    const types2 = await getCachedMuxTypes({ my_tool: toolV2 });
+    expect(types2).toContain("name: string");
+    expect(types2).toContain("age: number");
+  });
+
+  test("invalidates cache when tool description changes", async () => {
+    const tool1: Tool = {
+      description: "Version 1",
+      inputSchema: z.object({ x: z.string() }),
+      execute: () => Promise.resolve({ success: true }),
+    } as unknown as Tool;
+
+    const tool2: Tool = {
+      description: "Version 2",
+      inputSchema: z.object({ x: z.string() }),
+      execute: () => Promise.resolve({ success: true }),
+    } as unknown as Tool;
+
+    const types1 = await getCachedMuxTypes({ my_tool: tool1 });
+    expect(types1).toContain("Version 1");
+
+    const types2 = await getCachedMuxTypes({ my_tool: tool2 });
+    expect(types2).toContain("Version 2");
+  });
+
+  test("returns cached types when tools are identical", async () => {
+    const tool = createMockTool(z.object({ value: z.string() }));
+
+    const types1 = await getCachedMuxTypes({ my_tool: tool });
+    const types2 = await getCachedMuxTypes({ my_tool: tool });
+
+    // Should be the exact same object reference (cached)
+    expect(types1).toBe(types2);
+  });
+});

src/node/services/ptc/typeGenerator.ts

@@ -56,18 +56,27 @@ export function clearTypeCache(): void {
 }
 
 /**
- * Hash tool names to detect when tool set changes.
+ * Hash tool definitions (names, schemas, descriptions) to detect when tools change.
+ * This ensures cache invalidation when schemas are updated, not just when tool names change.
  */
-function hashToolNames(tools: Record<string, Tool>): string {
-  const names = Object.keys(tools).sort().join(",");
-  return createHash("md5").update(names).digest("hex");
+function hashToolDefinitions(tools: Record<string, Tool>): string {
+  const sortedNames = Object.keys(tools).sort();
+  const toolData = sortedNames.map((name) => {
+    const tool = tools[name];
+    return {
+      name,
+      schema: getInputJsonSchema(tool),
+      description: tool.description ?? "",
+    };
+  });
+  return createHash("md5").update(JSON.stringify(toolData)).digest("hex");
 }
 
 /**
- * Get cached mux types or generate new ones if tool set changed.
+ * Get cached mux types or generate new ones if tool definitions changed.
  */
 export async function getCachedMuxTypes(tools: Record<string, Tool>): Promise<string> {
-  const hash = hashToolNames(tools);
+  const hash = hashToolDefinitions(tools);
   const cached = cache.fullTypes.get(hash);
   if (cached) {
     return cached;