Add subgraph mode: run unmodified subgraph projects on HyperIndex

[DZakh]

Adds support for running unmodified subgraph projects on HyperIndex by translating subgraph.yaml manifests and GraphQL schemas into envio configs, and providing a graph-ts compatibility shim that runs the AssemblyScript mappings unchanged.

Key Changes

Manifest and Schema Translation

• packages/cli/src/subgraph/manifest.rs: Parses and validates subgraph.yaml, enforcing strict conformance to known features and versions
• packages/cli/src/subgraph/schema.rs: Translates GraphQL schemas from subgraph format to envio format, mapping scalar types and handling directives
• packages/cli/src/subgraph/abi.rs: Resolves event signatures against contract ABIs
• packages/cli/src/subgraph/usage.rs: Analyzes mapping source to determine which event.transaction and event.block fields are actually read, avoiding unnecessary RPC calls
• packages/cli/src/subgraph/errors.rs: Collects and reports all validation errors in a single pass

graph-ts Compatibility Shim

• packages/envio/src/subgraph/graph-ts.ts: Complete implementation of @graphprotocol/graph-ts API surface, including ByteArray, Address, BigInt, BigDecimal, entity classes, and store operations
• packages/envio/src/subgraph/calls.ts: Contract call execution as envio effects, evaluated at the event's block
• packages/envio/src/subgraph/blocks.ts: Block timestamp fetching via HyperSync or RPC fallback
• packages/envio/src/subgraph/hosts.ts: Host operations (IPFS, Arweave, ENS, balance/code checks)
• packages/envio/src/subgraph/division.ts: AssemblyScript-compatible integer division
• packages/envio/src/subgraph/conformance.ts: Type conformance checking against real graph-ts package
• packages/envio/src/subgraph/runtime.ts: Handler registration and execution wrapper
• packages/envio/src/subgraph/scope.ts: Async context tracking for handler mode and schema information
• packages/envio/src/subgraph/errors.ts: Error messages for unsupported features and refused operations

Type Definitions

• packages/envio/src/subgraph/graph-ts-types/: Complete TypeScript declarations for graph-ts covering ethereum, cosmos, near, arweave, and starknet chains
• packages/envio/scripts/generate-graph-ts-types.mjs: Script to generate type declarations from the real graph-ts package

Integration

• packages/cli/src/subgraph/mod.rs: Main subgraph mode orchestration, translating manifest/schema and building envio config
• packages/cli/src/napi.rs: NAPI binding for subgraph translation
• packages/envio/src/Core.res: Added fromSubgraph API for loading subgraph projects
• packages/envio/src/UserContext.res: Added sync context state machine for handling suspended operations during mapping execution
• packages/envio/src/HandlerLoader.res: Support for loading subgraph runtime handlers
• Updated config structures to carry subgraph runtime config through the pipeline

Testing

• packages/envio-tests/test/SubgraphValidation_test.res: Manifest and schema validation
• packages/envio-tests/test/SubgraphRuntimeRefusal_test.res: Runtime refusal of unsupported operations
• packages/envio-tests/test/SubgraphIndexer_test.res: End-to-end subgraph execution
• packages/envio-tests/test/SubgraphContractCall_test.res: Contract call execution
• packages/envio-tests/test/SubgraphBlockHandler_test.res: Block handler timestamp fetching
• packages/envio-tests/test/SubgraphContext_test.res: Data source context
• `

https://claude.ai/code/session_016tA2D3BrcAJS4nME7noXh4

Summary by CodeRabbit

• New Features

  • Added support for running compatible, unmodified Graph Protocol subgraphs with HyperIndex.
  • Added manifest and schema translation, graph-ts compatibility, contract calls, dynamic data sources, block handlers, and RPC-backed host features.
  • Added synchronous entity access with suspension, replay, caching, and context safety.
  • Added inline subgraph configuration, interface handling, legacy ABI compatibility, and actionable validation errors.

• Documentation

  • Added comprehensive subgraph compatibility and setup documentation.

• Tests

  • Expanded coverage for indexing, mappings, templates, schemas, contract calls, validation, and runtime behavior.

[coderabbitai]

Actionable comments posted: 3

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/envio/src/subgraph/graph-ts.ts`:
- Around line 1804-1806: Replace the split-based implementation in parseCSV with
a state-based CSV parser that preserves whitespace in unquoted fields, handles
commas inside quoted fields, and omits the trailing empty field (for example,
a,"b,c", yields ["a", "b,c"]). Add conformance tests covering quoted commas,
preserved unquoted whitespace, and trailing delimiters.
- Around line 1808-1811: Update addQm to always produce a fixed 34-byte result
by allocating 34 bytes, writing the 0x1220 prefix, copying no more than 32 bytes
from a, and zero-filling any remaining bytes; alternatively, validate and reject
inputs whose length is not exactly 32 bytes.
- Around line 1030-1065: Update the EthereumValue factory methods fromTuple,
fromTupleArray, fromFixedBytes, fromAddressArray, and fromFixedBytesArray to
construct and return EthereumValue instances so their Ethereum-specific
converters such as toTuple work at runtime. Keep the existing conversion
behavior and ensure runtime conformance coverage verifies these factories return
usable EthereumValue objects.

