$ npm install @mimicai/adapter-sdk

OpenAPI spec (.json)
    ↓
Codegen script (pnpm generate)
    ↓
  src/generated/
    ├── routes.ts           ← HTTP route definitions (method, path, operation type)
    ├── resource-specs.ts   ← Field metadata for data generation
    ├── schemas.ts          ← Default factory functions (one per resource)
    └── meta.ts             ← Spec version + timestamp
    ↓
Adapter class (extends OpenApiMockAdapter)
    ├── CRUD scaffolding    ← Automatic from generated routes
    ├── Override handlers   ← State machines, computed endpoints
    ├── MCP tools           ← AI agent access
    └── Error helpers       ← Platform-specific error format

packages/adapters/adapter-{name}/
├── adapter.json                 ← Identity: id, basePath, versions, spec URL
├── {name}-spec.json             ← OpenAPI spec (gitignored, download from source)
├── scripts/
│   └── {name}-codegen.ts        ← Reads spec → generates TypeScript files
├── src/
│   ├── index.ts                 ← Public exports + AdapterManifest
│   ├── adapter-meta.ts          ← Loads adapter.json at runtime
│   ├── config.ts                ← Zod config schema
│   ├── {name}-adapter.ts        ← Adapter class
│   ├── {name}-errors.ts         ← Platform-specific error builders
│   ├── mcp.ts                   ← MCP tool registration
│   ├── bin/mcp.ts               ← Standalone MCP binary
│   ├── generated/               ← Auto-generated (never hand-edit)
│   │   ├── routes.ts
│   │   ├── resource-specs.ts
│   │   ├── schemas.ts
│   │   └── meta.ts
│   ├── overrides/               ← Custom route handlers
│   └── __tests__/
└── package.json                 ← Scripts: build, generate, test

{
  "id": "my-platform",
  "name": "My Platform API",
  "description": "My Platform mock adapter",
  "type": "api-mock",
  "basePath": "/my-platform",
  "versions": ["2025-01-01", "2026-01-01"],
  "specUrl": "https://example.com/openapi/spec.json",
  "specFile": "my-platform-spec.json",
  "mcp": {
    "serverName": "mimic-my-platform",
    "serverVersion": "0.5.0",
    "description": "Mimic MCP server for My Platform"
  }
}

$ pnpm --filter @mimicai/adapter-my-platform generate

export function defaultCustomer(overrides = {}) {
  return {
    id: generateId("cus_", 14),
    object: "customer",
    created: unixNow(),
    email: null,
    metadata: {},
    // ... every field from the schema
    ...overrides,
  };
}

import { OpenApiMockAdapter } from '@mimicai/adapter-sdk';
import meta from './adapter-meta.js';
import { myPlatformResourceSpecs } from './generated/resource-specs.js';
import { SCHEMA_DEFAULTS } from './generated/schemas.js';
import { GENERATED_ROUTES } from './generated/routes.js';
​
function ns(resource: string): string {
  return `myplatform:${resource}`;
}
​
export class MyPlatformAdapter extends OpenApiMockAdapter {
  readonly id = meta.id;
  readonly name = meta.name;
  readonly basePath = meta.basePath;
  readonly versions = meta.versions;
  readonly resourceSpecs = myPlatformResourceSpecs;
​
  protected readonly generatedRoutes = GENERATED_ROUTES;
  protected readonly defaultFactories = SCHEMA_DEFAULTS;
​
  async registerRoutes(server, data, store) {
    this.mountOverrides(store);  // Override handlers FIRST
    await this.registerGeneratedRoutes(server, data, store, ns);  // CRUD scaffolding
  }
​
  getEndpoints() { return this.endpointsFromRoutes(); }
​
  resolvePersona(req) {
    // Match platform auth pattern (API key, Bearer token, etc.)
    const auth = req.headers.authorization;
    if (!auth) return null;
    const match = auth.match(/^Bearer\s+test_([a-z0-9-]+)_/);
    return match ? match[1] : null;
  }
​
  private mountOverrides(store) {
    // Register state-machine handlers BEFORE registerGeneratedRoutes()
    this.registerOverride('POST', '/my-platform/v1/orders/:order/confirm',
      orderOverrides.buildConfirmHandler(store));
  }
}

export function buildConfirmHandler(store: StateStore): OverrideHandler {
  return async (req, reply) => {
    const { order } = req.params as { order: string };
    const existing = store.get('myplatform:orders', order);
    if (!existing) return reply.code(404).send(notFoundError(order));
    if (existing.status !== 'draft')
      return reply.code(400).send(stateError(`Cannot confirm: ${existing.status}`));
​
    const updated = { ...existing, status: 'confirmed', confirmed_at: unixNow() };
    store.set('myplatform:orders', order, updated);
    return reply.code(200).send(updated);
  };
}

# Download the OpenAPI spec (gitignored)
$ curl -o packages/adapters/adapter-{name}/{name}-spec.json {SPEC_URL}
​
# Generate routes, schemas, resource-specs from the spec
$ pnpm --filter @mimicai/adapter-{name} generate
​
# Build
$ pnpm --filter @mimicai/adapter-{name} build
​
# Test
$ pnpm --filter @mimicai/adapter-{name} test