# T3 Code Project Dependencies: Complete Monorepo Breakdown

> Explore T3 code project dependencies within the pingdotgg/t3code monorepo. Discover its reliance on Effect, AI SDKs, React, TanStack, and internal packages for a robust tech stack.

- Repository: [Ping.gg/t3code](https://github.com/pingdotgg/t3code)
- Tags: deep-dive
- Published: 2026-04-18

---

**The T3 Code monorepo relies on the Effect ecosystem as its functional programming core, supplemented by AI SDKs for the server, React and TanStack libraries for the web client, and internal workspace packages for shared contracts and utilities.**

The **T3 code project dependencies** are organized within a TypeScript monorepo structure managed by pnpm workspaces. Located in `pingdotgg/t3code`, the project separates concerns across `apps/*` (server and web) and `packages/*` (shared logic, contracts, and client runtime), with a root workspace catalog centralizing versions for the Effect ecosystem.

## Root Workspace Dependencies

The root [`package.json`](https://github.com/pingdotgg/t3code/blob/main/package.json) serves as the central command center for the monorepo. It defines a **workspace catalog** that pins exact versions for the Effect ecosystem, ensuring every workspace resolves to the same release (e.g., `4.0.0-beta.45`).

Key catalog dependencies include:

- **`effect`** – The core functional programming library
- **`@effect/atom-react`** – React bindings for Effect
- **`@effect/openapi-generator`** – Generates OpenAPI specs from Effect schemas
- **`@effect/platform-bun`** and **`@effect/platform-node`** – Runtime environments for Bun and Node.js
- **`@effect/sql-sqlite-bun`** – SQLite driver for Bun
- **`@effect/vitest`** – Vitest bindings for Effect testing
- **`typescript`** and **`vitest`** – Core development tools

Development tooling at the root includes **oxfmt**, **oxlint**, and **turbo** for formatting, linting, and monorepo orchestration.

## Server Application Dependencies

The `apps/server` workspace handles AI orchestration, terminal management, and API endpoints. Its [`apps/server/package.json`](https://github.com/pingdotgg/t3code/blob/main/apps/server/package.json) declares runtime dependencies divided into external AI SDKs, platform runtimes, and internal workspace links.

External AI and utility libraries:

- **`@anthropic-ai/claude-agent-sdk`** – Claude AI provider integration
- **`@opencode-ai/sdk`** – OpenAI Codex integration
- **`@pierre/diffs`** – Text diff utilities for comparing code changes
- **`node-pty`** – Pseudo-terminal handling for interactive processes
- **`open`** – Cross-platform URL opener

Effect ecosystem runtime packages:

- **`@effect/platform-bun`**, **`@effect/platform-node`**, **`@effect/sql-sqlite-bun`**, and **`effect`**

Internal workspace dependencies:

- **`@t3tools/contracts`**, **`@t3tools/shared`**, and **`@t3tools/web`**

## Web Application Dependencies

The `apps/web` workspace provides the React-based user interface. Its [`apps/web/package.json`](https://github.com/pingdotgg/t3code/blob/main/apps/web/package.json) combines modern React UI libraries with Effect bindings and state management tools.

UI and component libraries:

- **`@base-ui/react`** – Unstyled React components
- **`@dnd-kit/*`** – Drag-and-drop toolkit (core, sortable, utilities)
- **`@lexical/react`** – Meta's Lexical text editor framework
- **`@xterm/*`** – Terminal emulation for the browser (xterm, addon-fit, addon-web-links)
- **`lucide-react`** – Icon library
- **`react`**, **`react-dom`** – Core React libraries
- **`react-markdown`** and **`remark-gfm`** – Markdown rendering

State management and data fetching:

- **`@tanstack/react-query`** – Server state management
- **`@tanstack/react-router`** – Type-safe routing
- **`@tanstack/react-pacer`** – Rate limiting and pacing
- **`zustand`** – Lightweight client state management

Effect integration:

- **`@effect/atom-react`** and **`effect`**

Internal workspace links:

- **`@t3tools/client-runtime`**, **`@t3tools/contracts`**, and **`@t3tools/shared`**

Development dependencies include **Vite** for building, **Vitest** and **Playwright** for testing, and **MSW** for API mocking.

## Internal Package Dependencies

The `packages/*` workspaces provide shared code consumed by both server and web applications.

### packages/shared

Located at [`packages/shared/package.json`](https://github.com/pingdotgg/t3code/blob/main/packages/shared/package.json), this workspace exports utilities like logging and git helpers. It depends on:
- **`@t3tools/contracts`** – Internal contract definitions
- **`effect`** – Core functional programming primitives

### packages/contracts

Defined in [`packages/contracts/package.json`](https://github.com/pingdotgg/t3code/blob/main/packages/contracts/package.json), this schema-only package contains type definitions used across the monorepo. It lists only:
- **`effect`** – For schema definitions and type utilities

### packages/client-runtime

Found in [`packages/client-runtime/package.json`](https://github.com/pingdotgg/t3code/blob/main/packages/client-runtime/package.json), this thin runtime bridges the web client to the contracts. It depends on:
- **`@t3tools/contracts`** – To ensure type safety between client and server

## Practical Usage Examples

The following snippets demonstrate how these dependencies interact in the source code.

### Using Shared Utilities with Effect

The server imports logging utilities from the internal shared package and wraps them in Effect workflows:

```typescript
// File: apps/server/src/someModule.ts
import { logging } from '@t3tools/shared/logging';
import { Effect } from 'effect';

export const startServer = Effect.gen(function* (_) {
  logging.info('Starting T3 server...');
  // …server logic…
});

```

The `@t3tools/shared/logging` export is defined in [`packages/shared/src/logging.ts`](https://github.com/pingdotgg/t3code/blob/main/packages/shared/src/logging.ts).

### Integrating OpenAI SDK

The server uses the OpenAI Codex SDK alongside Effect for error handling:

```typescript
import { OpenAI } from '@opencode-ai/sdk';
import { Effect } from 'effect';

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export const generate = (prompt: string) =>
  Effect.tryPromise({
    try: () => client.completions.create({ model: 'gpt-4', prompt }),
    catch: (e) => new Error(`OpenAI error: ${e}`),
  });

```

This dependency is declared in [`apps/server/package.json`](https://github.com/pingdotgg/t3code/blob/main/apps/server/package.json) under `@opencode-ai/sdk`.

### Consuming Contracts in the Web UI

The web application imports type definitions from the internal contracts package:

```tsx
import { Settings } from '@t3tools/contracts/settings';
import { useState } from 'react';

export function SettingsPanel() {
  const [settings, setSettings] = useState<Settings>({ theme: 'light' });

  // UI to edit settings …
}

```

`@t3tools/contracts` is listed in [`apps/web/package.json`](https://github.com/pingdotgg/t3code/blob/main/apps/web/package.json) as a workspace dependency.

### React Query with Effect Integration

The web client combines TanStack Query with Effect for type-safe data fetching:

```tsx
import { useQuery } from '@tanstack/react-query';
import { Effect } from 'effect';
import { fetchLogs } from '../api/logs';

export function LogViewer() {
  const { data, isLoading } = useQuery(['logs'], () =>
    Effect.runPromise(fetchLogs())
  );

  if (isLoading) return <div>Loading…</div>;
  return <pre>{JSON.stringify(data, null, 2)}</pre>;
}

```

This utilizes `@tanstack/react-query` from [`apps/web/package.json`](https://github.com/pingdotgg/t3code/blob/main/apps/web/package.json) alongside the `effect` runtime.

## Summary

- **T3 code project dependencies** are organized through a pnpm workspace catalog that enforces consistent versioning across the monorepo, particularly for the Effect ecosystem.
- The **root workspace** centralizes the Effect library and related runtime packages (`@effect/platform-node`, `@effect/sql-sqlite-bun`, etc.) alongside development tools like **Turbo**, **oxlint**, and **Vitest**.
- **apps/server** combines AI SDKs (**Claude Agent SDK**, **OpenAI Codex SDK**) with terminal utilities (**node-pty**) and internal workspace packages for API logic.
- **apps/web** leverages **React 18**, **TanStack Query/Router**, **Lexical** for text editing, **xterm.js** for terminal emulation, and **Effect** bindings for state management.
- Internal packages (`@t3tools/contracts`, `@t3tools/shared`, `@t3tools/client-runtime`) provide type-safe shared code with minimal external dependencies, primarily relying on the core `effect` library.

## Frequently Asked Questions

### What is the primary framework used in the T3 code project dependencies?

The **Effect** ecosystem serves as the primary functional programming framework across the entire monorepo. Every workspace—including `apps/server`, `apps/web`, and all `packages/*`—declares `effect` as a dependency, alongside specialized packages like `@effect/platform-node` for server runtimes and `@effect/atom-react` for React state management.

### How does the T3 code monorepo manage dependency versions consistently?

The project uses a **pnpm workspace catalog** defined in the root [`package.json`](https://github.com/pingdotgg/t3code/blob/main/package.json) to pin exact versions of the Effect ecosystem and other critical libraries. This catalog ensures that all workspaces resolve to the same release (e.g., `effect` version `4.0.0-beta.45`), preventing version mismatches across the server, web client, and internal packages.

### Which AI providers are integrated into the T3 code server dependencies?

The server application integrates two major AI providers: **Anthropic's Claude** via the `@anthropic-ai/claude-agent-sdk` and **OpenAI's Codex** via the `@opencode-ai/sdk`. These are listed as runtime dependencies in [`apps/server/package.json`](https://github.com/pingdotgg/t3code/blob/main/apps/server/package.json) and are used to power code generation and agentic workflows within the application.

### What UI libraries does the T3 code web application use?

The web client combines **React 18** with **Base UI** for unstyled components, **Lexical** for text editing, **xterm.js** for terminal emulation, and **TanStack** libraries (Query, Router, and Pacer) for data fetching and routing. Styling utilities include **Tailwind CSS**-related tools like `tailwind-merge` and `class-variance-authority`, while state management uses **Zustand** alongside Effect atoms.