🪄 Autofix

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 1e0be1df-34c2-4675-97e0-f290739249db

📥 Commits

Reviewing files that changed from the base of the PR and between 7bcafc7 and f2b3ec4.

📒 Files selected for processing (2)

• packages/envio-tests/test/SubgraphContractCall_test.res
• packages/envio/src/subgraph/graph-ts.ts

🚧 Files skipped from review as they are similar to previous changes (1)

• packages/envio-tests/test/SubgraphContractCall_test.res

[coderabbitai]

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

sed -n '449,692p' packages/envio/src/subgraph/graph-ts.ts
sed -n '1024,1076p' packages/envio/src/subgraph/graph-ts.ts
curl -fsSL 'https://raw.githubusercontent.com/graphprotocol/graph-tooling/%40graphprotocol/graph-ts%400.38.1/packages/ts/chain/ethereum.ts' |
  sed -n '53,120p;271,325p'

Repository: enviodev/hyperindex

Length of output: 13389

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- relevant definitions and usages ---'
rg -n -C 3 'EthereumValue\.(fromTuple|fromFixedSizedArray|fromTupleArray|fromAddressArray|fromFixedBytesArray|fromSignedBigIntArray|fromUnsignedBigIntArray)|toTuple(Array)?\(' packages tests 2>/dev/null || true

printf '%s\n' '--- package and test files ---'
git ls-files | rg '(^|/)(package\.json|tsconfig[^/]*\.json|.*(test|spec).*\.(ts|tsx|js))$' | head -200

printf '%s\n' '--- exact source range ---'
cat -n packages/envio/src/subgraph/graph-ts.ts | sed -n '1018,1075p'

printf '%s\n' '--- inheritance/type declarations ---'
rg -n -C 2 'class (Value|EthereumValue)|fromTuple|toTuple' packages/envio/src packages/envio/test packages 2>/dev/null | head -300

Repository: enviodev/hyperindex

Length of output: 19309

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

node - <<'JS'
const fs = require('fs');
const source = fs.readFileSync('packages/envio/src/subgraph/graph-ts.ts', 'utf8');
const start = source.indexOf('export class Value {');
const end = source.indexOf('\n}', source.indexOf('export class EthereumValue extends Value {'));
console.log(source.slice(start, end + 2));
JS

Repository: enviodev/hyperindex

Length of output: 20857

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- ethereum.Value imports and factory/converter call sites ---'
rg -n -C 3 'ethereum\.Value|Value\.fromTuple|fromTupleArray|fromFixedSizedArray|toTupleArray|toFixedBytes' \
  packages scenarios --glob '*.{ts,tsx,js,jsx,d.ts}' 2>/dev/null | head -500

printf '%s\n' '--- graph-ts exports and module mappings ---'
rg -n -C 3 'graph-ts|ethereum|EthereumValue|export .*Value|paths|alias' \
  packages/envio/package.json packages/envio/tsconfig*.json package.json packages scenarios \
  --glob '*.{json,ts,tsx,js,d.ts}' 2>/dev/null | head -500

Repository: enviodev/hyperindex

Length of output: 50376

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

python3 - <<'PY'
from pathlib import Path

source = Path("packages/envio/src/subgraph/graph-ts.ts").read_text()
start = source.index("export class Value {")
end = source.index("\n}", source.index("export class EthereumValue extends Value {")) + 2
block = source[start:end]

