Build Data Connectors with AI Agents

Build a Monospace data connector extension for <EXTERNAL DATA SOURCE, e.g. "the Acme REST API at https://api.acme.example">.
Expose <COLLECTIONS, e.g. "customers and invoices, with invoices -> customers"> as collections.
Writes: <"none, read-only" | "create and update on customers, behind an enableWrites option">.

Read these pages first, and trust them over anything you remember about Monospace. Re-read the
relevant page before each step:
- https://docs.monospace.io/raw/en/developer/extensions/data-connectors/runtime.md
- https://docs.monospace.io/raw/en/developer/extensions/data-connectors.md
- https://docs.monospace.io/raw/en/reference/extensions/data-connectors/limitations.md
- https://docs.monospace.io/raw/en/guides/data-connectors/stripe.md
- https://docs.monospace.io/raw/en/developer/extensions/data-connectors/data-source-mapping.md
- https://docs.monospace.io/raw/en/developer/extensions/data-connectors/errors.md
- https://docs.monospace.io/raw/en/developer/extensions/data-connectors/testing.md
- https://docs.monospace.io/raw/en/reference/extensions/data-connectors/api.md
- https://docs.monospace.io/raw/en/reference/extensions/data-connectors/operations.md
- https://docs.monospace.io/raw/en/reference/extensions/data-connectors/permissions.md
- https://docs.monospace.io/raw/en/reference/extensions/data-connectors/errors.md
- https://docs.monospace.io/raw/en/reference/extensions/cli.md
- https://docs.monospace.io/raw/en/reference/extensions/extension-kit/data-connector.md
- https://docs.monospace.io/raw/en/reference/extensions/extension-kit/protocol.md
- https://docs.monospace.io/raw/en/reference/extensions/extension-kit/experimental.md
The index of all pages is https://docs.monospace.io/llms.txt.

Rules:
- Run the Fit Check before building. If a limitation blocks what I asked for, stop and ask me.
- Probe the live external data source before declaring anything. Every filter, sort, count and
  paging option you declare must name a request to it that you ran. Don't trust the vendor's
  docs alone.
- Declare only what requests to the external data source can answer, and re-check every returned
  item against the filter where its match is broader. Refuse the rest before any request to the
  external data source when the request's shape decides it: QueryRejected for a valid request it
  can't serve (including shapes Monospace composes: not, or), a plain Error for anything the
  collection doesn't declare, anywhere in the filter. Monospace doesn't check the filters it
  sends, so a permission rule's condition or a stale stored declaration can bring an undeclared
  comparison: refuse it, never drop it. Exception: serve the relation and read-back
  lookups Monospace sends undeclared on a key no declaration can carry (in on a one-field
  boolean, bytes, json, geometry or unsupported key; equals on each field of a key with an
  unsupported field). Never scan, and never truncate a page.
- Bound every read. Monospace sends some reads without a limit (limit=-1, relation batches), so
  refuse with QueryRejected once a read would fetch more than a budget you set.
- Declare collections with the kit's builders: fields.all(), fieldsOf(...).pick(...),
  paging.limit() and paging.offset(). A field is writable exactly when a data list names it.
- Declare a query capability (insertReturning, updateReturning, deleteReturning, unique values
  in the entry's engine.capabilities.query, applying to every collection of the entry) only for
  writes whose answers carry the written items with every selected field. Updates always need
  readMany to read their items back by stable ID. A collection with a write whose capability is
  missing needs a primary or unique index. Without insertReturning, create.output lists the
  stable-ID fields, create answers them, and readMany must read the created items by stable
  ID. Without updateReturning, updates go through updateMany by stable ID, and no update's
  data names a stable-ID field. Without deleteReturning, deletes go through deleteMany by
  stable ID, after readMany reads the items by stable ID.
- A keyed operation (readOne, updateOne, deleteOne) answers { record: <item> }, or
  { record: null } when its key or guard misses, and then writes nothing. Never throw for a
  miss, and never answer records. Type it with QueryResultFor<'readOne'> (or its operation).
  int64 values and keys arrive as strings.
- Fixed hosts go in extension.config.json as net: permissions. Use preflight only for hosts
  derived from configuration. Validate configuration in setup and throw InvalidConfiguration;
  preflight may also throw InvalidConfiguration when the configuration it reads is invalid.
- No Node APIs, no environment variables, no filesystem. Credentials come from the data source
  configuration.
- Use test-mode or sandbox credentials only. Default writes off for credentials that can reach
  production data.
- Keep secrets and personal data out of error messages: the message is the only text of an
  error that can reach the caller. Never copy a response body or a query string into one.
- Give every request to the external data source a timeout (AbortSignal.timeout), and read the
  body inside the same try. Monospace sets no deadline on query, introspect or testConnection.
- Map failures in one client: no answer, a timeout or a 5xx is ConnectionFailed, a 429 is
  RateLimited, a rejected credential (401/403) is AccessDenied. A missing required value, a
  duplicate, or a missing reference is NullConstraintViolation, UniqueConstraintViolation or
  ForeignKeyConstraintViolation; any other value the external data source refuses is
  QueryRejected. Wrap a fetch rejection with { cause: error }, so a permission denial
  stays one. Throw a plain Error only for a changed API (a body that isn't JSON, a wrong shape)
  and for a request the declaration never offered. Compare error codes with ErrorCode, never
  with hard-coded numbers.
- Check every value before you return it: every selected field present, each value of its
  declared type, null only on nullable fields, and integers within their type's range.
- Writes aren't atomic. Read a keyed write's guard before writing, report how far a bulk write
  got when it fails, and never retry a write that isn't safe to repeat.
- If the external data source takes a credential, implement testConnection and test it with a
  malformed, a wrong, and a valid credential. If you don't implement it, say so in your report.

Work in this order, and stop to report at each checkpoint:
1. Fit Check, probes, and a capability table (what you'll declare, and the request to the external
   data source that answers each row). CHECKPOINT: show me the table and the limitations that apply.
2. Project, configuration parser, client with error mapping, and the schema. Until reads exist,
   make query throw QueryRejected. Typecheck, build, install, and request a data source
   in a throwaway workspace. CHECKPOINT: when Monospace answers 7001, show me the required network
   permissions before you resend them. Then create the data source before writing query code.
3. Reads, then keyed operations, then writes, each with network-free unit tests (a fake fetch for
   timeouts, 429s and bodies that aren't JSON) and artifact smoke checks: wire assertions for
   every translated filter, no-request assertions for every shape-based refusal.
4. The Engine smoke, one deliberate break per check, and a second full run. Send every Engine read
   with Cache-Control: no-cache, so a cached result can't hide a connector failure.
5. A README with the configuration, network access, the capability table, refusals, and gaps.

When you finish, list every test rung you ran, every rung you skipped, and everything you could
not verify yourself.