@workos/oagen-emitters 0.13.0 → 0.14.1

package/src/node/index.ts

@@ -16,6 +16,8 @@ import { generateEnums as generateEnumFiles } from './enums.js';
 import { generateResources, resolveResourceClassName, resolveResourceDir } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests as generateTestFiles } from './tests.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
+import { planDiscriminatedModels, generateDiscriminatedFiles } from './discriminated-models.js';
 import { buildLiveSurface, emptyLiveSurface, setActiveLiveSurface, type LiveSurface } from './live-surface.js';
 import {
   setBaselineSerializedNames,
@@ -36,6 +38,24 @@ import { fileName } from './naming.js';
  */
 const surfaceCache = new WeakMap<EmitterContext, LiveSurface>();
 
+/**
+ * Paths the node emitter has produced so far in this ctx, accumulated across
+ * `applyLiveSurface` calls. Drives `carryForwardManagedFiles` so files in the
+ * prior manifest that we did not re-emit this run still land in the new
+ * manifest as "still managed" — without that, the orchestrator's prune diff
+ * treats every untouched autogen file as stale.
+ */
+const emittedPathsCache = new WeakMap<EmitterContext, Set<string>>();
+
+function getEmittedPaths(ctx: EmitterContext): Set<string> {
+  let set = emittedPathsCache.get(ctx);
+  if (!set) {
+    set = new Set();
+    emittedPathsCache.set(ctx, set);
+  }
+  return set;
+}
+
 function getSurface(ctx: EmitterContext): LiveSurface {
   let surface = surfaceCache.get(ctx);
   if (surface) return surface;
@@ -113,8 +133,10 @@ function getSurface(ctx: EmitterContext): LiveSurface {
  * `integrateTarget: false` files (smoke-manifest.json etc.) are also dropped:
  * with no `--target` step they would otherwise land as untracked cruft.
  *
- * Note: pairing this with `--no-prune` is required for stable behavior — see
- * `scripts/sdk-generate.sh` in the spec repo, which enables it for `--lang node`.
+ * Note: the carry-forward step in `generateTests` re-declares prior-manifest
+ * paths we didn't touch this run, so the orchestrator's prune diff stays
+ * accurate without needing `--no-prune` at the call site. See
+ * `carryForwardManagedFiles` below.
  */
 /**
  * `*.spec.ts`, `*.test.ts`, and JSON fixtures under `fixtures/` are owned by
@@ -214,7 +236,10 @@ function computeOwnedServiceDirs(ctx: EmitterContext): Set<string> {
   const mountGroups = groupByMount(ctx);
   const services =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
   const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 
@@ -233,7 +258,10 @@ function computeAdoptedServiceDirs(ctx: EmitterContext, surface: LiveSurface): S
   const mountGroups = groupByMount(ctx);
   const services =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
   const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 
@@ -347,22 +375,110 @@ function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface:
     }
     out.push(f);
   }
+  const emitted = getEmittedPaths(ctx);
+  for (const f of out) emitted.add(f.path);
+  return out;
+}
+
+/**
+ * Re-declare prior-manifest paths that we did not emit this run so manifest
+ * pruning can tell "intentionally removed" from "untouched but still managed."
+ *
+ * The node emitter only outputs files it actually wants to write each run —
+ * untouched-but-up-to-date autogen files don't come back through any
+ * `generateXxx` method. Without this carry-forward, the orchestrator's
+ * `prevManifest.files − currentEmission` diff treats every such file as stale
+ * and prunes the whole tree on a regen. That's why `scripts/sdk-generate.sh`
+ * historically paired the node emitter with `--no-prune` — at the cost of
+ * never pruning legitimately-removed files (e.g. an enum file orphaned by a
+ * `schemaNameTransform` rename like `RadarAction` → `RadarListAction`).
+ *
+ * The carry-forward entry uses `skipIfExists: true`, so writer.ts skips the
+ * write and only ensures the header is present (no-op for files that already
+ * have it). The path still lands in `outputEmittedPaths` and therefore in the
+ * new manifest, which restores correct prune semantics.
+ *
+ * Files dropped from the carry-forward set:
+ *  - Not on disk anymore (file was hand-deleted — let prune confirm absence).
+ *  - `@oagen-ignore-file` protected (user has explicitly taken ownership).
+ *  - `.ts` files that no longer carry the auto-gen header (user has taken
+ *    ownership in-place; the next prune cycle will clear the manifest entry).
+ */
+function carryForwardManagedFiles(ctx: EmitterContext, surface: LiveSurface): GeneratedFile[] {
+  const priorPaths = ctx.priorTargetManifestPaths;
+  if (!priorPaths || priorPaths.size === 0) return [];
+
+  const emitted = getEmittedPaths(ctx);
+  const out: GeneratedFile[] = [];
+  for (const relPath of priorPaths) {
+    if (emitted.has(relPath)) continue;
+    if (!surface.files.has(relPath)) continue;
+    if (surface.protectedFiles.has(relPath)) continue;
+    if (relPath.endsWith('.ts') && !surface.autogenFiles.has(relPath)) continue;
+
+    out.push({
+      path: relPath,
+      content: '',
+      skipIfExists: true,
+      headerPlacement: 'skip',
+    });
+    emitted.add(relPath);
+  }
   return out;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields from the raw spec onto each
+ * model. `enrichModelsFromSpec` produces (a) extra optional fields on models
+ * whose schema is `allOf [base, oneOf [...]]`, and (b) synthetic models /
+ * enums for inline objects encountered inside variants (e.g. the inline
+ * `redirect_uris` item shape on `ConnectApplication`).
+ *
+ * Node, like Go / Kotlin / .NET, emits flat interfaces rather than a sum
+ * type, so on `enrichModelsFromSpec`-marked discriminated bases we restore
+ * the original IR fields — otherwise the base interface would be empty.
+ * A future change can emit a real TS discriminated union; for now the goal
+ * is parity with the other flat-emit languages so every variant field is
+ * at least reachable.
+ */
+function enrichModelsForNode(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const nodeEmitter: Emitter = {
   language: 'node',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateModelsAndSerializers(models, nodeCtx), nodeCtx, surface);
+    const enriched = enrichModelsForNode(models);
+    // Detect `allOf [base, oneOf [variant, …]]` schemas and hand them off
+    // to the discriminated-models module. Leave the model in the standard
+    // pipeline's input so its field-type deps stay reachable, but stash the
+    // name set on ctx so models.ts skips emitting an interface/serializer —
+    // the discriminated module owns those paths instead.
+    const discPlans = planDiscriminatedModels(enriched, nodeCtx);
+    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = new Set(discPlans.keys());
+    const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
+    const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
+    return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateEnumFiles(enums, nodeCtx), nodeCtx, surface);
+    const syntheticEnums = getSyntheticEnums();
+    return applyLiveSurface(generateEnumFiles([...enums, ...syntheticEnums], nodeCtx), nodeCtx, surface);
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
@@ -374,7 +490,11 @@ export const nodeEmitter: Emitter = {
   generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateClient(spec, nodeCtx), nodeCtx, surface);
+    // `nodeCtx.spec` has the synthetic models that `enrichModelsFromSpec`
+    // produced (e.g. inline-object item types like `ConnectApplicationRedirectUri`).
+    // The `spec` param is the engine's pre-enrichment spec, so the barrel
+    // generator would miss those synthetic interfaces. Use the enriched one.
+    return applyLiveSurface(generateClient(nodeCtx.spec, nodeCtx), nodeCtx, surface);
   },
 
   // workos-node ships its own exception hierarchy under src/common/exceptions/.
@@ -389,11 +509,16 @@ export const nodeEmitter: Emitter = {
 
   // Test specs and fixtures are hand-maintained except for explicitly-owned
   // service directories.
+  //
+  // This is also the last `generateXxx` hook in `generateAllFiles`, so it's
+  // where we tack on the carry-forward set — see `carryForwardManagedFiles`.
   generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
-    if (!nodeOptions(nodeCtx).regenerateOwnedTests) return [];
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateTestFiles(spec, nodeCtx), nodeCtx, surface);
+    const testFiles = nodeOptions(nodeCtx).regenerateOwnedTests
+      ? applyLiveSurface(generateTestFiles(spec, nodeCtx), nodeCtx, surface)
+      : [];
+    return [...testFiles, ...carryForwardManagedFiles(nodeCtx, surface)];
   },
 
   // No operations map needed — the manifest belongs to the staging+target flow,

package/src/node/models.ts

@@ -23,6 +23,7 @@ import {
   createServiceDirResolver,
   isListMetadataModel,
   isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
   buildDeduplicationMap,
   relativeImport,
   modelHasNewFields,
@@ -130,6 +131,13 @@ function isSupportedFieldType(
       // silently dropped on first emission because the target interface
       // (`UserObject` under the adopted `connect/` dir) hasn't landed yet.
       if (isAdoptedModelName(ref.name)) return true;
+      // Synthetic models produced by `enrichModelsFromSpec` (e.g. the
+      // inline-object item type for `ConnectApplication.redirect_uris`)
+      // are added to the models list passed into this generation pass —
+      // and hence into `shared.modelToService` — but won't yet exist on
+      // disk or in `apiSurface`. Accept them so their parent field
+      // survives field-projection.
+      if (shared.modelToService.has(ref.name)) return true;
       const relPath = `src/${shared.resolveDir(shared.modelToService.get(ref.name))}/interfaces/${fileName(ref.name)}.interface.ts`;
       return liveSurfaceHasManagedFile(relPath);
     }
@@ -201,12 +209,18 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
     }
   }
 
+  const discriminatedSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
+  // Wrappers referenced as a non-paginated response (e.g. `VersionListResponse`
+  // for `GET /vault/v1/kv/{id}/versions`) must still be emitted — the resource
+  // code references them by name and pagination iterators don't unwrap them.
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
     if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
+    if (discriminatedSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
     if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
@@ -723,13 +737,16 @@ export function generateSerializers(
     }
   }
 
+  const discriminatedSerializerSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
+  const serializerNonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
   const eligibleModels: Model[] = [];
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!serializerReachable.has(model.name)) continue;
     if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListWrapperModel(model) && !serializerNonPaginatedRefs.has(model.name)) continue;