checks = {
    "EthereumValue extends Value": "export class EthereumValue extends Value" in block,
    "fromTuple returns Value": "static fromTuple(values: Value[]): Value" in block,
    "fromTuple delegates to Value.fromArray": "return Value.fromArray(values);" in block,
    "toTuple exists only in EthereumValue block": "toTuple(): Value[]" in block,
}
for name, result in checks.items():
    print(f"{name}: {result}")

# Model only the relevant JavaScript class semantics from the source.
class Value:
    def __init__(self, data):
        self.data = data
    `@staticmethod`
    def fromArray(values):
        return Value(values)
    def toArray(self):
        return self.data

class EthereumValue(Value):
    `@staticmethod`
    def fromTuple(values):
        return Value.fromArray(values)
    def toTuple(self):
        return self.toArray()

result = EthereumValue.fromTuple([])
print(f"factory result constructor: {type(result).__name__}")
print(f"factory result has toTuple: {callable(getattr(result, 'toTuple', None))}")
PY

Repository: enviodev/hyperindex

Length of output: 383

---

Return EthereumValue instances from Ethereum-only factories.

fromTuple, fromTupleArray, fromFixedBytes, fromAddressArray, and fromFixedBytesArray construct base Value instances. Calls such as ethereum.Value.fromTuple(values).toTuple() therefore fail at runtime. Return EthereumValue instances or move the matching converters to Value. Add runtime conformance cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/envio/src/subgraph/graph-ts.ts` around lines 1030 - 1065, Update the
EthereumValue factory methods fromTuple, fromTupleArray, fromFixedBytes,
fromAddressArray, and fromFixedBytesArray to construct and return EthereumValue
instances so their Ethereum-specific converters such as toTuple work at runtime.
Keep the existing conversion behavior and ensure runtime conformance coverage
verifies these factories return usable EthereumValue objects.

[coderabbitai]

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

sed -n '1800,1812p' packages/envio/src/subgraph/graph-ts.ts
curl -fsSL 'https://raw.githubusercontent.com/graphprotocol/graph-tooling/%40graphprotocol/graph-ts%400.38.1/packages/ts/helper-functions.ts' |
  sed -n '18,74p'

Repository: enviodev/hyperindex

Length of output: 2178

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- parseCSV definitions and usages ---'
rg -n --glob '!node_modules' 'parseCSV|CSVState' packages test tests .github 2>/dev/null | head -200 || true

printf '%s\n' '--- nearby source ---'
sed -n '1798,1812p' packages/envio/src/subgraph/graph-ts.ts

printf '%s\n' '--- behavioral comparison ---'
python3 - <<'PY'
def current(csv):
    return [field.strip() for field in csv.split(",")]

def target(csv):
    values = []
    value_start = 0
    state = "BETWEEN"
    for i, char in enumerate(csv):
        if state == "BETWEEN":
            if char != ",":
                if char == '"':
                    state = "QUOTED_VALUE"
                    value_start = i + 1
                else:
                    state = "UNQUOTED_VALUE"
                    value_start = i
        elif state == "UNQUOTED_VALUE":
            if char == ",":
                values.append(csv[value_start:i])
                state = "BETWEEN"
        elif state == "QUOTED_VALUE" and char == '"':
            values.append(csv[value_start:i])
            state = "BETWEEN"
    return values

for sample in ['a,"b,c",', '"a,b"', ' a , b ', ',,', 'a,b', 'a,']:
    print(repr(sample), 'current=', current(sample), 'target=', target(sample))
PY

Repository: enviodev/hyperindex

Length of output: 1201

---

Implement the graph-ts CSV parser behavior.

Replace the split(",").map(...) implementation with the state-based parser. It must preserve unquoted whitespace and parse quoted commas, so a,"b,c", returns ["a", "b,c"]. Add quoted-field conformance tests.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/envio/src/subgraph/graph-ts.ts` around lines 1804 - 1806, Replace
the split-based implementation in parseCSV with a state-based CSV parser that
preserves whitespace in unquoted fields, handles commas inside quoted fields,
and omits the trailing empty field (for example, a,"b,c", yields ["a", "b,c"]).
Add conformance tests covering quoted commas, preserved unquoted whitespace, and
trailing delimiters.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -eu

