T3 Code Project Dependencies: Complete Monorepo Breakdown

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 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 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 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, 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, 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, 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:

// 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.

Integrating OpenAI SDK

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

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 under @opencode-ai/sdk.

Consuming Contracts in the Web UI

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

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 as a workspace dependency.

React Query with Effect Integration

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

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 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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}