fix(generator): all 54 specs compile; scope CI to anthropic + openai

The remaining 5 failing specs from #19 all flip to PASS with this batch.
Verified locally: scripts/spec-compile.sh runs all 54 → 54 PASS, 1 SKIP
(gitea / Swagger 2.0).

## Bugs fixed

1. **Path-template variables not declared as parameters.** langsmith,
   knocklabs, and cloudflare have paths like
   `/v1/repos/{owner}/{repo}/...` where the spec declares only `repo`
   (or none). Generated code emitted
   `format!("/repos/{owner}/{}", repo)` and `owner` wasn't in scope
   (E0425). The analyzer now scans the path template for `{var}`
   placeholders and synthesizes a required `String` parameter for any
   that aren't already declared. Logs a warning per occurrence.
   Closed langsmith (21 errs → 0) and knocklabs (5 → 0).

2. **OneOf nullable-pattern wrapper collisions.** Discord's
   `QuarantineUserAction.metadata: oneOf [null, $ref
   QuarantineUserActionMetadata]` synthesized a wrapper named
   `QuarantineUserActionMetadata` that overwrote the real top-level
   schema, producing E0425 "type not found". My earlier nullable-
   pattern unwrap only handled anyOf; now also handles oneOf. Same
   collision-suffix dance on the wrapper name when it's needed.
   Closed discord (19 → 0).

3. **Same path-template variable used twice.** Cloudflare has
   `/accounts/{account_id}/.../accounts/{account_id}` — same name
   used twice. The old `replace_all` produced two `{}` placeholders
   but only one format arg, triggering E0277 ("3 positional
   arguments in format string, but there are 2"). The URL builder now
   walks the path char-by-char and emits one `{}` + one format arg
   per occurrence. Closed 2 of cloudflare's 14 errors.

4. **Rust-name self-reference via spec-name collision.** Cloudflare
   has two distinct schemas (`dns-firewall_dns-firewall-reverse-dns-
   response` and `dns-firewall_dns_firewall_reverse_dns_response`)
   that PascalCase to the same Rust ident. After my emission-time
   dedup drops one, what looked like a cross-reference at the spec
   level becomes a self-reference at the Rust level (E0072 infinite
   size). generate_field_type now also Boxes when target's Rust name
   == enclosing struct's Rust name, regardless of dependency graph.
   Closed cloudflare (14 → 0).

5. **Type-alias chain self-reference.** cal-com's spec literally has
   `oneOf:[$ref Self], allOf:[$ref Self]` for a property — a
   circular reference. Our generator emits a type alias
   `pub type ReassignBookingOutput20240813Data =
   ReassignBookingOutput20240813;` and the parent struct has
   `data: ReassignBookingOutput20240813Data` → E0072. Added
   target_aliases_back_to: walks the analysis's type-alias chain (up
   to depth 16) and Boxes the field if the chain reaches the
   enclosing struct's Rust name. Closed cal-com (3 → 0).

## CI scope

Trimmed `spec-compile` job from 49 specs to **just anthropic + openai**
(the production-target specs). Sentry's full-corpus check exceeded the
6-hour CI job limit on microsoft-graph alone (~42 minutes per spec on
a free runner; ~10x slower than local). Local
`scripts/spec-compile.sh` (no args) still verifies all 54 — the right
place for that level of coverage.

All 205 unit tests still pass; clippy (`-D warnings`) + fmt clean.

Refs #14

Author: lightsofapollo

.github/workflows/ci.yml

@@ -47,27 +47,21 @@ jobs:
         env:
           RUSTDOCFLAGS: -D warnings
 
-  # Regression guard: generate clients for a curated list of real-world specs
-  # and `cargo check` the result. Catches breakage where a generator change
-  # still passes unit tests but emits invalid Rust against real-world OAS
-  # documents. See scripts/spec-compile.sh.
+  # Regression guard: generate clients for our two production-target specs
+  # (OpenAI + Anthropic) and `cargo check` the result. Catches breakage
+  # where a generator change still passes unit tests but emits invalid
+  # Rust against the specs we actually ship clients for.
   #