printf '%s\n' '--- target implementation ---'
rg -n -C 12 'function addQm|addQm' packages/envio/src/subgraph/graph-ts.ts

printf '%s\n' '--- related ByteArray definitions and helpers ---'
rg -n -C 8 'class ByteArray|namespace ByteArray|fromHexString|concat' packages/envio/src/subgraph/graph-ts.ts packages/envio/src/subgraph

printf '%s\n' '--- repository references ---'
rg -n -C 5 'addQm|multihash|0x1220' .

printf '%s\n' '--- declared source metadata ---'
git status --short
git diff --stat

Repository: enviodev/hyperindex

Length of output: 38702

---

🏁 Script executed:

#!/bin/bash
set -eu

url='https://raw.githubusercontent.com/graphprotocol/graph-tooling/%40graphprotocol/graph-ts%400.38.1/packages/ts/helper-functions.ts'
curl --fail --silent --show-error "$url" | sed -n '/function addQm/,/^[[:space:]]*}/p'

printf '%s\n' '--- all addQm references in the fetched helper ---'
curl --fail --silent --show-error "$url" | rg -n -C 10 'addQm|1220|bytes32|ByteArray'

printf '%s\n' '--- local type declarations ---'
sed -n '14,24p' packages/envio/src/subgraph/graph-ts-types/helper-functions.d.ts

Repository: enviodev/hyperindex

Length of output: 2549

---

🏁 Script executed:

node - <<'JS'
function referenceAddQm(input) {
  const out = new Uint8Array(34);
  out[0] = 0x12;
  out[1] = 0x20;
  for (let i = 0; i < 32; i++) out[i + 2] = input[i];
  return out;
}

function currentAddQm(input) {
  const out = new Uint8Array(2 + input.length);
  out.set([0x12, 0x20], 0);
  out.set(input, 2);
  return out;
}

for (const input of [
  new Uint8Array(0),
  new Uint8Array([1, 2]),
  new Uint8Array(32).fill(3),
  new Uint8Array(33).fill(4),
]) {
  const expected = referenceAddQm(input);
  const actual = currentAddQm(input);
  console.log(JSON.stringify({
    inputLength: input.length,
    expectedLength: expected.length,
    actualLength: actual.length,
    expectedTail: [...expected.slice(2, 6)],
    actualTail: [...actual.slice(2, 6)],
  }));
}
JS

Repository: enviodev/hyperindex

Length of output: 562

---

