Your agent writes a Yellowstone client that loses data. Here is the context that fixes it.

Build a production Yellowstone gRPC client in TypeScript (Node 20+) that streams Pump.fun transactions from Subglow.

Requirements:
- Use the standard `@triton-one/yellowstone-grpc` client. Subglow is a standard
  Yellowstone endpoint, so do not look for a vendor SDK.
- Endpoint `grpc.subglow.io:443` over TLS, auth via `x-api-key` metadata read
  from `process.env.SUBGLOW_API_KEY`. Fail fast with a clear message if unset.
- Subscribe to transactions with `accountInclude: ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"]`,
  `vote: false`, `failed: false`, `commitment: processed`.
- The read loop must only receive and enqueue. Put handling in a bounded queue
  (max 10k) drained by a pool of 8 async workers. Count and log drops when the
  queue is full rather than growing it.
- Implement a 5 second read-idle watchdog that destroys the stream if no message
  arrives. A Yellowstone stream can stay open and stop delivering, and nothing
  else detects that failure mode.
- Reconnect with jittered exponential backoff capped at 5 seconds.
- Track the last successfully processed slot and pass it as `fromSlot` on
  resubscribe. Deduplicate by signature using a bounded structure (last 10k
  signatures) because resuming re-delivers the boundary slot.
- Expose a metrics object: events received, events processed, drops, reconnects,
  last slot, current queue depth. Log it once a second.
- TypeScript strict mode, no `any`, graceful SIGINT shutdown.

Do not add Borsh decoding: Subglow delivers pre-parsed JSON for Pump.fun.

Build a production Yellowstone gRPC client in Rust that streams Pump.fun transactions from Subglow.

Requirements:
- Use `yellowstone-grpc-client` and `yellowstone-grpc-proto` with tokio and
  tonic. Subglow is a standard Yellowstone endpoint; there is no vendor SDK.
- Connect to `https://grpc.subglow.io:443` with the `x-api-key` header from the
  `SUBGLOW_API_KEY` environment variable.
- SubscribeRequest: transactions filter with
  `account_include = ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"]`,
  `vote: Some(false)`, `failed: Some(false)`, commitment Processed.
- Separate the receive loop from processing with a bounded `tokio::sync::mpsc`
  channel (capacity 10_000) and a fixed set of worker tasks. On a full channel,
  increment a dropped counter — do not await, and do not use an unbounded channel.
- Wrap the receive loop in `tokio::time::timeout` with a 5 second read-idle
  budget so a silently stalled stream is detected and torn down.
- Reconnect loop with jittered exponential backoff capped at 5 seconds.
- Track the last processed slot in an `AtomicU64` and set `from_slot` on
  resubscribe. Deduplicate by signature with a bounded structure, since resuming
  re-delivers the boundary slot.
- Structured logging via `tracing`, and a metrics snapshot every second:
  received, processed, dropped, reconnects, last slot, channel depth.
- No `unwrap()` outside of startup validation. Handle SIGINT cleanly.

Subglow ships pre-parsed JSON for Pump.fun, so no Borsh decoding is needed for
these events.

Build a production Yellowstone gRPC client in Python 3.11+ that streams Pump.fun transactions from Subglow.

Requirements:
- Use `grpcio` with the Yellowstone protobuf definitions and `grpc.aio` for
  async streaming. Subglow is a standard Yellowstone endpoint, so no vendor SDK.
- Secure channel to `grpc.subglow.io:443`, `x-api-key` metadata from
  `os.environ["SUBGLOW_API_KEY"]`.
- SubscribeRequest: transactions filter with
  `account_include=["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"]`,
  `vote=False`, `failed=False`, commitment PROCESSED.
- The receive coroutine must only put messages on an `asyncio.Queue(maxsize=10000)`.
  Run a fixed number of consumer tasks. On `QueueFull`, increment a drop counter
  instead of awaiting — blocking the receiver is what turns a slow consumer into
  a stalled stream.
- Wrap each stream read in `asyncio.wait_for` with a 5 second timeout so a
  silently stalled connection is detected rather than waited on forever.
- Reconnect with jittered exponential backoff capped at 5 seconds.
- Track the last processed slot and pass it as `from_slot` when resubscribing.
  Deduplicate by signature using a bounded `collections.deque` plus a set.
- Log a metrics line every second: received, processed, dropped, reconnects,
  last slot, queue depth. Handle SIGINT for clean shutdown.
- Type hints throughout; no bare `except`.

Note on performance: base58-encoding pubkeys dominates client-side decode cost in
Python. Keep pubkeys as bytes internally and only encode them when rendering.

Build a production Yellowstone gRPC client in Go (1.22+) that streams Pump.fun transactions from Subglow.

Requirements:
- Use `google.golang.org/grpc` with the Yellowstone protobuf definitions.
  Subglow is a standard Yellowstone endpoint, so there is no vendor SDK.
- Dial `grpc.subglow.io:443` with TLS credentials and per-RPC `x-api-key`
  metadata from `os.Getenv("SUBGLOW_API_KEY")`.
- SubscribeRequest: transactions filter with
  `AccountInclude: []string{"6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}`,
  `Vote: proto.Bool(false)`, `Failed: proto.Bool(false)`, commitment Processed.
- Receive loop sends to a buffered channel (capacity 10000) consumed by a fixed
  worker pool of 8 goroutines. Do NOT spawn a goroutine per event. On a full
  channel, use a non-blocking send with a default branch that increments a
  dropped counter.
- Detect silent stalls: a ticker that compares time since the last received
  message against a 5 second budget and cancels the stream context when exceeded.
- Reconnect with jittered exponential backoff capped at 5 seconds.
- Track the last processed slot with `atomic.Uint64` and set `FromSlot` on
  resubscribe. Deduplicate by signature with a bounded map plus ring buffer.
- Expose counters (received, processed, dropped, reconnects, last slot, channel
  depth) and log them every second. Handle SIGINT with context cancellation.
- No panics on stream errors; return them up to the reconnect loop.

Subglow delivers pre-parsed JSON for Pump.fun, so no Borsh decoding is required.