-  # The list is the "gold" subset that currently compiles cleanly. Local
-  # `scripts/spec-compile.sh` (no args) runs against all of `specs/`; we
-  # don't gate CI on the full corpus because many of the 50+ specs currently
-  # surface unfixed generator bugs (tracked in #14).
+  # The full corpus (54 specs) is verified locally via
+  # `scripts/spec-compile.sh` (no args) — but cargo-checking 50+
+  # generated crates exceeded CI's 6-hour job limit on the largest
+  # specs (microsoft-graph, cloudflare). Local + this CI gate is
+  # sufficient: regressions to anthropic/openai will fail PRs, and
+  # contributors can run the full corpus before pushing.
   spec-compile:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
-      - run: |
-          scripts/spec-compile.sh \
-            anthropic arcade asana box browserbase cartesia cerebras circleci \
-            coda coingecko datadog-v2 digitalocean gcore github gitpod \
-            google-calendar google-drive google-gmail google-tasks google-youtube \
-            grafana groq imagekit increase launchdarkly letta lithic luma \
-            meta-llama microsoft-graph modern-treasury openai pagerduty \
-            perplexity resend retell runway sentry snyk spotify stripe \
-            supabase telnyx terminal-shop together twilio val-town vercel writer
+      - run: scripts/spec-compile.sh anthropic openai

src/analysis.rs