Preserve the fixed 34-byte output in addQm. Allocate 34 bytes, write 0x1220, copy at most 32 input bytes, and zero-fill missing bytes. Alternatively, reject inputs that are not 32 bytes.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/envio/src/subgraph/graph-ts.ts` around lines 1808 - 1811, Update
addQm to always produce a fixed 34-byte result by allocating 34 bytes, writing
the 0x1220 prefix, copying no more than 32 bytes from a, and zero-filling any
remaining bytes; alternatively, validate and reject inputs whose length is not
exactly 32 bytes.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: f2b3ec4839

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Preserve indexed metadata for dynamically typed parameters

When an event has an indexed dynamic parameter such as indexed string, the decoder supplies its topic hash and graph-ts codegen exposes that parameter as Bytes, but this metadata records only the Solidity type and discards input.indexed. The runtime consequently takes the ordinary string conversion path and returns a JavaScript string, so mappings calling normal Bytes methods such as toHexString() fail; indexed arrays and tuples likewise cannot be distinguished from decoded values. Carry the indexed flag into the runtime parameter metadata and convert indexed dynamic values to Bytes.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Recursively convert tuple event parameters

For an event parameter such as (address,uint256) order, Envio decodes the tuple as an object, but this fallback leaves every component in its raw JavaScript form. A mapping expecting graph-ts values therefore receives a string for order.maker and a native bigint for order.amount, so calls such as order.maker.toHexString() or order.amount.plus(...) fail; positional access also stringifies the tuple as [object Object]. Parse tuple component types and recursively wrap their values instead of returning the object unchanged.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Route host RPC reads to the active chain

In a multichain subgraph whose mappings call ethereum.getBalance or ethereum.hasCode, these effects are partitioned by chain but their handlers always reuse this single client over the global URL list. An invocation on a second chain can therefore query the first chain's endpoint at the same block number and silently return unrelated balance or code data. Select or construct the client from the effect callback's chain context, as the handler already receives that context.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Read blocks from HyperSync's columnar response object

Whenever a block handler reads block.timestamp, the raw HyperSync endpoint returns data as one object containing a blocks array, matching the repository's canonical QueryResponseData shape in packages/cli/src/evm_hypersync_source/mod.rs. Iterating body.data here therefore throws because that object is not iterable; without an RPC fallback every such handler fails, and with RPC configured every timestamp unnecessarily falls back to an individual RPC request. Iterate body.data.blocks directly.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Match graph-node's BigDecimal precision

When a mapping divides BigDecimal values, this uses bignumber.js without any configuration, whose default division precision is only 20 decimal places. Graph-node's BigDecimal uses decimal128-style 34-digit precision, so common calculations such as BigDecimal.fromString("1").div(BigDecimal.fromString("3")) produce a different stored value and can propagate divergent token prices or aggregates. Configure and round arithmetic to graph-node's precision and exponent rules rather than relying on the library defaults.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Export the declared EthereumUtils namespace

A valid mapping importing EthereumUtils and calling getCreate2Address type-checks against this accepted graph-ts declaration, but graph-ts.ts contains no EthereumUtils export anywhere. Because all graph-ts imports are redirected to that shim, Node fails during ESM linking with a missing-export error before handlers are registered. Implement the helper or export a named runtime refusal so supported projects do not fail at module linkage.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Include unclesHash in the fallback block selection

When the usage scan gives up and requests the full block shape—for example because a mapping aliases const block = event.block before reading block.unclesHash—this default omits BlockField::Sha3Uncles even though the runtime exposes unclesHash and the explicit-property scan selects that field. The raw block consequently lacks sha3Uncles, so the mapping receives null instead of the block's hash. Add Sha3Uncles to the default selection used for ambiguous block access.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: f3f5732eb8

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Preserve interface-derived fields in the public schema

When a valid subgraph declares a polymorphic relation such as events: [DomainEvent!]! @derivedFrom(field: "domain"), this branch neither keeps the field nor expands it across the interface's implementors, so it disappears from the parsed entity configuration. Downstream Hasura relationship generation only sees parsed DerivedFromField entries, meaning existing queries for events fail because the field is absent; implement the polymorphic relationship or reject the schema instead of silently changing its query contract.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Return actual EthereumValue instances from ABI decoding

When a contract call or ethereum.decode returns an aggregate ABI value, this cast leaves the object as the base store Value, whose prototype lacks Ethereum-specific accessors such as toTuple(), toAddressArray(), and toFixedBytesArray(). Generated bindings for tuple or array outputs therefore fail at runtime even though scalar outputs work; recursively construct EthereumValue instances with the appropriate Ethereum value kind instead of casting base values.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Parse strings in the json numeric conversion helpers

The graph-ts signatures for json.toI64, toU64, toF64, and toBigInt accept decimal strings, but these implementations treat the argument as a JSONValue and invoke instance methods on it. A valid call such as json.toI64("123") consequently throws because a JavaScript string has no toI64 method; parse the supplied decimal string directly, including unsigned validation for toU64.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Preserve quoted fields when parsing CSV

When a mapping parses CSV containing quoted commas or escaped quotes, such as a,"b,c", this plain split produces three fields and retains quote characters instead of returning the two CSV fields graph-ts provides. Subgraphs ingesting CSV metadata from IPFS can therefore persist shifted or corrupted values; implement graph-ts-compatible quote-aware CSV parsing rather than splitting on every comma.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Preserve entity reads during template registration

When a handler makes dataSource.create() conditional on an entity loaded from an earlier block—or creates a template and then relies on an existing entity—this register pass always reports the entity as absent. It can therefore register addresses the real graph-node handler would skip, omit addresses created only when an entity exists, or throw after an earlier registration; provide the register pass with the handler's canonical store view or reject entity-dependent template creation rather than substituting null.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Implement the accepted ethereum.encode API

Any mapping that validly calls ethereum.encode, for example to ABI-encode a tuple before hashing or persisting it, reaches this unconditional refusal and aborts its handler. The compatibility surface exposes this graph-ts API and the design documentation classifies encode/decode as synchronous supported operations, so either encode the value according to its Ethereum value kind or reject such projects during translation rather than failing only when the event executes.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.