Address review: classifier coverage, write bookkeeping, equality bound

Author: RhysSullivan

packages/core/sdk/src/shape-inference.test.ts

@@ -57,6 +57,10 @@ describe("inferShape", () => {
       { "12345": { qty: 2 }, "67890": { qty: 1 } },
       { "https://example.com/page": 3 },
       { deadbeefdeadbeef00: true },
+      { U012ABCDEF: { presence: "active" } },
+      { cus_9s6XKzkNRiz8i3: { plan: "pro" } },
+      { "10.0.0.7": "reachable" },
+      { sk4bcD3fGh1jKlMnOpQr: true },
     ];
     for (const value of cases) {
       const shape = inferShape(value);
@@ -71,13 +75,19 @@ describe("inferShape", () => {
       created_at: "2026-01-01",
       pageUrl: "https://x",
       email2fa: true,
+      "@odata.context": "ctx",
+      organizationMembershipSettings: {},
+      sha256Fingerprint: "…",
     });
     expect(shape.properties).toBeDefined();
     expect(Object.keys(shape.properties ?? {}).sort()).toEqual([
+      "@odata.context",
       "created_at",
       "email2fa",
       "id",
+      "organizationMembershipSettings",
       "pageUrl",
+      "sha256Fingerprint",
     ]);
   });
 

packages/core/sdk/src/shape-inference.ts

@@ -55,12 +55,28 @@ const isUnknown = (shape: InferredShape): boolean =>
  * collapsing.
  */
 const DATA_KEY_PATTERNS: readonly RegExp[] = [
-  /@/,
+  // Email addresses (full-string — `@odata.context`-style annotation keys are
+  // legitimate API surface and must NOT collapse).
+  /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  // UUIDs.
   /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+  // Timestamps / dates.
   /^\d{4}-\d{2}-\d{2}/,
+  // Bare numbers and IPv4 addresses.
   /^\d+$/,
+  /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/,
+  // URLs.
   /^https?:\/\//,
+  // Long hex tokens (hashes, ids).
   /^[0-9a-f]{16,}$/i,
+  // Platform opaque ids: Slack-style ALL-CAPS ids (U012ABCDEF), and
+  // prefix_body ids (cus_..., price_..., asst_...). Real field names in
+  // snake_case are lowercase words, not lowercase prefix + mixed-case body.
+  /^[A-Z][A-Z0-9]{8,}$/,
+  /^[a-z]{1,6}_(?=.*[A-Z0-9])[A-Za-z0-9]{10,}$/,
+  // Generic digit-bearing opaque tokens (API keys, base62/base64 ids). Long
+  // camelCase field names rarely contain digits at this length.
+  /^(?=.*\d)[A-Za-z0-9+/=_-]{20,}$/,
 ];
 
 const looksLikeDataKey = (key: string): boolean =>

packages/core/sdk/src/shape-memory.test.ts

@@ -27,6 +27,7 @@ const makeStubStorage = () => {
       updatedAt: new Date(0),
     };
   };
+  let failNextWrites = 0;
   const unsupported = (member: string) => () =>
     Effect.die(`stub storage does not implement ${member}`);
   const storage: PluginStorageFacade = {
@@ -43,16 +44,27 @@ const makeStubStorage = () => {
     getForOwner: (input) => Effect.sync(() => entryFor(input.key)),
     list: unsupported("list"),
     put: (input) =>
-      Effect.sync(() => {
+      Effect.suspend(() => {
+        if (failNextWrites > 0) {
+          failNextWrites -= 1;
+          return Effect.fail({ _tag: "StorageError" as const }) as never;
+        }
         writes += 1;
         rows.set(input.key, input.data);
-        return entryFor(input.key) as never;
+        return Effect.sync(() => entryFor(input.key) as never);
       }),
     putMany: unsupported("putMany"),
     remove: unsupported("remove"),
     removeMany: unsupported("removeMany"),
   };
-  return { storage, rows, writeCount: () => writes };
+  return {
+    storage,
+    rows,
+    writeCount: () => writes,
+    failWrites: (count: number) => {
+      failNextWrites = count;
+    },
+  };
 };
 
 const HOUR = 60 * 60 * 1000;
@@ -120,6 +132,24 @@ describe("makeShapeMemory", () => {
     }),
   );
 
+  it.effect("retries after a failed write instead of pretending it persisted", () =>
+    Effect.gen(function* () {
+      const stub = makeStubStorage();
+      const memory = makeShapeMemory(stub.storage);
+
+      stub.failWrites(1);
+      yield* memory.observe(ADDRESS, OWNER, "direct", { id: 1 });
+      expect(stub.rows.has(ADDRESS), "the failed write stored nothing").toBe(false);
+
+      // The very next observation retries — no waiting out the freshness
+      // interval on bookkeeping that lied about persisting.
+      yield* memory.observe(ADDRESS, OWNER, "direct", { id: 2 });
+      expect(stub.rows.has(ADDRESS), "the retry persisted").toBe(true);
+      const stored = stub.rows.get(ADDRESS) as { observations: number };
+      expect(stored.observations).toBe(2);
+    }),
+  );
+
   it.effect("treats legacy records without a contract field as direct", () =>
     Effect.gen(function* () {
       const stub = makeStubStorage();

packages/core/sdk/src/shape-memory.ts

@@ -125,9 +125,16 @@ export const makeShapeMemory = (storage: PluginStorageFacade): ShapeMemory => {
         next.observations % OBSERVATION_WRITE_MILESTONE === 0 ||
         now - lastWrite >= FRESHNESS_WRITE_INTERVAL_MS;
       if (!shouldWrite) return;
-      yield* storage
+      // Advance the persisted-state bookkeeping only on a successful write:
+      // otherwise a transient storage failure would silence retries for the
+      // whole freshness interval while nothing is actually stored.
+      const wrote = yield* storage
         .put({ owner, collection: COLLECTION, key: address, data: next })
-        .pipe(Effect.catch(() => Effect.succeed(null)));
+        .pipe(
+          Effect.map(() => true),
+          Effect.catch(() => Effect.succeed(false)),
+        );
+      if (!wrote) return;
       persistedSchema.set(key, schemaJson);
       persistedAt.set(key, now);
     }).pipe(Effect.catchCause(() => Effect.void));

packages/core/sdk/src/tool-result-normalization.test.ts

@@ -86,6 +86,22 @@ describe("normalizeMcpCallToolResult", () => {
     expect(normalized.meta).toEqual({ "io.modelcontextprotocol/serverInfo": { name: "s" } });
   });
 
+  it("survives adversarially deep valid JSON without blowing the stack", () => {
+    const deep = "[".repeat(50_000) + "]".repeat(50_000);
+    // Deep duplicate-detection degrades to "not a duplicate" (block kept);
+    // it must never throw from inside the invocation path.
+    const normalized = normalizeMcpCallToolResult({
+      content: [text(deep)],
+      structuredContent: { safe: true },
+    });
+    expect(normalized.data).toEqual({ safe: true });
+    expect(normalized.content).toEqual([text(deep)]);
+    // The lone-text parse path is equally safe: a stack-exceeding parse is
+    // simply "not JSON" and the text stays a string.
+    const lone = normalizeMcpCallToolResult({ content: [text(deep)] });
+    expect(typeof lone.data === "string" || Array.isArray(lone.data)).toBe(true);
+  });
+
   it("passes non-envelope values through untouched", () => {
     expect(normalizeMcpCallToolResult({ rows: [1] }).data).toEqual({ rows: [1] });
     expect(normalizeMcpCallToolResult("plain").data).toBe("plain");

packages/core/sdk/src/tool-result-normalization.ts

@@ -77,21 +77,30 @@ const parseJsonPayload = (text: string): unknown | undefined => {
   }
 };
 
+/** Depth bound for duplicate detection. Beyond it two values are treated as
+ *  DIFFERENT — the safe direction: the block is kept rather than dropped —
+ *  and, critically, an adversarially deep (but valid) upstream JSON cannot
+ *  blow the stack inside the invocation path. */
+const MAX_EQUALITY_DEPTH = 64;
+
 /** Structural equality against the parsed form of a text block, used to
  *  suppress the spec-mandated serialized duplicate of `structuredContent`.
- *  Key-order insensitive; bounded by the same size guard as payload parsing. */
-const structurallyEquals = (left: unknown, right: unknown): boolean => {
+ *  Key-order insensitive; depth-bounded. */
+const structurallyEquals = (left: unknown, right: unknown, depth = 0): boolean => {
   if (Object.is(left, right)) return true;
+  if (depth >= MAX_EQUALITY_DEPTH) return false;
   if (Array.isArray(left) && Array.isArray(right)) {
     return (
       left.length === right.length &&
-      left.every((item, index) => structurallyEquals(item, right[index]))
+      left.every((item, index) => structurallyEquals(item, right[index], depth + 1))
     );
   }
   if (isRecord(left) && isRecord(right)) {
     const leftKeys = Object.keys(left);
     if (leftKeys.length !== Object.keys(right).length) return false;
-    return leftKeys.every((key) => key in right && structurallyEquals(left[key], right[key]));
+    return leftKeys.every(
+      (key) => key in right && structurallyEquals(left[key], right[key], depth + 1),
+    );
   }
   return false;
 };