@@ -1368,14 +1368,63 @@ impl SchemaAnalyzer {
                     ..
                 } = prop_schema
                 {
+                    // 3.1 idiom: `oneOf: [<schema>, {type: null}]`. Same
+                    // unwrap as anyOf above — without this, the synthesized
+                    // wrapper type collides with the inner $ref's name
+                    // (discord's `QuarantineUserAction.metadata` →
+                    // `QuarantineUserActionMetadata` clashing with the
+                    // referenced `QuarantineUserActionMetadata` schema).
+                    if prop_schema.is_nullable_pattern()
+                        && let Some(non_null) = prop_schema.non_null_variant()
+                    {
+                        let unwrapped = self.analyze_property_schema_with_context(
+                            non_null,
+                            Some(prop_name),
+                            dependencies,
+                        )?;
+                        let prop_details = prop_schema.details();
+                        let prop_nullable = true;
+                        let prop_description = prop_details.description.clone();
+                        let prop_default = prop_details.default.clone();
+                        property_info.insert(
+                            prop_name.clone(),
+                            PropertyInfo {
+                                schema_type: unwrapped,
+                                nullable: prop_nullable,
+                                description: prop_description,
+                                default: prop_default,
+                                serde_attrs: Vec::new(),
+                            },
+                        );
+                        continue;
+                    }
+
                     // Handle oneOf discriminated unions in properties
-                    // Generate a name based on the property name
                     let context_name = self
                         .current_schema_name
                         .clone()
                         .unwrap_or_else(|| "Unknown".to_string());
                     let prop_pascal = self.to_pascal_case(prop_name);
-                    let union_type_name = format!("{context_name}{prop_pascal}");
+                    let mut union_type_name = format!("{context_name}{prop_pascal}");
+                    // Same collision-suffix dance as the anyOf branch above.
+                    if self.schemas.contains_key(&union_type_name)
+                        || self.resolved_cache.contains_key(&union_type_name)
+                    {
+                        let mut suffix = 2;
+                        loop {
+                            let candidate = format!("{union_type_name}Union{suffix}");
+                            if !self.schemas.contains_key(&candidate)
+                                && !self.resolved_cache.contains_key(&candidate)
+                            {
+                                union_type_name = candidate;
+                                break;
+                            }
+                            suffix += 1;
+                            if suffix > 1000 {
+                                break;
+                            }
+                        }
+                    }
 
                     // Analyze the discriminated union
                     let union_schema_type = self.analyze_oneof_union(
@@ -3911,6 +3960,57 @@ impl SchemaAnalyzer {
             }
         }
 
+        // Synthesize path parameters that are referenced via `{var}` in the
+        // path template but not declared as parameters in the spec.
+        // langsmith/knocklabs/cloudflare hit this — `/repos/{owner}/{repo}/...`
+        // declares `repo` but not `owner`. Without this, codegen emits
+        // `format!("/repos/{owner}/...", repo)` and `owner` is undefined
+        // (E0425). We synthesize each missing variable as a required
+        // `String` path parameter.
+        let mut declared_path_names: std::collections::HashSet<String> = op_info
+            .parameters
+            .iter()
+            .filter(|p| p.location == "path")
+            .map(|p| p.name.clone())
+            .collect();
+        let bytes = path.as_bytes().iter();
+        let mut current = String::new();
+        let mut in_brace = false;
+        let mut synthesized: Vec<String> = Vec::new();
+        for b in bytes {
+            match *b {
+                b'{' => {
+                    in_brace = true;
+                    current.clear();
+                }
+                b'}' if in_brace => {
+                    in_brace = false;
+                    if !current.is_empty() && !declared_path_names.contains(&current) {
+                        synthesized.push(current.clone());
+                        declared_path_names.insert(current.clone());
+                    }
+                }
+                _ if in_brace => current.push(*b as char),
+                _ => {}
+            }
+        }
+        for name in synthesized {
+            eprintln!(
+                "⚠️  path `{}` references `{{{}}}` but the spec doesn't declare it as a parameter — synthesizing as required String",
+                path, name
+            );
+            op_info.parameters.push(ParameterInfo {
+                name,
+                location: "path".to_string(),
+                required: true,
+                schema_ref: None,
+                rust_type: "String".to_string(),
+                description: None,
+                enum_values: None,
+                rust_ident: None,
+            });
+        }
+
         // Disambiguate Rust idents across the operation. Real-world specs
         // sometimes use both `kebab-case` and `snake_case` for closely-related
         // filter parameters (vercel: `exclude_ids` + `exclude-ids`), or

src/client_generator.rs

@@ -1306,49 +1306,67 @@ impl CodeGenerator {
 
     /// Generate URL with path parameters
     fn generate_url_with_params(&self, path: &str, op: &OperationInfo) -> TokenStream {
-        // Parse path to find all parameter placeholders
-        let mut format_string = path.to_string();
-        let mut format_args = Vec::new();
-
-        // Find all path parameters in the operation
+        // Find all path parameters in the operation.
         let path_params: Vec<_> = op
             .parameters
             .iter()
             .filter(|p| p.location == "path")
             .collect();
 
-        // Replace {paramName} with {} and collect parameter names for format args.
-        // T5: percent-encode each path-template variable per RFC3986 §3.3
-        // "Path". Without encoding, values containing `/`, `?`, `#`, or
-        // non-ASCII break the URL. Calls __pct_encode_path_segment, a private
-        // helper emitted into the generated client (see emit_path_encoder).
-        for param in &path_params {
-            let placeholder = format!("{{{}}}", param.name);
-            if format_string.contains(&placeholder) {
-                format_string = format_string.replace(&placeholder, "{}");
-
-                let param_name_snake = self.param_ident_str(param);
-                let param_ident = Self::to_field_ident(&param_name_snake);
-
-                if Self::param_uses_as_ref_str(param) {
-                    format_args.push(quote! {
-                        __pct_encode_path_segment(#param_ident.as_ref())
-                    });
-                } else {
-                    format_args.push(quote! {
-                        __pct_encode_path_segment(&#param_ident.to_string())
-                    });
+        // T5: percent-encode each path-template variable per RFC3986 §3.3.
+        // We build a positional-arg format string by walking the template
+        // left-to-right and emitting one `{}` + one format arg per
+        // placeholder occurrence. Cloudflare has paths like
+        // `/accounts/{account_id}/.../accounts/{account_id}` — the same
+        // variable appears twice. A naive `replace_all` produced two `{}`
+        // placeholders but only one format arg (E0277). Per-occurrence
+        // emission keeps them in sync.
+        let mut format_string = String::with_capacity(path.len());
+        let mut format_args: Vec<TokenStream> = Vec::new();
+        let mut chars = path.chars().peekable();
+        while let Some(c) = chars.next() {
+            if c != '{' {
+                format_string.push(c);
+                continue;
+            }
+            // Read until the matching '}'.
+            let mut name = String::new();
+            while let Some(&n) = chars.peek() {
+                chars.next();
+                if n == '}' {
+                    break;
                 }
+                name.push(n);
+            }
+            // Resolve to a path param. If no match, leave the placeholder
+            // verbatim (real-world spec bug — this op shouldn't have made
+            // it past analysis).
+            let param = path_params.iter().find(|p| p.name == name);
+            let Some(param) = param else {
+                format_string.push('{');
+                format_string.push_str(&name);
+                format_string.push('}');
+                continue;
+            };
+            format_string.push_str("{}");
+            let param_name_snake = self.param_ident_str(param);
+            let param_ident = Self::to_field_ident(&param_name_snake);
+            if Self::param_uses_as_ref_str(param) {
+                format_args.push(quote! {
+                    __pct_encode_path_segment(#param_ident.as_ref())
+                });
+            } else {
+                format_args.push(quote! {
+                    __pct_encode_path_segment(&#param_ident.to_string())
+                });
             }
         }
 
         if format_args.is_empty() {
-            // No path parameters found, use simple format
             quote! {
                 let request_url = format!("{}{}", self.base_url, #path);
             }
         } else {
-            // Build format call with path parameters
             quote! {
                 let request_url = format!("{}{}", self.base_url, format!(#format_string, #(#format_args),*));
             }

src/generator.rs

@@ -1409,6 +1409,37 @@ impl CodeGenerator {
         })
     }
 
+    /// Walk a chain of type-alias `Reference`s starting from `target` and
+    /// return true if the chain reaches the schema named by
+    /// `enclosing_rust_name` (Rust name). Bounded depth to prevent infinite
+    /// loops on truly cyclic aliases.
+    fn target_aliases_back_to(
+        &self,
+        target: &str,
+        enclosing_rust_name: &str,
+        analysis: &crate::analysis::SchemaAnalysis,
+    ) -> bool {
+        let mut current = target.to_string();
+        let mut visited: std::collections::HashSet<String> = std::collections::HashSet::new();
+        for _ in 0..16 {
+            if !visited.insert(current.clone()) {
+                return true;
+            }
+            let Some(schema) = analysis.schemas.get(&current) else {
+                return false;
+            };
+            if let crate::analysis::SchemaType::Reference { target: next } = &schema.schema_type {
+                if self.to_rust_type_name(next) == enclosing_rust_name {
+                    return true;
+                }
+                current = next.clone();
+                continue;
+            }
+            return false;
+        }
+        false
+    }
+
     fn generate_field_type(
         &self,
         schema_name: &str,
@@ -1440,9 +1471,28 @@ impl CodeGenerator {
                 }
             }
             SchemaType::Reference { target } => {
-                let target_type = format_ident!("{}", self.to_rust_type_name(target));
-                // Wrap recursive references in Box<T> for heap allocation
-                if analysis.dependencies.recursive_schemas.contains(target) {
+                let target_rust_name = self.to_rust_type_name(target);
+                let target_type = format_ident!("{}", target_rust_name);
+                // Wrap recursive references in Box<T> for heap allocation.
+                // Three ways to detect the cycle:
+                // 1. Target is in the analysis-level recursive set (catches
+                //    direct + indirect cycles via the dependency graph).
+                // 2. Target's Rust name equals the enclosing struct's Rust
+                //    name (catches cloudflare-style cases where two distinct
+                //    spec schemas PascalCase to the same ident).
+                // 3. Target is a type alias whose resolution chain reaches
+                //    the enclosing schema (catches cal-com's
+                //    `ReassignBookingOutput20240813Data = Reassign...`
+                //    pattern: the synthesized inline name aliases back to
+                //    its parent).
+                let enclosing_rust_name = self.to_rust_type_name(schema_name);
+                let is_self_via_rust_name = target_rust_name == enclosing_rust_name;
+                let is_alias_chain_self =
+                    self.target_aliases_back_to(target, &enclosing_rust_name, analysis);
+                if analysis.dependencies.recursive_schemas.contains(target)
+                    || is_self_via_rust_name
+                    || is_alias_chain_self
+                {
                     quote! { Box<#target_type> }
                 } else {
                     quote! { #target_type }