feat(sdk): codex read/maintenance RPC wrappers (status, usage, mcp, skills, rename) (#146)

## Summary
- Adds six public wrappers to `CodexAxonConnection` over
already-vendored app-server protocol types, following the existing
`readConfig`/`compactThread` pattern:
  - `getAccountRateLimits()` → `account/rateLimits/read`
  - `getAccountTokenUsage()` → `account/usage/read`
- `readThread(params?)` → `thread/read` (defaults to the active thread)
  - `setThreadName(name)` → `thread/name/set`
  - `listMcpServerStatus(params?)` → `mcpServerStatus/list`
  - `listSkills(params?)` → `skills/list`
- Re-exports the corresponding v2 param/response types from
`protocol/index.ts` so they're available through the `codex` module
entry. No new codegen — all types were already vendored from
`@openai/codex` 0.144.1.
- Thread-scoped wrappers (`readThread`, `setThreadName`) throw
`ConnectionStateError("not_connected")` before a thread exists, matching
`compactThread`.
- Motivation: these back client-side slash commands (`/status`,
`/usage`, `/mcp`, `/skills`, `/rename`) in downstream apps, which
previously had no public path to these RPCs since `request()` is
private.

## Test plan
- New test asserts each wrapper emits the correct JSON-RPC method and
params on the wire (threadId injection, param passthrough).
- New test asserts thread-scoped wrappers reject with `not_connected`
before a thread exists.
- Full suite: 579 tests pass; `npm run typecheck` and `biome check`
clean.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: ross-rl

sdk/src/codex/connection.test.ts

@@ -177,6 +177,49 @@ describe("CodexAxonConnection", () => {
     expect(conn.threadId).toBeUndefined();
   });
 
+  it("sends the wire method and params for each read/maintenance wrapper", async () => {
+    const { ctrl, mock, conn } = setup();
+    mock.axon.publish.mockImplementation(async (event) => {
+      const frame = JSON.parse(event.payload);
+      if (frame.id == null) return;
+      if (frame.method === "thread/start") {
+        ctrl.push(
+          makeAgentEvent("response", { id: frame.id, result: { thread: { id: "thr-1" } } }),
+        );
+      } else {
+        ctrl.push(makeAgentEvent("response", { id: frame.id, result: {} }));
+      }
+    });
+    await conn.connect();
+    await conn.startThread();
+    await conn.getAccountRateLimits();
+    await conn.getAccountTokenUsage();
+    await conn.readThread({ includeTurns: true });
+    await conn.setThreadName("renamed");
+    await conn.listMcpServerStatus();
+    await conn.listSkills({ forceReload: true });
+    const frames = mock.axon.publish.mock.calls.map(([event]) => JSON.parse(event.payload));
+    const byMethod = Object.fromEntries(frames.map((frame) => [frame.method, frame]));
+    // Option<()> wire params: the field must be absent, not an empty object.
+    expect(byMethod["account/rateLimits/read"]).not.toHaveProperty("params");
+    expect(byMethod["account/usage/read"]).not.toHaveProperty("params");
+    expect(byMethod["thread/read"]).toMatchObject({
+      params: { threadId: "thr-1", includeTurns: true },
+    });
+    expect(byMethod["thread/name/set"]).toMatchObject({
+      params: { threadId: "thr-1", name: "renamed" },
+    });
+    expect(byMethod["mcpServerStatus/list"]).toMatchObject({ params: {} });
+    expect(byMethod["skills/list"]).toMatchObject({ params: { forceReload: true } });
+  });
+
+  it("rejects thread-scoped wrappers before a thread exists", async () => {
+    const { conn } = setup();
+    await conn.connect();
+    await expect(conn.readThread()).rejects.toMatchObject({ code: "not_connected" });
+    await expect(conn.setThreadName("nope")).rejects.toMatchObject({ code: "not_connected" });
+  });
+
   it("correlates responses by JSON-RPC id", async () => {
     const { ctrl, mock, conn } = setup();
     mock.axon.publish.mockImplementation(async (event) => {

sdk/src/codex/connection.ts

@@ -22,12 +22,21 @@ import type {
   CollaborationMode,
   ConfigReadParams,
   ConfigReadResponse,
+  GetAccountRateLimitsResponse,
+  GetAccountTokenUsageResponse,
   InitializeParams,
   InitializeResponse,
+  ListMcpServerStatusParams,
+  ListMcpServerStatusResponse,
   ReviewDelivery,
   ReviewStartResponse,
   ReviewTarget,
   ServerRequest,
+  SkillsListParams,
+  SkillsListResponse,
+  ThreadReadParams,
+  ThreadReadResponse,
+  ThreadSetNameResponse,
   ThreadStartParams,
   ThreadStartResponse,
   TurnStartParams,
@@ -554,6 +563,58 @@ export class CodexAxonConnection {
   async readConfig(params: ConfigReadParams = {}): Promise<ConfigReadResponse> {
     return (await this.request("config/read", params)) as ConfigReadResponse;
   }
+  /**
+   * Reads the account's current rate limits (`account/rateLimits/read`).
+   * Wire params are `Option<()>`: the params field must be omitted, not `{}`.
+   */
+  async getAccountRateLimits(): Promise<GetAccountRateLimitsResponse> {
+    return (await this.request(
+      "account/rateLimits/read",
+      undefined,
+    )) as GetAccountRateLimitsResponse;
+  }
+  /**
+   * Reads the account's token-usage summary (`account/usage/read`).
+   * Wire params are `Option<()>`: the params field must be omitted, not `{}`.
+   */
+  async getAccountTokenUsage(): Promise<GetAccountTokenUsageResponse> {
+    return (await this.request("account/usage/read", undefined)) as GetAccountTokenUsageResponse;
+  }
+  /**
+   * Reads a thread's metadata — and optionally its turns — from rollout
+   * history (`thread/read`). Defaults to the active thread.
+   */
+  async readThread(params?: Partial<ThreadReadParams>): Promise<ThreadReadResponse> {
+    const threadId = params?.threadId ?? this._threadId;
+    if (!threadId)
+      throw new ConnectionStateError(
+        "not_connected",
+        "No active thread. Call startThread() first.",
+      );
+    return (await this.request("thread/read", { ...params, threadId })) as ThreadReadResponse;
+  }
+  /** Renames the active thread (`thread/name/set`). */
+  async setThreadName(name: string): Promise<ThreadSetNameResponse> {
+    if (!this._threadId)
+      throw new ConnectionStateError(
+        "not_connected",
+        "No active thread. Call startThread() first.",
+      );
+    return (await this.request("thread/name/set", {
+      threadId: this._threadId,
+      name,
+    })) as ThreadSetNameResponse;
+  }
+  /** Lists configured MCP servers with startup/auth status (`mcpServerStatus/list`). */
+  async listMcpServerStatus(
+    params: ListMcpServerStatusParams = {},
+  ): Promise<ListMcpServerStatusResponse> {
+    return (await this.request("mcpServerStatus/list", params)) as ListMcpServerStatusResponse;
+  }
+  /** Lists skills available to the session (`skills/list`). */
+  async listSkills(params: SkillsListParams = {}): Promise<SkillsListResponse> {
+    return (await this.request("skills/list", params)) as SkillsListResponse;
+  }
   /** Interrupts the broker adapter's currently tracked turn. */
   async interrupt(): Promise<void> {
     await this.request("turn/interrupt", {});

sdk/src/codex/protocol/index.ts

@@ -3,9 +3,19 @@ export type * from "./generated/index.js";
 export type {
   ConfigReadParams,
   ConfigReadResponse,
+  GetAccountRateLimitsResponse,
+  GetAccountTokenUsageResponse,
+  ListMcpServerStatusParams,
+  ListMcpServerStatusResponse,
   ReviewDelivery,
   ReviewStartResponse,
   ReviewTarget,
+  SkillsListParams,
+  SkillsListResponse,
+  ThreadReadParams,
+  ThreadReadResponse,
+  ThreadSetNameParams,
+  ThreadSetNameResponse,
   ThreadStartParams,
   ThreadStartResponse,
   ToolRequestUserInputAnswer,