refactor(codegen): drive C# generation from @seamapi/blueprint

Remove all temporary, output-parity workarounds and TODOs from the C# SDK
codegen and generate entirely from @seamapi/blueprint. The generator no longer
parses the raw OpenAPI spec.

- Wire the @seamapi/smith blueprint plugin into smith.ts so generation reads
  metalsmith.metadata().blueprint.
- Add lib/fields.ts to normalize blueprint request parameters and resource
  properties into a single neutral Field shape.
- Rewrite lib/build-model.ts and lib/csharp.ts to build models, discriminated
  unions (including the Event and ActionAttempt unions), and API route classes
  from the blueprint.
- Clean previously generated Api/Model files before each run so schemas removed
  from the blueprint no longer leave stale output behind.
- Delete the ported OpenAPI parsing helpers (lib/openapi/*), the frozen
  lib/types.ts, and lib/schema-modifications.ts.

The generated output changes as a result: resource model properties are now
uniformly optional/nullable, internal /seam and /unstable_partner routes are
excluded from the public SDK, and a few routes/resources are added or removed to
match the current blueprint.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Dsd5rETycPuurxdfT9LHa4

Author: claude

codegen/lib/build-model.ts

@@ -1,9 +1,9 @@
 // Durable data model for the C# SDK codegen.
 //
 // These interfaces hold the resolved structure of each generated file, decoupled
-// from serialization. build-model.ts produces them from the (raw-OpenAPI)
-// schemas; the Handlebars layouts and their context builders turn them into C#.
-// String serialization lives entirely in the templates.
+// from serialization. build-model.ts produces them from the @seamapi/blueprint;
+// the Handlebars layouts turn them into C#. String serialization lives entirely
+// in the templates.
 
 // A single enum member, e.g. `[EnumMember(Value = "setting")] Setting = 1,`.
 export interface CsEnumMember {

codegen/lib/class-model.ts

@@ -1,130 +1,143 @@
-import * as types from '@seamapi/types/connect'
+import type { Blueprint, Resource, Route } from '@seamapi/blueprint'
 import { pascalCase } from 'change-case'
 import type Metalsmith from 'metalsmith'
 
-import { buildApiFile, buildModelFile } from './build-model.js'
-import { GLOBAL_NAMESPACE } from './constants.js'
-import { deepFlattenAllOfSchema } from './openapi/flatten-obj-schema.js'
-import { getFilteredRoutes } from './openapi/get-filtered-routes.js'
-import { getParameterAndResponseSchema } from './openapi/get-parameter-and-response-schema.js'
-import { modifySchemaForSpecialCases } from './schema-modifications.js'
-import type { ObjSchema, OpenAPISchema, PropertySchema } from './types.js'
+import { buildApiFile, buildModelFile, buildUnionFile } from './build-model.js'
+import {
+  type Field,
+  normalizeField,
+  type RouteEndpoint,
+  type Variant,
+} from './fields.js'
 
 const outputRoot = 'output/csharp/src/Seam'
 
-interface RouteInfo {
-  methodName: string
-  path: string
-  parameterSchema: ObjSchema
-  responseObjType: string | undefined
-  responseArrType: string | undefined
-  isVoid: boolean
-  nullable: boolean
-  returnPath: string
+// Resource types modeled as top-level discriminated unions instead of plain
+// resource classes. `event` is a resource in the blueprint but is emitted from
+// blueprint.events; `action_attempt` is only available via blueprint.actionAttempts.
+const UNION_RESOURCE_TYPES = new Set(['event', 'action_attempt'])
+
+// Internal API surfaces that the public C# SDK does not expose.
+const isInternalRoute = (route: Route): boolean =>
+  route.path.startsWith('/seam/') || route.path.startsWith('/unstable_partner')
+
+// The API class name reverses the route path segments, e.g. /acs/credential_pools
+// becomes CredentialPoolsAcs.
+const apiClassName = (route: Route): string =>
+  pascalCase(route.path.split('/').filter(Boolean).reverse().join('_'))
+
+const resourceClassName = (resourceType: string): string =>
+  resourceType === 'unknown' ? 'object' : pascalCase(resourceType)
+
+const toEndpoint = (endpoint: Route['endpoints'][number]): RouteEndpoint => {
+  const parameters: Field[] = endpoint.request.parameters.map(normalizeField)
+  const { response } = endpoint
+
+  if (response.responseType === 'void') {
+    return {
+      name: endpoint.name,
+      path: endpoint.path,
+      parameters,
+      isVoid: true,
+      isList: false,
+      responseKey: '',
+      returnType: '',
+    }
+  }
+
+  return {
+    name: endpoint.name,
+    path: endpoint.path,
+    parameters,
+    isVoid: false,
+    isList: response.responseType === 'resource_list',
+    responseKey: response.responseKey,
+    returnType: resourceClassName(response.resourceType),
+  }
 }
 
+const resourceVariants = (
+  resources: Array<Resource & { discriminatorValue: string }>,
+): Variant[] =>
+  resources.map((resource) => ({
+    value: resource.discriminatorValue,
+    fields: resource.properties.map(normalizeField),
+  }))
+
 // Metalsmith plugin that generates the schema-derived C# SDK files: the Api
 // route classes (output/csharp/src/Seam/Api/*.cs) and the resource models
 // (output/csharp/src/Seam/Model/*.cs). Static, schema-independent files (the
 // Client/* runtime, the two static Model helpers, the .sln, the test project)
-// are normal committed package source and are intentionally NOT generated here.
+// are normal committed package source and are intentionally not generated here.
 //
-// The iteration reads the raw OpenAPI spec from @seamapi/types rather than
-// @seamapi/blueprint so the generated output stays byte-identical to the
-// previous generator.
-// TODO: Drive iteration and structure from metalsmith.metadata().blueprint once
-// the generated output is allowed to change. Blueprint is not wired into the
-// pipeline: the port does not use blueprint data, and @seamapi/blueprint does
-// not currently parse the pinned @seamapi/types.
-export const csharp = (files: Metalsmith.Files): void => {
-  const openapi = types.openapi as unknown as OpenAPISchema
-
-  const classMap: Record<string, RouteInfo[]> = {}
-
-  for (const route of getFilteredRoutes(openapi)) {
-    if (!route.post) continue
-    if (!route.post['x-fern-sdk-group-name']) continue
-
-    // TODO: Use blueprint route/namespace names once the generated output is
-    // allowed to change. The class name reverses x-fern-sdk-group-name (e.g.
-    // ['acs', 'credential_pools'] -> CredentialPoolsAcs), a load-bearing quirk
-    // of the previous generator that must be preserved for output parity.
-    const groupNames = [...route.post['x-fern-sdk-group-name']]
-    groupNames.reverse()
-    const className = pascalCase(groupNames.join('_'))
-
-    const {
-      parameter_schema: parameterSchema,
-      response_obj_type: responseObjType,
-      response_arr_type: responseArrType,
-      nullable,
-      response_schema: responseSchema,
-    } = getParameterAndResponseSchema(route)
-
-    // TODO: Determine void vs. returning endpoints from
-    // @seamapi/blueprint endpoint.response once the generated output is allowed
-    // to change. This reproduces the previous generator's filter, including its
-    // `ok`-property and x-response-key special-casing, from the raw OpenAPI.
-    let isVoid = false
-    if (!responseObjType && !responseArrType) {
-      if (
-        !responseSchema ||
-        'oneOf' in responseSchema ||
-        (Object.keys(responseSchema.properties).filter(
-          (k) => k.toLowerCase() !== 'ok',
-        ).length > 0 &&
-          route.post['x-response-key'] !== null)
-      ) {
-        continue
-      }
-      isVoid = true
+// Generation is driven entirely by the @seamapi/blueprint stored in
+// metalsmith.metadata().blueprint by the @seamapi/smith blueprint plugin.
+export const csharp = (
+  files: Metalsmith.Files,
+  metalsmith: Metalsmith,
+): void => {
+  const { blueprint } = metalsmith.metadata() as { blueprint: Blueprint }
+
+  const emitModel = (
+    name: string,
+    file: ReturnType<typeof buildModelFile>['file'],
+  ): void => {
+    files[`${outputRoot}/Model/${name}.cs`] = {
+      contents: Buffer.from('\n'),
+      layout: 'model.hbs',
+      ...file,
     }
+  }
 
-    if (!parameterSchema) continue
-
-    ;(classMap[className] ??= []).push({
-      methodName: route.post['x-fern-sdk-method-name'],
-      path: route.path,
-      parameterSchema,
-      responseObjType,
-      responseArrType,
-      isVoid,
-      nullable,
-      returnPath: route.post['x-fern-sdk-return-value'],
-    })
+  for (const resource of blueprint.resources) {
+    if (UNION_RESOURCE_TYPES.has(resource.resourceType)) continue
+    const { name, file } = buildModelFile(
+      resource.resourceType,
+      resource.properties.map(normalizeField),
+    )
+    emitModel(name, file)
   }
 
-  for (const [className, routes] of Object.entries(classMap)) {
-    const apiFile = buildApiFile(className, routes)
-    files[`${outputRoot}/Api/${apiFile.className}.cs`] = {
-      contents: Buffer.from('\n'),
-      layout: 'api.hbs',
-      ...apiFile,
-    }
+  {
+    const { name, file } = buildUnionFile(
+      'event',
+      'event_type',
+      resourceVariants(
+        blueprint.events.map((event) => ({
+          ...event,
+          discriminatorValue: event.eventType,
+        })),
+      ),
+    )
+    emitModel(name, file)
   }
 
-  for (const [schemaName, rawSchema] of Object.entries(
-    openapi.components.schemas,
-  )) {
-    let schema = modifySchemaForSpecialCases(
-      schemaName,
-      rawSchema as PropertySchema,
+  {
+    const { name, file } = buildUnionFile(
+      'action_attempt',
+      'action_type',
+      resourceVariants(
+        blueprint.actionAttempts.map((actionAttempt) => ({
+          ...actionAttempt,
+          discriminatorValue: actionAttempt.actionAttemptType,
+        })),
+      ),
     )
+    emitModel(name, file)
+  }
 
-    if ('allOf' in schema) {
-      const flattened = deepFlattenAllOfSchema(schema)
-      if (flattened == null) continue
-      schema = flattened
-    }
+  for (const route of blueprint.routes) {
+    if (isInternalRoute(route)) continue
+    if (route.endpoints.length === 0) continue
 
-    const { name, file } = buildModelFile(schemaName, schema, [
-      ...GLOBAL_NAMESPACE,
-      'Model',
-    ])
-    files[`${outputRoot}/Model/${name}.cs`] = {
+    const apiFile = buildApiFile(
+      apiClassName(route),
+      route.endpoints.map(toEndpoint),
+    )
+    files[`${outputRoot}/Api/${apiFile.className}.cs`] = {
       contents: Buffer.from('\n'),
-      layout: 'model.hbs',
-      ...file,
+      layout: 'api.hbs',
+      ...apiFile,
     }
   }
 }