pi-mcp-extension 1.11.1 → 1.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-extension",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "MCP (Model Context Protocol) client extension for the Pi coding agent — connect Pi to any MCP server",
   "type": "module",
   "keywords": [

package/src/schema-convert.ts

@@ -111,6 +111,67 @@ function hasArraySchemaKeywords(schema: Record<string, unknown>): boolean {
   return schema["items"] !== undefined || Array.isArray(schema["prefixItems"]);
 }
 
+/** Whether `ref` is already on the active resolution path. */
+function isRefSeenOnPath(
+  ref: string,
+  ctx: ConversionContext,
+  extraRefs: ReadonlySet<string>,
+): boolean {
+  return ctx.seenRefs.has(ref) || extraRefs.has(ref);
+}
+
+/** Whether a `$ref` on an `allOf` member resolves to an object-like schema. */
+function isRefToObjectSchema(
+  ref: unknown,
+  ctx: ConversionContext,
+  seenRefs: Set<string>,
+): boolean {
+  if (typeof ref !== "string" || isRefSeenOnPath(ref, ctx, seenRefs)) {
+    return false;
+  }
+  seenRefs.add(ref);
+  const resolved = resolveRefTarget(ref, ctx.rootDefs, ctx.effectiveRoot);
+  return resolved ? isObjectLikeSubSchema(resolved, ctx, seenRefs) : false;
+}
+
+/** Whether a sub-schema describes an object directly, through a `$ref`, or through a nested `allOf`. */
+function isObjectLikeSubSchema(
+  sub: Record<string, unknown>,
+  ctx: ConversionContext,
+  seenRefs: Set<string>,
+): boolean {
+  return (
+    sub["type"] === "object" ||
+    hasObjectSchemaKeywords(sub) ||
+    hasAllOfObjectSubSchema(sub, ctx, seenRefs) ||
+    isRefToObjectSchema(sub["$ref"], ctx, seenRefs)
+  );
+}
+
+/**
+ * Whether `allOf` composes object sub-schemas / `$ref`s to object definitions.
+ * WHY: JSON Schema generators (Pydantic, FastAPI, OpenAPI 3.0) omit `type: "object"`
+ * on the `allOf` wrapper. Without object inference the schema becomes a bare
+ * `Type.Intersect`, which has no `properties` — Pi's `normalizeOptionalNulls` then
+ * skips it (coercing optional `null`s into `"null"` / `0` / `false`) and Anthropic's
+ * adapter sends an empty `input_schema`.
+ */
+function hasAllOfObjectSubSchema(
+  schema: Record<string, unknown>,
+  ctx: ConversionContext,
+  seenRefs: Set<string> = new Set<string>(),
+): boolean {
+  const allOf = schema["allOf"];
+  if (!Array.isArray(allOf)) {
+    return false;
+  }
+  return allOf.some((sub) => isPlainObject(sub) && isObjectLikeSubSchema(sub, ctx, seenRefs));
+}
+
+function hasObjectSchemaShape(schema: Record<string, unknown>, ctx: ConversionContext): boolean {
+  return hasObjectSchemaKeywords(schema) || hasAllOfObjectSubSchema(schema, ctx);
+}
+
 interface ConversionContext {
   rootDefs: Record<string, Record<string, unknown>>;
   effectiveRoot: Record<string, unknown>;
@@ -347,23 +408,34 @@ function convertArraySchema(
   );
 }
 
-/** Resolve an `allOf` sub-schema's `$ref` (unless it is already being resolved). */
-function resolveAllOfSubSchema(sub: Record<string, unknown>, ctx: ConversionContext): Record<string, unknown> {
-  const ref = sub["$ref"];
-  if (typeof ref !== "string" || ctx.seenRefs.has(ref)) {
-    return sub;
-  }
-  return resolveRefTarget(ref, ctx.rootDefs, ctx.effectiveRoot) ?? sub;
+/** A property schema paired with the `$ref` path that was dereferenced to reach it. */
+interface MergedProperty {
+  schema: Record<string, unknown>;
+  seenRefs: ReadonlySet<string>;
+}
+
+/** Accumulates flattened `allOf` contributions plus the refs already walked. */
+interface AllOfMerge {
+  properties: Record<string, MergedProperty>;
+  required: Set<string>;
+  visitedRefs: Set<string>;
 }
 
 /** Merge a sub-schema's properties without overwriting properties declared by the caller. */
-function mergeSubSchemaProperties(props: unknown, rawProperties: Record<string, unknown>): void {
+function mergeSubSchemaProperties(
+  props: unknown,
+  mergedProperties: Record<string, MergedProperty>,
+  seenRefs: ReadonlySet<string>,
+): void {
   if (!isPlainObject(props)) {
     return;
   }
   for (const [key, value] of Object.entries(props)) {
-    if (!(key in rawProperties)) {
-      rawProperties[key] = value;
+    if (!(key in mergedProperties)) {
+      mergedProperties[key] = {
+        schema: value as Record<string, unknown>,
+        seenRefs,
+      };
     }
   }
 }
@@ -380,18 +452,51 @@ function mergeSubSchemaRequired(req: unknown, required: Set<string>): void {
   }
 }
 
+/**
+ * Follow an `allOf` member's `$ref` if not yet visited, recording `ref` on the active
+ * resolution path for any properties inherited from the referenced definition.
+ * WHY: generators chain definitions (`A: { $ref: B }`) and emit recursive fields wrapped
+ * in `allOf: [{ $ref: "#/$defs/Node" }]`; carrying `nextActiveRefs` onto inherited
+ * properties ensures `convertJsonSchemaToTypebox` breaks `$ref` cycles on inlined fields.
+ */
+function mergeAllOfRef(
+  ref: unknown,
+  merge: AllOfMerge,
+  ctx: ConversionContext,
+  activeRefs: ReadonlySet<string>,
+): void {
+  if (typeof ref !== "string" || isRefSeenOnPath(ref, ctx, merge.visitedRefs)) {
+    return;
+  }
+  merge.visitedRefs.add(ref);
+  const resolved = resolveRefTarget(ref, ctx.rootDefs, ctx.effectiveRoot);
+  if (!resolved) {
+    return;
+  }
+  const nextActiveRefs = new Set(activeRefs);
+  nextActiveRefs.add(ref);
+  mergeAllOfSubSchema(resolved, merge, ctx, nextActiveRefs);
+}
+
+/** Merge one `allOf` member (and every `$ref` or nested `allOf` beneath it) into the accumulator. */
 function mergeAllOfSubSchema(
   sub: unknown,
-  rawProperties: Record<string, unknown>,
-  required: Set<string>,
+  merge: AllOfMerge,
   ctx: ConversionContext,
+  activeRefs: ReadonlySet<string> = ctx.seenRefs,
 ): void {
   if (!isPlainObject(sub)) {
     return;
   }
-  const resolvedSub = resolveAllOfSubSchema(sub, ctx);
-  mergeSubSchemaProperties(resolvedSub["properties"], rawProperties);
-  mergeSubSchemaRequired(resolvedSub["required"], required);
+  mergeSubSchemaProperties(sub["properties"], merge.properties, activeRefs);
+  mergeSubSchemaRequired(sub["required"], merge.required);
+  mergeAllOfRef(sub["$ref"], merge, ctx, activeRefs);
+  const nested = sub["allOf"];
+  if (Array.isArray(nested)) {
+    for (const nestedSub of nested) {
+      mergeAllOfSubSchema(nestedSub, merge, ctx, activeRefs);
+    }
+  }
 }
 
 function convertObjectSchema(
@@ -399,14 +504,16 @@ function convertObjectSchema(
   opts: Record<string, unknown>,
   ctx: ConversionContext,
 ): TSchema {
-  const rawProperties: Record<string, unknown> = isPlainObject(schema["properties"])
-    ? { ...schema["properties"] }
-    : {};
-  const required = new Set<string>(
-    Array.isArray(schema["required"])
-      ? (schema["required"] as unknown[]).filter((r): r is string => typeof r === "string")
-      : [],
-  );
+  const merge: AllOfMerge = {
+    properties: {},
+    required: new Set<string>(
+      Array.isArray(schema["required"])
+        ? (schema["required"] as unknown[]).filter((r): r is string => typeof r === "string")
+        : [],
+    ),
+    visitedRefs: new Set<string>(),
+  };
+  mergeSubSchemaProperties(schema["properties"], merge.properties, ctx.seenRefs);
   const additionalProperties = schema["additionalProperties"];
 
   let allOfSchemas: TSchema[] | undefined;
@@ -420,19 +527,19 @@ function convertObjectSchema(
       ),
     );
     for (const sub of schema["allOf"] as unknown[]) {
-      mergeAllOfSubSchema(sub, rawProperties, required, ctx);
+      mergeAllOfSubSchema(sub, merge, ctx);
     }
   }
 
   const props: Record<string, TSchema> = {};
-  for (const [key, value] of Object.entries(rawProperties)) {
+  for (const [key, entry] of Object.entries(merge.properties)) {
     const converted = convertJsonSchemaToTypebox(
-      value as Record<string, unknown>,
+      entry.schema,
       ctx.rootDefs,
       ctx.effectiveRoot,
-      ctx.seenRefs,
+      entry.seenRefs,
     );
-    props[key] = required.has(key) ? converted : Type.Optional(converted);
+    props[key] = merge.required.has(key) ? converted : Type.Optional(converted);
   }
 
   const objOpts: Record<string, unknown> = { ...opts };
@@ -447,8 +554,8 @@ function convertObjectSchema(
     );
   }
 
-  if (required.size > 0) {
-    objOpts["required"] = Array.from(required);
+  if (merge.required.size > 0) {
+    objOpts["required"] = Array.from(merge.required);
   }
 
   if (Array.isArray(schema["oneOf"])) {
@@ -511,6 +618,23 @@ function convertTypedSchema(
   return Type.Any(opts);
 }
 
+function inferSchemaType(
+  schema: Record<string, unknown>,
+  ctx: ConversionContext,
+): string | undefined {
+  const rawType = schema["type"];
+  if (typeof rawType === "string") {
+    return rawType;
+  }
+  if (hasObjectSchemaShape(schema, ctx)) {
+    return "object";
+  }
+  if (hasArraySchemaKeywords(schema)) {
+    return "array";
+  }
+  return undefined;
+}
+
 function resolveNonTypedSchema(
   schema: Record<string, unknown>,
   opts: Record<string, unknown>,
@@ -524,14 +648,6 @@ function resolveNonTypedSchema(
   if (Array.isArray(rawType)) {
     return convertMultiTypeSchema(schema, rawType, opts, ctx);
   }
-  if (
-    !hasObjectSchemaKeywords(schema) &&
-    !hasArraySchemaKeywords(schema) &&
-    rawType !== "object" &&
-    rawType !== "array"
-  ) {
-    return convertCombinatorSchema(schema, rawType, opts, ctx) ?? null;
-  }
   return null;
 }
 
@@ -544,7 +660,9 @@ function resolveNonTypedSchema(
  *   - Nullable and multi-type arrays ("type": ["string", "null"]) with Type.Null() ordered first
  *   - Cycle-safe $ref (#, #/$defs/, #/definitions/, and arbitrary RFC 6901 JSON Pointers)
  *   - oneOf / anyOf → TypeBox Union
- *   - allOf → TypeBox Intersect
+ *   - allOf → TypeBox Intersect; when it composes object sub-schemas or `$ref`s to
+ *     object definitions, an object schema with merged `properties` / `required`
+ *     (recursing through nested `allOf` and chained `$ref`s) that keeps the members
  * Falls back to Type.Any() for unresolvable $ref, recursive cycles, or missing type.
  */
 export function convertJsonSchemaToTypebox(
@@ -575,15 +693,13 @@ export function convertJsonSchemaToTypebox(
     return nonTyped;
   }
 
-  const rawType = schema["type"];
-  const type =
-    typeof rawType === "string"
-      ? rawType
-      : hasObjectSchemaKeywords(schema)
-        ? "object"
-        : hasArraySchemaKeywords(schema)
-          ? "array"
-          : undefined;
+  const type = inferSchemaType(schema, ctx);
+  if (type !== "object" && type !== "array") {
+    const combinator = convertCombinatorSchema(schema, type, opts, ctx);
+    if (combinator) {
+      return combinator;
+    }
+  }
 
   return convertTypedSchema(type, schema, opts, ctx);
 }