+    if (discriminatedSerializerSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
     if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
@@ -928,7 +945,10 @@ function buildGeneratedResourceModelUsage(
   const mountGroups = groupByMount(ctx);
   const services: Service[] =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
 
   for (const service of services) {

package/src/node/node-overrides.ts

@@ -1,4 +1,5 @@
-import type { EmitterContext, ResolvedOperation } from '@workos/oagen';
+import type { EmitterContext, Model, ResolvedOperation } from '@workos/oagen';
+import { enrichModelsFromSpec } from '../shared/model-utils.js';
 
 type OperationOverride = {
   methodName?: string;
@@ -42,17 +43,52 @@ function operationKey(resolved: ResolvedOperation): string {
   return `${resolved.operation.httpMethod.toUpperCase()} ${resolved.operation.path}`;
 }
 
+/**
+ * Apply oneOf / allOf+oneOf enrichment (flattening variant fields onto the
+ * parent model, plus synthetic models/enums for inline shapes) so the rest
+ * of the Node emitter sees a richer `spec.models`.
+ *
+ * Without this, `ConnectApplication` (and any other `allOf [base, oneOf [...]]`
+ * schema whose first variant is itself wrapped in `allOf`) loses every
+ * non-M2M field — the IR parser's discriminator detection silently skips
+ * variants whose properties live behind another `allOf`. Mirrors what the
+ * Go / Kotlin / .NET emitters already do.
+ *
+ * Discriminated bases produced by `enrichModelsFromSpec` get their original
+ * fields restored — Node emits flat interfaces today, not TS sum types, so
+ * an empty base would otherwise drop the common fields.
+ */
+function enrichSpecModels(models: readonly Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models as Model[]);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext {
   const cached = contextCache.get(ctx);
   if (cached) return cached;
 
+  const enrichedModels = enrichSpecModels(ctx.spec.models);
+  const specChanged =
+    enrichedModels.length !== ctx.spec.models.length || enrichedModels.some((m, i) => m !== ctx.spec.models[i]);
+  const enrichedSpec = specChanged ? { ...ctx.spec, models: enrichedModels } : ctx.spec;
+
   const resolvedOperations = ctx.resolvedOperations;
   if (!resolvedOperations?.length) {
-    contextCache.set(ctx, ctx);
-    return ctx;
+    const next = specChanged ? { ...ctx, spec: enrichedSpec } : ctx;
+    contextCache.set(ctx, next);
+    return next;
   }
 
-  let changed = false;
+  let opsChanged = false;
   const nextResolved = resolvedOperations.map((resolved) => {
     const override = OPERATION_OVERRIDES[operationKey(resolved)];
     if (!override) return resolved;
@@ -63,7 +99,7 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
       return resolved;
     }
 
-    changed = true;
+    opsChanged = true;
     return {
       ...resolved,
       methodName,
@@ -71,7 +107,14 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
     };
   });
 
-  const next = changed ? { ...ctx, resolvedOperations: nextResolved } : ctx;
+  const next =
+    opsChanged || specChanged
+      ? {
+          ...ctx,
+          ...(opsChanged ? { resolvedOperations: nextResolved } : {}),
+          ...(specChanged ? { spec: enrichedSpec } : {}),
+        }
+      : ctx;
   contextCache.set(ctx, next);
   return next;
 }

package/src/node/utils.ts

@@ -277,7 +277,11 @@ export function isBaselineGeneric(fields: Record<string, unknown>, knownNames: S
   return false;
 }
 
-export { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+export {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 
 function modelFingerprint(model: Model): string {
   const fields = model.fields.map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`).sort();

package/src/php/index.ts

@@ -18,6 +18,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { initializeEnumDedup } from './naming.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Initialize enum deduplication from spec data. */
 function ensureNamingInitialized(ctx: EmitterContext): void {
@@ -34,17 +35,39 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+ * in synthetic models / enums for inline variant shapes. PHP emits flat
+ * classes (no sum types), so a discriminated base whose IR fields the
+ * parser stripped (post-allOf-aware detection) gets its original fields
+ * restored to avoid silently dropping variant data.
+ */
+function enrichModelsForPhp(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const phpEmitter: Emitter = {
   language: 'php',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateModels(models, ctx));
+    return ensureTrailingNewlines(generateModels(enrichModelsForPhp(models), ctx));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {

package/src/php/models.ts

@@ -4,7 +4,11 @@ import { className, enumClassName, fieldName } from './naming.js';
 import { phpDocComment } from './utils.js';
 
 // Import and re-export shared model detection utilities
-import { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+import {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 export { isListMetadataModel, isListWrapperModel };
 
 /**
@@ -32,9 +36,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     overwriteExisting: true,
   });
 
+  // Wrappers referenced as a non-paginated response (e.g. `VersionListResponse`
+  // for `GET /vault/v1/kv/{id}/versions`) must still be emitted — the resource
+  // code references them by name and the pagination iterator doesn't unwrap them.
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+
   for (const model of models) {
     if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     const name = className(model.name);
     const lines: string[] = [];
 

package/src/python/models.ts

@@ -41,9 +41,15 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   // oneOf enrichment collide with existing IR models in snake_case.
   const emittedFilePaths = new Set<string>();
 
+  // Wrappers referenced as a non-paginated operation response (e.g.
+  // `VersionListResponse` for `GET /vault/v1/kv/{id}/versions`) must still be
+  // emitted — the resource code references them by name and SyncPage doesn't
+  // wrap them.
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+
   for (const model of models) {
     // Skip list wrapper models (e.g., OrganizationList) — SyncPage handles envelopes
-    if (isListWrapperModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     // Skip all list metadata models (e.g., ListMetadata, FooListListMetadata)
     if (isListMetadataModel(model)) continue;
 
@@ -865,5 +871,9 @@ function serializeField(ref: any, accessor: string): string {
 }
 
 // Import and re-export shared model detection utilities
-import { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+import {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 export { isListMetadataModel, isListWrapperModel };

package/src/python/resources.ts

@@ -1053,8 +1053,14 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
 
     for (const op of allOperations) {
       const plan = planOperation(op);
-      if (plan.responseModelName && !listWrapperNames.has(plan.responseModelName)) {
-        modelImports.add(plan.responseModelName);
+      if (plan.responseModelName) {
+        // List-wrapper responses are normally replaced by SyncPage on paginated
+        // ops, so the wrapper itself is never referenced. On non-paginated ops
+        // (e.g. `GET /vault/v1/kv/{id}/versions` → `VersionListResponse`) the
+        // resource method still returns the wrapper by name and must import it.
+        if (!listWrapperNames.has(plan.responseModelName) || !plan.isPaginated) {
+          modelImports.add(plan.responseModelName);
+        }
       }
       if (op.requestBody?.kind === 'model') {
         const requestBodyRef = op.requestBody;

package/src/ruby/index.ts

@@ -15,6 +15,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { generateRbiFiles } from './rbi.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -26,16 +27,40 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pick
+ * up the synthetic models / enums `enrichModelsFromSpec` produces for inline
+ * variant shapes. Ruby emits flat hash-backed models, not sum types, so a
+ * discriminated base whose IR fields were stripped (the new EventSchema-
+ * style behaviour after the parser learned to walk allOf-wrapped variants)
+ * has its original fields restored — otherwise `ConnectApplication`-style
+ * bases would silently lose every variant field they had previously.
+ */
+function enrichModelsForRuby(models: Model[], enums: Enum[]): Model[] {
+  const enriched = enrichModelsFromSpec(models, enums);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const rubyEmitter: Emitter = {
   language: 'ruby',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
-    const modelFiles = generateModels(models, ctx);
+    const modelFiles = generateModels(enrichModelsForRuby(models, ctx.spec.enums), ctx);
     return ensureTrailingNewlines(modelFiles);
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {

package/src/ruby/models.ts

@@ -1,7 +1,11 @@
 import type { Model, EmitterContext, GeneratedFile, TypeRef, Field } from '@workos/oagen';
 import { walkTypeRef, assignModelsToServices } from '@workos/oagen';
 import { className, fieldName, fileName, buildMountDirMap } from './naming.js';
-import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import {
+  isListWrapperModel,
+  isListMetadataModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 
 /** Folder under lib/workos/ for models not owned by any service. */
 export const SHARED_MODEL_DIR = 'shared';
@@ -77,11 +81,17 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
   const files: GeneratedFile[] = [];
 
+  // Wrappers referenced as a non-paginated response (e.g. `VersionListResponse`
+  // for `GET /vault/v1/kv/{id}/versions`) must still be emitted — the resource
+  // code references them by name and the pagination iterator doesn't unwrap them.
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+  const skipAsListWrapper = (m: Model): boolean => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
+
   // Dedup identical models (by recursive structural hash).
   const recursiveHashes = buildRecursiveHashMap(models, enumNames);
   const hashGroups = new Map<string, string[]>();
   for (const m of models) {
-    if (isListWrapperModel(m) || isListMetadataModel(m)) continue;
+    if (skipAsListWrapper(m) || isListMetadataModel(m)) continue;
     const h = recursiveHashes.get(m.name) ?? '';
     if (!hashGroups.has(h)) hashGroups.set(h, []);
     hashGroups.get(h)!.push(m.name);
@@ -95,7 +105,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   }
 
   for (const model of models) {
-    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
 
     const cls = className(model.name);
     const file = fileName(model.name);

package/src/rust/index.ts

@@ -16,6 +16,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { UnionRegistry } from './type-map.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /**
  * Shared per-emit registry that collects synthesised oneOf-style unions
@@ -34,16 +35,39 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+ * in synthetic models / enums for inline variant shapes. Rust emits flat
+ * structs (a synthesised enum-union from `UnionRegistry` exists, but the
+ * field-on-base pattern is what matches `ConnectApplication` today). A
+ * discriminated base whose IR fields the parser stripped gets its original
+ * fields restored to avoid losing variant data.
+ */
+function enrichModelsForRust(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const rustEmitter: Emitter = {
   language: 'rust',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     unionRegistry.reset();
-    return ensureTrailingNewlines(generateModels(models, ctx, unionRegistry));
+    return ensureTrailingNewlines(generateModels(enrichModelsForRust(models), ctx, unionRegistry));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {