@workos/oagen-emitters 0.2.0 → 0.3.0

package/smoke/sdk-go.ts

@@ -140,6 +140,43 @@ function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
   return manifest;
 }
 
+// ---------------------------------------------------------------------------
+// Accessor map -- discover actual method names from the generated workos.go
+// ---------------------------------------------------------------------------
+
+function buildAccessorMap(sdkPath: string): Map<string, string> {
+  const map = new Map<string, string>();
+  // Find the main workos.go or *.go file that has Client methods
+  const candidates = ['workos.go'];
+  for (const fname of candidates) {
+    const fpath = resolve(sdkPath, fname);
+    if (!existsSync(fpath)) continue;
+    const content = readFileSync(fpath, 'utf-8');
+    // Match: func (c *Client) ServiceName() *serviceNameService {
+    const re = /func \(c \*Client\) (\w+)\(\)/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const accessor = m[1];
+      // Map by lowercase key for case-insensitive matching
+      map.set(accessor.toLowerCase(), accessor);
+    }
+  }
+  return map;
+}
+
+/**
+ * Resolve the Go service accessor name from the manifest service name.
+ * Uses the accessor map (built from the generated SDK) for exact matching.
+ * Falls back to PascalCase for services not found in the map.
+ */
+function resolveAccessorName(manifestService: string, accessorMap: Map<string, string>): string {
+  // Try case-insensitive lookup: "sso" -> "SSO", "api_keys" -> "ApiKeys"
+  const pascalized = toPascalCase(manifestService);
+  const found = accessorMap.get(pascalized.toLowerCase());
+  if (found) return found;
+  return pascalized;
+}
+
 // ---------------------------------------------------------------------------
 // Method resolution
 // ---------------------------------------------------------------------------
@@ -257,7 +294,12 @@ class CaptureProxy {
       }
     }
 
-    const capturedReq: CapturedRequest = { method, path, queryParams, body: parsedReqBody };
+    const capturedReq: CapturedRequest = {
+      method,
+      path,
+      queryParams,
+      body: parsedReqBody,
+    };
 
     // Forward to the real API
     const targetUrl = new URL(path, this.targetBaseUrl);
@@ -340,15 +382,16 @@ function detectModulePath(sdkPath: string): string {
     const match = goMod.match(/^module\s+(\S+)/m);
     if (match) return match[1];
   }
-  return 'github.com/workos/workos-go/v4';
+  return 'github.com/workos/workos-go/v2';
 }
 
 function generateGoImports(
   modulePath: string,
-  servicePackages: Set<string>,
+  _servicePackages: Set<string>,
   needsJson: boolean,
-  needsServicePkg: boolean,
+  _needsServicePkg: boolean,
 ): string {
+  // New emitter: flat package -- everything lives in the root module, no sub-packages.
   const lines: string[] = [];
   lines.push('import (');
   lines.push('\t"context"');
@@ -358,20 +401,21 @@ function generateGoImports(
   lines.push('\t"fmt"');
   lines.push('\t"os"');
   lines.push('');
-  lines.push(`\tworkos "${modulePath}/pkg"`);
-  if (needsServicePkg) {
-    for (const pkg of [...servicePackages].sort()) {
-      lines.push(`\t"${modulePath}/pkg/${pkg}"`);
-    }
-  }
+  lines.push(`\t"${modulePath}"`);
   lines.push(')');
   return lines.join('\n');
 }
 
-function generateGoPayloadStruct(payload: Record<string, unknown>, optsType: string, servicePackage: string): string {
+function generateGoPayloadStruct(payload: Record<string, unknown>, paramsType: string): string {
+  // New emitter: all types in root workos package, params are pointers.
+  // Skip nested objects, arrays, and nil values since Go requires typed structs
+  // and primitive fields can't be nil.
   const lines: string[] = [];
-  lines.push(`${servicePackage}.${optsType}{`);
+  lines.push(`&workos.${paramsType}{`);
   for (const [key, value] of Object.entries(payload)) {
+    // Skip nil, nested objects, and arrays
+    if (value === null || value === undefined) continue;
+    if (typeof value === 'object') continue;
     const goField = goFieldName(key);
     lines.push(`\t\t${goField}: ${goLiteral(value)},`);
   }
@@ -409,9 +453,9 @@ function generateGoCallBlock(
   pathParams: Record<string, string>,
   spec: any,
   callIndex: number,
+  accessorMap: Map<string, string>,
 ): string {
   const lines: string[] = [];
-  const servicePackage = goServicePackageName(resolution.service);
   const method = resolution.method;
 
   // Build arguments
@@ -422,52 +466,63 @@ function generateGoCallBlock(
     args.push(`"${pathParams[p.name] || ''}"`);
   }
 
-  // Request body opts struct
+  // Build service-prefixed params struct name (matches emitter's paramsStructName)
+  const servicePrefix = goExportedName(resolution.service);
+  const paramsTypeName = method.startsWith(servicePrefix) ? `${method}Params` : `${servicePrefix}${method}Params`;
+
+  // Request body params struct (emitter uses &workos.{ServicePrefix}{Method}Params{...})
+  const hasQueryParams = op.queryParams && op.queryParams.length > 0;
   if (op.requestBody) {
     const payload = generatePayload(op, spec);
     if (payload && Object.keys(payload).length > 0) {
-      const optsType = `${method}Opts`;
-      args.push(generateGoPayloadStruct(payload, optsType, servicePackage));
-    }
-  }
-
-  // Paginated operations: pass opts with Limit=1
-  if (op.pagination && !op.requestBody) {
-    const extraParams = op.queryParams.filter((p: any) => !['limit', 'before', 'after', 'order'].includes(p.name));
-    if (extraParams.length > 0) {
-      // Match the emitter convention: List → ListFilterOpts, others → ${method}Opts
-      const optsType = method === 'List' ? 'ListFilterOpts' : `${method}Opts`;
-      args.push(`${servicePackage}.${optsType}{Limit: 1}`);
+      args.push(generateGoPayloadStruct(payload, paramsTypeName));
     } else {
-      args.push(`${servicePackage}.ListOpts{Limit: 1}`);
+      // Even with empty payload, the method signature requires the params arg
+      args.push(`&workos.${paramsTypeName}{}`);
     }
+  } else if (op.pagination || hasQueryParams) {
+    // Paginated or query-param operations need a params struct
+    args.push(`&workos.${paramsTypeName}{}`);
   }
 
-  // Determine the service accessor on the client
-  const serviceProp = goExportedName(resolution.service);
+  // Service accessor: resolve from the generated SDK's actual accessor names
+  const serviceProp = resolveAccessorName(resolution.service, accessorMap);
 
   lines.push(`\t// Call ${callIndex}: ${op.httpMethod.toUpperCase()} ${op.path}`);
   lines.push(`\tfmt.Fprintf(os.Stderr, "CALL_START:${callIndex}\\n")`);
 
-  // Determine return type: paginated and GET-with-response return (result, error),
-  // DELETE returns just error
+  // Determine return type: paginated returns Iterator, DELETE and void/redirect return just error
   const isDelete = op.httpMethod === 'delete';
-  const hasResponse = !isDelete;
-
-  if (hasResponse) {
-    lines.push(`\tresult${callIndex}, err${callIndex} := client.${serviceProp}.${method}(${args.join(', ')})`);
+  const isPaginated = !!op.pagination;
+  const isVoidResponse =
+    !isPaginated &&
+    !isDelete &&
+    ((op.response.kind === 'primitive' && (op.response as any).type === 'unknown') ||
+      (op.successResponses && op.successResponses.some((r: any) => r.statusCode >= 300 && r.statusCode < 400)));
+
+  if (isPaginated) {
+    // Iterator-based: call Next() once to trigger the first HTTP request
+    lines.push(`\titer${callIndex} := client.${serviceProp}().${method}(${args.join(', ')})`);
+    lines.push(`\titer${callIndex}.Next()`);
+    lines.push(`\tif err${callIndex} := iter${callIndex}.Err(); err${callIndex} != nil {`);
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_ERROR:${callIndex}:%s\\n", err${callIndex}.Error())`);
+    lines.push('\t} else {');
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:\\n")`);
+    lines.push('\t}');
+  } else if (isDelete || isVoidResponse) {
+    lines.push(`\terr${callIndex} := client.${serviceProp}().${method}(${args.join(', ')})`);
     lines.push(`\tif err${callIndex} != nil {`);
     lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_ERROR:${callIndex}:%s\\n", err${callIndex}.Error())`);
     lines.push('\t} else {');
-    lines.push(`\t\tjsonResult${callIndex}, _ := json.Marshal(result${callIndex})`);
-    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:%s\\n", string(jsonResult${callIndex}))`);
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:\\n")`);
     lines.push('\t}');
   } else {
-    lines.push(`\terr${callIndex} := client.${serviceProp}.${method}(${args.join(', ')})`);
+    lines.push(`\tresult${callIndex}, err${callIndex} := client.${serviceProp}().${method}(${args.join(', ')})`);
     lines.push(`\tif err${callIndex} != nil {`);
     lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_ERROR:${callIndex}:%s\\n", err${callIndex}.Error())`);
     lines.push('\t} else {');
-    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:\\n")`);
+    lines.push(`\t\tjsonResult${callIndex}, _ := json.Marshal(result${callIndex})`);
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:%s\\n", string(jsonResult${callIndex}))`);
     lines.push('\t}');
   }
 
@@ -518,6 +573,11 @@ async function main(): Promise<void> {
   // Load manifest
   const manifest = loadManifest(sdkPath);
 
+  // Build accessor name map by scanning the generated workos.go for
+  // `func (c *Client) XxxYyy()` patterns, then matching them to manifest
+  // service names via case-insensitive comparison.
+  const accessorMap = buildAccessorMap(sdkPath);
+
   const baseUrl = process.env.WORKOS_BASE_URL || spec.baseUrl;
 
   // Start capture proxy
@@ -580,7 +640,11 @@ async function main(): Promise<void> {
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -624,7 +688,7 @@ async function main(): Promise<void> {
       // Generate all call blocks for this wave
       const callBlocks: string[] = [];
       for (const call of plannedCalls) {
-        callBlocks.push(generateGoCallBlock(call.op, call.resolution, call.pathParams, spec, call.index));
+        callBlocks.push(generateGoCallBlock(call.op, call.resolution, call.pathParams, spec, call.index, accessorMap));
       }
 
       const imports = generateGoImports(modulePath, servicePackages, needsJson, needsServicePkg);
@@ -635,7 +699,7 @@ async function main(): Promise<void> {
         imports,
         '',
         'func main() {',
-        `\tclient := workos.NewClient("${apiKey}", workos.WithEndpoint("http://127.0.0.1:${proxyPort}"))`,
+        `\tclient := workos.NewClient("${apiKey}", workos.WithBaseURL("http://127.0.0.1:${proxyPort}"))`,
         '\tctx := context.Background()',
         '',
         ...callBlocks,
@@ -651,19 +715,41 @@ async function main(): Promise<void> {
 
       // Step 1: Build (sync — no proxy needed during compilation)
       let buildError: string | null = null;
+
+      // Run go mod tidy first to resolve dependencies
       try {
-        execSync('go build -o smoke-driver main.go', {
+        execSync('go mod tidy', {
           cwd: tmpDir,
           timeout: 120_000,
-          env: { ...process.env, GOPATH: process.env.GOPATH || resolve(process.env.HOME || '~', 'go') },
+          env: {
+            ...process.env,
+            GOPATH: process.env.GOPATH || resolve(process.env.HOME || '~', 'go'),
+          },
           encoding: 'utf-8',
           stdio: ['pipe', 'pipe', 'pipe'],
         });
       } catch (err: any) {
         const stderr = typeof err.stderr === 'string' ? err.stderr : '';
-        buildError = stderr.trim().split('\n').slice(0, 5).join(' ') || 'go build failed';
+        buildError = `go mod tidy failed: ${stderr.trim().split('\n').slice(0, 3).join(' ')}`;
       }
 
+      if (!buildError)
+        try {
+          execSync('go build -o smoke-driver main.go', {
+            cwd: tmpDir,
+            timeout: 120_000,
+            env: {
+              ...process.env,
+              GOPATH: process.env.GOPATH || resolve(process.env.HOME || '~', 'go'),
+            },
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+        } catch (err: any) {
+          const stderr = typeof err.stderr === 'string' ? err.stderr : '';
+          buildError = stderr.trim().split('\n').slice(0, 5).join(' ') || 'go build failed';
+        }
+
       if (buildError) {
         // Build failure affects entire wave
         const elapsed = Date.now() - waveStart;
@@ -903,7 +989,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-kotlin.ts

@@ -123,7 +123,12 @@ function createProxyServer(
             }
 
             captures.push({
-              request: { method: req.method!, path: url.pathname, queryParams, body },
+              request: {
+                method: req.method!,
+                path: url.pathname,
+                queryParams,
+                body,
+              },
               response: { status: proxyRes.statusCode!, body: resBody },
             });
 
@@ -135,7 +140,12 @@ function createProxyServer(
         proxyReq.on('error', (err) => {
           console.error('Proxy request error:', err.message);
           captures.push({
-            request: { method: req.method!, path: url.pathname, queryParams, body },
+            request: {
+              method: req.method!,
+              path: url.pathname,
+              queryParams,
+              body,
+            },
             response: { status: 502, body: { error: err.message } },
           });
           res.writeHead(502);
@@ -499,7 +509,11 @@ async function main(): Promise<void> {
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -754,7 +768,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-node.ts

@@ -52,7 +52,10 @@ interface CapturedResponse {
 // HTTP Interception
 // ---------------------------------------------------------------------------
 
-let currentCapture: { request: CapturedRequest; response: CapturedResponse } | null = null;
+let currentCapture: {
+  request: CapturedRequest;
+  response: CapturedResponse;
+} | null = null;
 const originalFetch = globalThis.fetch;
 
 function interceptFetch(): void {
@@ -259,7 +262,11 @@ async function main(): Promise<void> {
   const groups = planOperations(spec);
   const ids = new IdRegistry();
   const exchanges: CapturedExchange[] = [];
-  const createdEntities: Array<{ service: string; id: string; deleteFn?: () => Promise<void> }> = [];
+  const createdEntities: Array<{
+    service: string;
+    id: string;
+    deleteFn?: () => Promise<void>;
+  }> = [];
   const delayMs = Number(process.env.SMOKE_DELAY_MS) || 200;
 
   let successCount = 0;
@@ -452,7 +459,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-php.ts

@@ -184,8 +184,8 @@ function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
 // ---------------------------------------------------------------------------
 
 interface MethodResolution {
-  className: string;
-  method: string;
+  service: string; // camelCase accessor on client (e.g., "organizations")
+  method: string; // camelCase method name (e.g., "get")
   tier: ExchangeProvenance['resolutionTier'];
   confidence: number;
 }
@@ -200,14 +200,12 @@ function resolveMethod(
   if (manifest) {
     const entry = manifest.get(httpKey);
     if (entry) {
-      const className = entry.service.charAt(0).toUpperCase() + entry.service.slice(1);
-      return { className, method: entry.sdkMethod, tier: 'manifest', confidence: 1.0 };
+      return { service: entry.service, method: entry.sdkMethod, tier: 'manifest', confidence: 1.0 };
     }
   }
 
   const sdkProp = SERVICE_PROPERTY_MAP[irService] || toCamelCase(irService);
-  const className = sdkProp.charAt(0).toUpperCase() + sdkProp.slice(1);
-  return { className, method: toCamelCase(op.name), tier: 'exact', confidence: 0.8 };
+  return { service: sdkProp, method: toCamelCase(op.name), tier: 'exact', confidence: 0.8 };
 }
 
 // ---------------------------------------------------------------------------
@@ -278,9 +276,14 @@ function buildBatchedPhpScript(
   }
   lines.push('');
 
-  // Configure SDK
-  lines.push(`${namespace}\\Client::setApiKey('${apiKey}');`);
-  lines.push(`${namespace}\\Client::setBaseUrl('http://127.0.0.1:${proxyPort}');`);
+  // Configure SDK — generated SDK uses instance-based client with Guzzle handler
+  lines.push(`use GuzzleHttp\\HandlerStack;`);
+  lines.push(`use GuzzleHttp\\Handler\\CurlHandler;`);
+  lines.push('');
+  lines.push(`$client = new ${namespace}\\${namespace}(`);
+  lines.push(`    apiKey: '${escapePhpString(apiKey)}',`);
+  lines.push(`    baseUrl: 'http://127.0.0.1:${proxyPort}',`);
+  lines.push(');');
   lines.push('');
 
   for (const call of calls) {
@@ -289,7 +292,8 @@ function buildBatchedPhpScript(
     // Marker: start
     lines.push(`fwrite(STDERR, "OAGEN_CALL_START:${index}\\n");`);
 
-    // Build arguments
+    // Build arguments — generated PHP SDK takes positional path params,
+    // then named keyword args for body fields and query params
     const phpArgs: string[] = [];
 
     for (const p of op.pathParams) {
@@ -299,33 +303,31 @@ function buildBatchedPhpScript(
 
     if (op.requestBody) {
       const payload = generatePayload(op, spec);
-      if (payload && Object.keys(payload).length > 0) {
-        phpArgs.push(phpArrayLiteral(payload));
-      } else {
-        phpArgs.push('[]');
+      if (payload && typeof payload === 'object') {
+        // Pass as named arguments (the generated SDK uses promoted properties)
+        for (const [key, value] of Object.entries(payload)) {
+          phpArgs.push(`${toCamelCase(key)}: ${phpArrayLiteral(value)}`);
+        }
       }
     }
 
     if (!op.requestBody && op.queryParams.some((p) => p.required)) {
       const queryOpts = generateQueryParams(op, spec);
-      if (Object.keys(queryOpts).length > 0) {
-        phpArgs.push(phpArrayLiteral(queryOpts));
+      for (const [key, value] of Object.entries(queryOpts)) {
+        phpArgs.push(`${toCamelCase(key)}: ${phpArrayLiteral(value)}`);
       }
     }
 
-    if (op.pagination && phpArgs.length === 0) {
-      phpArgs.push("['limit' => 1]");
-    } else if (op.pagination && !op.requestBody) {
-      const last = phpArgs[phpArgs.length - 1];
-      if (last && last.startsWith('[')) {
-        phpArgs[phpArgs.length - 1] = last.replace(/\]$/, ", 'limit' => 1]");
-      } else {
-        phpArgs.push("['limit' => 1]");
+    if (op.pagination) {
+      if (!phpArgs.some((a) => a.startsWith('limit:'))) {
+        phpArgs.push('limit: 1');
       }
     }
 
+    // The generated SDK uses $client->resource()->method(...) pattern
+    const serviceAccessor = resolution.service;
     lines.push('try {');
-    lines.push(`    $result = ${namespace}\\${resolution.className}::${resolution.method}(${phpArgs.join(', ')});`);
+    lines.push(`    $result = $client->${serviceAccessor}()->${resolution.method}(${phpArgs.join(', ')});`);
     lines.push(`    fwrite(STDERR, "OAGEN_CALL_OK:${index}\\n");`);
     lines.push('} catch (\\Throwable $e) {');
     lines.push(`    fwrite(STDERR, "OAGEN_CALL_ERROR:${index}:" . $e->getMessage() . "\\n");`);
@@ -669,7 +671,7 @@ function buildExchange(
     provenance: {
       resolutionTier: resolution.tier,
       resolutionConfidence: resolution.confidence,
-      sdkMethodName: `${resolution.className}::${resolution.method}`,
+      sdkMethodName: `${resolution.service}->${resolution.method}`,
       captureIndex: 0,
       totalCaptures: 1,
     },

package/smoke/sdk-python.ts

@@ -284,7 +284,10 @@ function buildBatchedPythonScript(
   calls: PlannedCall[],
   spec: any,
 ): string {
-  const srcPath = resolve(sdkPath, 'src');
+  // Use src/ subdirectory if it exists, otherwise use the SDK root directly.
+  // Generated SDKs use a flat layout (workos/ at root), while some hand-written
+  // SDKs nest under src/.
+  const srcPath = existsSync(resolve(sdkPath, 'src')) ? resolve(sdkPath, 'src') : resolve(sdkPath);
   const lines: string[] = [];
 
   // Preamble -- loaded once
@@ -504,7 +507,7 @@ async function main(): Promise<void> {
         const child = spawn(python3Path, [scriptPath], {
           env: {
             ...process.env,
-            PYTHONPATH: resolve(sdkPath, 'src'),
+            PYTHONPATH: existsSync(resolve(sdkPath, 'src')) ? resolve(sdkPath, 'src') : resolve(sdkPath),
             PYTHONDONTWRITEBYTECODE: '1',
           },
           stdio: ['pipe', 'pipe', 'pipe'],

package/smoke/sdk-ruby.ts

@@ -160,7 +160,12 @@ function startProxy(
           }
         }
 
-        const capturedReq: CapturedRequest = { method, path, queryParams, body: reqBody };
+        const capturedReq: CapturedRequest = {
+          method,
+          path,
+          queryParams,
+          body: reqBody,
+        };
 
         // Forward to real API
         const forwardHeaders: Record<string, string> = {
@@ -420,7 +425,11 @@ async function main(): Promise<void> {
 
     // Build planned calls for this wave, resolving methods
     const plannedCalls: PlannedCall[] = [];
-    const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+    const waveSkipped: Array<{
+      op: Operation;
+      irService: string;
+      reason: string;
+    }> = [];
 
     for (const { op, irService, pathParams } of wave.calls) {
       const resolution = resolveMethod(op, irService, manifest);
@@ -678,7 +687,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-rust.ts

@@ -452,7 +452,11 @@ serde_json = "1"
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -534,7 +538,11 @@ serde_json = "1"
         await new Promise<void>((resolvePromise, rejectPromise) => {
           const child = spawn(join(tmpDir, 'target', 'debug', 'smoke-driver'), [], {
             cwd: tmpDir,
-            env: { ...process.env, WORKOS_API_KEY: apiKey, WORKOS_BASE_URL: `http://localhost:${proxy.port}` },
+            env: {
+              ...process.env,
+              WORKOS_API_KEY: apiKey,
+              WORKOS_BASE_URL: `http://localhost:${proxy.port}`,
+            },
             stdio: ['pipe', 'pipe', 'pipe'],
           });
 
@@ -729,7 +737,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,