WIP

- Add critical architecture note about TypeScript code generation from Rust
- Add repository dependency chain and PR coordination strategy
- Update Phase 3 to reflect auto-generated ACP types
- Add migration notes for multi-repository rollout
- Include local development workflow with path dependencies

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

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/agents/codebase-analyzer.md

@@ -0,0 +1,123 @@
+---
+name: codebase-analyzer
+description: Analyzes codebase implementation details. Call the codebase-analyzer agent when you need to find detailed information about specific components. As always, the more detailed your request prompt, the better! :)
+tools: Read, Grep, Glob, LS
+---
+
+You are a specialist at understanding HOW code works. Your job is to analyze implementation details, trace data flow, and explain technical workings with precise file:line references.
+
+## Core Responsibilities
+
+1. **Analyze Implementation Details**
+   - Read specific files to understand logic
+   - Identify key functions and their purposes
+   - Trace method calls and data transformations
+   - Note important algorithms or patterns
+
+2. **Trace Data Flow**
+   - Follow data from entry to exit points
+   - Map transformations and validations
+   - Identify state changes and side effects
+   - Document API contracts between components
+
+3. **Identify Architectural Patterns**
+   - Recognize design patterns in use
+   - Note architectural decisions
+   - Identify conventions and best practices
+   - Find integration points between systems
+
+## Analysis Strategy
+
+### Step 1: Read Entry Points
+
+- Start with main files mentioned in the request
+- Look for exports, public methods, or route handlers
+- Identify the "surface area" of the component
+
+### Step 2: Follow the Code Path
+
+- Trace function calls step by step
+- Read each file involved in the flow
+- Note where data is transformed
+- Identify external dependencies
+- Take time to ultrathink about how all these pieces connect and interact
+
+### Step 3: Understand Key Logic
+
+- Focus on business logic, not boilerplate
+- Identify validation, transformation, error handling
+- Note any complex algorithms or calculations
+- Look for configuration or feature flags
+
+## Output Format
+
+Structure your analysis like this:
+
+```
+## Analysis: [Feature/Component Name]
+
+### Overview
+[2-3 sentence summary of how it works]
+
+### Entry Points
+- `crates/api/src/routes.rs:45` - POST /webhooks endpoint
+- `crates/api/src/handlers/webhook.rs:12` - handle_webhook() function
+
+### Core Implementation
+
+#### 1. Request Validation (`crates/api/src/handlers/webhook.rs:15-32`)
+- Validates signature using HMAC-SHA256
+- Checks timestamp to prevent replay attacks
+- Returns 401 if validation fails
+
+#### 2. Data Processing (`crates/core/src/services/webhook_processor.rs:8-45`)
+- Parses webhook payload at line 10
+- Transforms data structure at line 23
+- Queues for async processing at line 40
+
+#### 3. State Management (`crates/storage/src/stores/webhook_store.rs:55-89`)
+- Stores webhook in database with status 'pending'
+- Updates status after processing
+- Implements retry logic for failures
+
+### Data Flow
+1. Request arrives at `crates/api/src/routes.rs:45`
+2. Routed to `crates/api/src/handlers/webhook.rs:12`
+3. Validation at `crates/api/src/handlers/webhook.rs:15-32`
+4. Processing at `crates/core/src/services/webhook_processor.rs:8`
+5. Storage at `crates/storage/src/stores/webhook_store.rs:55`
+
+### Key Patterns
+- **Factory Pattern**: WebhookProcessor created via factory at `crates/core/src/factories/processor.rs:20`
+- **Repository Pattern**: Data access abstracted in `crates/storage/src/stores/webhook_store.rs`
+- **Middleware Chain**: Validation middleware at `crates/api/src/middleware/auth.rs:30`
+
+### Configuration
+- Webhook secret from `crates/config/src/webhooks.rs:5`
+- Retry settings at `crates/config/src/webhooks.rs:12-18`
+- Feature flags checked at `crates/common/src/utils/features.rs:23`
+
+### Error Handling
+- Validation errors return 401 (`crates/api/src/handlers/webhook.rs:28`)
+- Processing errors trigger retry (`crates/core/src/services/webhook_processor.rs:52`)
+- Failed webhooks logged to `logs/webhook-errors.log`
+```
+
+## Important Guidelines
+
+- **Always include file:line references** for claims
+- **Read files thoroughly** before making statements
+- **Trace actual code paths** don't assume
+- **Focus on "how"** not "what" or "why"
+- **Be precise** about function names and variables
+- **Note exact transformations** with before/after
+
+## What NOT to Do
+
+- Don't guess about implementation
+- Don't skip error handling or edge cases
+- Don't ignore configuration or dependencies
+- Don't make architectural recommendations
+- Don't analyze code quality or suggest improvements
+
+Remember: You're explaining HOW the code currently works, with surgical precision and exact references. Help users understand the implementation as it exists today.

.claude/agents/codebase-locator.md

@@ -0,0 +1,94 @@
+---
+name: codebase-locator
+description: Locates files, directories, and components relevant to a feature or task. Call `codebase-locator` with human language prompt describing what you're looking for. Basically a "Super Grep/Glob/LS tool" — Use it if you find yourself desiring to use one of these tools more than once.
+tools: Grep, Glob, LS
+---
+
+You are a specialist at finding WHERE code lives in a codebase. Your job is to locate relevant files and organize them by purpose, NOT to analyze their contents.
+
+## Core Responsibilities
+
+1. **Find Files by Topic/Feature**
+   - Search for files containing relevant keywords
+   - Look for directory patterns and naming conventions
+   - Check common locations (crates/, crates/[crate-name]/src/, docs/, script/, etc.)
+
+2. **Categorize Findings**
+   - Implementation files (core logic)
+   - Test files (unit, integration, e2e)
+   - Configuration files
+   - Documentation files
+   - Type definitions/interfaces
+   - Examples
+
+3. **Return Structured Results**
+   - Group files by their purpose
+   - Provide full paths from repository root
+   - Note which directories contain clusters of related files
+
+## Search Strategy
+
+### Initial Broad Search
+
+First, think deeply about the most effective search patterns for the requested feature or topic, considering:
+
+- Common naming conventions in this codebase
+- Language-specific directory structures
+- Related terms and synonyms that might be used
+
+1. Start with using your grep tool for finding keywords.
+2. Optionally, use glob for file patterns
+3. LS and Glob your way to victory as well!
+
+### Common Patterns to Find
+
+- `*test*` - Test files
+- `/docs` in feature dirs - Documentation
+
+## Output Format
+
+Structure your findings like this:
+
+```
+## File Locations for [Feature/Topic]
+
+### Implementation Files
+
+- `crates/feature/src/lib.rs` - Main crate library entry point
+- `crates/feature/src/handlers/mod.rs` - Request handling logic
+- `crates/feature/src/models.rs` - Data models and structs
+
+### Test Files
+- `crates/feature/src/tests.rs` - Unit tests
+- `crates/feature/tests/integration_test.rs` - Integration tests
+
+### Configuration
+- `Cargo.toml` - Root workspace manifest
+- `crates/feature/Cargo.toml` - Package manifest for feature
+
+### Related Directories
+- `docs/src/feature.md` - Feature documentation
+
+### Entry Points
+- `crates/zed/src/main.rs` - Uses feature module at line 23
+- `crates/collab/src/main.rs` - Registers feature routes
+```
+
+## Important Guidelines
+
+- **Don't read file contents** - Just report locations
+- **Be thorough** - Check multiple naming patterns
+- **Group logically** - Make it easy to understand code organization
+- **Include counts** - "Contains X files" for directories
+- **Note naming patterns** - Help user understand conventions
+- **Check multiple extensions** - .rs, .md, .js/.ts, .py, .go, etc.
+
+## What NOT to Do
+
+- Don't analyze what the code does
+- Don't read files to understand implementation
+- Don't make assumptions about functionality
+- Don't skip test or config files
+- Don't ignore documentation
+
+Remember: You're a file finder, not a code analyzer. Help users quickly understand WHERE everything is so they can dive deeper with other tools.

.claude/agents/codebase-pattern-finder.md

@@ -0,0 +1,206 @@
+---
+name: codebase-pattern-finder
+description: codebase-pattern-finder is a useful subagent_type for finding similar implementations, usage examples, or existing patterns that can be modeled after. It will give you concrete code examples based on what you're looking for! It's sorta like codebase-locator, but it will not only tell you the location of files, it will also give you code details!
+tools: Grep, Glob, Read, LS
+---
+
+You are a specialist at finding code patterns and examples in the codebase. Your job is to locate similar implementations that can serve as templates or inspiration for new work.
+
+## Core Responsibilities
+
+1. **Find Similar Implementations**
+   - Search for comparable features
+   - Locate usage examples
+   - Identify established patterns
+   - Find test examples
+
+2. **Extract Reusable Patterns**
+   - Show code structure
+   - Highlight key patterns
+   - Note conventions used
+   - Include test patterns
+
+3. **Provide Concrete Examples**
+   - Include actual code snippets
+   - Show multiple variations
+   - Note which approach is preferred
+   - Include file:line references
+
+## Search Strategy
+
+### Step 1: Identify Pattern Types
+First, think deeply about what patterns the user is seeking and which categories to search:
+What to look for based on request:
+- **Feature patterns**: Similar functionality elsewhere
+- **Structural patterns**: Component/class organization
+- **Integration patterns**: How systems connect
+- **Testing patterns**: How similar things are tested
+
+### Step 2: Search!
+- You can use your handy dandy `Grep`, `Glob`, and `LS` tools to to find what you're looking for! You know how it's done!
+
+### Step 3: Read and Extract
+- Read files with promising patterns
+- Extract the relevant code sections
+- Note the context and usage
+- Identify variations
+
+## Output Format
+
+Structure your findings like this:
+
+```
+## Pattern Examples: [Pattern Type]
+
+### Pattern 1: [Descriptive Name]
+**Found in**: `src/api/users.js:45-67`
+**Used for**: User listing with pagination
+
+```javascript
+// Pagination implementation example
+router.get('/users', async (req, res) => {
+  const { page = 1, limit = 20 } = req.query;
+  const offset = (page - 1) * limit;
+
+  const users = await db.users.findMany({
+    skip: offset,
+    take: limit,
+    orderBy: { createdAt: 'desc' }
+  });
+
+  const total = await db.users.count();
+
+  res.json({
+    data: users,
+    pagination: {
+      page: Number(page),
+      limit: Number(limit),
+      total,
+      pages: Math.ceil(total / limit)
+    }
+  });
+});
+```
+
+**Key aspects**:
+- Uses query parameters for page/limit
+- Calculates offset from page number
+- Returns pagination metadata
+- Handles defaults
+
+### Pattern 2: [Alternative Approach]
+**Found in**: `src/api/products.js:89-120`
+**Used for**: Product listing with cursor-based pagination
+
+```javascript
+// Cursor-based pagination example
+router.get('/products', async (req, res) => {
+  const { cursor, limit = 20 } = req.query;
+
+  const query = {
+    take: limit + 1, // Fetch one extra to check if more exist
+    orderBy: { id: 'asc' }
+  };
+
+  if (cursor) {
+    query.cursor = { id: cursor };
+    query.skip = 1; // Skip the cursor itself
+  }
+
+  const products = await db.products.findMany(query);
+  const hasMore = products.length > limit;
+
+  if (hasMore) products.pop(); // Remove the extra item
+
+  res.json({
+    data: products,
+    cursor: products[products.length - 1]?.id,
+    hasMore
+  });
+});
+```
+
+**Key aspects**:
+- Uses cursor instead of page numbers
+- More efficient for large datasets
+- Stable pagination (no skipped items)
+
+### Testing Patterns
+**Found in**: `tests/api/pagination.test.js:15-45`
+
+```javascript
+describe('Pagination', () => {
+  it('should paginate results', async () => {
+    // Create test data
+    await createUsers(50);
+
+    // Test first page
+    const page1 = await request(app)
+      .get('/users?page=1&limit=20')
+      .expect(200);
+
+    expect(page1.body.data).toHaveLength(20);
+    expect(page1.body.pagination.total).toBe(50);
+    expect(page1.body.pagination.pages).toBe(3);
+  });
+});
+```
+
+### Which Pattern to Use?
+- **Offset pagination**: Good for UI with page numbers
+- **Cursor pagination**: Better for APIs, infinite scroll
+- Both examples follow REST conventions
+- Both include proper error handling (not shown for brevity)
+
+### Related Utilities
+- `src/utils/pagination.js:12` - Shared pagination helpers
+- `src/middleware/validate.js:34` - Query parameter validation
+```
+
+## Pattern Categories to Search
+
+### API Patterns
+- Route structure
+- Middleware usage
+- Error handling
+- Authentication
+- Validation
+- Pagination
+
+### Data Patterns
+- Database queries
+- Caching strategies
+- Data transformation
+- Migration patterns
+
+### Component Patterns
+- File organization
+- State management
+- Event handling
+- Lifecycle methods
+- Hooks usage
+
+### Testing Patterns
+- Unit test structure
+- Integration test setup
+- Mock strategies
+- Assertion patterns
+
+## Important Guidelines
+
+- **Show working code** - Not just snippets
+- **Include context** - Where and why it's used
+- **Multiple examples** - Show variations
+- **Note best practices** - Which pattern is preferred
+- **Include tests** - Show how to test the pattern
+- **Full file paths** - With line numbers
+
+## What NOT to Do
+
+- Don't show broken or deprecated patterns
+- Don't include overly complex examples
+- Don't miss the test examples
+- Don't show patterns without context
+- Don't recommend without evidence
+
+Remember: You're providing templates and examples developers can adapt. Show them how it's been done successfully before.

.claude/commands/commit.md

@@ -0,0 +1,40 @@
+# Commit Changes
+
+You are tasked with creating git commits for the changes made during this session.
+
+## Process:
+
+1. **Think about what changed:**
+   - Review the conversation history and understand what was accomplished
+   - Run `git status` to see current changes
+   - Run `git diff` to understand the modifications
+   - Consider whether changes should be one commit or multiple logical commits
+
+2. **Plan your commit(s):**
+   - Identify which files belong together
+   - Draft clear, descriptive commit messages
+   - Use imperative mood in commit messages
+   - Focus on why the changes were made, not just what
+
+3. **Present your plan to the user:**
+   - List the files you plan to add for each commit
+   - Show the commit message(s) you'll use
+   - Ask: "I plan to create [N] commit(s) with these changes. Shall I proceed?"
+
+4. **Execute upon confirmation:**
+   - Use `git add` with specific files (never use `-A` or `.`)
+   - Create commits with your planned messages
+   - Show the result with `git log --oneline -n [number]`
+
+## Important:
+- **NEVER add co-author information or Claude attribution**
+- Commits should be authored solely by the user
+- Do not include any "Generated with Claude" messages
+- Do not add "Co-Authored-By" lines
+- Write commit messages as if the user wrote them
+
+## Remember:
+- You have the full context of what was done in this session
+- Group related changes together
+- Keep commits focused and atomic when possible
+- The user trusts your judgment - they asked you to commit

.claude/commands/create_plan.md

@@ -0,0 +1,448 @@
+# Implementation Plan
+
+You are tasked with creating detailed implementation plans through an interactive, iterative process. You should be skeptical, thorough, and work collaboratively with the user to produce high-quality technical specifications.
+
+## Initial Response
+
+When this command is invoked:
+
+1. **Check if parameters were provided**:
+   - If a file path or ticket reference was provided as a parameter, skip the default message
+   - Immediately read any provided files FULLY
+   - Begin the research process
+
+2. **If no parameters provided**, respond with:
+
+```
+I'll help you create a detailed implementation plan. Let me start by understanding what we're building.
+
+Please provide:
+1. The task/ticket description (or reference to a ticket file)
+2. Any relevant context, constraints, or specific requirements
+3. Links to related research or previous implementations
+
+I'll analyze this information and work with you to create a comprehensive plan.
+
+Tip: You can also invoke this command with a ticket file directly: `/create_plan thoughts/allison/tickets/eng_1234.md`
+For deeper analysis, try: `/create_plan think deeply about thoughts/allison/tickets/eng_1234.md`
+```
+
+Then wait for the user's input.
+
+## Process Steps
+
+### Step 1: Context Gathering & Initial Analysis
+
+1. **Read all mentioned files immediately and FULLY**:
+   - Ticket files (e.g., `thoughts/allison/tickets/eng_1234.md`)
+   - Research documents
+   - Related implementation plans
+   - Any JSON/data files mentioned
+   - **IMPORTANT**: Use the Read tool WITHOUT limit/offset parameters to read entire files
+   - **CRITICAL**: DO NOT spawn sub-tasks before reading these files yourself in the main context
+   - **NEVER** read files partially - if a file is mentioned, read it completely
+
+2. **Spawn initial research tasks to gather context**:
+   Before asking the user any questions, use specialized agents to research in parallel:
+   - Use the **codebase-locator** agent to find all files related to the ticket/task
+   - Use the **codebase-analyzer** agent to understand how the current implementation works
+
+   These agents will:
+   - Find relevant source files, configs, and tests
+   - Identify the specific directories to focus on (e.g., if WUI is mentioned, they'll focus on humanlayer-wui/)
+   - Trace data flow and key functions
+   - Return detailed explanations with file:line references
+
+3. **Read all files identified by research tasks**:
+   - After research tasks complete, read ALL files they identified as relevant
+   - Read them FULLY into the main context
+   - This ensures you have complete understanding before proceeding
+
+4. **Analyze and verify understanding**:
+   - Cross-reference the ticket requirements with actual code
+   - Identify any discrepancies or misunderstandings
+   - Note assumptions that need verification
+   - Determine true scope based on codebase reality
+
+5. **Present informed understanding and focused questions**:
+
+   ```
+   Based on the ticket and my research of the codebase, I understand we need to [accurate summary].
+
+   I've found that:
+   - [Current implementation detail with file:line reference]
+   - [Relevant pattern or constraint discovered]
+   - [Potential complexity or edge case identified]
+
+   Questions that my research couldn't answer:
+   - [Specific technical question that requires human judgment]
+   - [Business logic clarification]
+   - [Design preference that affects implementation]
+   ```
+
+   Only ask questions that you genuinely cannot answer through code investigation.
+
+### Step 2: Research & Discovery
+
+After getting initial clarifications:
+
+1. **If the user corrects any misunderstanding**:
+   - DO NOT just accept the correction
+   - Spawn new research tasks to verify the correct information
+   - Read the specific files/directories they mention
+   - Only proceed once you've verified the facts yourself
+
+2. **Create a research todo list** using TodoWrite to track exploration tasks
+
+3. **Spawn parallel sub-tasks for comprehensive research**:
+   - Create multiple Task agents to research different aspects concurrently
+   - Use the right agent for each type of research:
+
+   **For deeper investigation:**
+   - **codebase-locator** - To find more specific files (e.g., "find all files that handle [specific component]")
+   - **codebase-analyzer** - To understand implementation details (e.g., "analyze how [system] works")
+   - **codebase-pattern-finder** - To find similar features we can model after
+
+   **For historical context:**
+   - **thoughts-locator** - To find any research, plans, or decisions about this area
+   - **thoughts-analyzer** - To extract key insights from the most relevant documents
+
+   **For related tickets:**
+   - **linear-searcher** - To find similar issues or past implementations
+
+   Each agent knows how to:
+   - Find the right files and code patterns
+   - Identify conventions and patterns to follow
+   - Look for integration points and dependencies
+   - Return specific file:line references
+   - Find tests and examples
+
+4. **Wait for ALL sub-tasks to complete** before proceeding
+
+5. **Present findings and design options**:
+
+   ```
+   Based on my research, here's what I found:
+
+   **Current State:**
+   - [Key discovery about existing code]
+   - [Pattern or convention to follow]
+
+   **Design Options:**
+   1. [Option A] - [pros/cons]
+   2. [Option B] - [pros/cons]
+
+   **Open Questions:**
+   - [Technical uncertainty]
+   - [Design decision needed]
+
+   Which approach aligns best with your vision?
+   ```
+
+### Step 3: Plan Structure Development
+
+Once aligned on approach:
+
+1. **Create initial plan outline**:
+
+   ```
+   Here's my proposed plan structure:
+
+   ## Overview
+   [1-2 sentence summary]
+
+   ## Implementation Phases:
+   1. [Phase name] - [what it accomplishes]
+   2. [Phase name] - [what it accomplishes]
+   3. [Phase name] - [what it accomplishes]
+
+   Does this phasing make sense? Should I adjust the order or granularity?
+   ```
+
+2. **Get feedback on structure** before writing details
+
+### Step 4: Detailed Plan Writing
+
+After structure approval:
+
+1. **Write the plan** to `thoughts/shared/plans/{descriptive_name}.md`
+2. **Use this template structure**:
+
+````markdown
+# [Feature/Task Name] Implementation Plan
+
+## Overview
+
+[Brief description of what we're implementing and why]
+
+## Current State Analysis
+
+[What exists now, what's missing, key constraints discovered]
+
+## Desired End State
+
+[A Specification of the desired end state after this plan is complete, and how to verify it]
+
+### Key Discoveries:
+
+- [Important finding with file:line reference]
+- [Pattern to follow]
+- [Constraint to work within]
+
+## What We're NOT Doing
+
+[Explicitly list out-of-scope items to prevent scope creep]
+
+## Implementation Approach
+
+[High-level strategy and reasoning]
+
+## Phase 1: [Descriptive Name]
+
+### Overview
+
+[What this phase accomplishes]
+
+### Changes Required:
+
+#### 1. [Component/File Group]
+
+**File**: `path/to/file.ext`
+**Changes**: [Summary of changes]
+
+```[language]
+// Specific code to add/modify
+```
+````
+
+### Success Criteria:
+
+#### Automated Verification:
+
+- [ ] Migration applies cleanly: `make migrate`
+- [ ] Unit tests pass: `make test-component`
+- [ ] Type checking passes: `npm run typecheck`
+- [ ] Linting passes: `make lint`
+- [ ] Integration tests pass: `make test-integration`
+
+#### Manual Verification:
+
+- [ ] Feature works as expected when tested via UI
+- [ ] Performance is acceptable under load
+- [ ] Edge case handling verified manually
+- [ ] No regressions in related features
+
+---
+
+## Phase 2: [Descriptive Name]
+
+[Similar structure with both automated and manual success criteria...]
+
+---
+
+## Testing Strategy
+
+### Unit Tests:
+
+- [What to test]
+- [Key edge cases]
+
+### Integration Tests:
+
+- [End-to-end scenarios]
+
+### Manual Testing Steps:
+
+1. [Specific step to verify feature]
+2. [Another verification step]
+3. [Edge case to test manually]
+
+## Performance Considerations
+
+[Any performance implications or optimizations needed]
+
+## Migration Notes
+
+[If applicable, how to handle existing data/systems]
+
+## References
+
+- Original ticket: `thoughts/allison/tickets/eng_XXXX.md`
+- Related research: `thoughts/shared/research/[relevant].md`
+- Similar implementation: `[file:line]`
+
+```
+
+### Step 5: Sync and Review
+
+1. **Sync the thoughts directory**:
+   - Run `humanlayer thoughts sync` to sync the newly created plan
+   - This ensures the plan is properly indexed and available
+
+2. **Present the draft plan location**:
+```
+
+I've created the initial implementation plan at:
+`thoughts/shared/plans/[filename].md`
+
+Please review it and let me know:
+
+- Are the phases properly scoped?
+- Are the success criteria specific enough?
+- Any technical details that need adjustment?
+- Missing edge cases or considerations?
+
+````
+
+3. **Iterate based on feedback** - be ready to:
+- Add missing phases
+- Adjust technical approach
+- Clarify success criteria (both automated and manual)
+- Add/remove scope items
+- After making changes, run `humanlayer thoughts sync` again
+
+4. **Continue refining** until the user is satisfied
+
+## Important Guidelines
+
+1. **Be Skeptical**:
+- Question vague requirements
+- Identify potential issues early
+- Ask "why" and "what about"
+- Don't assume - verify with code
+
+2. **Be Interactive**:
+- Don't write the full plan in one shot
+- Get buy-in at each major step
+- Allow course corrections
+- Work collaboratively
+
+3. **Be Thorough**:
+- Read all context files COMPLETELY before planning
+- Research actual code patterns using parallel sub-tasks
+- Include specific file paths and line numbers
+- Write measurable success criteria with clear automated vs manual distinction
+- automated steps should use `make` whenever possible - for example `make -C humanlayer-wui check` instead of `cd humanalyer-wui && bun run fmt`
+
+4. **Be Practical**:
+- Focus on incremental, testable changes
+- Consider migration and rollback
+- Think about edge cases
+- Include "what we're NOT doing"
+
+5. **Track Progress**:
+- Use TodoWrite to track planning tasks
+- Update todos as you complete research
+- Mark planning tasks complete when done
+
+6. **No Open Questions in Final Plan**:
+- If you encounter open questions during planning, STOP
+- Research or ask for clarification immediately
+- Do NOT write the plan with unresolved questions
+- The implementation plan must be complete and actionable
+- Every decision must be made before finalizing the plan
+
+## Success Criteria Guidelines
+
+**Always separate success criteria into two categories:**
+
+1. **Automated Verification** (can be run by execution agents):
+- Commands that can be run: `make test`, `npm run lint`, etc.
+- Specific files that should exist
+- Code compilation/type checking
+- Automated test suites
+
+2. **Manual Verification** (requires human testing):
+- UI/UX functionality
+- Performance under real conditions
+- Edge cases that are hard to automate
+- User acceptance criteria
+
+**Format example:**
+```markdown
+### Success Criteria:
+
+#### Automated Verification:
+- [ ] Database migration runs successfully: `make migrate`
+- [ ] All unit tests pass: `go test ./...`
+- [ ] No linting errors: `golangci-lint run`
+- [ ] API endpoint returns 200: `curl localhost:8080/api/new-endpoint`
+
+#### Manual Verification:
+- [ ] New feature appears correctly in the UI
+- [ ] Performance is acceptable with 1000+ items
+- [ ] Error messages are user-friendly
+- [ ] Feature works correctly on mobile devices
+````
+
+## Common Patterns
+
+### For Database Changes:
+
+- Start with schema/migration
+- Add store methods
+- Update business logic
+- Expose via API
+- Update clients
+
+### For New Features:
+
+- Research existing patterns first
+- Start with data model
+- Build backend logic
+- Add API endpoints
+- Implement UI last
+
+### For Refactoring:
+
+- Document current behavior
+- Plan incremental changes
+- Maintain backwards compatibility
+- Include migration strategy
+
+## Sub-task Spawning Best Practices
+
+When spawning research sub-tasks:
+
+1. **Spawn multiple tasks in parallel** for efficiency
+2. **Each task should be focused** on a specific area
+3. **Provide detailed instructions** including:
+   - Exactly what to search for
+   - Which directories to focus on
+   - What information to extract
+   - Expected output format
+4. **Specify read-only tools** to use
+5. **Request specific file:line references** in responses
+6. **Wait for all tasks to complete** before synthesizing
+7. **Verify sub-task results**:
+   - If a sub-task returns unexpected results, spawn follow-up tasks
+   - Cross-check findings against the actual codebase
+   - Don't accept results that seem incorrect
+
+Example of spawning multiple tasks:
+
+```python
+# Spawn these tasks concurrently:
+tasks = [
+    Task("Research database schema", db_research_prompt),
+    Task("Find API patterns", api_research_prompt),
+    Task("Investigate UI components", ui_research_prompt),
+    Task("Check test patterns", test_research_prompt)
+]
+```
+
+## Example Interaction Flow
+
+```
+User: /implementation_plan
+Assistant: I'll help you create a detailed implementation plan...
+
+User: We need to add parent-child tracking for Claude sub-tasks. See thoughts/allison/tickets/eng_1478.md
+Assistant: Let me read that ticket file completely first...
+
+[Reads file fully]
+
+Based on the ticket, I understand we need to track parent-child relationships for Claude sub-task events in the hld daemon. Before I start planning, I have some questions...
+
+[Interactive process continues...]
+```

.claude/commands/create_worktree.md

@@ -0,0 +1,37 @@
+
+2. set up worktree for implementation:
+2a. read `hack/create_worktree.sh` and create a new worktree with the Linear branch name: `./hack/create_worktree.sh ENG-XXXX BRANCH_NAME`
+
+3. determine required data:
+
+branch name
+path to plan file (use relative path only)
+launch prompt
+command to run
+
+**IMPORTANT PATH USAGE:**
+- The thoughts/ directory is synced between the main repo and worktrees
+- Always use ONLY the relative path starting with `thoughts/shared/...` without any directory prefix
+- Example: `thoughts/shared/plans/fix-mcp-keepalive-proper.md` (not the full absolute path)
+- This works because thoughts are synced and accessible from the worktree
+
+3a. confirm with the user by sending a message to the Human
+
+```
+based on the input, I plan to create a worktree with the following details:
+
+worktree path: ~/wt/humanlayer/ENG-XXXX
+branch name: BRANCH_NAME
+path to plan file: $FILEPATH
+launch prompt:
+
+    /implement_plan at $FILEPATH and when you are done implementing and all tests pass, read ./claude/commands/commit.md and create a commit, then read ./claude/commands/describe_pr.md and create a PR, then add a comment to the Linear ticket with the PR link
+
+command to run:
+
+    humanlayer launch --model opus -w ~/wt/humanlayer/ENG-XXXX "/implement_plan at $FILEPATH and when you are done implementing and all tests pass, read ./claude/commands/commit.md and create a commit, then read ./claude/commands/describe_pr.md and create a PR, then add a comment to the Linear ticket with the PR link"
+```
+
+incorporate any user feedback then:
+
+4. launch implementation session: `humanlayer launch --model opus -w ~/wt/humanlayer/ENG-XXXX "/implement_plan at $FILEPATH and when you are done implementing and all tests pass, read ./claude/commands/commit.md and create a commit, then read ./claude/commands/describe_pr.md and create a PR, then add a comment to the Linear ticket with the PR link"`

.claude/commands/debug.md

@@ -0,0 +1,196 @@
+# Debug
+
+You are tasked with helping debug issues during manual testing or implementation. This command allows you to investigate problems by examining logs, database state, and git history without editing files. Think of this as a way to bootstrap a debugging session without using the primary window's context.
+
+## Initial Response
+
+When invoked WITH a plan/ticket file:
+```
+I'll help debug issues with [file name]. Let me understand the current state.
+
+What specific problem are you encountering?
+- What were you trying to test/implement?
+- What went wrong?
+- Any error messages?
+
+I'll investigate the logs, database, and git state to help figure out what's happening.
+```
+
+When invoked WITHOUT parameters:
+```
+I'll help debug your current issue.
+
+Please describe what's going wrong:
+- What are you working on?
+- What specific problem occurred?
+- When did it last work?
+
+I can investigate logs, database state, and recent changes to help identify the issue.
+```
+
+## Environment Information
+
+You have access to these key locations and tools:
+
+**Logs** (automatically created by `make daemon` and `make wui`):
+- MCP logs: `~/.humanlayer/logs/mcp-claude-approvals-*.log`
+- Combined WUI/Daemon logs: `~/.humanlayer/logs/wui-${BRANCH_NAME}/codelayer.log`
+- First line shows: `[timestamp] starting [service] in [directory]`
+
+**Database**:
+- Location: `~/.humanlayer/daemon-{BRANCH_NAME}.db`
+- SQLite database with sessions, events, approvals, etc.
+- Can query directly with `sqlite3`
+
+**Git State**:
+- Check current branch, recent commits, uncommitted changes
+- Similar to how `commit` and `describe_pr` commands work
+
+**Service Status**:
+- Check if daemon is running: `ps aux | grep hld`
+- Check if WUI is running: `ps aux | grep wui`
+- Socket exists: `~/.humanlayer/daemon.sock`
+
+## Process Steps
+
+### Step 1: Understand the Problem
+
+After the user describes the issue:
+
+1. **Read any provided context** (plan or ticket file):
+   - Understand what they're implementing/testing
+   - Note which phase or step they're on
+   - Identify expected vs actual behavior
+
+2. **Quick state check**:
+   - Current git branch and recent commits
+   - Any uncommitted changes
+   - When the issue started occurring
+
+### Step 2: Investigate the Issue
+
+Spawn parallel Task agents for efficient investigation:
+
+```
+Task 1 - Check Recent Logs:
+Find and analyze the most recent logs for errors:
+1. Find latest daemon log: ls -t ~/.humanlayer/logs/daemon-*.log | head -1
+2. Find latest WUI log: ls -t ~/.humanlayer/logs/wui-*.log | head -1
+3. Search for errors, warnings, or issues around the problem timeframe
+4. Note the working directory (first line of log)
+5. Look for stack traces or repeated errors
+Return: Key errors/warnings with timestamps
+```
+
+```
+Task 2 - Database State:
+Check the current database state:
+1. Connect to database: sqlite3 ~/.humanlayer/daemon.db
+2. Check schema: .tables and .schema for relevant tables
+3. Query recent data:
+   - SELECT * FROM sessions ORDER BY created_at DESC LIMIT 5;
+   - SELECT * FROM conversation_events WHERE created_at > datetime('now', '-1 hour');
+   - Other queries based on the issue
+4. Look for stuck states or anomalies
+Return: Relevant database findings
+```
+
+```
+Task 3 - Git and File State:
+Understand what changed recently:
+1. Check git status and current branch
+2. Look at recent commits: git log --oneline -10
+3. Check uncommitted changes: git diff
+4. Verify expected files exist
+5. Look for any file permission issues
+Return: Git state and any file issues
+```
+
+### Step 3: Present Findings
+
+Based on the investigation, present a focused debug report:
+
+```markdown
+## Debug Report
+
+### What's Wrong
+[Clear statement of the issue based on evidence]
+
+### Evidence Found
+
+**From Logs** (`~/.humanlayer/logs/`):
+- [Error/warning with timestamp]
+- [Pattern or repeated issue]
+
+**From Database**:
+```sql
+-- Relevant query and result
+[Finding from database]
+```
+
+**From Git/Files**:
+- [Recent changes that might be related]
+- [File state issues]
+
+### Root Cause
+[Most likely explanation based on evidence]
+
+### Next Steps
+
+1. **Try This First**:
+   ```bash
+   [Specific command or action]
+   ```
+
+2. **If That Doesn't Work**:
+   - Restart services: `make daemon` and `make wui`
+   - Check browser console for WUI errors
+   - Run with debug: `HUMANLAYER_DEBUG=true make daemon`
+
+### Can't Access?
+Some issues might be outside my reach:
+- Browser console errors (F12 in browser)
+- MCP server internal state
+- System-level issues
+
+Would you like me to investigate something specific further?
+```
+
+## Important Notes
+
+- **Focus on manual testing scenarios** - This is for debugging during implementation
+- **Always require problem description** - Can't debug without knowing what's wrong
+- **Read files completely** - No limit/offset when reading context
+- **Think like `commit` or `describe_pr`** - Understand git state and changes
+- **Guide back to user** - Some issues (browser console, MCP internals) are outside reach
+- **No file editing** - Pure investigation only
+
+## Quick Reference
+
+**Find Latest Logs**:
+```bash
+ls -t ~/.humanlayer/logs/daemon-*.log | head -1
+ls -t ~/.humanlayer/logs/wui-*.log | head -1
+```
+
+**Database Queries**:
+```bash
+sqlite3 ~/.humanlayer/daemon.db ".tables"
+sqlite3 ~/.humanlayer/daemon.db ".schema sessions"
+sqlite3 ~/.humanlayer/daemon.db "SELECT * FROM sessions ORDER BY created_at DESC LIMIT 5;"
+```
+
+**Service Check**:
+```bash
+ps aux | grep hld     # Is daemon running?
+ps aux | grep wui     # Is WUI running?
+```
+
+**Git State**:
+```bash
+git status
+git log --oneline -10
+git diff
+```
+
+Remember: This command helps you investigate without burning the primary window's context. Perfect for when you hit an issue during manual testing and need to dig into logs, database, or git state.

.claude/commands/describe_pr.md

@@ -0,0 +1,71 @@
+# Generate PR Description
+
+You are tasked with generating a comprehensive pull request description following the repository's standard template.
+
+## Steps to follow:
+
+1. **Read the PR description template:**
+   - First, check if `thoughts/shared/pr_description.md` exists
+   - If it doesn't exist, inform the user that their `humanlayer thoughts` setup is incomplete and they need to create a PR description template at `thoughts/shared/pr_description.md`
+   - Read the template carefully to understand all sections and requirements
+
+2. **Identify the PR to describe:**
+   - Check if the current branch has an associated PR: `gh pr view --json url,number,title,state 2>/dev/null`
+   - If no PR exists for the current branch, or if on main/master, list open PRs: `gh pr list --limit 10 --json number,title,headRefName,author`
+   - Ask the user which PR they want to describe
+
+3. **Check for existing description:**
+   - Check if `thoughts/shared/prs/{number}_description.md` already exists
+   - If it exists, read it and inform the user you'll be updating it
+   - Consider what has changed since the last description was written
+
+4. **Gather comprehensive PR information:**
+   - Get the full PR diff: `gh pr diff {number}`
+   - If you get an error about no default remote repository, instruct the user to run `gh repo set-default` and select the appropriate repository
+   - Get commit history: `gh pr view {number} --json commits`
+   - Review the base branch: `gh pr view {number} --json baseRefName`
+   - Get PR metadata: `gh pr view {number} --json url,title,number,state`
+
+5. **Analyze the changes thoroughly:** (ultrathink about the code changes, their architectural implications, and potential impacts)
+   - Read through the entire diff carefully
+   - For context, read any files that are referenced but not shown in the diff
+   - Understand the purpose and impact of each change
+   - Identify user-facing changes vs internal implementation details
+   - Look for breaking changes or migration requirements
+
+6. **Handle verification requirements:**
+   - Look for any checklist items in the "How to verify it" section of the template
+   - For each verification step:
+     - If it's a command you can run (like `make check test`, `npm test`, etc.), run it
+     - If it passes, mark the checkbox as checked: `- [x]`
+     - If it fails, keep it unchecked and note what failed: `- [ ]` with explanation
+     - If it requires manual testing (UI interactions, external services), leave unchecked and note for user
+   - Document any verification steps you couldn't complete
+
+7. **Generate the description:**
+   - Fill out each section from the template thoroughly:
+     - Answer each question/section based on your analysis
+     - Be specific about problems solved and changes made
+     - Focus on user impact where relevant
+     - Include technical details in appropriate sections
+     - Write a concise changelog entry
+   - Ensure all checklist items are addressed (checked or explained)
+
+8. **Save and sync the description:**
+   - Write the completed description to `thoughts/shared/prs/{number}_description.md`
+   - Run `humanlayer thoughts sync` to sync the thoughts directory
+   - Show the user the generated description
+
+9. **Update the PR:**
+   - Update the PR description directly: `gh pr edit {number} --body-file thoughts/shared/prs/{number}_description.md`
+   - Confirm the update was successful
+   - If any verification steps remain unchecked, remind the user to complete them before merging
+
+## Important notes:
+- This command works across different repositories - always read the local template
+- Be thorough but concise - descriptions should be scannable
+- Focus on the "why" as much as the "what"
+- Include any breaking changes or migration notes prominently
+- If the PR touches multiple components, organize the description accordingly
+- Always attempt to run verification commands when possible
+- Clearly communicate which verification steps need manual testing

.claude/commands/implement_plan.md

@@ -0,0 +1,65 @@
+# Implement Plan
+
+You are tasked with implementing an approved technical plan from `thoughts/shared/plans/`. These plans contain phases with specific changes and success criteria.
+
+## Getting Started
+
+When given a plan path:
+- Read the plan completely and check for any existing checkmarks (- [x])
+- Read the original ticket and all files mentioned in the plan
+- **Read files fully** - never use limit/offset parameters, you need complete context
+- Think deeply about how the pieces fit together
+- Create a todo list to track your progress
+- Start implementing if you understand what needs to be done
+
+If no plan path provided, ask for one.
+
+## Implementation Philosophy
+
+Plans are carefully designed, but reality can be messy. Your job is to:
+- Follow the plan's intent while adapting to what you find
+- Implement each phase fully before moving to the next
+- Verify your work makes sense in the broader codebase context
+- Update checkboxes in the plan as you complete sections
+
+When things don't match the plan exactly, think about why and communicate clearly. The plan is your guide, but your judgment matters too.
+
+If you encounter a mismatch:
+- STOP and think deeply about why the plan can't be followed
+- Present the issue clearly:
+  ```
+  Issue in Phase [N]:
+  Expected: [what the plan says]
+  Found: [actual situation]
+  Why this matters: [explanation]
+
+  How should I proceed?
+  ```
+
+## Verification Approach
+
+After implementing a phase:
+- Run the success criteria checks (usually `cargo test -p [crate_name]` covers everything)
+- Fix any issues before proceeding
+- Update your progress in both the plan and your todos
+- Check off completed items in the plan file itself using Edit
+
+Don't let verification interrupt your flow - batch it at natural stopping points.
+
+## If You Get Stuck
+
+When something isn't working as expected:
+- First, make sure you've read and understood all the relevant code
+- Consider if the codebase has evolved since the plan was written
+- Present the mismatch clearly and ask for guidance
+
+Use sub-tasks sparingly - mainly for targeted debugging or exploring unfamiliar territory.
+
+## Resuming Work
+
+If the plan has existing checkmarks:
+- Trust that completed work is done
+- Pick up from the first unchecked item
+- Verify previous work only if something seems off
+
+Remember: You're implementing a solution, not just checking boxes. Keep the end goal in mind and maintain forward momentum.

.claude/commands/local_review.md

@@ -0,0 +1,44 @@
+# Local Review
+
+You are tasked with setting up a local review environment for a colleague's branch. This involves creating a worktree, setting up dependencies, and launching a new Claude Code session.
+
+## Process
+
+When invoked with a parameter like `gh_username:branchName`:
+
+1. **Parse the input**:
+   - Extract GitHub username and branch name from the format `username:branchname`
+   - If no parameter provided, ask for it in the format: `gh_username:branchName`
+
+2. **Extract ticket information**:
+   - Look for ticket numbers in the branch name (e.g., `eng-1696`, `ENG-1696`)
+   - Use this to create a short worktree directory name
+   - If no ticket found, use a sanitized version of the branch name
+
+3. **Set up the remote and worktree**:
+   - Check if the remote already exists using `git remote -v`
+   - If not, add it: `git remote add USERNAME git@github.com:USERNAME/humanlayer`
+   - Fetch from the remote: `git fetch USERNAME`
+   - Create worktree: `git worktree add -b BRANCHNAME ~/wt/humanlayer/SHORT_NAME USERNAME/BRANCHNAME`
+
+4. **Configure the worktree**:
+   - Copy Claude settings: `cp .claude/settings.local.json WORKTREE/.claude/`
+   - Run setup: `make -C WORKTREE setup`
+   - Initialize thoughts: `cd WORKTREE && npx humanlayer thoughts init --directory humanlayer`
+
+## Error Handling
+
+- If worktree already exists, inform the user they need to remove it first
+- If remote fetch fails, check if the username/repo exists
+- If setup fails, provide the error but continue with the launch
+
+## Example Usage
+
+```
+/local_review samdickson22:sam/eng-1696-hotkey-for-yolo-mode
+```
+
+This will:
+- Add 'samdickson22' as a remote
+- Create worktree at `~/wt/humanlayer/eng-1696`
+- Set up the environment

.claude/commands/ralph_impl.md

@@ -0,0 +1,28 @@
+## PART I - IF A TICKET IS MENTIONED
+
+0c. use `linear` cli to fetch the selected item into thoughts with the ticket number - ./thoughts/shared/tickets/ENG-xxxx.md
+0d. read the ticket and all comments to understand the implementation plan and any concerns
+
+## PART I - IF NO TICKET IS MENTIOND
+
+0.  read .claude/commands/linear.md
+0a. fetch the top 10 priority items from linear in status "ready for dev" using the MCP tools, noting all items in the `links` section
+0b. select the highest priority SMALL or XS issue from the list (if no SMALL or XS issues exist, EXIT IMMEDIATELY and inform the user)
+0c. use `linear` cli to fetch the selected item into thoughts with the ticket number - ./thoughts/shared/tickets/ENG-xxxx.md
+0d. read the ticket and all comments to understand the implementation plan and any concerns
+
+## PART II - NEXT STEPS
+
+think deeply
+
+1. move the item to "in dev" using the MCP tools
+1a. identify the linked implementation plan document from the `links` section
+1b. if no plan exists, move the ticket back to "ready for spec" and EXIT with an explanation
+
+think deeply about the implementation
+
+2. set up worktree for implementation:
+2a. read `hack/create_worktree.sh` and create a new worktree with the Linear branch name: `./hack/create_worktree.sh ENG-XXXX BRANCH_NAME`
+2b. launch implementation session: `npx humanlayer launch --model opus -w ~/wt/humanlayer/ENG-XXXX "/implement_plan and when you are done implementing and all tests pass, read ./claude/commands/commit.md and create a commit, then read ./claude/commands/describe_pr.md and create a PR, then add a comment to the Linear ticket with the PR link"`
+
+think deeply, use TodoWrite to track your tasks. When fetching from linear, get the top 10 items by priority but only work on ONE item - specifically the highest priority SMALL or XS sized issue.

.claude/commands/ralph_plan.md

@@ -0,0 +1,30 @@
+## PART I - IF A TICKET IS MENTIONED
+
+0c. use `linear` cli to fetch the selected item into thoughts with the ticket number - ./thoughts/shared/tickets/ENG-xxxx.md
+0d. read the ticket and all comments to learn about past implementations and research, and any questions or concerns about them
+
+
+### PART I - IF NO TICKET IS MENTIONED
+
+0.  read .claude/commands/linear.md
+0a. fetch the top 10 priority items from linear in status "ready for spec" using the MCP tools, noting all items in the `links` section
+0b. select the highest priority SMALL or XS issue from the list (if no SMALL or XS issues exist, EXIT IMMEDIATELY and inform the user)
+0c. use `linear` cli to fetch the selected item into thoughts with the ticket number - ./thoughts/shared/tickets/ENG-xxxx.md
+0d. read the ticket and all comments to learn about past implementations and research, and any questions or concerns about them
+
+### PART II - NEXT STEPS
+
+think deeply
+
+1. move the item to "plan in progress" using the MCP tools
+1a. read ./claude/commands/create_plan.md
+1b. determine if the item has a linked implementation plan document based on the `links` section
+1d. if the plan exists, you're done, respond with a link to the ticket
+1e. if the research is insufficient or has unaswered questions, create a new plan document following the instructions in ./claude/commands/create_plan.md
+
+think deeply
+
+2. when the plan is complete, `humanlayer thoughts sync` and attach the doc to the ticket using the MCP tools and create a terse comment with a link to it (re-read .claude/commands/linear.md if needed)
+2a. move the item to "plan in review" using the MCP tools
+
+think deeply, use TodoWrite to track your tasks. When fetching from linear, get the top 10 items by priority but only work on ONE item - specifically the highest priority SMALL or XS sized issue.

.claude/commands/ralph_research.md

@@ -0,0 +1,46 @@
+## PART I - IF A LINEAR TICKET IS MENTIONED
+
+0c. use `linear` cli to fetch the selected item into thoughts with the ticket number - ./thoughts/shared/tickets/ENG-xxxx.md
+0d. read the ticket and all comments to understand what research is needed and any previous attempts
+
+## PART I - IF NO TICKET IS MENTIONED
+
+0.  read .claude/commands/linear.md
+0a. fetch the top 10 priority items from linear in status "research needed" using the MCP tools, noting all items in the `links` section
+0b. select the highest priority SMALL or XS issue from the list (if no SMALL or XS issues exist, EXIT IMMEDIATELY and inform the user)
+0c. use `linear` cli to fetch the selected item into thoughts with the ticket number - ./thoughts/shared/tickets/ENG-xxxx.md
+0d. read the ticket and all comments to understand what research is needed and any previous attempts
+
+## PART II - NEXT STEPS
+
+think deeply
+
+1. move the item to "research in progress" using the MCP tools
+1a. read any linked documents in the `links` section to understand context
+1b. if insufficient information to conduct research, add a comment asking for clarification and move back to "research needed"
+
+think deeply about the research needs
+
+2. conduct the research:
+2a. read .claude/commands/research_codebase.md for guidance on effective codebase research
+2b. if the linear comments suggest web research is needed, use WebSearch to research external solutions, APIs, or best practices
+2c. search the codebase for relevant implementations and patterns
+2d. examine existing similar features or related code
+2e. identify technical constraints and opportunities
+2f. Be unbiased - don't think too much about an ideal implementation plan, just document all related files and how the systems work today
+2g. document findings in a new thoughts document: `thoughts/shared/research/ENG-XXXX_research.md`
+
+think deeply about the findings
+
+3. synthesize research into actionable insights:
+3a. summarize key findings and technical decisions
+3b. identify potential implementation approaches
+3c. note any risks or concerns discovered
+3d. run `humanlayer thoughts sync` to save the research
+
+4. update the ticket:
+4a. attach the research document to the ticket using the MCP tools with proper link formatting
+4b. add a comment summarizing the research outcomes
+4c. move the item to "research in review" using the MCP tools
+
+think deeply, use TodoWrite to track your tasks. When fetching from linear, get the top 10 items by priority but only work on ONE item - specifically the highest priority issue.

.claude/commands/research_codebase.md

@@ -0,0 +1,172 @@
+# Research Codebase
+
+You are tasked with conducting comprehensive research across the codebase to answer user questions by spawning parallel sub-agents and synthesizing their findings.
+
+## Initial Setup:
+
+When this command is invoked, respond with:
+
+```
+I'm ready to research the codebase. Please provide your research question or area of interest, and I'll analyze it thoroughly by exploring relevant components and connections.
+```
+
+Then wait for the user's research query.
+
+## Steps to follow after receiving the research query:
+
+1. **Read any directly mentioned files first:**
+   - If the user mentions specific files (crates, docs, JSON), read them FULLY first
+   - **IMPORTANT**: Use the Read tool WITHOUT limit/offset parameters to read entire files
+   - **CRITICAL**: Read these files yourself in the main context before spawning any sub-tasks
+   - This ensures you have full context before decomposing the research
+
+2. **Analyze and decompose the research question:**
+   - Break down the user's query into composable research areas
+   - Take time to ultrathink about the underlying patterns, connections, and architectural implications the user might be seeking
+   - Identify specific components, patterns, or concepts to investigate
+   - Create a research plan using TodoWrite to track all subtasks
+   - Consider which directories, files, or architectural patterns are relevant
+
+3. **Spawn parallel sub-agent tasks for comprehensive research:**
+   - Create multiple Task agents to research different aspects concurrently
+   - We now have specialized agents that know how to do specific research tasks:
+
+   **For codebase research:**
+   - Use the **codebase-locator** agent to find WHERE files and components live
+   - Use the **codebase-analyzer** agent to understand HOW specific code works
+
+   The key is to use these agents intelligently:
+   - Start with locator agents to find what exists
+   - Then use analyzer agents on the most promising findings
+   - Run multiple agents in parallel when they're searching for different things
+   - Each agent knows its job - just tell it what you're looking for
+   - Don't write detailed prompts about HOW to search - the agents already know
+
+4. **Wait for all sub-agents to complete and synthesize findings:**
+   - IMPORTANT: Wait for ALL sub-agent tasks to complete before proceeding
+   - Compile all sub-agent results (both codebase and thoughts findings)
+   - Prioritize live codebase findings as primary source of truth
+   - Use thoughts/ findings as supplementary historical context
+   - Connect findings across different components
+   - Include specific file paths and line numbers for reference
+   - Verify all thoughts/ paths are correct (e.g., thoughts/allison/ not thoughts/shared/ for personal files)
+   - Highlight patterns, connections, and architectural decisions
+   - Answer the user's specific questions with concrete evidence
+
+5. **Gather metadata for the research document:**
+   - Run the `zed/script/spec_metadata.sh` script to generate all relevant metadata
+   - Filename: `thoughts/shared/research/YYYY-MM-DD_HH-MM-SS_topic.md`
+
+6. **Generate research document:**
+   - Use the metadata gathered in step 4
+   - Structure the document with YAML frontmatter followed by content:
+
+     ```markdown
+     ---
+     date: [Current date and time with timezone in ISO format]
+     researcher: [Researcher name from thoughts status]
+     git_commit: [Current commit hash]
+     branch: [Current branch name]
+     repository: [Repository name]
+     topic: "[User's Question/Topic]"
+     tags: [research, codebase, relevant-component-names]
+     status: complete
+     last_updated: [Current date in YYYY-MM-DD format]
+     last_updated_by: [Researcher name]
+     ---
+
+     # Research: [User's Question/Topic]
+
+     **Date**: [Current date and time with timezone from step 4]
+     **Researcher**: [Researcher name from thoughts status]
+     **Git Commit**: [Current commit hash from step 4]
+     **Branch**: [Current branch name from step 4]
+     **Repository**: [Repository name]
+
+     ## Research Question
+
+     [Original user query]
+
+     ## Summary
+
+     [High-level findings answering the user's question]
+
+     ## Detailed Findings
+
+     ### [Component/Area 1]
+
+     - Finding with reference ([file.ext:line](link))
+     - Connection to other components
+     - Implementation details
+
+     ### [Component/Area 2]
+
+     ...
+
+     ## Code References
+
+     - `path/to/file.py:123` - Description of what's there
+     - `another/file.ts:45-67` - Description of the code block
+
+     ## Architecture Insights
+
+     [Patterns, conventions, and design decisions discovered]
+
+     ## Historical Context (from thoughts/)
+
+     [Relevant insights from thoughts/ directory with references]
+
+     - `thoughts/shared/something.md` - Historical decision about X
+     - `thoughts/local/notes.md` - Past exploration of Y
+       Note: Paths exclude "searchable/" even if found there
+
+     ## Related Research
+
+     [Links to other research documents in thoughts/shared/research/]
+
+     ## Open Questions
+
+     [Any areas that need further investigation]
+     ```
+
+7. **Add GitHub permalinks (if applicable):**
+   - Check if on main branch or if commit is pushed: `git branch --show-current` and `git status`
+   - If on main/master or pushed, generate GitHub permalinks:
+     - Get repo info: `gh repo view --json owner,name`
+     - Create permalinks: `https://github.com/{owner}/{repo}/blob/{commit}/{file}#L{line}`
+   - Replace local file references with permalinks in the document
+
+8. **Handle follow-up questions:**
+   - If the user has follow-up questions, append to the same research document
+   - Update the frontmatter fields `last_updated` and `last_updated_by` to reflect the update
+   - Add `last_updated_note: "Added follow-up research for [brief description]"` to frontmatter
+   - Add a new section: `## Follow-up Research [timestamp]`
+   - Spawn new sub-agents as needed for additional investigation
+   - Continue updating the document and syncing
+
+## Important notes:
+
+- Always use parallel Task agents to maximize efficiency and minimize context usage
+- Always run fresh codebase research - never rely solely on existing research documents
+- The thoughts/ directory provides historical context to supplement live findings
+- Focus on finding concrete file paths and line numbers for developer reference
+- Research documents should be self-contained with all necessary context
+- Each sub-agent prompt should be specific and focused on read-only operations
+- Consider cross-component connections and architectural patterns
+- Include temporal context (when the research was conducted)
+- Link to GitHub when possible for permanent references
+- Keep the main agent focused on synthesis, not deep file reading
+- Encourage sub-agents to find examples and usage patterns, not just definitions
+- Explore all of thoughts/ directory, not just research subdirectory
+- **File reading**: Always read mentioned files FULLY (no limit/offset) before spawning sub-tasks
+- **Critical ordering**: Follow the numbered steps exactly
+  - ALWAYS read mentioned files first before spawning sub-tasks (step 1)
+  - ALWAYS wait for all sub-agents to complete before synthesizing (step 4)
+  - ALWAYS gather metadata before writing the document (step 5 before step 6)
+  - NEVER write the research document with placeholder values
+- **Frontmatter consistency**:
+  - Always include frontmatter at the beginning of research documents
+  - Keep frontmatter fields consistent across all research documents
+  - Update frontmatter when adding follow-up research
+  - Use snake_case for multi-word field names (e.g., `last_updated`, `git_commit`)
+  - Tags should be relevant to the research topic and components studied

.claude/commands/validate_plan.md

@@ -0,0 +1,162 @@
+# Validate Plan
+
+You are tasked with validating that an implementation plan was correctly executed, verifying all success criteria and identifying any deviations or issues.
+
+## Initial Setup
+
+When invoked:
+1. **Determine context** - Are you in an existing conversation or starting fresh?
+   - If existing: Review what was implemented in this session
+   - If fresh: Need to discover what was done through git and codebase analysis
+
+2. **Locate the plan**:
+   - If plan path provided, use it
+   - Otherwise, search recent commits for plan references or ask user
+
+3. **Gather implementation evidence**:
+   ```bash
+   # Check recent commits
+   git log --oneline -n 20
+   git diff HEAD~N..HEAD  # Where N covers implementation commits
+
+   # Run comprehensive checks
+   cd $(git rev-parse --show-toplevel) && make check test
+   ```
+
+## Validation Process
+
+### Step 1: Context Discovery
+
+If starting fresh or need more context:
+
+1. **Read the implementation plan** completely
+2. **Identify what should have changed**:
+   - List all files that should be modified
+   - Note all success criteria (automated and manual)
+   - Identify key functionality to verify
+
+3. **Spawn parallel research tasks** to discover implementation:
+   ```
+   Task 1 - Verify database changes:
+   Research if migration [N] was added and schema changes match plan.
+   Check: migration files, schema version, table structure
+   Return: What was implemented vs what plan specified
+
+   Task 2 - Verify code changes:
+   Find all modified files related to [feature].
+   Compare actual changes to plan specifications.
+   Return: File-by-file comparison of planned vs actual
+
+   Task 3 - Verify test coverage:
+   Check if tests were added/modified as specified.
+   Run test commands and capture results.
+   Return: Test status and any missing coverage
+   ```
+
+### Step 2: Systematic Validation
+
+For each phase in the plan:
+
+1. **Check completion status**:
+   - Look for checkmarks in the plan (- [x])
+   - Verify the actual code matches claimed completion
+
+2. **Run automated verification**:
+   - Execute each command from "Automated Verification"
+   - Document pass/fail status
+   - If failures, investigate root cause
+
+3. **Assess manual criteria**:
+   - List what needs manual testing
+   - Provide clear steps for user verification
+
+4. **Think deeply about edge cases**:
+   - Were error conditions handled?
+   - Are there missing validations?
+   - Could the implementation break existing functionality?
+
+### Step 3: Generate Validation Report
+
+Create comprehensive validation summary:
+
+```markdown
+## Validation Report: [Plan Name]
+
+### Implementation Status
+✓ Phase 1: [Name] - Fully implemented
+✓ Phase 2: [Name] - Fully implemented
+⚠️ Phase 3: [Name] - Partially implemented (see issues)
+
+### Automated Verification Results
+✓ Build passes: `make build`
+✓ Tests pass: `make test`
+✗ Linting issues: `make lint` (3 warnings)
+
+### Code Review Findings
+
+#### Matches Plan:
+- Database migration correctly adds [table]
+- API endpoints implement specified methods
+- Error handling follows plan
+
+#### Deviations from Plan:
+- Used different variable names in [file:line]
+- Added extra validation in [file:line] (improvement)
+
+#### Potential Issues:
+- Missing index on foreign key could impact performance
+- No rollback handling in migration
+
+### Manual Testing Required:
+1. UI functionality:
+   - [ ] Verify [feature] appears correctly
+   - [ ] Test error states with invalid input
+
+2. Integration:
+   - [ ] Confirm works with existing [component]
+   - [ ] Check performance with large datasets
+
+### Recommendations:
+- Address linting warnings before merge
+- Consider adding integration test for [scenario]
+- Document new API endpoints
+```
+
+## Working with Existing Context
+
+If you were part of the implementation:
+- Review the conversation history
+- Check your todo list for what was completed
+- Focus validation on work done in this session
+- Be honest about any shortcuts or incomplete items
+
+## Important Guidelines
+
+1. **Be thorough but practical** - Focus on what matters
+2. **Run all automated checks** - Don't skip verification commands
+3. **Document everything** - Both successes and issues
+4. **Think critically** - Question if the implementation truly solves the problem
+5. **Consider maintenance** - Will this be maintainable long-term?
+
+## Validation Checklist
+
+Always verify:
+- [ ] All phases marked complete are actually done
+- [ ] Automated tests pass
+- [ ] Code follows existing patterns
+- [ ] No regressions introduced
+- [ ] Error handling is robust
+- [ ] Documentation updated if needed
+- [ ] Manual test steps are clear
+
+## Relationship to Other Commands
+
+Recommended workflow:
+1. `/implement_plan` - Execute the implementation
+2. `/commit` - Create atomic commits for changes
+3. `/validate_plan` - Verify implementation correctness
+4. `/describe_pr` - Generate PR description
+
+The validation works best after commits are made, as it can analyze the git history to understand what was implemented.
+
+Remember: Good validation catches issues before they reach production. Be constructive but thorough in identifying gaps or improvements.

.claude/settings.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      // "Bash(./hack/spec_metadata.sh)",
+      // "Bash(hack/spec_metadata.sh)",
+      // "Bash(bash hack/spec_metadata.sh)"
+    ]
+  },
+  "enableAllProjectMcpServers": false
+}

.claude/settings.local.json

@@ -0,0 +1,31 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(/Users/mikaylamaki/projects/zed-work/zed-monorepo-real/**)",
+      "Read(/Users/nathan/src/agent-client-protocol/rust/**)",
+      "Read(/Users/nathan/src/agent-client-protocol/rust/**)",
+      "Read(/Users/nathan/src/agent-client-protocol/rust/**)",
+      "Read(/Users/nathan/src/agent-client-protocol/rust/**)",
+      "Bash(git add:*)",
+      "Read(/Users/nathan/src/agent-client-protocol/rust/**)",
+      "Bash(./script/spec_metadata.sh:*)",
+      "Bash(npm run generate:*)",
+      "Bash(npm run typecheck:*)",
+      "Bash(npm run:*)",
+      "Bash(npm install)",
+      "Bash(grep:*)",
+      "Bash(find:*)",
+      "Bash(node:*)",
+      "Bash(cargo check:*)",
+      "Bash(cargo test)",
+      "Bash(npx tsc:*)"
+    ],
+    "additionalDirectories": [
+      "/Users/mikaylamaki/projects/zed-work/zed-monorepo-real/claude-code-acp/",
+      "/Users/mikaylamaki/projects/zed-work/zed-monorepo-real/agentic-coding-protocol/",
+      "/Users/nathan/src/agent",
+      "/Users/nathan/src/agent-client-protocol/",
+      "/Users/nathan/src/claude-code-acp"
+    ]
+  }
+}

.github/ISSUE_TEMPLATE/10_bug_report.yml

@@ -14,7 +14,7 @@ body:
         ### Description
         <!--  Describe with sufficient detail to reproduce from a clean Zed install.
           - Any code must be sufficient to reproduce (include context!)
-          - Code must as text, not just as a screenshot.
+          - Include code as text, not just as a screenshot.
           - Issues with insufficient detail may be summarily closed.
         -->
 

.github/actionlint.yml

@@ -19,14 +19,27 @@ self-hosted-runner:
     - namespace-profile-16x32-ubuntu-2004-arm
     - namespace-profile-32x64-ubuntu-2004-arm
     # Namespace Ubuntu 22.04 (Everything else)
-    - namespace-profile-2x4-ubuntu-2204
     - namespace-profile-4x8-ubuntu-2204
     - namespace-profile-8x16-ubuntu-2204
     - namespace-profile-16x32-ubuntu-2204
     - namespace-profile-32x64-ubuntu-2204
+    # Namespace Ubuntu 24.04 (like ubuntu-latest)
+    - namespace-profile-2x4-ubuntu-2404
     # Namespace Limited Preview
     - namespace-profile-8x16-ubuntu-2004-arm-m4
     - namespace-profile-8x32-ubuntu-2004-arm-m4
     # Self Hosted Runners
     - self-mini-macos
     - self-32vcpu-windows-2022
+
+# Disable shellcheck because it doesn't like powershell
+# This should have been triggered with initial rollout of actionlint
+# but https://github.com/zed-industries/zed/pull/36693
+# somehow caused actionlint to actually check those windows jobs
+# where previously they were being skipped. Likely caused by an
+# unknown bug in actionlint where parsing of `runs-on: [ ]`
+# breaks something else. (yuck)
+paths:
+  .github/workflows/{ci,release_nightly}.yml:
+    ignore:
+      - "shellcheck"

.github/workflows/bump_collab_staging.yml

@@ -8,7 +8,7 @@ on:
 jobs:
   update-collab-staging-tag:
     if: github.repository_owner == 'zed-industries'
-    runs-on: ubuntu-latest
+    runs-on: namespace-profile-2x4-ubuntu-2404
     steps:
       - name: Checkout repository
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

.github/workflows/ci.yml

@@ -37,7 +37,7 @@ jobs:
       run_nix: ${{ steps.filter.outputs.run_nix }}
       run_actionlint: ${{ steps.filter.outputs.run_actionlint }}
     runs-on:
-      - ubuntu-latest
+      - namespace-profile-2x4-ubuntu-2404
     steps:
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -237,7 +237,7 @@ jobs:
         uses: ./.github/actions/build_docs
 
   actionlint:
-    runs-on: ubuntu-latest
+    runs-on: namespace-profile-2x4-ubuntu-2404
     if: github.repository_owner == 'zed-industries' && needs.job_spec.outputs.run_actionlint == 'true'
     needs: [job_spec]
     steps:
@@ -418,7 +418,7 @@ jobs:
     if: |
       github.repository_owner == 'zed-industries' &&
       needs.job_spec.outputs.run_tests == 'true'
-    runs-on: [self-hosted, Windows, X64]
+    runs-on: [self-32vcpu-windows-2022]
     steps:
       - name: Environment Setup
         run: |
@@ -458,7 +458,7 @@ jobs:
 
   tests_pass:
     name: Tests Pass
-    runs-on: ubuntu-latest
+    runs-on: namespace-profile-2x4-ubuntu-2404
     needs:
       - job_spec
       - style
@@ -784,7 +784,7 @@ jobs:
   bundle-windows-x64:
     timeout-minutes: 120
     name: Create a Windows installer
-    runs-on: [self-hosted, Windows, X64]
+    runs-on: [self-32vcpu-windows-2022]
     if: contains(github.event.pull_request.labels.*.name, 'run-bundling')
     # if: (startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling'))
     needs: [windows_tests]

.github/workflows/danger.yml

@@ -12,7 +12,7 @@ on:
 jobs:
   danger:
     if: github.repository_owner == 'zed-industries'
-    runs-on: ubuntu-latest
+    runs-on: namespace-profile-2x4-ubuntu-2404
 
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

.github/workflows/release_nightly.yml

@@ -59,7 +59,7 @@ jobs:
     timeout-minutes: 60
     name: Run tests on Windows
     if: github.repository_owner == 'zed-industries'
-    runs-on: [self-hosted, Windows, X64]
+    runs-on: [self-32vcpu-windows-2022]
     steps:
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -248,7 +248,7 @@ jobs:
     timeout-minutes: 60
     name: Create a Windows installer
     if: github.repository_owner == 'zed-industries'
-    runs-on: [self-hosted, Windows, X64]
+    runs-on: [self-32vcpu-windows-2022]
     needs: windows-tests
     env:
       AZURE_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
@@ -290,7 +290,7 @@ jobs:
   update-nightly-tag:
     name: Update nightly tag
     if: github.repository_owner == 'zed-industries'
-    runs-on: ubuntu-latest
+    runs-on: namespace-profile-2x4-ubuntu-2404
     needs:
       - bundle-mac
       - bundle-linux-x86

.github/workflows/script_checks.yml

@@ -12,7 +12,7 @@ jobs:
   shellcheck:
     name: "ShellCheck Scripts"
     if: github.repository_owner == 'zed-industries'
-    runs-on: ubuntu-latest
+    runs-on: namespace-profile-2x4-ubuntu-2404
 
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

Cargo.lock

@@ -39,6 +39,26 @@ dependencies = [
  "workspace-hack",
 ]
 
+[[package]]
+name = "acp_tools"
+version = "0.1.0"
+dependencies = [
+ "agent-client-protocol",
+ "collections",
+ "gpui",
+ "language",
+ "markdown",
+ "project",
+ "serde",
+ "serde_json",
+ "settings",
+ "theme",
+ "ui",
+ "util",
+ "workspace",
+ "workspace-hack",
+]
+
 [[package]]
 name = "action_log"
 version = "0.1.0"
@@ -171,11 +191,10 @@ dependencies = [
 
 [[package]]
 name = "agent-client-protocol"
-version = "0.0.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f792e009ba59b137ee1db560bc37e567887ad4b5af6f32181d381fff690e2d4"
+version = "0.2.0-alpha.0"
 dependencies = [
  "anyhow",
+ "async-broadcast",
  "futures 0.3.31",
  "log",
  "parking_lot",
@@ -244,6 +263,7 @@ dependencies = [
  "terminal",
  "text",
  "theme",
+ "thiserror 2.0.12",
  "tree-sitter-rust",
  "ui",
  "unindent",
@@ -263,10 +283,10 @@ name = "agent_servers"
 version = "0.1.0"
 dependencies = [
  "acp_thread",
+ "acp_tools",
  "action_log",
  "agent-client-protocol",
  "agent_settings",
- "agentic-coding-protocol",
  "anyhow",
  "client",
  "collections",
@@ -284,6 +304,7 @@ dependencies = [
  "libc",
  "log",
  "nix 0.29.0",
+ "node_runtime",
  "paths",
  "project",
  "rand 0.8.5",
@@ -381,6 +402,7 @@ dependencies = [
  "parking_lot",
  "paths",
  "picker",
+ "postage",
  "pretty_assertions",
  "project",
  "prompt_store",
@@ -420,24 +442,6 @@ dependencies = [
  "zed_actions",
 ]
 
-[[package]]
-name = "agentic-coding-protocol"
-version = "0.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e6ae951b36fa2f8d9dd6e1af6da2fcaba13d7c866cf6a9e65deda9dc6c5fe4"
-dependencies = [
- "anyhow",
- "chrono",
- "derive_more 2.0.1",
- "futures 0.3.31",
- "log",
- "parking_lot",
- "schemars",
- "semver",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "ahash"
 version = "0.7.8"
@@ -853,7 +857,7 @@ dependencies = [
  "anyhow",
  "async-trait",
  "collections",
- "derive_more 0.99.19",
+ "derive_more",
  "extension",
  "futures 0.3.31",
  "gpui",
@@ -916,7 +920,7 @@ dependencies = [
  "clock",
  "collections",
  "ctor",
- "derive_more 0.99.19",
+ "derive_more",
  "gpui",
  "icons",
  "indoc",
@@ -953,7 +957,7 @@ dependencies = [
  "cloud_llm_client",
  "collections",
  "component",
- "derive_more 0.99.19",
+ "derive_more",
  "diffy",
  "editor",
  "feature_flags",
@@ -3066,7 +3070,7 @@ dependencies = [
  "cocoa 0.26.0",
  "collections",
  "credentials_provider",
- "derive_more 0.99.19",
+ "derive_more",
  "feature_flags",
  "fs",
  "futures 0.3.31",
@@ -3498,7 +3502,7 @@ name = "command_palette_hooks"
 version = "0.1.0"
 dependencies = [
  "collections",
- "derive_more 0.99.19",
+ "derive_more",
  "gpui",
  "workspace-hack",
 ]
@@ -4049,6 +4053,7 @@ dependencies = [
 name = "crashes"
 version = "0.1.0"
 dependencies = [
+ "bincode",
  "crash-handler",
  "log",
  "mach2 0.5.0",
@@ -4058,6 +4063,7 @@ dependencies = [
  "serde",
  "serde_json",
  "smol",
+ "system_specs",
  "workspace-hack",
 ]
 
@@ -4659,27 +4665,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "derive_more"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.101",
- "unicode-xid",
-]
-
 [[package]]
 name = "derive_refineable"
 version = "0.1.0"
@@ -4700,7 +4685,6 @@ dependencies = [
  "component",
  "ctor",
  "editor",
- "futures 0.3.31",
  "gpui",
  "indoc",
  "language",
@@ -5737,14 +5721,10 @@ dependencies = [
 name = "feedback"
 version = "0.1.0"
 dependencies = [
- "client",
  "editor",
  "gpui",
- "human_bytes",
  "menu",
- "release_channel",
- "serde",
- "sysinfo",
+ "system_specs",
  "ui",
  "urlencoding",
  "util",
@@ -6420,7 +6400,7 @@ dependencies = [
  "askpass",
  "async-trait",
  "collections",
- "derive_more 0.99.19",
+ "derive_more",
  "futures 0.3.31",
  "git2",
  "gpui",
@@ -7450,7 +7430,7 @@ dependencies = [
  "core-video",
  "cosmic-text",
  "ctor",
- "derive_more 0.99.19",
+ "derive_more",
  "embed-resource",
  "env_logger 0.11.8",
  "etagere",
@@ -7538,6 +7518,7 @@ dependencies = [
 name = "gpui_tokio"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "gpui",
  "tokio",
  "util",
@@ -7974,7 +7955,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "bytes 1.10.1",
- "derive_more 0.99.19",
+ "derive_more",
  "futures 0.3.31",
  "http 1.3.1",
  "http-body 1.0.1",
@@ -8486,6 +8467,7 @@ dependencies = [
  "theme",
  "ui",
  "util",
+ "util_macros",
  "workspace",
  "workspace-hack",
  "zed_actions",
@@ -9230,6 +9212,7 @@ dependencies = [
  "language",
  "lsp",
  "project",
+ "proto",
  "release_channel",
  "serde_json",
  "settings",
@@ -11632,6 +11615,12 @@ dependencies = [
  "hmac",
 ]
 
+[[package]]
+name = "pciid-parser"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0008e816fcdaf229cdd540e9b6ca2dc4a10d65c31624abb546c6420a02846e61"
+
 [[package]]
 name = "pem"
 version = "3.0.5"
@@ -13532,6 +13521,7 @@ dependencies = [
  "smol",
  "sysinfo",
  "telemetry_events",
+ "thiserror 2.0.12",
  "toml 0.8.20",
  "unindent",
  "util",
@@ -14371,12 +14361,10 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe8c9d1c68d67dd9f97ecbc6f932b60eb289c5dbddd8aa1405484a8fd2fcd984"
 dependencies = [
- "chrono",
  "dyn-clone",
  "indexmap",
  "ref-cast",
  "schemars_derive",
- "semver",
  "serde",
  "serde_json",
 ]
@@ -16152,6 +16140,21 @@ dependencies = [
  "winx",
 ]
 
+[[package]]
+name = "system_specs"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client",
+ "gpui",
+ "human_bytes",
+ "pciid-parser",
+ "release_channel",
+ "serde",
+ "sysinfo",
+ "workspace-hack",
+]
+
 [[package]]
 name = "tab_switcher"
 version = "0.1.0"
@@ -16445,7 +16448,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "collections",
- "derive_more 0.99.19",
+ "derive_more",
  "fs",
  "futures 0.3.31",
  "gpui",
@@ -17182,8 +17185,7 @@ dependencies = [
 [[package]]
 name = "tree-sitter-cpp"
 version = "0.23.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df2196ea9d47b4ab4a31b9297eaa5a5d19a0b121dceb9f118f6790ad0ab94743"
+source = "git+https://github.com/tree-sitter/tree-sitter-cpp?rev=5cb9b693cfd7bfacab1d9ff4acac1a4150700609#5cb9b693cfd7bfacab1d9ff4acac1a4150700609"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -19786,7 +19788,6 @@ dependencies = [
  "any_vec",
  "anyhow",
  "async-recursion",
- "bincode",
  "call",
  "client",
  "clock",
@@ -19805,6 +19806,7 @@ dependencies = [
  "node_runtime",
  "parking_lot",
  "postage",
+ "pretty_assertions",
  "project",
  "remote",
  "schemars",
@@ -19960,7 +19962,6 @@ dependencies = [
  "rustix 1.0.7",
  "rustls 0.23.26",
  "rustls-webpki 0.103.1",
- "schemars",
  "scopeguard",
  "sea-orm",
  "sea-query-binder",
@@ -20394,8 +20395,9 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.202.0"
+version = "0.203.0"
 dependencies = [
+ "acp_tools",
  "activity_indicator",
  "agent",
  "agent_servers",
@@ -20411,6 +20413,7 @@ dependencies = [
  "auto_update",
  "auto_update_ui",
  "backtrace",
+ "bincode",
  "breadcrumbs",
  "call",
  "channel",
@@ -20509,6 +20512,7 @@ dependencies = [
  "supermaven",
  "svg_preview",
  "sysinfo",
+ "system_specs",
  "tab_switcher",
  "task",
  "tasks_ui",
@@ -20585,7 +20589,7 @@ dependencies = [
 
 [[package]]
 name = "zed_html"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
+    "crates/acp_tools",
     "crates/acp_thread",
     "crates/action_log",
     "crates/activity_indicator",
@@ -155,6 +156,7 @@ members = [
     "crates/streaming_diff",
     "crates/sum_tree",
     "crates/supermaven",
+    "crates/system_specs",
     "crates/supermaven_api",
     "crates/svg_preview",
     "crates/tab_switcher",
@@ -226,6 +228,7 @@ edition = "2024"
 # Workspace member crates
 #
 
+acp_tools = { path = "crates/acp_tools" }
 acp_thread = { path = "crates/acp_thread" }
 action_log = { path = "crates/action_log" }
 agent = { path = "crates/agent" }
@@ -381,6 +384,7 @@ streaming_diff = { path = "crates/streaming_diff" }
 sum_tree = { path = "crates/sum_tree" }
 supermaven = { path = "crates/supermaven" }
 supermaven_api = { path = "crates/supermaven_api" }
+system_specs = { path = "crates/system_specs" }
 tab_switcher = { path = "crates/tab_switcher" }
 task = { path = "crates/task" }
 tasks_ui = { path = "crates/tasks_ui" }
@@ -422,8 +426,7 @@ zlog_settings = { path = "crates/zlog_settings" }
 # External crates
 #
 
-agentic-coding-protocol = "0.0.10"
-agent-client-protocol = "0.0.30"
+agent-client-protocol = { path = "../agent-client-protocol" }
 aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" }
 any_vec = "0.14"
@@ -450,6 +453,7 @@ aws-sdk-bedrockruntime = { version = "1.80.0", features = [
 aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
 aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
 base64 = "0.22"
+bincode = "1.2.1"
 bitflags = "2.6.0"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
 blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
@@ -493,6 +497,7 @@ handlebars = "4.3"
 heck = "0.5"
 heed = { version = "0.21.0", features = ["read-txn-no-tls"] }
 hex = "0.4.3"
+human_bytes = "0.4.1"
 html5ever = "0.27.0"
 http = "1.1"
 http-body = "1.0"
@@ -532,6 +537,7 @@ palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
 partial-json-fixer = "0.5.3"
 parse_int = "0.9"
+pciid-parser = "0.8.0"
 pathdiff = "0.2"
 pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
 pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
@@ -618,7 +624,7 @@ tower-http = "0.4.4"
 tree-sitter = { version = "0.25.6", features = ["wasm"] }
 tree-sitter-bash = "0.25.0"
 tree-sitter-c = "0.23"
-tree-sitter-cpp = "0.23"
+tree-sitter-cpp = { git = "https://github.com/tree-sitter/tree-sitter-cpp", rev = "5cb9b693cfd7bfacab1d9ff4acac1a4150700609" }
 tree-sitter-css = "0.23"
 tree-sitter-diff = "0.1.0"
 tree-sitter-elixir = "0.3"

Procfile.web

@@ -0,0 +1,2 @@
+postgrest_llm: postgrest crates/collab/postgrest_llm.conf
+website: cd ../zed.dev; npm run dev -- --port=3000

assets/icons/attach.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.37288 4.48506L7.43539 10.6638C7.43539 10.9365 7.54373 11.1981 7.73655 11.3909C7.92938 11.5837 8.19092 11.6921 8.46362 11.6921C8.73632 11.6921 8.99785 11.5837 9.19068 11.3909C9.38351 11.1981 9.49184 10.9366 9.49184 10.6638L9.42933 4.48506C9.42933 3.93975 9.2127 3.41678 8.82711 3.03119C8.44152 2.6456 7.91855 2.42898 7.37324 2.42898C6.82794 2.42898 6.30496 2.6456 5.91937 3.03119C5.53378 3.41678 5.31716 3.93975 5.31716 4.48506L5.37968 10.6384C5.37636 11.0455 5.45368 11.4492 5.60718 11.8263C5.76067 12.2034 5.98731 12.5463 6.27401 12.8354C6.56071 13.1244 6.9018 13.3538 7.27761 13.5104C7.65341 13.667 8.0565 13.7476 8.46362 13.7476C8.87073 13.7476 9.27382 13.667 9.64963 13.5104C10.0254 13.3538 10.3665 13.1244 10.6532 12.8354C10.9399 12.5463 11.1666 12.2034 11.3201 11.8263C11.4736 11.4492 11.5509 11.0455 11.5476 10.6384L11.485 4.48506" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/copy.svg

@@ -1 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="none"><path stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.2" d="M12.286 6H7.048C6.469 6 6 6.469 6 7.048v5.238c0 .578.469 1.047 1.048 1.047h5.238c.578 0 1.047-.469 1.047-1.047V7.048c0-.579-.469-1.048-1.047-1.048Z"/><path stroke="#000" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.2" d="M3.714 10a1.05 1.05 0 0 1-1.047-1.048V3.714a1.05 1.05 0 0 1 1.047-1.047h5.238A1.05 1.05 0 0 1 10 3.714"/></svg>
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12.486 6.2H7.24795C6.66895 6.2 6.19995 6.669 6.19995 7.248V12.486C6.19995 13.064 6.66895 13.533 7.24795 13.533H12.486C13.064 13.533 13.533 13.064 13.533 12.486V7.248C13.533 6.669 13.064 6.2 12.486 6.2Z" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3.91712 10.203C3.63951 10.2022 3.37351 10.0915 3.1773 9.89511C2.98109 9.69872 2.87064 9.43261 2.87012 9.155V3.917C2.87091 3.63956 2.98147 3.37371 3.17765 3.17753C3.37383 2.98135 3.63968 2.87079 3.91712 2.87H9.15512C9.43273 2.87053 9.69883 2.98097 9.89523 3.17718C10.0916 3.37339 10.2023 3.63939 10.2031 3.917" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/list_filter.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-list-filter-icon lucide-list-filter"><path d="M3 6h18"/><path d="M7 12h10"/><path d="M10 18h4"/></svg>

assets/icons/pencil_unavailable.svg

@@ -0,0 +1,6 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8.5 5.50621L10.5941 3.41227C10.8585 3.14798 11.217 2.99953 11.5908 2.99957C11.9646 2.99962 12.3231 3.14816 12.5874 3.41252C12.8517 3.67688 13.0001 4.03541 13.0001 4.40922C13.0001 4.78304 12.8515 5.14152 12.5872 5.40582L10.493 7.5" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5.50789 8.5L3.92098 10.0869C3.80488 10.2027 3.71903 10.3452 3.67097 10.5019L3.01047 12.678C2.99754 12.7212 2.99657 12.7672 3.00764 12.8109C3.01872 12.8547 3.04143 12.8946 3.07337 12.9265C3.1053 12.9584 3.14528 12.981 3.18905 12.992C3.23282 13.003 3.27875 13.002 3.32197 12.989L5.49849 12.329C5.65508 12.2813 5.79758 12.196 5.91349 12.0805L7.49184 10.5019" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M9 5L11 7" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3 3L13 13" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/terminal_ghost.svg

@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8 12.375H13" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3 11.125L6.75003 7.375L3 3.62497" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/tool_think.svg

@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M9.95231 10.2159C10.0803 9.58974 9.95231 9.57261 10.9111 8.46959C11.4686 7.82822 11.8699 7.09214 11.8699 6.27818C11.8699 5.28184 11.4658 4.32631 10.7467 3.62179C10.0275 2.91728 9.05201 2.52148 8.03492 2.52148C7.01782 2.52148 6.04239 2.91728 5.32319 3.62179C4.604 4.32631 4.19995 5.28184 4.19995 6.27818C4.19995 6.9043 4.32779 7.65565 5.1587 8.46959C6.11744 9.59098 5.98965 9.58974 6.11748 10.2159M9.95231 10.2159V12.2989C9.95231 12.9504 9.41327 13.4786 8.7482 13.4786H7.32165C6.65658 13.4786 6.11744 12.9504 6.11744 12.2989L6.11748 10.2159M9.95231 10.2159H8.03492H6.11748" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M9.9526 10.2625C10.0833 9.62316 9.9526 9.60566 10.9315 8.47946C11.5008 7.82461 11.9105 7.07306 11.9105 6.242C11.9105 5.22472 11.4979 4.2491 10.7637 3.52978C10.0294 2.81046 9.03338 2.40634 7.99491 2.40634C6.95644 2.40634 5.96051 2.81046 5.22619 3.52978C4.49189 4.2491 4.07935 5.22472 4.07935 6.242C4.07935 6.88128 4.20987 7.64842 5.05825 8.47946C6.03714 9.62442 5.90666 9.62316 6.03718 10.2625M9.9526 10.2625V12.3893C9.9526 13.0544 9.40223 13.5937 8.72319 13.5937H7.26665C6.58761 13.5937 6.03714 13.0544 6.03714 12.3893L6.03718 10.2625M9.9526 10.2625H7.99491H6.03718" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>

assets/images/acp_logo.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="160" height="61" fill="none"><g clip-path="url(#a)"><path fill="#000" d="M130.75.385c5.428 0 10.297 2.81 13.011 7.511l14.214 24.618-.013-.005c2.599 4.504 2.707 9.932.28 14.513-2.618 4.944-7.862 8.015-13.679 8.015h-31.811c-.452 0-.873-.242-1.103-.637a1.268 1.268 0 0 1 0-1.274l3.919-6.78c.223-.394.65-.636 1.102-.636h28.288a5.622 5.622 0 0 0 4.925-2.849 5.615 5.615 0 0 0 0-5.69l-14.214-24.617a5.621 5.621 0 0 0-4.925-2.848 5.621 5.621 0 0 0-4.925 2.848l-14.214 24.618a6.267 6.267 0 0 0-.319.643.998.998 0 0 1-.069.14L101.724 54.4l-.823 1.313-2.529 4.39a1.27 1.27 0 0 1-1.103.636h-7.83c-.452 0-.873-.242-1.102-.637-.23-.394-.23-.879 0-1.274l2.188-3.791H66.803c-3.32 0-6.454-1.122-8.818-3.167a17.141 17.141 0 0 1-3.394-3.96 1.261 1.261 0 0 1-.091-.137L34.2 12.573a5.622 5.622 0 0 0-4.925-2.849 5.621 5.621 0 0 0-4.924 2.85L10.137 37.19a5.615 5.615 0 0 0 0 5.69 5.63 5.63 0 0 0 4.925 2.841h29.862a1.276 1.276 0 0 1 1.102 1.912l-3.912 6.778a1.27 1.27 0 0 1-1.102.638H14.495c-3.32 0-6.454-1.128-8.817-3.173-5.906-5.104-7.36-12.883-3.62-19.363L16.267 7.89C18.872 3.385 23.517.583 28.697.39c.184-.006.356-.006.534-.006 5.378 0 10.45 3.007 13.246 7.85l12.986 22.372L68.58 7.891C71.186 3.385 75.83.582 81.01.39c.185-.006.358-.006.536-.006 4.453 0 8.71 2.039 11.672 5.588.337.407.388.98.127 1.446l-3.765 6.6a1.268 1.268 0 0 1-2.205.006l-.847-1.465a5.623 5.623 0 0 0-4.926-2.848 5.622 5.622 0 0 0-4.924 2.848L62.464 37.18a5.614 5.614 0 0 0 0 5.689 5.628 5.628 0 0 0 4.925 2.842H95.91L117.76 7.87c2.714-4.683 7.575-7.486 12.99-7.486Z"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 .385h160v60.36H0z"/></clipPath></defs></svg>

assets/keymaps/default-linux.json

@@ -16,7 +16,6 @@
       "up": "menu::SelectPrevious",
       "enter": "menu::Confirm",
       "ctrl-enter": "menu::SecondaryConfirm",
-      "ctrl-escape": "menu::Cancel",
       "ctrl-c": "menu::Cancel",
       "escape": "menu::Cancel",
       "alt-shift-enter": "menu::Restart",
@@ -41,7 +40,7 @@
       "shift-f11": "debugger::StepOut",
       "f11": "zed::ToggleFullScreen",
       "ctrl-alt-z": "edit_prediction::RateCompletions",
-      "ctrl-shift-i": "edit_prediction::ToggleMenu",
+      "ctrl-alt-shift-i": "edit_prediction::ToggleMenu",
       "ctrl-alt-l": "lsp_tool::ToggleMenu"
     }
   },
@@ -121,7 +120,7 @@
       "alt-g m": "git::OpenModifiedFiles",
       "menu": "editor::OpenContextMenu",
       "shift-f10": "editor::OpenContextMenu",
-      "ctrl-shift-e": "editor::ToggleEditPrediction",
+      "ctrl-alt-shift-e": "editor::ToggleEditPrediction",
       "f9": "editor::ToggleBreakpoint",
       "shift-f9": "editor::EditLogBreakpoint"
     }
@@ -131,8 +130,8 @@
     "bindings": {
       "shift-enter": "editor::Newline",
       "enter": "editor::Newline",
-      "ctrl-enter": "editor::NewlineAbove",
-      "ctrl-shift-enter": "editor::NewlineBelow",
+      "ctrl-enter": "editor::NewlineBelow",
+      "ctrl-shift-enter": "editor::NewlineAbove",
       "ctrl-k ctrl-z": "editor::ToggleSoftWrap",
       "ctrl-k z": "editor::ToggleSoftWrap",
       "find": "buffer_search::Deploy",
@@ -856,7 +855,7 @@
       "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
       "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-ctrl-r": "project_panel::RevealInFileManager",
-      "ctrl-shift-enter": "project_panel::OpenWithSystem",
+      "ctrl-shift-enter": "workspace::OpenWithSystem",
       "alt-d": "project_panel::CompareMarkedFiles",
       "shift-find": "project_panel::NewSearchInDirectory",
       "ctrl-alt-shift-f": "project_panel::NewSearchInDirectory",
@@ -1195,9 +1194,16 @@
       "ctrl-1": "onboarding::ActivateBasicsPage",
       "ctrl-2": "onboarding::ActivateEditingPage",
       "ctrl-3": "onboarding::ActivateAISetupPage",
-      "ctrl-escape": "onboarding::Finish",
-      "alt-tab": "onboarding::SignIn",
+      "ctrl-enter": "onboarding::Finish",
+      "alt-shift-l": "onboarding::SignIn",
       "alt-shift-a": "onboarding::OpenAccount"
     }
+  },
+  {
+    "context": "InvalidBuffer",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-shift-enter": "workspace::OpenWithSystem"
+    }
   }
 ]

assets/keymaps/default-macos.json

@@ -915,7 +915,7 @@
       "cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
       "cmd-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-cmd-r": "project_panel::RevealInFileManager",
-      "ctrl-shift-enter": "project_panel::OpenWithSystem",
+      "ctrl-shift-enter": "workspace::OpenWithSystem",
       "alt-d": "project_panel::CompareMarkedFiles",
       "cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
       "cmd-alt-shift-f": "project_panel::NewSearchInDirectory",
@@ -1301,5 +1301,12 @@
       "alt-tab": "onboarding::SignIn",
       "alt-shift-a": "onboarding::OpenAccount"
     }
+  },
+  {
+    "context": "InvalidBuffer",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-shift-enter": "workspace::OpenWithSystem"
+    }
   }
 ]

assets/keymaps/linux/emacs.json

@@ -38,6 +38,7 @@
       "alt-;": ["editor::ToggleComments", { "advance_downwards": false }],
       "ctrl-x ctrl-;": "editor::ToggleComments",
       "alt-.": "editor::GoToDefinition", // xref-find-definitions
+      "alt-?": "editor::FindAllReferences", // xref-find-references
       "alt-,": "pane::GoBack", // xref-pop-marker-stack
       "ctrl-x h": "editor::SelectAll", // mark-whole-buffer
       "ctrl-d": "editor::Delete", // delete-char

assets/keymaps/macos/emacs.json

@@ -38,6 +38,7 @@
       "alt-;": ["editor::ToggleComments", { "advance_downwards": false }],
       "ctrl-x ctrl-;": "editor::ToggleComments",
       "alt-.": "editor::GoToDefinition", // xref-find-definitions
+      "alt-?": "editor::FindAllReferences", // xref-find-references
       "alt-,": "pane::GoBack", // xref-pop-marker-stack
       "ctrl-x h": "editor::SelectAll", // mark-whole-buffer
       "ctrl-d": "editor::Delete", // delete-char

assets/keymaps/vim.json

@@ -428,12 +428,14 @@
       "g h": "vim::StartOfLine",
       "g s": "vim::FirstNonWhitespace", // "g s" default behavior is "space s"
       "g e": "vim::EndOfDocument",
+      "g .": "vim::HelixGotoLastModification", // go to last modification
       "g r": "editor::FindAllReferences", // zed specific
       "g t": "vim::WindowTop",
       "g c": "vim::WindowMiddle",
       "g b": "vim::WindowBottom",
 
-      "x": "editor::SelectLine",
+      "shift-r": "editor::Paste",
+      "x": "vim::HelixSelectLine",
       "shift-x": "editor::SelectLine",
       "%": "editor::SelectAll",
       // Window mode
@@ -819,7 +821,7 @@
       "v": "project_panel::OpenPermanent",
       "p": "project_panel::Open",
       "x": "project_panel::RevealInFileManager",
-      "s": "project_panel::OpenWithSystem",
+      "s": "workspace::OpenWithSystem",
       "z d": "project_panel::CompareMarkedFiles",
       "] c": "project_panel::SelectNextGitEntry",
       "[ c": "project_panel::SelectPrevGitEntry",

assets/settings/default.json

@@ -162,6 +162,12 @@
   //  2. Always quit the application
   //         "on_last_window_closed": "quit_app",
   "on_last_window_closed": "platform_default",
+  // Whether to show padding for zoomed panels.
+  // When enabled, zoomed center panels (e.g. code editor) will have padding all around,
+  // while zoomed bottom/left/right panels will have padding to the top/right/left (respectively).
+  //
+  // Default: true
+  "zoomed_padding": true,
   // Whether to use the system provided dialogs for Open and Save As.
   // When set to false, Zed will use the built-in keyboard-first pickers.
   "use_system_path_prompts": true,
@@ -357,6 +363,8 @@
     // Whether to show code action buttons in the editor toolbar.
     "code_actions": false
   },
+  // Whether to allow windows to tab together based on the user’s tabbing preference (macOS only).
+  "use_system_window_tabs": false,
   // Titlebar related settings
   "title_bar": {
     // Whether to show the branch icon beside branch switcher in the titlebar.
@@ -647,6 +655,8 @@
       //    "never"
       "show": "always"
     },
+    // Whether to enable drag-and-drop operations in the project panel.
+    "drag_and_drop": true,
     // Whether to hide the root entry when only one folder is open in the window.
     "hide_root": false
   },
@@ -1133,11 +1143,6 @@
       // The minimum severity of the diagnostics to show inline.
       // Inherits editor's diagnostics' max severity settings when `null`.
       "max_severity": null
-    },
-    "cargo": {
-      // When enabled, Zed disables rust-analyzer's check on save and starts to query
-      // Cargo diagnostics separately.
-      "fetch_cargo_diagnostics": false
     }
   },
   // Files or globs of files that will be excluded by Zed entirely. They will be skipped during file
@@ -1503,6 +1508,11 @@
     //
     // Default: fallback
     "words": "fallback",
+    // Minimum number of characters required to automatically trigger word-based completions.
+    // Before that value, it's still possible to trigger the words-based completion manually with the corresponding editor command.
+    //
+    // Default: 3
+    "words_min_length": 3,
     // Whether to fetch LSP completions or not.
     //
     // Default: true
@@ -1629,6 +1639,9 @@
         "allowed": true
       }
     },
+    "Kotlin": {
+      "language_servers": ["kotlin-language-server", "!kotlin-lsp", "..."]
+    },
     "LaTeX": {
       "formatter": "language_server",
       "language_servers": ["texlab", "..."],
@@ -1642,9 +1655,6 @@
       "use_on_type_format": false,
       "allow_rewrap": "anywhere",
       "soft_wrap": "editor_width",
-      "completions": {
-        "words": "disabled"
-      },
       "prettier": {
         "allowed": true
       }
@@ -1658,9 +1668,6 @@
       }
     },
     "Plain Text": {
-      "completions": {
-        "words": "disabled"
-      },
       "allow_rewrap": "anywhere"
     },
     "Python": {

assets/settings/initial_tasks.json

@@ -43,8 +43,8 @@
     //           "args": ["--login"]
     //         }
     //     }
-    "shell": "system",
+    "shell": "system"
     // Represents the tags for inline runnable indicators, or spawning multiple tasks at once.
-    "tags": []
+    // "tags": []
   }
 ]

assets/themes/ayu/ayu.json

@@ -93,7 +93,7 @@
         "terminal.ansi.bright_cyan": "#4c806fff",
         "terminal.ansi.dim_cyan": "#cbf2e4ff",
         "terminal.ansi.white": "#bfbdb6ff",
-        "terminal.ansi.bright_white": "#bfbdb6ff",
+        "terminal.ansi.bright_white": "#fafafaff",
         "terminal.ansi.dim_white": "#787876ff",
         "link_text.hover": "#5ac1feff",
         "conflict": "#feb454ff",
@@ -479,7 +479,7 @@
         "terminal.ansi.bright_cyan": "#ace0cbff",
         "terminal.ansi.dim_cyan": "#2a5f4aff",
         "terminal.ansi.white": "#fcfcfcff",
-        "terminal.ansi.bright_white": "#fcfcfcff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#bcbec0ff",
         "link_text.hover": "#3b9ee5ff",
         "conflict": "#f1ad49ff",
@@ -865,7 +865,7 @@
         "terminal.ansi.bright_cyan": "#4c806fff",
         "terminal.ansi.dim_cyan": "#cbf2e4ff",
         "terminal.ansi.white": "#cccac2ff",
-        "terminal.ansi.bright_white": "#cccac2ff",
+        "terminal.ansi.bright_white": "#fafafaff",
         "terminal.ansi.dim_white": "#898a8aff",
         "link_text.hover": "#72cffeff",
         "conflict": "#fecf72ff",

assets/themes/gruvbox/gruvbox.json

@@ -94,7 +94,7 @@
         "terminal.ansi.bright_cyan": "#45603eff",
         "terminal.ansi.dim_cyan": "#c7dfbdff",
         "terminal.ansi.white": "#fbf1c7ff",
-        "terminal.ansi.bright_white": "#fbf1c7ff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#b0a189ff",
         "link_text.hover": "#83a598ff",
         "version_control.added": "#b7bb26ff",
@@ -494,7 +494,7 @@
         "terminal.ansi.bright_cyan": "#45603eff",
         "terminal.ansi.dim_cyan": "#c7dfbdff",
         "terminal.ansi.white": "#fbf1c7ff",
-        "terminal.ansi.bright_white": "#fbf1c7ff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#b0a189ff",
         "link_text.hover": "#83a598ff",
         "version_control.added": "#b7bb26ff",
@@ -894,7 +894,7 @@
         "terminal.ansi.bright_cyan": "#45603eff",
         "terminal.ansi.dim_cyan": "#c7dfbdff",
         "terminal.ansi.white": "#fbf1c7ff",
-        "terminal.ansi.bright_white": "#fbf1c7ff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#b0a189ff",
         "link_text.hover": "#83a598ff",
         "version_control.added": "#b7bb26ff",
@@ -1294,7 +1294,7 @@
         "terminal.ansi.bright_cyan": "#9fbca8ff",
         "terminal.ansi.dim_cyan": "#253e2eff",
         "terminal.ansi.white": "#fbf1c7ff",
-        "terminal.ansi.bright_white": "#fbf1c7ff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#b0a189ff",
         "link_text.hover": "#0b6678ff",
         "version_control.added": "#797410ff",
@@ -1694,7 +1694,7 @@
         "terminal.ansi.bright_cyan": "#9fbca8ff",
         "terminal.ansi.dim_cyan": "#253e2eff",
         "terminal.ansi.white": "#f9f5d7ff",
-        "terminal.ansi.bright_white": "#f9f5d7ff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#b0a189ff",
         "link_text.hover": "#0b6678ff",
         "version_control.added": "#797410ff",
@@ -2094,7 +2094,7 @@
         "terminal.ansi.bright_cyan": "#9fbca8ff",
         "terminal.ansi.dim_cyan": "#253e2eff",
         "terminal.ansi.white": "#f2e5bcff",
-        "terminal.ansi.bright_white": "#f2e5bcff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#b0a189ff",
         "link_text.hover": "#0b6678ff",
         "version_control.added": "#797410ff",

assets/themes/one/one.json

@@ -93,7 +93,7 @@
         "terminal.ansi.bright_cyan": "#3a565bff",
         "terminal.ansi.dim_cyan": "#b9d9dfff",
         "terminal.ansi.white": "#dce0e5ff",
-        "terminal.ansi.bright_white": "#dce0e5ff",
+        "terminal.ansi.bright_white": "#fafafaff",
         "terminal.ansi.dim_white": "#575d65ff",
         "link_text.hover": "#74ade8ff",
         "version_control.added": "#27a657ff",
@@ -468,7 +468,7 @@
         "terminal.bright_foreground": "#242529ff",
         "terminal.dim_foreground": "#fafafaff",
         "terminal.ansi.black": "#242529ff",
-        "terminal.ansi.bright_black": "#242529ff",
+        "terminal.ansi.bright_black": "#747579ff",
         "terminal.ansi.dim_black": "#97979aff",
         "terminal.ansi.red": "#d36151ff",
         "terminal.ansi.bright_red": "#f0b0a4ff",
@@ -489,7 +489,7 @@
         "terminal.ansi.bright_cyan": "#a3bedaff",
         "terminal.ansi.dim_cyan": "#254058ff",
         "terminal.ansi.white": "#fafafaff",
-        "terminal.ansi.bright_white": "#fafafaff",
+        "terminal.ansi.bright_white": "#ffffffff",
         "terminal.ansi.dim_white": "#aaaaaaff",
         "link_text.hover": "#5c78e2ff",
         "version_control.added": "#27a657ff",

crates/acp_thread/src/acp_thread.rs

@@ -183,16 +183,15 @@ impl ToolCall {
         language_registry: Arc<LanguageRegistry>,
         cx: &mut App,
     ) -> Self {
+        let title = if let Some((first_line, _)) = tool_call.title.split_once("\n") {
+            first_line.to_owned() + "…"
+        } else {
+            tool_call.title
+        };
         Self {
             id: tool_call.id,
-            label: cx.new(|cx| {
-                Markdown::new(
-                    tool_call.title.into(),
-                    Some(language_registry.clone()),
-                    None,
-                    cx,
-                )
-            }),
+            label: cx
+                .new(|cx| Markdown::new(title.into(), Some(language_registry.clone()), None, cx)),
             kind: tool_call.kind,
             content: tool_call
                 .content
@@ -233,15 +232,30 @@ impl ToolCall {
 
         if let Some(title) = title {
             self.label.update(cx, |label, cx| {
-                label.replace(title, cx);
+                if let Some((first_line, _)) = title.split_once("\n") {
+                    label.replace(first_line.to_owned() + "…", cx)
+                } else {
+                    label.replace(title, cx);
+                }
             });
         }
 
         if let Some(content) = content {
-            self.content = content
-                .into_iter()
-                .map(|chunk| ToolCallContent::from_acp(chunk, language_registry.clone(), cx))
-                .collect();
+            let new_content_len = content.len();
+            let mut content = content.into_iter();
+
+            // Reuse existing content if we can
+            for (old, new) in self.content.iter_mut().zip(content.by_ref()) {
+                old.update_from_acp(new, language_registry.clone(), cx);
+            }
+            for new in content {
+                self.content.push(ToolCallContent::from_acp(
+                    new,
+                    language_registry.clone(),
+                    cx,
+                ))
+            }
+            self.content.truncate(new_content_len);
         }
 
         if let Some(locations) = locations {
@@ -498,7 +512,7 @@ impl ContentBlock {
         "`Image`".into()
     }
 
-    fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
+    pub fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
         match self {
             ContentBlock::Empty => "",
             ContentBlock::Markdown { markdown } => markdown.read(cx).source(),
@@ -551,6 +565,28 @@ impl ToolCallContent {
         }
     }
 
+    pub fn update_from_acp(
+        &mut self,
+        new: acp::ToolCallContent,
+        language_registry: Arc<LanguageRegistry>,
+        cx: &mut App,
+    ) {
+        let needs_update = match (&self, &new) {
+            (Self::Diff(old_diff), acp::ToolCallContent::Diff { diff: new_diff }) => {
+                old_diff.read(cx).needs_update(
+                    new_diff.old_text.as_deref().unwrap_or(""),
+                    &new_diff.new_text,
+                    cx,
+                )
+            }
+            _ => true,
+        };
+
+        if needs_update {
+            *self = Self::from_acp(new, language_registry, cx);
+        }
+    }
+
     pub fn to_markdown(&self, cx: &App) -> String {
         match self {
             Self::ContentBlock(content) => content.to_markdown(cx).to_string(),
@@ -723,6 +759,8 @@ pub struct AcpThread {
     connection: Rc<dyn AgentConnection>,
     session_id: acp::SessionId,
     token_usage: Option<TokenUsage>,
+    prompt_capabilities: acp::PromptCapabilities,
+    _observe_prompt_capabilities: Task<anyhow::Result<()>>,
 }
 
 #[derive(Debug)]
@@ -737,11 +775,12 @@ pub enum AcpThreadEvent {
     Stopped,
     Error,
     LoadError(LoadError),
+    PromptCapabilitiesUpdated,
 }
 
 impl EventEmitter<AcpThreadEvent> for AcpThread {}
 
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Debug)]
 pub enum ThreadStatus {
     Idle,
     WaitingForToolConfirmation,
@@ -750,16 +789,12 @@ pub enum ThreadStatus {
 
 #[derive(Debug, Clone)]
 pub enum LoadError {
-    NotInstalled {
-        error_message: SharedString,
-        install_message: SharedString,
-        install_command: String,
-    },
     Unsupported {
-        error_message: SharedString,
-        upgrade_message: SharedString,
-        upgrade_command: String,
+        command: SharedString,
+        current_version: SharedString,
+        minimum_version: SharedString,
     },
+    FailedToInstall(SharedString),
     Exited {
         status: ExitStatus,
     },
@@ -769,12 +804,19 @@ pub enum LoadError {
 impl Display for LoadError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            LoadError::NotInstalled { error_message, .. }
-            | LoadError::Unsupported { error_message, .. } => {
-                write!(f, "{error_message}")
+            LoadError::Unsupported {
+                command: path,
+                current_version,
+                minimum_version,
+            } => {
+                write!(
+                    f,
+                    "version {current_version} from {path} is not supported (need at least {minimum_version})"
+                )
             }
+            LoadError::FailedToInstall(msg) => write!(f, "Failed to install: {msg}"),
             LoadError::Exited { status } => write!(f, "Server exited with status {status}"),
-            LoadError::Other(msg) => write!(f, "{}", msg),
+            LoadError::Other(msg) => write!(f, "{msg}"),
         }
     }
 }
@@ -788,7 +830,20 @@ impl AcpThread {
         project: Entity<Project>,
         action_log: Entity<ActionLog>,
         session_id: acp::SessionId,
+        mut prompt_capabilities_rx: watch::Receiver<acp::PromptCapabilities>,
+        cx: &mut Context<Self>,
     ) -> Self {
+        let prompt_capabilities = *prompt_capabilities_rx.borrow();
+        let task = cx.spawn::<_, anyhow::Result<()>>(async move |this, cx| {
+            loop {
+                let caps = prompt_capabilities_rx.recv().await?;
+                this.update(cx, |this, cx| {
+                    this.prompt_capabilities = caps;
+                    cx.emit(AcpThreadEvent::PromptCapabilitiesUpdated);
+                })?;
+            }
+        });
+
         Self {
             action_log,
             shared_buffers: Default::default(),
@@ -800,13 +855,24 @@ impl AcpThread {
             connection,
             session_id,
             token_usage: None,
+            prompt_capabilities,
+            _observe_prompt_capabilities: task,
         }
     }
 
+    pub fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+        self.prompt_capabilities
+    }
+
     pub fn connection(&self) -> &Rc<dyn AgentConnection> {
         &self.connection
     }
 
+    /// Returns true if the agent supports custom slash commands.
+    pub fn supports_custom_commands(&self) -> bool {
+        self.prompt_capabilities.supports_custom_commands
+    }
+
     pub fn action_log(&self) -> &Entity<ActionLog> {
         &self.action_log
     }
@@ -987,10 +1053,19 @@ impl AcpThread {
         cx.emit(AcpThreadEvent::NewEntry);
     }
 
-    pub fn update_title(&mut self, title: SharedString, cx: &mut Context<Self>) -> Result<()> {
-        self.title = title;
-        cx.emit(AcpThreadEvent::TitleUpdated);
-        Ok(())
+    pub fn can_set_title(&mut self, cx: &mut Context<Self>) -> bool {
+        self.connection.set_title(&self.session_id, cx).is_some()
+    }
+
+    pub fn set_title(&mut self, title: SharedString, cx: &mut Context<Self>) -> Task<Result<()>> {
+        if title != self.title {
+            self.title = title.clone();
+            cx.emit(AcpThreadEvent::TitleUpdated);
+            if let Some(set_title) = self.connection.set_title(&self.session_id, cx) {
+                return set_title.run(title, cx);
+            }
+        }
+        Task::ready(Ok(()))
     }
 
     pub fn update_token_usage(&mut self, usage: Option<TokenUsage>, cx: &mut Context<Self>) {
@@ -1293,11 +1368,7 @@ impl AcpThread {
         };
         let git_store = self.project.read(cx).git_store().clone();
 
-        let message_id = if self
-            .connection
-            .session_editor(&self.session_id, cx)
-            .is_some()
-        {
+        let message_id = if self.connection.truncate(&self.session_id, cx).is_some() {
             Some(UserMessageId::new())
         } else {
             None
@@ -1335,6 +1406,10 @@ impl AcpThread {
         })
     }
 
+    pub fn can_resume(&self, cx: &App) -> bool {
+        self.connection.resume(&self.session_id, cx).is_some()
+    }
+
     pub fn resume(&mut self, cx: &mut Context<Self>) -> BoxFuture<'static, Result<()>> {
         self.run_turn(cx, async move |this, cx| {
             this.update(cx, |this, cx| {
@@ -1443,7 +1518,7 @@ impl AcpThread {
     /// Rewinds this thread to before the entry at `index`, removing it and all
     /// subsequent entries while reverting any changes made from that point.
     pub fn rewind(&mut self, id: UserMessageId, cx: &mut Context<Self>) -> Task<Result<()>> {
-        let Some(session_editor) = self.connection.session_editor(&self.session_id, cx) else {
+        let Some(truncate) = self.connection.truncate(&self.session_id, cx) else {
             return Task::ready(Err(anyhow!("not supported")));
         };
         let Some(message) = self.user_message(&id) else {
@@ -1463,8 +1538,7 @@ impl AcpThread {
                     .await?;
             }
 
-            cx.update(|cx| session_editor.truncate(id.clone(), cx))?
-                .await?;
+            cx.update(|cx| truncate.run(id.clone(), cx))?.await?;
             this.update(cx, |this, cx| {
                 if let Some((ix, _)) = this.user_message_mut(&id) {
                     let range = ix..this.entries.len();
@@ -2558,13 +2632,20 @@ mod tests {
                     .into(),
             );
             let action_log = cx.new(|_| ActionLog::new(project.clone()));
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                 AcpThread::new(
                     "Test",
                     self.clone(),
                     project,
                     action_log,
                     session_id.clone(),
+                    watch::Receiver::constant(acp::PromptCapabilities {
+                        image: true,
+                        audio: true,
+                        embedded_context: true,
+                        supports_custom_commands: false,
+                    }),
+                    cx,
                 )
             });
             self.sessions.lock().insert(session_id, thread.downgrade());
@@ -2598,14 +2679,6 @@ mod tests {
             }
         }
 
-        fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-            acp::PromptCapabilities {
-                image: true,
-                audio: true,
-                embedded_context: true,
-            }
-        }
-
         fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
             let sessions = self.sessions.lock();
             let thread = sessions.get(session_id).unwrap().clone();
@@ -2619,11 +2692,11 @@ mod tests {
             .detach();
         }
 
-        fn session_editor(
+        fn truncate(
             &self,
             session_id: &acp::SessionId,
-            _cx: &mut App,
-        ) -> Option<Rc<dyn AgentSessionEditor>> {
+            _cx: &App,
+        ) -> Option<Rc<dyn AgentSessionTruncate>> {
             Some(Rc::new(FakeAgentSessionEditor {
                 _session_id: session_id.clone(),
             }))
@@ -2638,8 +2711,8 @@ mod tests {
         _session_id: acp::SessionId,
     }
 
-    impl AgentSessionEditor for FakeAgentSessionEditor {
-        fn truncate(&self, _message_id: UserMessageId, _cx: &mut App) -> Task<Result<()>> {
+    impl AgentSessionTruncate for FakeAgentSessionEditor {
+        fn run(&self, _message_id: UserMessageId, _cx: &mut App) -> Task<Result<()>> {
             Task::ready(Ok(()))
         }
     }

crates/acp_thread/src/connection.rs

@@ -38,23 +38,29 @@ pub trait AgentConnection {
         cx: &mut App,
     ) -> Task<Result<acp::PromptResponse>>;
 
-    fn prompt_capabilities(&self) -> acp::PromptCapabilities;
-
     fn resume(
         &self,
         _session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
     ) -> Option<Rc<dyn AgentSessionResume>> {
         None
     }
 
     fn cancel(&self, session_id: &acp::SessionId, cx: &mut App);
 
-    fn session_editor(
+    fn truncate(
         &self,
         _session_id: &acp::SessionId,
-        _cx: &mut App,
-    ) -> Option<Rc<dyn AgentSessionEditor>> {
+        _cx: &App,
+    ) -> Option<Rc<dyn AgentSessionTruncate>> {
+        None
+    }
+
+    fn set_title(
+        &self,
+        _session_id: &acp::SessionId,
+        _cx: &App,
+    ) -> Option<Rc<dyn AgentSessionSetTitle>> {
         None
     }
 
@@ -70,6 +76,9 @@ pub trait AgentConnection {
         None
     }
 
+    fn list_commands(&self, session_id: &acp::SessionId, cx: &mut App) -> Task<Result<acp::ListCommandsResponse>>;
+    fn run_command(&self, request: acp::RunCommandRequest, cx: &mut App) -> Task<Result<()>>;
+
     fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
 }
 
@@ -79,14 +88,18 @@ impl dyn AgentConnection {
     }
 }
 
-pub trait AgentSessionEditor {
-    fn truncate(&self, message_id: UserMessageId, cx: &mut App) -> Task<Result<()>>;
+pub trait AgentSessionTruncate {
+    fn run(&self, message_id: UserMessageId, cx: &mut App) -> Task<Result<()>>;
 }
 
 pub trait AgentSessionResume {
     fn run(&self, cx: &mut App) -> Task<Result<acp::PromptResponse>>;
 }
 
+pub trait AgentSessionSetTitle {
+    fn run(&self, title: SharedString, cx: &mut App) -> Task<Result<()>>;
+}
+
 pub trait AgentTelemetry {
     /// The name of the agent used for telemetry.
     fn agent_name(&self) -> String;
@@ -317,13 +330,20 @@ mod test_support {
         ) -> Task<gpui::Result<Entity<AcpThread>>> {
             let session_id = acp::SessionId(self.sessions.lock().len().to_string().into());
             let action_log = cx.new(|_| ActionLog::new(project.clone()));
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                 AcpThread::new(
                     "Test",
                     self.clone(),
                     project,
                     action_log,
                     session_id.clone(),
+                    watch::Receiver::constant(acp::PromptCapabilities {
+                        image: true,
+                        audio: true,
+                        embedded_context: true,
+                        supports_custom_commands: false,
+                    }),
+                    cx,
                 )
             });
             self.sessions.lock().insert(
@@ -336,14 +356,6 @@ mod test_support {
             Task::ready(Ok(thread))
         }
 
-        fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-            acp::PromptCapabilities {
-                image: true,
-                audio: true,
-                embedded_context: true,
-            }
-        }
-
         fn authenticate(
             &self,
             _method_id: acp::AuthMethodId,
@@ -424,14 +436,22 @@ mod test_support {
             }
         }
 
-        fn session_editor(
+        fn truncate(
             &self,
             _session_id: &agent_client_protocol::SessionId,
-            _cx: &mut App,
-        ) -> Option<Rc<dyn AgentSessionEditor>> {
+            _cx: &App,
+        ) -> Option<Rc<dyn AgentSessionTruncate>> {
             Some(Rc::new(StubAgentSessionEditor))
         }
 
+        fn list_commands(&self, _session_id: &acp::SessionId, _cx: &mut App) -> Task<Result<acp::ListCommandsResponse>> {
+            Task::ready(Ok(acp::ListCommandsResponse { commands: vec![] }))
+        }
+
+        fn run_command(&self, _request: acp::RunCommandRequest, _cx: &mut App) -> Task<Result<()>> {
+            Task::ready(Ok(()))
+        }
+
         fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
             self
         }
@@ -439,8 +459,8 @@ mod test_support {
 
     struct StubAgentSessionEditor;
 
-    impl AgentSessionEditor for StubAgentSessionEditor {
-        fn truncate(&self, _: UserMessageId, _: &mut App) -> Task<Result<()>> {
+    impl AgentSessionTruncate for StubAgentSessionEditor {
+        fn run(&self, _: UserMessageId, _: &mut App) -> Task<Result<()>> {
             Task::ready(Ok(()))
         }
     }

crates/acp_thread/src/diff.rs

@@ -28,10 +28,12 @@ impl Diff {
         cx: &mut Context<Self>,
     ) -> Self {
         let multibuffer = cx.new(|_cx| MultiBuffer::without_headers(Capability::ReadOnly));
-        let buffer = cx.new(|cx| Buffer::local(new_text, cx));
+        let new_buffer = cx.new(|cx| Buffer::local(new_text, cx));
+        let base_text = old_text.clone().unwrap_or(String::new()).into();
         let task = cx.spawn({
             let multibuffer = multibuffer.clone();
             let path = path.clone();
+            let buffer = new_buffer.clone();
             async move |_, cx| {
                 let language = language_registry
                     .language_for_file_path(&path)
@@ -76,32 +78,26 @@ impl Diff {
         Self::Finalized(FinalizedDiff {
             multibuffer,
             path,
+            base_text,
+            new_buffer,
             _update_diff: task,
         })
     }
 
     pub fn new(buffer: Entity<Buffer>, cx: &mut Context<Self>) -> Self {
-        let buffer_snapshot = buffer.read(cx).snapshot();
-        let base_text = buffer_snapshot.text();
-        let language_registry = buffer.read(cx).language_registry();
-        let text_snapshot = buffer.read(cx).text_snapshot();
+        let buffer_text_snapshot = buffer.read(cx).text_snapshot();
+        let base_text_snapshot = buffer.read(cx).snapshot();
+        let base_text = base_text_snapshot.text();
+        debug_assert_eq!(buffer_text_snapshot.text(), base_text);
         let buffer_diff = cx.new(|cx| {
-            let mut diff = BufferDiff::new(&text_snapshot, cx);
-            let _ = diff.set_base_text(
-                buffer_snapshot.clone(),
-                language_registry,
-                text_snapshot,
-                cx,
-            );
+            let mut diff = BufferDiff::new_unchanged(&buffer_text_snapshot, base_text_snapshot);
             let snapshot = diff.snapshot(cx);
-
             let secondary_diff = cx.new(|cx| {
-                let mut diff = BufferDiff::new(&buffer_snapshot, cx);
-                diff.set_snapshot(snapshot, &buffer_snapshot, cx);
+                let mut diff = BufferDiff::new(&buffer_text_snapshot, cx);
+                diff.set_snapshot(snapshot, &buffer_text_snapshot, cx);
                 diff
             });
             diff.set_secondary_diff(secondary_diff);
-
             diff
         });
 
@@ -119,7 +115,7 @@ impl Diff {
                     diff.update(cx);
                 }
             }),
-            buffer,
+            new_buffer: buffer,
             diff: buffer_diff,
             revealed_ranges: Vec::new(),
             update_diff: Task::ready(Ok(())),
@@ -154,9 +150,9 @@ impl Diff {
             .map(|buffer| buffer.read(cx).text())
             .join("\n");
         let path = match self {
-            Diff::Pending(PendingDiff { buffer, .. }) => {
-                buffer.read(cx).file().map(|file| file.path().as_ref())
-            }
+            Diff::Pending(PendingDiff {
+                new_buffer: buffer, ..
+            }) => buffer.read(cx).file().map(|file| file.path().as_ref()),
             Diff::Finalized(FinalizedDiff { path, .. }) => Some(path.as_path()),
         };
         format!(
@@ -169,12 +165,33 @@ impl Diff {
     pub fn has_revealed_range(&self, cx: &App) -> bool {
         self.multibuffer().read(cx).excerpt_paths().next().is_some()
     }
+
+    pub fn needs_update(&self, old_text: &str, new_text: &str, cx: &App) -> bool {
+        match self {
+            Diff::Pending(PendingDiff {
+                base_text,
+                new_buffer,
+                ..
+            }) => {
+                base_text.as_str() != old_text
+                    || !new_buffer.read(cx).as_rope().chunks().equals_str(new_text)
+            }
+            Diff::Finalized(FinalizedDiff {
+                base_text,
+                new_buffer,
+                ..
+            }) => {
+                base_text.as_str() != old_text
+                    || !new_buffer.read(cx).as_rope().chunks().equals_str(new_text)
+            }
+        }
+    }
 }
 
 pub struct PendingDiff {
     multibuffer: Entity<MultiBuffer>,
     base_text: Arc<String>,
-    buffer: Entity<Buffer>,
+    new_buffer: Entity<Buffer>,
     diff: Entity<BufferDiff>,
     revealed_ranges: Vec<Range<Anchor>>,
     _subscription: Subscription,
@@ -183,7 +200,7 @@ pub struct PendingDiff {
 
 impl PendingDiff {
     pub fn update(&mut self, cx: &mut Context<Diff>) {
-        let buffer = self.buffer.clone();
+        let buffer = self.new_buffer.clone();
         let buffer_diff = self.diff.clone();
         let base_text = self.base_text.clone();
         self.update_diff = cx.spawn(async move |diff, cx| {
@@ -221,10 +238,10 @@ impl PendingDiff {
     fn finalize(&self, cx: &mut Context<Diff>) -> FinalizedDiff {
         let ranges = self.excerpt_ranges(cx);
         let base_text = self.base_text.clone();
-        let language_registry = self.buffer.read(cx).language_registry();
+        let language_registry = self.new_buffer.read(cx).language_registry();
 
         let path = self
-            .buffer
+            .new_buffer
             .read(cx)
             .file()
             .map(|file| file.path().as_ref())
@@ -233,12 +250,12 @@ impl PendingDiff {
 
         // Replace the buffer in the multibuffer with the snapshot
         let buffer = cx.new(|cx| {
-            let language = self.buffer.read(cx).language().cloned();
+            let language = self.new_buffer.read(cx).language().cloned();
             let buffer = TextBuffer::new_normalized(
                 0,
                 cx.entity_id().as_non_zero_u64().into(),
-                self.buffer.read(cx).line_ending(),
-                self.buffer.read(cx).as_rope().clone(),
+                self.new_buffer.read(cx).line_ending(),
+                self.new_buffer.read(cx).as_rope().clone(),
             );
             let mut buffer = Buffer::build(buffer, None, Capability::ReadWrite);
             buffer.set_language(language, cx);
@@ -274,7 +291,9 @@ impl PendingDiff {
 
         FinalizedDiff {
             path,
+            base_text: self.base_text.clone(),
             multibuffer: self.multibuffer.clone(),
+            new_buffer: self.new_buffer.clone(),
             _update_diff: update_diff,
         }
     }
@@ -283,8 +302,8 @@ impl PendingDiff {
         let ranges = self.excerpt_ranges(cx);
         self.multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.set_excerpts_for_path(
-                PathKey::for_buffer(&self.buffer, cx),
-                self.buffer.clone(),
+                PathKey::for_buffer(&self.new_buffer, cx),
+                self.new_buffer.clone(),
                 ranges,
                 editor::DEFAULT_MULTIBUFFER_CONTEXT,
                 cx,
@@ -296,7 +315,7 @@ impl PendingDiff {
     }
 
     fn excerpt_ranges(&self, cx: &App) -> Vec<Range<Point>> {
-        let buffer = self.buffer.read(cx);
+        let buffer = self.new_buffer.read(cx);
         let diff = self.diff.read(cx);
         let mut ranges = diff
             .hunks_intersecting_range(Anchor::MIN..Anchor::MAX, buffer, cx)
@@ -330,6 +349,8 @@ impl PendingDiff {
 
 pub struct FinalizedDiff {
     path: PathBuf,
+    base_text: Arc<String>,
+    new_buffer: Entity<Buffer>,
     multibuffer: Entity<MultiBuffer>,
     _update_diff: Task<Result<()>>,
 }
@@ -383,3 +404,21 @@ async fn build_buffer_diff(
         diff
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use gpui::{AppContext as _, TestAppContext};
+    use language::Buffer;
+
+    use crate::Diff;
+
+    #[gpui::test]
+    async fn test_pending_diff(cx: &mut TestAppContext) {
+        let buffer = cx.new(|cx| Buffer::local("hello!", cx));
+        let _diff = cx.new(|cx| Diff::new(buffer.clone(), cx));
+        buffer.update(cx, |buffer, cx| {
+            buffer.set_text("HELLO!", cx);
+        });
+        cx.run_until_parked();
+    }
+}

crates/acp_thread/src/mention.rs

@@ -5,7 +5,7 @@ use prompt_store::{PromptId, UserPromptId};
 use serde::{Deserialize, Serialize};
 use std::{
     fmt,
-    ops::Range,
+    ops::RangeInclusive,
     path::{Path, PathBuf},
     str::FromStr,
 };
@@ -17,13 +17,14 @@ pub enum MentionUri {
     File {
         abs_path: PathBuf,
     },
+    PastedImage,
     Directory {
         abs_path: PathBuf,
     },
     Symbol {
-        path: PathBuf,
+        abs_path: PathBuf,
         name: String,
-        line_range: Range<u32>,
+        line_range: RangeInclusive<u32>,
     },
     Thread {
         id: acp::SessionId,
@@ -38,8 +39,9 @@ pub enum MentionUri {
         name: String,
     },
     Selection {
-        path: PathBuf,
-        line_range: Range<u32>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        abs_path: Option<PathBuf>,
+        line_range: RangeInclusive<u32>,
     },
     Fetch {
         url: Url,
@@ -48,36 +50,44 @@ pub enum MentionUri {
 
 impl MentionUri {
     pub fn parse(input: &str) -> Result<Self> {
+        fn parse_line_range(fragment: &str) -> Result<RangeInclusive<u32>> {
+            let range = fragment
+                .strip_prefix("L")
+                .context("Line range must start with \"L\"")?;
+            let (start, end) = range
+                .split_once(":")
+                .context("Line range must use colon as separator")?;
+            let range = start
+                .parse::<u32>()
+                .context("Parsing line range start")?
+                .checked_sub(1)
+                .context("Line numbers should be 1-based")?
+                ..=end
+                    .parse::<u32>()
+                    .context("Parsing line range end")?
+                    .checked_sub(1)
+                    .context("Line numbers should be 1-based")?;
+            Ok(range)
+        }
+
         let url = url::Url::parse(input)?;
         let path = url.path();
         match url.scheme() {
             "file" => {
                 let path = url.to_file_path().ok().context("Extracting file path")?;
                 if let Some(fragment) = url.fragment() {
-                    let range = fragment
-                        .strip_prefix("L")
-                        .context("Line range must start with \"L\"")?;
-                    let (start, end) = range
-                        .split_once(":")
-                        .context("Line range must use colon as separator")?;
-                    let line_range = start
-                        .parse::<u32>()
-                        .context("Parsing line range start")?
-                        .checked_sub(1)
-                        .context("Line numbers should be 1-based")?
-                        ..end
-                            .parse::<u32>()
-                            .context("Parsing line range end")?
-                            .checked_sub(1)
-                            .context("Line numbers should be 1-based")?;
+                    let line_range = parse_line_range(fragment)?;
                     if let Some(name) = single_query_param(&url, "symbol")? {
                         Ok(Self::Symbol {
                             name,
-                            path,
+                            abs_path: path,
                             line_range,
                         })
                     } else {
-                        Ok(Self::Selection { path, line_range })
+                        Ok(Self::Selection {
+                            abs_path: Some(path),
+                            line_range,
+                        })
                     }
                 } else if input.ends_with("/") {
                     Ok(Self::Directory { abs_path: path })
@@ -105,6 +115,17 @@ impl MentionUri {
                         id: rule_id.into(),
                         name,
                     })
+                } else if path.starts_with("/agent/pasted-image") {
+                    Ok(Self::PastedImage)
+                } else if path.starts_with("/agent/untitled-buffer") {
+                    let fragment = url
+                        .fragment()
+                        .context("Missing fragment for untitled buffer selection")?;
+                    let line_range = parse_line_range(fragment)?;
+                    Ok(Self::Selection {
+                        abs_path: None,
+                        line_range,
+                    })
                 } else {
                     bail!("invalid zed url: {:?}", input);
                 }
@@ -121,13 +142,16 @@ impl MentionUri {
                 .unwrap_or_default()
                 .to_string_lossy()
                 .into_owned(),
+            MentionUri::PastedImage => "Image".to_string(),
             MentionUri::Symbol { name, .. } => name.clone(),
             MentionUri::Thread { name, .. } => name.clone(),
             MentionUri::TextThread { name, .. } => name.clone(),
             MentionUri::Rule { name, .. } => name.clone(),
             MentionUri::Selection {
-                path, line_range, ..
-            } => selection_name(path, line_range),
+                abs_path: path,
+                line_range,
+                ..
+            } => selection_name(path.as_deref(), line_range),
             MentionUri::Fetch { url } => url.to_string(),
         }
     }
@@ -137,6 +161,7 @@ impl MentionUri {
             MentionUri::File { abs_path } => {
                 FileIcons::get_icon(abs_path, cx).unwrap_or_else(|| IconName::File.path().into())
             }
+            MentionUri::PastedImage => IconName::Image.path().into(),
             MentionUri::Directory { .. } => FileIcons::get_folder_icon(false, cx)
                 .unwrap_or_else(|| IconName::Folder.path().into()),
             MentionUri::Symbol { .. } => IconName::Code.path().into(),
@@ -157,29 +182,40 @@ impl MentionUri {
             MentionUri::File { abs_path } => {
                 Url::from_file_path(abs_path).expect("mention path should be absolute")
             }
+            MentionUri::PastedImage => Url::parse("zed:///agent/pasted-image").unwrap(),
             MentionUri::Directory { abs_path } => {
                 Url::from_directory_path(abs_path).expect("mention path should be absolute")
             }
             MentionUri::Symbol {
-                path,
+                abs_path,
                 name,
                 line_range,
             } => {
-                let mut url = Url::from_file_path(path).expect("mention path should be absolute");
+                let mut url =
+                    Url::from_file_path(abs_path).expect("mention path should be absolute");
                 url.query_pairs_mut().append_pair("symbol", name);
                 url.set_fragment(Some(&format!(
                     "L{}:{}",
-                    line_range.start + 1,
-                    line_range.end + 1
+                    line_range.start() + 1,
+                    line_range.end() + 1
                 )));
                 url
             }
-            MentionUri::Selection { path, line_range } => {
-                let mut url = Url::from_file_path(path).expect("mention path should be absolute");
+            MentionUri::Selection {
+                abs_path: path,
+                line_range,
+            } => {
+                let mut url = if let Some(path) = path {
+                    Url::from_file_path(path).expect("mention path should be absolute")
+                } else {
+                    let mut url = Url::parse("zed:///").unwrap();
+                    url.set_path("/agent/untitled-buffer");
+                    url
+                };
                 url.set_fragment(Some(&format!(
                     "L{}:{}",
-                    line_range.start + 1,
-                    line_range.end + 1
+                    line_range.start() + 1,
+                    line_range.end() + 1
                 )));
                 url
             }
@@ -191,7 +227,10 @@ impl MentionUri {
             }
             MentionUri::TextThread { path, name } => {
                 let mut url = Url::parse("zed:///").unwrap();
-                url.set_path(&format!("/agent/text-thread/{}", path.to_string_lossy()));
+                url.set_path(&format!(
+                    "/agent/text-thread/{}",
+                    path.to_string_lossy().trim_start_matches('/')
+                ));
                 url.query_pairs_mut().append_pair("name", name);
                 url
             }
@@ -237,12 +276,14 @@ fn single_query_param(url: &Url, name: &'static str) -> Result<Option<String>> {
     }
 }
 
-pub fn selection_name(path: &Path, line_range: &Range<u32>) -> String {
+pub fn selection_name(path: Option<&Path>, line_range: &RangeInclusive<u32>) -> String {
     format!(
         "{} ({}:{})",
-        path.file_name().unwrap_or_default().display(),
-        line_range.start + 1,
-        line_range.end + 1
+        path.and_then(|path| path.file_name())
+            .unwrap_or("Untitled".as_ref())
+            .display(),
+        *line_range.start() + 1,
+        *line_range.end() + 1
     )
 }
 
@@ -302,14 +343,14 @@ mod tests {
         let parsed = MentionUri::parse(symbol_uri).unwrap();
         match &parsed {
             MentionUri::Symbol {
-                path,
+                abs_path: path,
                 name,
                 line_range,
             } => {
                 assert_eq!(path.to_str().unwrap(), path!("/path/to/file.rs"));
                 assert_eq!(name, "MySymbol");
-                assert_eq!(line_range.start, 9);
-                assert_eq!(line_range.end, 19);
+                assert_eq!(line_range.start(), &9);
+                assert_eq!(line_range.end(), &19);
             }
             _ => panic!("Expected Symbol variant"),
         }
@@ -321,16 +362,39 @@ mod tests {
         let selection_uri = uri!("file:///path/to/file.rs#L5:15");
         let parsed = MentionUri::parse(selection_uri).unwrap();
         match &parsed {
-            MentionUri::Selection { path, line_range } => {
-                assert_eq!(path.to_str().unwrap(), path!("/path/to/file.rs"));
-                assert_eq!(line_range.start, 4);
-                assert_eq!(line_range.end, 14);
+            MentionUri::Selection {
+                abs_path: path,
+                line_range,
+            } => {
+                assert_eq!(
+                    path.as_ref().unwrap().to_str().unwrap(),
+                    path!("/path/to/file.rs")
+                );
+                assert_eq!(line_range.start(), &4);
+                assert_eq!(line_range.end(), &14);
             }
             _ => panic!("Expected Selection variant"),
         }
         assert_eq!(parsed.to_uri().to_string(), selection_uri);
     }
 
+    #[test]
+    fn test_parse_untitled_selection_uri() {
+        let selection_uri = uri!("zed:///agent/untitled-buffer#L1:10");
+        let parsed = MentionUri::parse(selection_uri).unwrap();
+        match &parsed {
+            MentionUri::Selection {
+                abs_path: None,
+                line_range,
+            } => {
+                assert_eq!(line_range.start(), &0);
+                assert_eq!(line_range.end(), &9);
+            }
+            _ => panic!("Expected Selection variant without path"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), selection_uri);
+    }
+
     #[test]
     fn test_parse_thread_uri() {
         let thread_uri = "zed:///agent/thread/session123?name=Thread+name";

crates/acp_tools/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "acp_tools"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/acp_tools.rs"
+doctest = false
+
+[dependencies]
+agent-client-protocol.workspace = true
+collections.workspace = true
+gpui.workspace = true
+language.workspace= true
+markdown.workspace = true
+project.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+theme.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace-hack.workspace = true
+workspace.workspace = true

crates/acp_tools/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/acp_tools/src/acp_tools.rs

@@ -0,0 +1,494 @@
+use std::{
+    cell::RefCell,
+    collections::HashSet,
+    fmt::Display,
+    rc::{Rc, Weak},
+    sync::Arc,
+};
+
+use agent_client_protocol as acp;
+use collections::HashMap;
+use gpui::{
+    App, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global, ListAlignment, ListState,
+    StyleRefinement, Subscription, Task, TextStyleRefinement, Window, actions, list, prelude::*,
+};
+use language::LanguageRegistry;
+use markdown::{CodeBlockRenderer, Markdown, MarkdownElement, MarkdownStyle};
+use project::Project;
+use settings::Settings;
+use theme::ThemeSettings;
+use ui::prelude::*;
+use util::ResultExt as _;
+use workspace::{Item, Workspace};
+
+actions!(dev, [OpenAcpLogs]);
+
+pub fn init(cx: &mut App) {
+    cx.observe_new(
+        |workspace: &mut Workspace, _window, _cx: &mut Context<Workspace>| {
+            workspace.register_action(|workspace, _: &OpenAcpLogs, window, cx| {
+                let acp_tools =
+                    Box::new(cx.new(|cx| AcpTools::new(workspace.project().clone(), cx)));
+                workspace.add_item_to_active_pane(acp_tools, None, true, window, cx);
+            });
+        },
+    )
+    .detach();
+}
+
+struct GlobalAcpConnectionRegistry(Entity<AcpConnectionRegistry>);
+
+impl Global for GlobalAcpConnectionRegistry {}
+
+#[derive(Default)]
+pub struct AcpConnectionRegistry {
+    active_connection: RefCell<Option<ActiveConnection>>,
+}
+
+struct ActiveConnection {
+    server_name: SharedString,
+    connection: Weak<acp::ClientSideConnection>,
+}
+
+impl AcpConnectionRegistry {
+    pub fn default_global(cx: &mut App) -> Entity<Self> {
+        if cx.has_global::<GlobalAcpConnectionRegistry>() {
+            cx.global::<GlobalAcpConnectionRegistry>().0.clone()
+        } else {
+            let registry = cx.new(|_cx| AcpConnectionRegistry::default());
+            cx.set_global(GlobalAcpConnectionRegistry(registry.clone()));
+            registry
+        }
+    }
+
+    pub fn set_active_connection(
+        &self,
+        server_name: impl Into<SharedString>,
+        connection: &Rc<acp::ClientSideConnection>,
+        cx: &mut Context<Self>,
+    ) {
+        self.active_connection.replace(Some(ActiveConnection {
+            server_name: server_name.into(),
+            connection: Rc::downgrade(connection),
+        }));
+        cx.notify();
+    }
+}
+
+struct AcpTools {
+    project: Entity<Project>,
+    focus_handle: FocusHandle,
+    expanded: HashSet<usize>,
+    watched_connection: Option<WatchedConnection>,
+    connection_registry: Entity<AcpConnectionRegistry>,
+    _subscription: Subscription,
+}
+
+struct WatchedConnection {
+    server_name: SharedString,
+    messages: Vec<WatchedConnectionMessage>,
+    list_state: ListState,
+    connection: Weak<acp::ClientSideConnection>,
+    incoming_request_methods: HashMap<i32, Arc<str>>,
+    outgoing_request_methods: HashMap<i32, Arc<str>>,
+    _task: Task<()>,
+}
+
+impl AcpTools {
+    fn new(project: Entity<Project>, cx: &mut Context<Self>) -> Self {
+        let connection_registry = AcpConnectionRegistry::default_global(cx);
+
+        let subscription = cx.observe(&connection_registry, |this, _, cx| {
+            this.update_connection(cx);
+            cx.notify();
+        });
+
+        let mut this = Self {
+            project,
+            focus_handle: cx.focus_handle(),
+            expanded: HashSet::default(),
+            watched_connection: None,
+            connection_registry,
+            _subscription: subscription,
+        };
+        this.update_connection(cx);
+        this
+    }
+
+    fn update_connection(&mut self, cx: &mut Context<Self>) {
+        let active_connection = self.connection_registry.read(cx).active_connection.borrow();
+        let Some(active_connection) = active_connection.as_ref() else {
+            return;
+        };
+
+        if let Some(watched_connection) = self.watched_connection.as_ref() {
+            if Weak::ptr_eq(
+                &watched_connection.connection,
+                &active_connection.connection,
+            ) {
+                return;
+            }
+        }
+
+        if let Some(connection) = active_connection.connection.upgrade() {
+            let mut receiver = connection.subscribe();
+            let task = cx.spawn(async move |this, cx| {
+                while let Ok(message) = receiver.recv().await {
+                    this.update(cx, |this, cx| {
+                        this.push_stream_message(message, cx);
+                    })
+                    .ok();
+                }
+            });
+
+            self.watched_connection = Some(WatchedConnection {
+                server_name: active_connection.server_name.clone(),
+                messages: vec![],
+                list_state: ListState::new(0, ListAlignment::Bottom, px(2048.)),
+                connection: active_connection.connection.clone(),
+                incoming_request_methods: HashMap::default(),
+                outgoing_request_methods: HashMap::default(),
+                _task: task,
+            });
+        }
+    }
+
+    fn push_stream_message(&mut self, stream_message: acp::StreamMessage, cx: &mut Context<Self>) {
+        let Some(connection) = self.watched_connection.as_mut() else {
+            return;
+        };
+        let language_registry = self.project.read(cx).languages().clone();
+        let index = connection.messages.len();
+
+        let (request_id, method, message_type, params) = match stream_message.message {
+            acp::StreamMessageContent::Request { id, method, params } => {
+                let method_map = match stream_message.direction {
+                    acp::StreamMessageDirection::Incoming => {
+                        &mut connection.incoming_request_methods
+                    }
+                    acp::StreamMessageDirection::Outgoing => {
+                        &mut connection.outgoing_request_methods
+                    }
+                };
+
+                method_map.insert(id, method.clone());
+                (Some(id), method.into(), MessageType::Request, Ok(params))
+            }
+            acp::StreamMessageContent::Response { id, result } => {
+                let method_map = match stream_message.direction {
+                    acp::StreamMessageDirection::Incoming => {
+                        &mut connection.outgoing_request_methods
+                    }
+                    acp::StreamMessageDirection::Outgoing => {
+                        &mut connection.incoming_request_methods
+                    }
+                };
+
+                if let Some(method) = method_map.remove(&id) {
+                    (Some(id), method.into(), MessageType::Response, result)
+                } else {
+                    (
+                        Some(id),
+                        "[unrecognized response]".into(),
+                        MessageType::Response,
+                        result,
+                    )
+                }
+            }
+            acp::StreamMessageContent::Notification { method, params } => {
+                (None, method.into(), MessageType::Notification, Ok(params))
+            }
+        };
+
+        let message = WatchedConnectionMessage {
+            name: method,
+            message_type,
+            request_id,
+            direction: stream_message.direction,
+            collapsed_params_md: match params.as_ref() {
+                Ok(params) => params
+                    .as_ref()
+                    .map(|params| collapsed_params_md(params, &language_registry, cx)),
+                Err(err) => {
+                    if let Ok(err) = &serde_json::to_value(err) {
+                        Some(collapsed_params_md(&err, &language_registry, cx))
+                    } else {
+                        None
+                    }
+                }
+            },
+
+            expanded_params_md: None,
+            params,
+        };
+
+        connection.messages.push(message);
+        connection.list_state.splice(index..index, 1);
+        cx.notify();
+    }
+
+    fn render_message(
+        &mut self,
+        index: usize,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let Some(connection) = self.watched_connection.as_ref() else {
+            return Empty.into_any();
+        };
+
+        let Some(message) = connection.messages.get(index) else {
+            return Empty.into_any();
+        };
+
+        let base_size = TextSize::Editor.rems(cx);
+
+        let theme_settings = ThemeSettings::get_global(cx);
+        let text_style = window.text_style();
+
+        let colors = cx.theme().colors();
+        let expanded = self.expanded.contains(&index);
+
+        v_flex()
+            .w_full()
+            .px_4()
+            .py_3()
+            .border_color(colors.border)
+            .border_b_1()
+            .gap_2()
+            .items_start()
+            .font_buffer(cx)
+            .text_size(base_size)
+            .id(index)
+            .group("message")
+            .hover(|this| this.bg(colors.element_background.opacity(0.5)))
+            .on_click(cx.listener(move |this, _, _, cx| {
+                if this.expanded.contains(&index) {
+                    this.expanded.remove(&index);
+                } else {
+                    this.expanded.insert(index);
+                    let Some(connection) = &mut this.watched_connection else {
+                        return;
+                    };
+                    let Some(message) = connection.messages.get_mut(index) else {
+                        return;
+                    };
+                    message.expanded(this.project.read(cx).languages().clone(), cx);
+                    connection.list_state.scroll_to_reveal_item(index);
+                }
+                cx.notify()
+            }))
+            .child(
+                h_flex()
+                    .w_full()
+                    .gap_2()
+                    .items_center()
+                    .flex_shrink_0()
+                    .child(match message.direction {
+                        acp::StreamMessageDirection::Incoming => {
+                            ui::Icon::new(ui::IconName::ArrowDown).color(Color::Error)
+                        }
+                        acp::StreamMessageDirection::Outgoing => {
+                            ui::Icon::new(ui::IconName::ArrowUp).color(Color::Success)
+                        }
+                    })
+                    .child(
+                        Label::new(message.name.clone())
+                            .buffer_font(cx)
+                            .color(Color::Muted),
+                    )
+                    .child(div().flex_1())
+                    .child(
+                        div()
+                            .child(ui::Chip::new(message.message_type.to_string()))
+                            .visible_on_hover("message"),
+                    )
+                    .children(
+                        message
+                            .request_id
+                            .map(|req_id| div().child(ui::Chip::new(req_id.to_string()))),
+                    ),
+            )
+            // I'm aware using markdown is a hack. Trying to get something working for the demo.
+            // Will clean up soon!
+            .when_some(
+                if expanded {
+                    message.expanded_params_md.clone()
+                } else {
+                    message.collapsed_params_md.clone()
+                },
+                |this, params| {
+                    this.child(
+                        div().pl_6().w_full().child(
+                            MarkdownElement::new(
+                                params,
+                                MarkdownStyle {
+                                    base_text_style: text_style,
+                                    selection_background_color: colors.element_selection_background,
+                                    syntax: cx.theme().syntax().clone(),
+                                    code_block_overflow_x_scroll: true,
+                                    code_block: StyleRefinement {
+                                        text: Some(TextStyleRefinement {
+                                            font_family: Some(
+                                                theme_settings.buffer_font.family.clone(),
+                                            ),
+                                            font_size: Some((base_size * 0.8).into()),
+                                            ..Default::default()
+                                        }),
+                                        ..Default::default()
+                                    },
+                                    ..Default::default()
+                                },
+                            )
+                            .code_block_renderer(
+                                CodeBlockRenderer::Default {
+                                    copy_button: false,
+                                    copy_button_on_hover: expanded,
+                                    border: false,
+                                },
+                            ),
+                        ),
+                    )
+                },
+            )
+            .into_any()
+    }
+}
+
+struct WatchedConnectionMessage {
+    name: SharedString,
+    request_id: Option<i32>,
+    direction: acp::StreamMessageDirection,
+    message_type: MessageType,
+    params: Result<Option<serde_json::Value>, acp::Error>,
+    collapsed_params_md: Option<Entity<Markdown>>,
+    expanded_params_md: Option<Entity<Markdown>>,
+}
+
+impl WatchedConnectionMessage {
+    fn expanded(&mut self, language_registry: Arc<LanguageRegistry>, cx: &mut App) {
+        let params_md = match &self.params {
+            Ok(Some(params)) => Some(expanded_params_md(params, &language_registry, cx)),
+            Err(err) => {
+                if let Some(err) = &serde_json::to_value(err).log_err() {
+                    Some(expanded_params_md(&err, &language_registry, cx))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        };
+        self.expanded_params_md = params_md;
+    }
+}
+
+fn collapsed_params_md(
+    params: &serde_json::Value,
+    language_registry: &Arc<LanguageRegistry>,
+    cx: &mut App,
+) -> Entity<Markdown> {
+    let params_json = serde_json::to_string(params).unwrap_or_default();
+    let mut spaced_out_json = String::with_capacity(params_json.len() + params_json.len() / 4);
+
+    for ch in params_json.chars() {
+        match ch {
+            '{' => spaced_out_json.push_str("{ "),
+            '}' => spaced_out_json.push_str(" }"),
+            ':' => spaced_out_json.push_str(": "),
+            ',' => spaced_out_json.push_str(", "),
+            c => spaced_out_json.push(c),
+        }
+    }
+
+    let params_md = format!("```json\n{}\n```", spaced_out_json);
+    cx.new(|cx| Markdown::new(params_md.into(), Some(language_registry.clone()), None, cx))
+}
+
+fn expanded_params_md(
+    params: &serde_json::Value,
+    language_registry: &Arc<LanguageRegistry>,
+    cx: &mut App,
+) -> Entity<Markdown> {
+    let params_json = serde_json::to_string_pretty(params).unwrap_or_default();
+    let params_md = format!("```json\n{}\n```", params_json);
+    cx.new(|cx| Markdown::new(params_md.into(), Some(language_registry.clone()), None, cx))
+}
+
+enum MessageType {
+    Request,
+    Response,
+    Notification,
+}
+
+impl Display for MessageType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MessageType::Request => write!(f, "Request"),
+            MessageType::Response => write!(f, "Response"),
+            MessageType::Notification => write!(f, "Notification"),
+        }
+    }
+}
+
+enum AcpToolsEvent {}
+
+impl EventEmitter<AcpToolsEvent> for AcpTools {}
+
+impl Item for AcpTools {
+    type Event = AcpToolsEvent;
+
+    fn tab_content_text(&self, _detail: usize, _cx: &App) -> ui::SharedString {
+        format!(
+            "ACP: {}",
+            self.watched_connection
+                .as_ref()
+                .map_or("Disconnected", |connection| &connection.server_name)
+        )
+        .into()
+    }
+
+    fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
+        Some(ui::Icon::new(IconName::Thread))
+    }
+}
+
+impl Focusable for AcpTools {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for AcpTools {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .track_focus(&self.focus_handle)
+            .size_full()
+            .bg(cx.theme().colors().editor_background)
+            .child(match self.watched_connection.as_ref() {
+                Some(connection) => {
+                    if connection.messages.is_empty() {
+                        h_flex()
+                            .size_full()
+                            .justify_center()
+                            .items_center()
+                            .child("No messages recorded yet")
+                            .into_any()
+                    } else {
+                        list(
+                            connection.list_state.clone(),
+                            cx.processor(Self::render_message),
+                        )
+                        .with_sizing_behavior(gpui::ListSizingBehavior::Auto)
+                        .flex_grow()
+                        .into_any()
+                    }
+                }
+                None => h_flex()
+                    .size_full()
+                    .justify_center()
+                    .items_center()
+                    .child("No active connection")
+                    .into_any(),
+            })
+    }
+}

crates/agent/src/thread_store.rs

@@ -893,8 +893,19 @@ impl ThreadsDatabase {
 
         let needs_migration_from_heed = mdb_path.exists();
 
-        let connection = if *ZED_STATELESS || cfg!(any(feature = "test-support", test)) {
+        let connection = if *ZED_STATELESS {
             Connection::open_memory(Some("THREAD_FALLBACK_DB"))
+        } else if cfg!(any(feature = "test-support", test)) {
+            // rust stores the name of the test on the current thread.
+            // We use this to automatically create a database that will
+            // be shared within the test (for the test_retrieve_old_thread)
+            // but not with concurrent tests.
+            let thread = std::thread::current();
+            let test_name = thread.name();
+            Connection::open_memory(Some(&format!(
+                "THREAD_FALLBACK_{}",
+                test_name.unwrap_or_default()
+            )))
         } else {
             Connection::open_file(&sqlite_path.to_string_lossy())
         };

crates/agent2/Cargo.toml

@@ -61,6 +61,7 @@ sqlez.workspace = true
 task.workspace = true
 telemetry.workspace = true
 terminal.workspace = true
+thiserror.workspace = true
 text.workspace = true
 ui.workspace = true
 util.workspace = true

crates/agent2/src/agent.rs

@@ -2,7 +2,7 @@ use crate::{
     ContextServerRegistry, Thread, ThreadEvent, ThreadsDatabase, ToolCallAuthorization,
     UserMessageContent, templates::Templates,
 };
-use crate::{HistoryStore, TokenUsageUpdated};
+use crate::{HistoryStore, TitleUpdated, TokenUsageUpdated};
 use acp_thread::{AcpThread, AgentModelSelector};
 use action_log::ActionLog;
 use agent_client_protocol as acp;
@@ -61,16 +61,19 @@ pub struct LanguageModels {
     model_list: acp_thread::AgentModelList,
     refresh_models_rx: watch::Receiver<()>,
     refresh_models_tx: watch::Sender<()>,
+    _authenticate_all_providers_task: Task<()>,
 }
 
 impl LanguageModels {
-    fn new(cx: &App) -> Self {
+    fn new(cx: &mut App) -> Self {
         let (refresh_models_tx, refresh_models_rx) = watch::channel(());
+
         let mut this = Self {
             models: HashMap::default(),
             model_list: acp_thread::AgentModelList::Grouped(IndexMap::default()),
             refresh_models_rx,
             refresh_models_tx,
+            _authenticate_all_providers_task: Self::authenticate_all_language_model_providers(cx),
         };
         this.refresh_list(cx);
         this
@@ -90,7 +93,7 @@ impl LanguageModels {
         let mut recommended = Vec::new();
         for provider in &providers {
             for model in provider.recommended_models(cx) {
-                recommended_models.insert(model.id());
+                recommended_models.insert((model.provider_id(), model.id()));
                 recommended.push(Self::map_language_model_to_info(&model, provider));
             }
         }
@@ -107,7 +110,7 @@ impl LanguageModels {
             for model in provider.provided_models(cx) {
                 let model_info = Self::map_language_model_to_info(&model, &provider);
                 let model_id = model_info.id.clone();
-                if !recommended_models.contains(&model.id()) {
+                if !recommended_models.contains(&(model.provider_id(), model.id())) {
                     provider_models.push(model_info);
                 }
                 models.insert(model_id, model);
@@ -150,6 +153,52 @@ impl LanguageModels {
     fn model_id(model: &Arc<dyn LanguageModel>) -> acp_thread::AgentModelId {
         acp_thread::AgentModelId(format!("{}/{}", model.provider_id().0, model.id().0).into())
     }
+
+    fn authenticate_all_language_model_providers(cx: &mut App) -> Task<()> {
+        let authenticate_all_providers = LanguageModelRegistry::global(cx)
+            .read(cx)
+            .providers()
+            .iter()
+            .map(|provider| (provider.id(), provider.name(), provider.authenticate(cx)))
+            .collect::<Vec<_>>();
+
+        cx.background_spawn(async move {
+            for (provider_id, provider_name, authenticate_task) in authenticate_all_providers {
+                if let Err(err) = authenticate_task.await {
+                    if matches!(err, language_model::AuthenticateError::CredentialsNotFound) {
+                        // Since we're authenticating these providers in the
+                        // background for the purposes of populating the
+                        // language selector, we don't care about providers
+                        // where the credentials are not found.
+                    } else {
+                        // Some providers have noisy failure states that we
+                        // don't want to spam the logs with every time the
+                        // language model selector is initialized.
+                        //
+                        // Ideally these should have more clear failure modes
+                        // that we know are safe to ignore here, like what we do
+                        // with `CredentialsNotFound` above.
+                        match provider_id.0.as_ref() {
+                            "lmstudio" | "ollama" => {
+                                // LM Studio and Ollama both make fetch requests to the local APIs to determine if they are "authenticated".
+                                //
+                                // These fail noisily, so we don't log them.
+                            }
+                            "copilot_chat" => {
+                                // Copilot Chat returns an error if Copilot is not enabled, so we don't log those errors.
+                            }
+                            _ => {
+                                log::error!(
+                                    "Failed to authenticate provider: {}: {err}",
+                                    provider_name.0
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        })
+    }
 }
 
 pub struct NativeAgent {
@@ -180,7 +229,7 @@ impl NativeAgent {
         fs: Arc<dyn Fs>,
         cx: &mut AsyncApp,
     ) -> Result<Entity<NativeAgent>> {
-        log::info!("Creating new NativeAgent");
+        log::debug!("Creating new NativeAgent");
 
         let project_context = cx
             .update(|cx| Self::build_project_context(&project, prompt_store.as_ref(), cx))?
@@ -240,19 +289,23 @@ impl NativeAgent {
         let title = thread.title();
         let project = thread.project.clone();
         let action_log = thread.action_log.clone();
-        let acp_thread = cx.new(|_cx| {
+        let prompt_capabilities_rx = thread.prompt_capabilities_rx.clone();
+        let acp_thread = cx.new(|cx| {
             acp_thread::AcpThread::new(
                 title,
                 connection,
                 project.clone(),
                 action_log.clone(),
                 session_id.clone(),
+                prompt_capabilities_rx,
+                cx,
             )
         });
         let subscriptions = vec![
             cx.observe_release(&acp_thread, |this, acp_thread, _cx| {
                 this.sessions.remove(acp_thread.session_id());
             }),
+            cx.subscribe(&thread_handle, Self::handle_thread_title_updated),
             cx.subscribe(&thread_handle, Self::handle_thread_token_usage_updated),
             cx.observe(&thread_handle, move |this, thread, cx| {
                 this.save_thread(thread, cx)
@@ -441,6 +494,26 @@ impl NativeAgent {
         })
     }
 
+    fn handle_thread_title_updated(
+        &mut self,
+        thread: Entity<Thread>,
+        _: &TitleUpdated,
+        cx: &mut Context<Self>,
+    ) {
+        let session_id = thread.read(cx).id();
+        let Some(session) = self.sessions.get(session_id) else {
+            return;
+        };
+        let thread = thread.downgrade();
+        let acp_thread = session.acp_thread.clone();
+        cx.spawn(async move |_, cx| {
+            let title = thread.read_with(cx, |thread, _| thread.title())?;
+            let task = acp_thread.update(cx, |acp_thread, cx| acp_thread.set_title(title, cx))?;
+            task.await
+        })
+        .detach_and_log_err(cx);
+    }
+
     fn handle_thread_token_usage_updated(
         &mut self,
         thread: Entity<Thread>,
@@ -717,10 +790,6 @@ impl NativeAgentConnection {
                                     thread.update_tool_call(update, cx)
                                 })??;
                             }
-                            ThreadEvent::TitleUpdate(title) => {
-                                acp_thread
-                                    .update(cx, |thread, cx| thread.update_title(title, cx))??;
-                            }
                             ThreadEvent::Retry(status) => {
                                 acp_thread.update(cx, |thread, cx| {
                                     thread.update_retry_status(status, cx)
@@ -739,7 +808,7 @@ impl NativeAgentConnection {
                 }
             }
 
-            log::info!("Response stream completed");
+            log::debug!("Response stream completed");
             anyhow::Ok(acp::PromptResponse {
                 stop_reason: acp::StopReason::EndTurn,
             })
@@ -764,7 +833,7 @@ impl AgentModelSelector for NativeAgentConnection {
         model_id: acp_thread::AgentModelId,
         cx: &mut App,
     ) -> Task<Result<()>> {
-        log::info!("Setting model for session {}: {}", session_id, model_id);
+        log::debug!("Setting model for session {}: {}", session_id, model_id);
         let Some(thread) = self
             .0
             .read(cx)
@@ -835,12 +904,11 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
         cx: &mut App,
     ) -> Task<Result<Entity<acp_thread::AcpThread>>> {
         let agent = self.0.clone();
-        log::info!("Creating new thread for project at: {:?}", cwd);
+        log::debug!("Creating new thread for project at: {:?}", cwd);
 
         cx.spawn(async move |cx| {
             log::debug!("Starting thread creation in async context");
 
-            let action_log = cx.new(|_cx| ActionLog::new(project.clone()))?;
             // Create Thread
             let thread = agent.update(
                 cx,
@@ -856,20 +924,16 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                             .models
                             .model_from_id(&LanguageModels::model_id(&default_model.model))
                     });
-
-                    let thread = cx.new(|cx| {
+                    Ok(cx.new(|cx| {
                         Thread::new(
                             project.clone(),
                             agent.project_context.clone(),
                             agent.context_server_registry.clone(),
-                            action_log.clone(),
                             agent.templates.clone(),
                             default_model,
                             cx,
                         )
-                    });
-
-                    Ok(thread)
+                    }))
                 },
             )??;
             agent.update(cx, |agent, cx| agent.register_session(thread, cx))
@@ -905,7 +969,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                 .into_iter()
                 .map(Into::into)
                 .collect::<Vec<_>>();
-            log::info!("Converted prompt to message: {} chars", content.len());
+            log::debug!("Converted prompt to message: {} chars", content.len());
             log::debug!("Message id: {:?}", id);
             log::debug!("Message content: {:?}", content);
 
@@ -913,18 +977,10 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
         })
     }
 
-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        acp::PromptCapabilities {
-            image: true,
-            audio: false,
-            embedded_context: true,
-        }
-    }
-
     fn resume(
         &self,
         session_id: &acp::SessionId,
-        _cx: &mut App,
+        _cx: &App,
     ) -> Option<Rc<dyn acp_thread::AgentSessionResume>> {
         Some(Rc::new(NativeAgentSessionResume {
             connection: self.clone(),
@@ -941,12 +997,12 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
         });
     }
 
-    fn session_editor(
+    fn truncate(
         &self,
         session_id: &agent_client_protocol::SessionId,
-        cx: &mut App,
-    ) -> Option<Rc<dyn acp_thread::AgentSessionEditor>> {
-        self.0.update(cx, |agent, _cx| {
+        cx: &App,
+    ) -> Option<Rc<dyn acp_thread::AgentSessionTruncate>> {
+        self.0.read_with(cx, |agent, _cx| {
             agent.sessions.get(session_id).map(|session| {
                 Rc::new(NativeAgentSessionEditor {
                     thread: session.thread.clone(),
@@ -956,10 +1012,34 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
         })
     }
 
+    fn set_title(
+        &self,
+        session_id: &acp::SessionId,
+        _cx: &App,
+    ) -> Option<Rc<dyn acp_thread::AgentSessionSetTitle>> {
+        Some(Rc::new(NativeAgentSessionSetTitle {
+            connection: self.clone(),
+            session_id: session_id.clone(),
+        }) as _)
+    }
+
     fn telemetry(&self) -> Option<Rc<dyn acp_thread::AgentTelemetry>> {
         Some(Rc::new(self.clone()) as Rc<dyn acp_thread::AgentTelemetry>)
     }
 
+    fn list_commands(&self, session_id: &acp::SessionId, _cx: &mut App) -> Task<Result<acp::ListCommandsResponse>> {
+        // Native agent doesn't support custom commands yet
+        let _session_id = session_id.clone();
+        Task::ready(Ok(acp::ListCommandsResponse {
+            commands: vec![],
+        }))
+    }
+
+    fn run_command(&self, _request: acp::RunCommandRequest, _cx: &mut App) -> Task<Result<()>> {
+        // Native agent doesn't support custom commands yet
+        Task::ready(Err(anyhow!("Custom commands not supported")))
+    }
+
     fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
         self
     }
@@ -991,8 +1071,8 @@ struct NativeAgentSessionEditor {
     acp_thread: WeakEntity<AcpThread>,
 }
 
-impl acp_thread::AgentSessionEditor for NativeAgentSessionEditor {
-    fn truncate(&self, message_id: acp_thread::UserMessageId, cx: &mut App) -> Task<Result<()>> {
+impl acp_thread::AgentSessionTruncate for NativeAgentSessionEditor {
+    fn run(&self, message_id: acp_thread::UserMessageId, cx: &mut App) -> Task<Result<()>> {
         match self.thread.update(cx, |thread, cx| {
             thread.truncate(message_id.clone(), cx)?;
             Ok(thread.latest_token_usage())
@@ -1024,6 +1104,22 @@ impl acp_thread::AgentSessionResume for NativeAgentSessionResume {
     }
 }
 
+struct NativeAgentSessionSetTitle {
+    connection: NativeAgentConnection,
+    session_id: acp::SessionId,
+}
+
+impl acp_thread::AgentSessionSetTitle for NativeAgentSessionSetTitle {
+    fn run(&self, title: SharedString, cx: &mut App) -> Task<Result<()>> {
+        let Some(session) = self.connection.0.read(cx).sessions.get(&self.session_id) else {
+            return Task::ready(Err(anyhow!("session not found")));
+        };
+        let thread = session.thread.clone();
+        thread.update(cx, |thread, cx| thread.set_title(title, cx));
+        Task::ready(Ok(()))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::HistoryEntryId;
@@ -1323,6 +1419,8 @@ mod tests {
             )
         });
 
+        cx.run_until_parked();
+
         // Drop the ACP thread, which should cause the session to be dropped as well.
         cx.update(|_| {
             drop(thread);
@@ -1365,10 +1463,9 @@ mod tests {
         history: &Entity<HistoryStore>,
         cx: &mut TestAppContext,
     ) -> Vec<(HistoryEntryId, String)> {
-        history.read_with(cx, |history, cx| {
+        history.read_with(cx, |history, _| {
             history
-                .entries(cx)
-                .iter()
+                .entries()
                 .map(|e| (e.id(), e.title().to_string()))
                 .collect::<Vec<_>>()
         })

crates/agent2/src/db.rs

@@ -266,8 +266,19 @@ impl ThreadsDatabase {
     }
 
     pub fn new(executor: BackgroundExecutor) -> Result<Self> {
-        let connection = if *ZED_STATELESS || cfg!(any(feature = "test-support", test)) {
+        let connection = if *ZED_STATELESS {
             Connection::open_memory(Some("THREAD_FALLBACK_DB"))
+        } else if cfg!(any(feature = "test-support", test)) {
+            // rust stores the name of the test on the current thread.
+            // We use this to automatically create a database that will
+            // be shared within the test (for the test_retrieve_old_thread)
+            // but not with concurrent tests.
+            let thread = std::thread::current();
+            let test_name = thread.name();
+            Connection::open_memory(Some(&format!(
+                "THREAD_FALLBACK_{}",
+                test_name.unwrap_or_default()
+            )))
         } else {
             let threads_dir = paths::data_dir().join("threads");
             std::fs::create_dir_all(&threads_dir)?;

crates/agent2/src/history_store.rs

@@ -86,6 +86,7 @@ enum SerializedRecentOpen {
 
 pub struct HistoryStore {
     threads: Vec<DbThreadMetadata>,
+    entries: Vec<HistoryEntry>,
     context_store: Entity<assistant_context::ContextStore>,
     recently_opened_entries: VecDeque<HistoryEntryId>,
     _subscriptions: Vec<gpui::Subscription>,
@@ -97,7 +98,7 @@ impl HistoryStore {
         context_store: Entity<assistant_context::ContextStore>,
         cx: &mut Context<Self>,
     ) -> Self {
-        let subscriptions = vec![cx.observe(&context_store, |_, _, cx| cx.notify())];
+        let subscriptions = vec![cx.observe(&context_store, |this, _, cx| this.update_entries(cx))];
 
         cx.spawn(async move |this, cx| {
             let entries = Self::load_recently_opened_entries(cx).await;
@@ -116,6 +117,7 @@ impl HistoryStore {
             context_store,
             recently_opened_entries: VecDeque::default(),
             threads: Vec::default(),
+            entries: Vec::default(),
             _subscriptions: subscriptions,
             _save_recently_opened_entries_task: Task::ready(()),
         }
@@ -181,20 +183,18 @@ impl HistoryStore {
                     }
                 }
                 this.threads = threads;
-                cx.notify();
+                this.update_entries(cx);
             })
         })
         .detach_and_log_err(cx);
     }
 
-    pub fn entries(&self, cx: &App) -> Vec<HistoryEntry> {
-        let mut history_entries = Vec::new();
-
+    fn update_entries(&mut self, cx: &mut Context<Self>) {
         #[cfg(debug_assertions)]
         if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
-            return history_entries;
+            return;
         }
-
+        let mut history_entries = Vec::new();
         history_entries.extend(self.threads.iter().cloned().map(HistoryEntry::AcpThread));
         history_entries.extend(
             self.context_store
@@ -205,17 +205,12 @@ impl HistoryStore {
         );
 
         history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
-        history_entries
+        self.entries = history_entries;
+        cx.notify()
     }
 
-    pub fn is_empty(&self, cx: &App) -> bool {
-        self.threads.is_empty()
-            && self
-                .context_store
-                .read(cx)
-                .unordered_contexts()
-                .next()
-                .is_none()
+    pub fn is_empty(&self, _cx: &App) -> bool {
+        self.entries.is_empty()
     }
 
     pub fn recently_opened_entries(&self, cx: &App) -> Vec<HistoryEntry> {
@@ -356,7 +351,7 @@ impl HistoryStore {
         self.save_recently_opened_entries(cx);
     }
 
-    pub fn recent_entries(&self, limit: usize, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
-        self.entries(cx).into_iter().take(limit).collect()
+    pub fn entries(&self) -> impl Iterator<Item = HistoryEntry> {
+        self.entries.iter().cloned()
     }
 }

crates/agent2/src/native_agent_server.rs

@@ -1,10 +1,9 @@
 use std::{any::Any, path::Path, rc::Rc, sync::Arc};
 
-use agent_servers::AgentServer;
+use agent_servers::{AgentServer, AgentServerDelegate};
 use anyhow::Result;
 use fs::Fs;
-use gpui::{App, Entity, Task};
-use project::Project;
+use gpui::{App, Entity, SharedString, Task};
 use prompt_store::PromptStore;
 
 use crate::{HistoryStore, NativeAgent, NativeAgentConnection, templates::Templates};
@@ -22,16 +21,12 @@ impl NativeAgentServer {
 }
 
 impl AgentServer for NativeAgentServer {
-    fn name(&self) -> &'static str {
-        "Native Agent"
+    fn telemetry_id(&self) -> &'static str {
+        "zed"
     }
 
-    fn empty_state_headline(&self) -> &'static str {
-        "Welcome to the Agent Panel"
-    }
-
-    fn empty_state_message(&self) -> &'static str {
-        ""
+    fn name(&self) -> SharedString {
+        "Zed Agent".into()
     }
 
     fn logo(&self) -> ui::IconName {
@@ -41,14 +36,14 @@ impl AgentServer for NativeAgentServer {
     fn connect(
         &self,
         _root_dir: &Path,
-        project: &Entity<Project>,
+        delegate: AgentServerDelegate,
         cx: &mut App,
     ) -> Task<Result<Rc<dyn acp_thread::AgentConnection>>> {
-        log::info!(
+        log::debug!(
             "NativeAgentServer::connect called for path: {:?}",
             _root_dir
         );
-        let project = project.clone();
+        let project = delegate.project().clone();
         let fs = self.fs.clone();
         let history = self.history.clone();
         let prompt_store = PromptStore::global(cx);
@@ -63,7 +58,7 @@ impl AgentServer for NativeAgentServer {
 
             // Create the connection wrapper
             let connection = NativeAgentConnection(agent);
-            log::info!("NativeAgentServer connection established successfully");
+            log::debug!("NativeAgentServer connection established successfully");
 
             Ok(Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>)
         })

crates/agent2/src/tests/test_tools.rs

@@ -16,11 +16,11 @@ impl AgentTool for EchoTool {
     type Input = EchoToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "echo".into()
+    fn name() -> &'static str {
+        "echo"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Other
     }
 
@@ -51,8 +51,8 @@ impl AgentTool for DelayTool {
     type Input = DelayToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "delay".into()
+    fn name() -> &'static str {
+        "delay"
     }
 
     fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
@@ -63,7 +63,7 @@ impl AgentTool for DelayTool {
         }
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Other
     }
 
@@ -92,11 +92,11 @@ impl AgentTool for ToolRequiringPermission {
     type Input = ToolRequiringPermissionInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "tool_requiring_permission".into()
+    fn name() -> &'static str {
+        "tool_requiring_permission"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Other
     }
 
@@ -127,11 +127,11 @@ impl AgentTool for InfiniteTool {
     type Input = InfiniteToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "infinite".into()
+    fn name() -> &'static str {
+        "infinite"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Other
     }
 
@@ -178,11 +178,11 @@ impl AgentTool for WordListTool {
     type Input = WordListInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "word_list".into()
+    fn name() -> &'static str {
+        "word_list"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Other
     }
 

crates/agent2/src/tools.rs

@@ -16,6 +16,29 @@ mod terminal_tool;
 mod thinking_tool;
 mod web_search_tool;
 
+/// A list of all built in tool names, for use in deduplicating MCP tool names
+pub fn default_tool_names() -> impl Iterator<Item = &'static str> {
+    [
+        CopyPathTool::name(),
+        CreateDirectoryTool::name(),
+        DeletePathTool::name(),
+        DiagnosticsTool::name(),
+        EditFileTool::name(),
+        FetchTool::name(),
+        FindPathTool::name(),
+        GrepTool::name(),
+        ListDirectoryTool::name(),
+        MovePathTool::name(),
+        NowTool::name(),
+        OpenTool::name(),
+        ReadFileTool::name(),
+        TerminalTool::name(),
+        ThinkingTool::name(),
+        WebSearchTool::name(),
+    ]
+    .into_iter()
+}
+
 pub use context_server_registry::*;
 pub use copy_path_tool::*;
 pub use create_directory_tool::*;
@@ -33,3 +56,5 @@ pub use read_file_tool::*;
 pub use terminal_tool::*;
 pub use thinking_tool::*;
 pub use web_search_tool::*;
+
+use crate::AgentTool;

crates/agent2/src/tools/copy_path_tool.rs

@@ -1,7 +1,7 @@
 use crate::{AgentTool, ToolCallEventStream};
 use agent_client_protocol::ToolKind;
 use anyhow::{Context as _, Result, anyhow};
-use gpui::{App, AppContext, Entity, SharedString, Task};
+use gpui::{App, AppContext, Entity, Task};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -50,11 +50,11 @@ impl AgentTool for CopyPathTool {
     type Input = CopyPathToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "copy_path".into()
+    fn name() -> &'static str {
+        "copy_path"
     }
 
-    fn kind(&self) -> ToolKind {
+    fn kind() -> ToolKind {
         ToolKind::Move
     }
 

crates/agent2/src/tools/create_directory_tool.rs

@@ -41,11 +41,11 @@ impl AgentTool for CreateDirectoryTool {
     type Input = CreateDirectoryToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "create_directory".into()
+    fn name() -> &'static str {
+        "create_directory"
     }
 
-    fn kind(&self) -> ToolKind {
+    fn kind() -> ToolKind {
         ToolKind::Read
     }
 

crates/agent2/src/tools/delete_path_tool.rs

@@ -44,11 +44,11 @@ impl AgentTool for DeletePathTool {
     type Input = DeletePathToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "delete_path".into()
+    fn name() -> &'static str {
+        "delete_path"
     }
 
-    fn kind(&self) -> ToolKind {
+    fn kind() -> ToolKind {
         ToolKind::Delete
     }
 

crates/agent2/src/tools/diagnostics_tool.rs

@@ -63,11 +63,11 @@ impl AgentTool for DiagnosticsTool {
     type Input = DiagnosticsToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "diagnostics".into()
+    fn name() -> &'static str {
+        "diagnostics"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Read
     }
 

crates/agent2/src/tools/edit_file_tool.rs

@@ -186,11 +186,11 @@ impl AgentTool for EditFileTool {
     type Input = EditFileToolInput;
     type Output = EditFileToolOutput;
 
-    fn name(&self) -> SharedString {
-        "edit_file".into()
+    fn name() -> &'static str {
+        "edit_file"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Edit
     }
 
@@ -273,6 +273,13 @@ impl AgentTool for EditFileTool {
 
             let diff = cx.new(|cx| Diff::new(buffer.clone(), cx))?;
             event_stream.update_diff(diff.clone());
+            let _finalize_diff = util::defer({
+               let diff = diff.downgrade();
+               let mut cx = cx.clone();
+               move || {
+                   diff.update(&mut cx, |diff, cx| diff.finalize(cx)).ok();
+               }
+            });
 
             let old_snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
             let old_text = cx
@@ -389,8 +396,6 @@ impl AgentTool for EditFileTool {
                 })
                 .await;
 
-            diff.update(cx, |diff, cx| diff.finalize(cx)).ok();
-
             let input_path = input.path.display();
             if unified_diff.is_empty() {
                 anyhow::ensure!(
@@ -517,7 +522,6 @@ fn resolve_path(
 mod tests {
     use super::*;
     use crate::{ContextServerRegistry, Templates};
-    use action_log::ActionLog;
     use client::TelemetrySettings;
     use fs::Fs;
     use gpui::{TestAppContext, UpdateGlobal};
@@ -535,7 +539,6 @@ mod tests {
         fs.insert_tree("/root", json!({})).await;
         let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let model = Arc::new(FakeLanguageModel::default());
@@ -544,7 +547,6 @@ mod tests {
                 project,
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
-                action_log,
                 Templates::new(),
                 Some(model),
                 cx,
@@ -735,7 +737,6 @@ mod tests {
             }
         });
 
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let model = Arc::new(FakeLanguageModel::default());
@@ -744,7 +745,6 @@ mod tests {
                 project,
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -801,7 +801,9 @@ mod tests {
             "Code should be formatted when format_on_save is enabled"
         );
 
-        let stale_buffer_count = action_log.read_with(cx, |log, cx| log.stale_buffers(cx).count());
+        let stale_buffer_count = thread
+            .read_with(cx, |thread, _cx| thread.action_log.clone())
+            .read_with(cx, |log, cx| log.stale_buffers(cx).count());
 
         assert_eq!(
             stale_buffer_count, 0,
@@ -879,14 +881,12 @@ mod tests {
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
                 project,
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1008,14 +1008,12 @@ mod tests {
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
                 project,
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1146,14 +1144,12 @@ mod tests {
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
                 project,
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1254,7 +1250,6 @@ mod tests {
         )
         .await;
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let model = Arc::new(FakeLanguageModel::default());
@@ -1263,7 +1258,6 @@ mod tests {
                 project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry.clone(),
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1336,7 +1330,6 @@ mod tests {
         .await;
         let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let model = Arc::new(FakeLanguageModel::default());
@@ -1345,7 +1338,6 @@ mod tests {
                 project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry.clone(),
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1421,7 +1413,6 @@ mod tests {
         .await;
         let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let model = Arc::new(FakeLanguageModel::default());
@@ -1430,7 +1421,6 @@ mod tests {
                 project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry.clone(),
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1503,7 +1493,6 @@ mod tests {
         let fs = project::FakeFs::new(cx.executor());
         let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
         let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let context_server_registry =
             cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
         let model = Arc::new(FakeLanguageModel::default());
@@ -1512,7 +1501,6 @@ mod tests {
                 project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
-                action_log.clone(),
                 Templates::new(),
                 Some(model.clone()),
                 cx,
@@ -1562,6 +1550,100 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_diff_finalization(cx: &mut TestAppContext) {
+        init_test(cx);
+        let fs = project::FakeFs::new(cx.executor());
+        fs.insert_tree("/", json!({"main.rs": ""})).await;
+
+        let project = Project::test(fs.clone(), [path!("/").as_ref()], cx).await;
+        let languages = project.read_with(cx, |project, _cx| project.languages().clone());
+        let context_server_registry =
+            cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
+        let model = Arc::new(FakeLanguageModel::default());
+        let thread = cx.new(|cx| {
+            Thread::new(
+                project.clone(),
+                cx.new(|_cx| ProjectContext::default()),
+                context_server_registry.clone(),
+                Templates::new(),
+                Some(model.clone()),
+                cx,
+            )
+        });
+
+        // Ensure the diff is finalized after the edit completes.
+        {
+            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
+            let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
+            let edit = cx.update(|cx| {
+                tool.run(
+                    EditFileToolInput {
+                        display_description: "Edit file".into(),
+                        path: path!("/main.rs").into(),
+                        mode: EditFileMode::Edit,
+                    },
+                    stream_tx,
+                    cx,
+                )
+            });
+            stream_rx.expect_update_fields().await;
+            let diff = stream_rx.expect_diff().await;
+            diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Pending(_))));
+            cx.run_until_parked();
+            model.end_last_completion_stream();
+            edit.await.unwrap();
+            diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Finalized(_))));
+        }
+
+        // Ensure the diff is finalized if an error occurs while editing.
+        {
+            model.forbid_requests();
+            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
+            let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
+            let edit = cx.update(|cx| {
+                tool.run(
+                    EditFileToolInput {
+                        display_description: "Edit file".into(),
+                        path: path!("/main.rs").into(),
+                        mode: EditFileMode::Edit,
+                    },
+                    stream_tx,
+                    cx,
+                )
+            });
+            stream_rx.expect_update_fields().await;
+            let diff = stream_rx.expect_diff().await;
+            diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Pending(_))));
+            edit.await.unwrap_err();
+            diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Finalized(_))));
+            model.allow_requests();
+        }
+
+        // Ensure the diff is finalized if the tool call gets dropped.
+        {
+            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
+            let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
+            let edit = cx.update(|cx| {
+                tool.run(
+                    EditFileToolInput {
+                        display_description: "Edit file".into(),
+                        path: path!("/main.rs").into(),
+                        mode: EditFileMode::Edit,
+                    },
+                    stream_tx,
+                    cx,
+                )
+            });
+            stream_rx.expect_update_fields().await;
+            let diff = stream_rx.expect_diff().await;
+            diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Pending(_))));
+            drop(edit);
+            cx.run_until_parked();
+            diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Finalized(_))));
+        }
+    }
+
     fn init_test(cx: &mut TestAppContext) {
         cx.update(|cx| {
             let settings_store = SettingsStore::test(cx);

crates/agent2/src/tools/fetch_tool.rs

@@ -118,11 +118,11 @@ impl AgentTool for FetchTool {
     type Input = FetchToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "fetch".into()
+    fn name() -> &'static str {
+        "fetch"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Fetch
     }
 
@@ -136,12 +136,17 @@ impl AgentTool for FetchTool {
     fn run(
         self: Arc<Self>,
         input: Self::Input,
-        _event_stream: ToolCallEventStream,
+        event_stream: ToolCallEventStream,
         cx: &mut App,
     ) -> Task<Result<Self::Output>> {
+        let authorize = event_stream.authorize(input.url.clone(), cx);
+
         let text = cx.background_spawn({
             let http_client = self.http_client.clone();
-            async move { Self::build_message(http_client, &input.url).await }
+            async move {
+                authorize.await?;
+                Self::build_message(http_client, &input.url).await
+            }
         });
 
         cx.foreground_executor().spawn(async move {

crates/agent2/src/tools/find_path_tool.rs

@@ -85,11 +85,11 @@ impl AgentTool for FindPathTool {
     type Input = FindPathToolInput;
     type Output = FindPathToolOutput;
 
-    fn name(&self) -> SharedString {
-        "find_path".into()
+    fn name() -> &'static str {
+        "find_path"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Search
     }
 
@@ -165,16 +165,17 @@ fn search_paths(glob: &str, project: Entity<Project>, cx: &mut App) -> Task<Resu
         .collect();
 
     cx.background_spawn(async move {
-        Ok(snapshots
-            .iter()
-            .flat_map(|snapshot| {
+        let mut results = Vec::new();
+        for snapshot in snapshots {
+            for entry in snapshot.entries(false, 0) {
                 let root_name = PathBuf::from(snapshot.root_name());
-                snapshot
-                    .entries(false, 0)
-                    .map(move |entry| root_name.join(&entry.path))
-                    .filter(|path| path_matcher.is_match(&path))
-            })
-            .collect())
+                if path_matcher.is_match(root_name.join(&entry.path)) {
+                    results.push(snapshot.abs_path().join(entry.path.as_ref()));
+                }
+            }
+        }
+
+        Ok(results)
     })
 }
 
@@ -215,8 +216,8 @@ mod test {
         assert_eq!(
             matches,
             &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
+                PathBuf::from(path!("/root/apple/banana/carrot")),
+                PathBuf::from(path!("/root/apple/bandana/carbonara"))
             ]
         );
 
@@ -227,8 +228,8 @@ mod test {
         assert_eq!(
             matches,
             &[
-                PathBuf::from("root/apple/banana/carrot"),
-                PathBuf::from("root/apple/bandana/carbonara")
+                PathBuf::from(path!("/root/apple/banana/carrot")),
+                PathBuf::from(path!("/root/apple/bandana/carbonara"))
             ]
         );
     }

crates/agent2/src/tools/grep_tool.rs

@@ -67,11 +67,11 @@ impl AgentTool for GrepTool {
     type Input = GrepToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "grep".into()
+    fn name() -> &'static str {
+        "grep"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Search
     }
 

crates/agent2/src/tools/list_directory_tool.rs

@@ -51,11 +51,11 @@ impl AgentTool for ListDirectoryTool {
     type Input = ListDirectoryToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "list_directory".into()
+    fn name() -> &'static str {
+        "list_directory"
     }
 
-    fn kind(&self) -> ToolKind {
+    fn kind() -> ToolKind {
         ToolKind::Read
     }
 

crates/agent2/src/tools/move_path_tool.rs

@@ -52,11 +52,11 @@ impl AgentTool for MovePathTool {
     type Input = MovePathToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "move_path".into()
+    fn name() -> &'static str {
+        "move_path"
     }
 
-    fn kind(&self) -> ToolKind {
+    fn kind() -> ToolKind {
         ToolKind::Move
     }
 

crates/agent2/src/tools/now_tool.rs

@@ -32,11 +32,11 @@ impl AgentTool for NowTool {
     type Input = NowToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "now".into()
+    fn name() -> &'static str {
+        "now"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Other
     }
 

crates/agent2/src/tools/open_tool.rs

@@ -37,11 +37,11 @@ impl AgentTool for OpenTool {
     type Input = OpenToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "open".into()
+    fn name() -> &'static str {
+        "open"
     }
 
-    fn kind(&self) -> ToolKind {
+    fn kind() -> ToolKind {
         ToolKind::Execute
     }
 

crates/agent2/src/tools/read_file_tool.rs

@@ -10,7 +10,8 @@ use project::{AgentLocation, ImageItem, Project, WorktreeSettings, image_store};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
-use std::sync::Arc;
+use std::{path::Path, sync::Arc};
+use util::markdown::MarkdownCodeBlock;
 
 use crate::{AgentTool, ToolCallEventStream};
 
@@ -59,36 +60,21 @@ impl AgentTool for ReadFileTool {
     type Input = ReadFileToolInput;
     type Output = LanguageModelToolResultContent;
 
-    fn name(&self) -> SharedString {
-        "read_file".into()
+    fn name() -> &'static str {
+        "read_file"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Read
     }
 
     fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
-        if let Ok(input) = input {
-            let path = &input.path;
-            match (input.start_line, input.end_line) {
-                (Some(start), Some(end)) => {
-                    format!(
-                        "[Read file `{}` (lines {}-{})](@selection:{}:({}-{}))",
-                        path, start, end, path, start, end
-                    )
-                }
-                (Some(start), None) => {
-                    format!(
-                        "[Read file `{}` (from line {})](@selection:{}:({}-{}))",
-                        path, start, path, start, start
-                    )
-                }
-                _ => format!("[Read file `{}`](@file:{})", path, path),
-            }
-            .into()
-        } else {
-            "Read file".into()
-        }
+        input
+            .ok()
+            .as_ref()
+            .and_then(|input| Path::new(&input.path).file_name())
+            .map(|file_name| file_name.to_string_lossy().to_string().into())
+            .unwrap_or_default()
     }
 
     fn run(
@@ -258,6 +244,19 @@ impl AgentTool for ReadFileTool {
                         }]),
                         ..Default::default()
                     });
+                    if let Ok(LanguageModelToolResultContent::Text(text)) = &result {
+                        let markdown = MarkdownCodeBlock {
+                            tag: &input.path,
+                            text,
+                        }
+                        .to_string();
+                        event_stream.update_fields(ToolCallUpdateFields {
+                            content: Some(vec![acp::ToolCallContent::Content {
+                                content: markdown.into(),
+                            }]),
+                            ..Default::default()
+                        })
+                    }
                 }
             })?;
 

crates/agent2/src/tools/terminal_tool.rs

@@ -2,7 +2,7 @@ use agent_client_protocol as acp;
 use anyhow::Result;
 use futures::{FutureExt as _, future::Shared};
 use gpui::{App, AppContext, Entity, SharedString, Task};
-use project::{Project, terminals::TerminalKind};
+use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{
@@ -63,11 +63,11 @@ impl AgentTool for TerminalTool {
     type Input = TerminalToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "terminal".into()
+    fn name() -> &'static str {
+        "terminal"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Execute
     }
 
@@ -144,14 +144,14 @@ impl AgentTool for TerminalTool {
                 let terminal = self
                     .project
                     .update(cx, |project, cx| {
-                        project.create_terminal(
-                            TerminalKind::Task(task::SpawnInTerminal {
+                        project.create_terminal_task(
+                            task::SpawnInTerminal {
                                 command: Some(program),
                                 args,
                                 cwd: working_dir.clone(),
                                 env,
                                 ..Default::default()
-                            }),
+                            },
                             cx,
                         )
                     })?

crates/agent2/src/tools/thinking_tool.rs

@@ -21,11 +21,11 @@ impl AgentTool for ThinkingTool {
     type Input = ThinkingToolInput;
     type Output = String;
 
-    fn name(&self) -> SharedString {
-        "thinking".into()
+    fn name() -> &'static str {
+        "thinking"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Think
     }
 

crates/agent2/src/tools/web_search_tool.rs

@@ -40,11 +40,11 @@ impl AgentTool for WebSearchTool {
     type Input = WebSearchToolInput;
     type Output = WebSearchToolOutput;
 
-    fn name(&self) -> SharedString {
-        "web_search".into()
+    fn name() -> &'static str {
+        "web_search"
     }
 
-    fn kind(&self) -> acp::ToolKind {
+    fn kind() -> acp::ToolKind {
         acp::ToolKind::Fetch
     }
 

crates/agent_servers/Cargo.toml

@@ -6,7 +6,7 @@ publish.workspace = true
 license = "GPL-3.0-or-later"
 
 [features]
-test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support", "dep:env_logger", "fs", "client/test-support", "dep:gpui_tokio", "reqwest_client/test-support"]
+test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support", "dep:env_logger", "client/test-support", "dep:gpui_tokio", "reqwest_client/test-support"]
 e2e = []
 
 [lints]
@@ -17,17 +17,17 @@ path = "src/agent_servers.rs"
 doctest = false
 
 [dependencies]
+acp_tools.workspace = true
 acp_thread.workspace = true
 action_log.workspace = true
 agent-client-protocol.workspace = true
 agent_settings.workspace = true
-agentic-coding-protocol.workspace = true
 anyhow.workspace = true
 client = { workspace = true, optional = true }
 collections.workspace = true
 context_server.workspace = true
 env_logger = { workspace = true, optional = true }
-fs = { workspace = true, optional = true }
+fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 gpui_tokio = { workspace = true, optional = true }
@@ -37,6 +37,7 @@ language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 log.workspace = true
+node_runtime.workspace = true
 paths.workspace = true
 project.workspace = true
 rand.workspace = true

crates/agent_servers/src/acp.rs

@@ -1,34 +1,463 @@
-use std::{path::Path, rc::Rc};
-
 use crate::AgentServerCommand;
 use acp_thread::AgentConnection;
-use anyhow::Result;
-use gpui::AsyncApp;
+use acp_tools::AcpConnectionRegistry;
+use action_log::ActionLog;
+use agent_client_protocol::{self as acp, Agent as _, ErrorCode};
+use agent_settings::AgentSettings;
+use anyhow::anyhow;
+use collections::HashMap;
+use futures::AsyncBufReadExt as _;
+use futures::channel::oneshot;
+use futures::io::BufReader;
+use project::Project;
+use serde::Deserialize;
+use settings::Settings as _;
+use std::{any::Any, cell::RefCell};
+use std::{path::Path, rc::Rc};
 use thiserror::Error;
 
-mod v0;
-mod v1;
+use anyhow::{Context as _, Result};
+use gpui::{App, AppContext as _, AsyncApp, Entity, SharedString, Task, WeakEntity};
+
+use acp_thread::{AcpThread, AuthRequired, LoadError};
 
 #[derive(Debug, Error)]
 #[error("Unsupported version")]
 pub struct UnsupportedVersion;
 
+pub struct AcpConnection {
+    server_name: SharedString,
+    connection: Rc<acp::ClientSideConnection>,
+    sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
+    auth_methods: Vec<acp::AuthMethod>,
+    prompt_capabilities: acp::PromptCapabilities,
+    _io_task: Task<Result<()>>,
+    _wait_task: Task<Result<()>>,
+    _stderr_task: Task<Result<()>>,
+}
+
+pub struct AcpSession {
+    thread: WeakEntity<AcpThread>,
+    suppress_abort_err: bool,
+}
+
 pub async fn connect(
-    server_name: &'static str,
+    server_name: SharedString,
     command: AgentServerCommand,
     root_dir: &Path,
     cx: &mut AsyncApp,
 ) -> Result<Rc<dyn AgentConnection>> {
-    let conn = v1::AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await;
+    let conn = AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await?;
+    Ok(Rc::new(conn) as _)
+}
 
-    match conn {
-        Ok(conn) => Ok(Rc::new(conn) as _),
-        Err(err) if err.is::<UnsupportedVersion>() => {
-            // Consider re-using initialize response and subprocess when adding another version here
-            let conn: Rc<dyn AgentConnection> =
-                Rc::new(v0::AcpConnection::stdio(server_name, command, root_dir, cx).await?);
-            Ok(conn)
+const MINIMUM_SUPPORTED_VERSION: acp::ProtocolVersion = acp::V1;
+
+impl AcpConnection {
+    pub async fn stdio(
+        server_name: SharedString,
+        command: AgentServerCommand,
+        root_dir: &Path,
+        cx: &mut AsyncApp,
+    ) -> Result<Self> {
+        let mut child = util::command::new_smol_command(command.path)
+            .args(command.args.iter().map(|arg| arg.as_str()))
+            .envs(command.env.iter().flatten())
+            .current_dir(root_dir)
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .kill_on_drop(true)
+            .spawn()?;
+
+        let stdout = child.stdout.take().context("Failed to take stdout")?;
+        let stdin = child.stdin.take().context("Failed to take stdin")?;
+        let stderr = child.stderr.take().context("Failed to take stderr")?;
+        log::trace!("Spawned (pid: {})", child.id());
+
+        let sessions = Rc::new(RefCell::new(HashMap::default()));
+
+        let client = ClientDelegate {
+            sessions: sessions.clone(),
+            cx: cx.clone(),
+        };
+        let (connection, io_task) = acp::ClientSideConnection::new(client, stdin, stdout, {
+            let foreground_executor = cx.foreground_executor().clone();
+            move |fut| {
+                foreground_executor.spawn(fut).detach();
+            }
+        });
+
+        let io_task = cx.background_spawn(io_task);
+
+        let stderr_task = cx.background_spawn(async move {
+            let mut stderr = BufReader::new(stderr);
+            let mut line = String::new();
+            while let Ok(n) = stderr.read_line(&mut line).await
+                && n > 0
+            {
+                log::warn!("agent stderr: {}", &line);
+                line.clear();
+            }
+            Ok(())
+        });
+
+        let wait_task = cx.spawn({
+            let sessions = sessions.clone();
+            async move |cx| {
+                let status = child.status().await?;
+
+                for session in sessions.borrow().values() {
+                    session
+                        .thread
+                        .update(cx, |thread, cx| {
+                            thread.emit_load_error(LoadError::Exited { status }, cx)
+                        })
+                        .ok();
+                }
+
+                anyhow::Ok(())
+            }
+        });
+
+        let connection = Rc::new(connection);
+
+        cx.update(|cx| {
+            AcpConnectionRegistry::default_global(cx).update(cx, |registry, cx| {
+                registry.set_active_connection(server_name.clone(), &connection, cx)
+            });
+        })?;
+
+        let response = connection
+            .initialize(acp::InitializeRequest {
+                protocol_version: acp::VERSION,
+                client_capabilities: acp::ClientCapabilities {
+                    fs: acp::FileSystemCapability {
+                        read_text_file: true,
+                        write_text_file: true,
+                    },
+                    terminal: true,
+                },
+            })
+            .await?;
+
+        if response.protocol_version < MINIMUM_SUPPORTED_VERSION {
+            return Err(UnsupportedVersion.into());
         }
-        Err(err) => Err(err),
+
+        Ok(Self {
+            auth_methods: response.auth_methods,
+            connection,
+            server_name,
+            sessions,
+            prompt_capabilities: response.agent_capabilities.prompt_capabilities,
+            _io_task: io_task,
+            _wait_task: wait_task,
+            _stderr_task: stderr_task,
+        })
+    }
+
+    pub fn prompt_capabilities(&self) -> &acp::PromptCapabilities {
+        &self.prompt_capabilities
+    }
+}
+
+impl AgentConnection for AcpConnection {
+    fn new_thread(
+        self: Rc<Self>,
+        project: Entity<Project>,
+        cwd: &Path,
+        cx: &mut App,
+    ) -> Task<Result<Entity<AcpThread>>> {
+        let conn = self.connection.clone();
+        let sessions = self.sessions.clone();
+        let cwd = cwd.to_path_buf();
+        let context_server_store = project.read(cx).context_server_store().read(cx);
+        let mcp_servers = context_server_store
+            .configured_server_ids()
+            .iter()
+            .filter_map(|id| {
+                let configuration = context_server_store.configuration_for_server(id)?;
+                let command = configuration.command();
+                Some(acp::McpServer {
+                    name: id.0.to_string(),
+                    command: command.path.clone(),
+                    args: command.args.clone(),
+                    env: if let Some(env) = command.env.as_ref() {
+                        env.iter()
+                            .map(|(name, value)| acp::EnvVariable {
+                                name: name.clone(),
+                                value: value.clone(),
+                            })
+                            .collect()
+                    } else {
+                        vec![]
+                    },
+                })
+            })
+            .collect();
+
+        cx.spawn(async move |cx| {
+            let response = conn
+                .new_session(acp::NewSessionRequest { mcp_servers, cwd })
+                .await
+                .map_err(|err| {
+                    if err.code == acp::ErrorCode::AUTH_REQUIRED.code {
+                        let mut error = AuthRequired::new();
+
+                        if err.message != acp::ErrorCode::AUTH_REQUIRED.message {
+                            error = error.with_description(err.message);
+                        }
+
+                        anyhow!(error)
+                    } else {
+                        anyhow!(err)
+                    }
+                })?;
+
+            let session_id = response.session_id;
+            let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
+            let thread = cx.new(|cx| {
+                AcpThread::new(
+                    self.server_name.clone(),
+                    self.clone(),
+                    project,
+                    action_log,
+                    session_id.clone(),
+                    // ACP doesn't currently support per-session prompt capabilities or changing capabilities dynamically.
+                    watch::Receiver::constant(self.prompt_capabilities),
+                    cx,
+                )
+            })?;
+
+            let session = AcpSession {
+                thread: thread.downgrade(),
+                suppress_abort_err: false,
+            };
+            sessions.borrow_mut().insert(session_id, session);
+
+            Ok(thread)
+        })
+    }
+
+    fn auth_methods(&self) -> &[acp::AuthMethod] {
+        &self.auth_methods
+    }
+
+    fn authenticate(&self, method_id: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>> {
+        let conn = self.connection.clone();
+        cx.foreground_executor().spawn(async move {
+            let result = conn
+                .authenticate(acp::AuthenticateRequest {
+                    method_id: method_id.clone(),
+                })
+                .await?;
+
+            Ok(result)
+        })
+    }
+
+    fn prompt(
+        &self,
+        _id: Option<acp_thread::UserMessageId>,
+        params: acp::PromptRequest,
+        cx: &mut App,
+    ) -> Task<Result<acp::PromptResponse>> {
+        let conn = self.connection.clone();
+        let sessions = self.sessions.clone();
+        let session_id = params.session_id.clone();
+        cx.foreground_executor().spawn(async move {
+            let result = conn.prompt(params).await;
+
+            let mut suppress_abort_err = false;
+
+            if let Some(session) = sessions.borrow_mut().get_mut(&session_id) {
+                suppress_abort_err = session.suppress_abort_err;
+                session.suppress_abort_err = false;
+            }
+
+            match result {
+                Ok(response) => Ok(response),
+                Err(err) => {
+                    if err.code != ErrorCode::INTERNAL_ERROR.code {
+                        anyhow::bail!(err)
+                    }
+
+                    let Some(data) = &err.data else {
+                        anyhow::bail!(err)
+                    };
+
+                    // Temporary workaround until the following PR is generally available:
+                    // https://github.com/google-gemini/gemini-cli/pull/6656
+
+                    #[derive(Deserialize)]
+                    #[serde(deny_unknown_fields)]
+                    struct ErrorDetails {
+                        details: Box<str>,
+                    }
+
+                    match serde_json::from_value(data.clone()) {
+                        Ok(ErrorDetails { details }) => {
+                            if suppress_abort_err
+                                && (details.contains("This operation was aborted")
+                                    || details.contains("The user aborted a request"))
+                            {
+                                Ok(acp::PromptResponse {
+                                    stop_reason: acp::StopReason::Cancelled,
+                                })
+                            } else {
+                                Err(anyhow!(details))
+                            }
+                        }
+                        Err(_) => Err(anyhow!(err)),
+                    }
+                }
+            }
+        })
+    }
+
+    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
+        if let Some(session) = self.sessions.borrow_mut().get_mut(session_id) {
+            session.suppress_abort_err = true;
+        }
+        let conn = self.connection.clone();
+        let params = acp::CancelNotification {
+            session_id: session_id.clone(),
+        };
+        cx.foreground_executor()
+            .spawn(async move { conn.cancel(params).await })
+            .detach();
+    }
+
+    fn list_commands(&self, session_id: &acp::SessionId, cx: &mut App) -> Task<Result<acp::ListCommandsResponse>> {
+        let conn = self.connection.clone();
+        let session_id = session_id.clone();
+        cx.foreground_executor().spawn(async move {
+            conn.list_commands(acp::ListCommandsRequest { session_id }).await
+                .map_err(Into::into)
+        })
+    }
+
+    fn run_command(&self, request: acp::RunCommandRequest, cx: &mut App) -> Task<Result<()>> {
+        let conn = self.connection.clone();
+        cx.foreground_executor().spawn(async move {
+            conn.run_command(request).await
+                .map_err(Into::into)
+        })
+    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
+}
+
+struct ClientDelegate {
+    sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
+    cx: AsyncApp,
+}
+
+impl acp::Client for ClientDelegate {
+    async fn request_permission(
+        &self,
+        arguments: acp::RequestPermissionRequest,
+    ) -> Result<acp::RequestPermissionResponse, acp::Error> {
+        let cx = &mut self.cx.clone();
+
+        // If always_allow_tool_actions is enabled, then auto-choose the first "Allow" button
+        if AgentSettings::try_read_global(cx, |settings| settings.always_allow_tool_actions)
+            .unwrap_or(false)
+        {
+            // Don't use AllowAlways, because then if you were to turn off always_allow_tool_actions,
+            // some tools would (incorrectly) continue to auto-accept.
+            if let Some(allow_once_option) = arguments.options.iter().find_map(|option| {
+                if matches!(option.kind, acp::PermissionOptionKind::AllowOnce) {
+                    Some(option.id.clone())
+                } else {
+                    None
+                }
+            }) {
+                return Ok(acp::RequestPermissionResponse {
+                    outcome: acp::RequestPermissionOutcome::Selected {
+                        option_id: allow_once_option,
+                    },
+                });
+            }
+        }
+
+        let rx = self
+            .sessions
+            .borrow()
+            .get(&arguments.session_id)
+            .context("Failed to get session")?
+            .thread
+            .update(cx, |thread, cx| {
+                thread.request_tool_call_authorization(arguments.tool_call, arguments.options, cx)
+            })?;
+
+        let result = rx?.await;
+
+        let outcome = match result {
+            Ok(option) => acp::RequestPermissionOutcome::Selected { option_id: option },
+            Err(oneshot::Canceled) => acp::RequestPermissionOutcome::Cancelled,
+        };
+
+        Ok(acp::RequestPermissionResponse { outcome })
+    }
+
+    async fn write_text_file(
+        &self,
+        arguments: acp::WriteTextFileRequest,
+    ) -> Result<(), acp::Error> {
+        let cx = &mut self.cx.clone();
+        let task = self
+            .sessions
+            .borrow()
+            .get(&arguments.session_id)
+            .context("Failed to get session")?
+            .thread
+            .update(cx, |thread, cx| {
+                thread.write_text_file(arguments.path, arguments.content, cx)
+            })?;
+
+        task.await?;
+
+        Ok(())
+    }
+
+    async fn read_text_file(
+        &self,
+        arguments: acp::ReadTextFileRequest,
+    ) -> Result<acp::ReadTextFileResponse, acp::Error> {
+        let cx = &mut self.cx.clone();
+        let task = self
+            .sessions
+            .borrow()
+            .get(&arguments.session_id)
+            .context("Failed to get session")?
+            .thread
+            .update(cx, |thread, cx| {
+                thread.read_text_file(arguments.path, arguments.line, arguments.limit, false, cx)
+            })?;
+
+        let content = task.await?;
+
+        Ok(acp::ReadTextFileResponse { content })
+    }
+
+    async fn session_notification(
+        &self,
+        notification: acp::SessionNotification,
+    ) -> Result<(), acp::Error> {
+        let cx = &mut self.cx.clone();
+        let sessions = self.sessions.borrow();
+        let session = sessions
+            .get(&notification.session_id)
+            .context("Failed to get session")?;
+
+        session.thread.update(cx, |thread, cx| {
+            thread.handle_session_update(notification.update, cx)
+        })??;
+
+        Ok(())
     }
 }

crates/agent_servers/src/acp/v0.rs

@@ -1,524 +0,0 @@
-// Translates old acp agents into the new schema
-use action_log::ActionLog;
-use agent_client_protocol as acp;
-use agentic_coding_protocol::{self as acp_old, AgentRequest as _};
-use anyhow::{Context as _, Result, anyhow};
-use futures::channel::oneshot;
-use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity};
-use project::Project;
-use std::{any::Any, cell::RefCell, path::Path, rc::Rc};
-use ui::App;
-use util::ResultExt as _;
-
-use crate::AgentServerCommand;
-use acp_thread::{AcpThread, AgentConnection, AuthRequired};
-
-#[derive(Clone)]
-struct OldAcpClientDelegate {
-    thread: Rc<RefCell<WeakEntity<AcpThread>>>,
-    cx: AsyncApp,
-    next_tool_call_id: Rc<RefCell<u64>>,
-    // sent_buffer_versions: HashMap<Entity<Buffer>, HashMap<u64, BufferSnapshot>>,
-}
-
-impl OldAcpClientDelegate {
-    fn new(thread: Rc<RefCell<WeakEntity<AcpThread>>>, cx: AsyncApp) -> Self {
-        Self {
-            thread,
-            cx,
-            next_tool_call_id: Rc::new(RefCell::new(0)),
-        }
-    }
-}
-
-impl acp_old::Client for OldAcpClientDelegate {
-    async fn stream_assistant_message_chunk(
-        &self,
-        params: acp_old::StreamAssistantMessageChunkParams,
-    ) -> Result<(), acp_old::Error> {
-        let cx = &mut self.cx.clone();
-
-        cx.update(|cx| {
-            self.thread
-                .borrow()
-                .update(cx, |thread, cx| match params.chunk {
-                    acp_old::AssistantMessageChunk::Text { text } => {
-                        thread.push_assistant_content_block(text.into(), false, cx)
-                    }
-                    acp_old::AssistantMessageChunk::Thought { thought } => {
-                        thread.push_assistant_content_block(thought.into(), true, cx)
-                    }
-                })
-                .log_err();
-        })?;
-
-        Ok(())
-    }
-
-    async fn request_tool_call_confirmation(
-        &self,
-        request: acp_old::RequestToolCallConfirmationParams,
-    ) -> Result<acp_old::RequestToolCallConfirmationResponse, acp_old::Error> {
-        let cx = &mut self.cx.clone();
-
-        let old_acp_id = *self.next_tool_call_id.borrow() + 1;
-        self.next_tool_call_id.replace(old_acp_id);
-
-        let tool_call = into_new_tool_call(
-            acp::ToolCallId(old_acp_id.to_string().into()),
-            request.tool_call,
-        );
-
-        let mut options = match request.confirmation {
-            acp_old::ToolCallConfirmation::Edit { .. } => vec![(
-                acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
-                acp::PermissionOptionKind::AllowAlways,
-                "Always Allow Edits".to_string(),
-            )],
-            acp_old::ToolCallConfirmation::Execute { root_command, .. } => vec![(
-                acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
-                acp::PermissionOptionKind::AllowAlways,
-                format!("Always Allow {}", root_command),
-            )],
-            acp_old::ToolCallConfirmation::Mcp {
-                server_name,
-                tool_name,
-                ..
-            } => vec![
-                (
-                    acp_old::ToolCallConfirmationOutcome::AlwaysAllowMcpServer,
-                    acp::PermissionOptionKind::AllowAlways,
-                    format!("Always Allow {}", server_name),
-                ),
-                (
-                    acp_old::ToolCallConfirmationOutcome::AlwaysAllowTool,
-                    acp::PermissionOptionKind::AllowAlways,
-                    format!("Always Allow {}", tool_name),
-                ),
-            ],
-            acp_old::ToolCallConfirmation::Fetch { .. } => vec![(
-                acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
-                acp::PermissionOptionKind::AllowAlways,
-                "Always Allow".to_string(),
-            )],
-            acp_old::ToolCallConfirmation::Other { .. } => vec![(
-                acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
-                acp::PermissionOptionKind::AllowAlways,
-                "Always Allow".to_string(),
-            )],
-        };
-
-        options.extend([
-            (
-                acp_old::ToolCallConfirmationOutcome::Allow,
-                acp::PermissionOptionKind::AllowOnce,
-                "Allow".to_string(),
-            ),
-            (
-                acp_old::ToolCallConfirmationOutcome::Reject,
-                acp::PermissionOptionKind::RejectOnce,
-                "Reject".to_string(),
-            ),
-        ]);
-
-        let mut outcomes = Vec::with_capacity(options.len());
-        let mut acp_options = Vec::with_capacity(options.len());
-
-        for (index, (outcome, kind, label)) in options.into_iter().enumerate() {
-            outcomes.push(outcome);
-            acp_options.push(acp::PermissionOption {
-                id: acp::PermissionOptionId(index.to_string().into()),
-                name: label,
-                kind,
-            })
-        }
-
-        let response = cx
-            .update(|cx| {
-                self.thread.borrow().update(cx, |thread, cx| {
-                    thread.request_tool_call_authorization(tool_call.into(), acp_options, cx)
-                })
-            })??
-            .context("Failed to update thread")?
-            .await;
-
-        let outcome = match response {
-            Ok(option_id) => outcomes[option_id.0.parse::<usize>().unwrap_or(0)],
-            Err(oneshot::Canceled) => acp_old::ToolCallConfirmationOutcome::Cancel,
-        };
-
-        Ok(acp_old::RequestToolCallConfirmationResponse {
-            id: acp_old::ToolCallId(old_acp_id),
-            outcome,
-        })
-    }
-
-    async fn push_tool_call(
-        &self,
-        request: acp_old::PushToolCallParams,
-    ) -> Result<acp_old::PushToolCallResponse, acp_old::Error> {
-        let cx = &mut self.cx.clone();
-
-        let old_acp_id = *self.next_tool_call_id.borrow() + 1;
-        self.next_tool_call_id.replace(old_acp_id);
-
-        cx.update(|cx| {
-            self.thread.borrow().update(cx, |thread, cx| {
-                thread.upsert_tool_call(
-                    into_new_tool_call(acp::ToolCallId(old_acp_id.to_string().into()), request),
-                    cx,
-                )
-            })
-        })??
-        .context("Failed to update thread")?;
-
-        Ok(acp_old::PushToolCallResponse {
-            id: acp_old::ToolCallId(old_acp_id),
-        })
-    }
-
-    async fn update_tool_call(
-        &self,
-        request: acp_old::UpdateToolCallParams,
-    ) -> Result<(), acp_old::Error> {
-        let cx = &mut self.cx.clone();
-
-        cx.update(|cx| {
-            self.thread.borrow().update(cx, |thread, cx| {
-                thread.update_tool_call(
-                    acp::ToolCallUpdate {
-                        id: acp::ToolCallId(request.tool_call_id.0.to_string().into()),
-                        fields: acp::ToolCallUpdateFields {
-                            status: Some(into_new_tool_call_status(request.status)),
-                            content: Some(
-                                request
-                                    .content
-                                    .into_iter()
-                                    .map(into_new_tool_call_content)
-                                    .collect::<Vec<_>>(),
-                            ),
-                            ..Default::default()
-                        },
-                    },
-                    cx,
-                )
-            })
-        })?
-        .context("Failed to update thread")??;
-
-        Ok(())
-    }
-
-    async fn update_plan(&self, request: acp_old::UpdatePlanParams) -> Result<(), acp_old::Error> {
-        let cx = &mut self.cx.clone();
-
-        cx.update(|cx| {
-            self.thread.borrow().update(cx, |thread, cx| {
-                thread.update_plan(
-                    acp::Plan {
-                        entries: request
-                            .entries
-                            .into_iter()
-                            .map(into_new_plan_entry)
-                            .collect(),
-                    },
-                    cx,
-                )
-            })
-        })?
-        .context("Failed to update thread")?;
-
-        Ok(())
-    }
-
-    async fn read_text_file(
-        &self,
-        acp_old::ReadTextFileParams { path, line, limit }: acp_old::ReadTextFileParams,
-    ) -> Result<acp_old::ReadTextFileResponse, acp_old::Error> {
-        let content = self
-            .cx
-            .update(|cx| {
-                self.thread.borrow().update(cx, |thread, cx| {
-                    thread.read_text_file(path, line, limit, false, cx)
-                })
-            })?
-            .context("Failed to update thread")?
-            .await?;
-        Ok(acp_old::ReadTextFileResponse { content })
-    }
-
-    async fn write_text_file(
-        &self,
-        acp_old::WriteTextFileParams { path, content }: acp_old::WriteTextFileParams,
-    ) -> Result<(), acp_old::Error> {
-        self.cx
-            .update(|cx| {
-                self.thread
-                    .borrow()
-                    .update(cx, |thread, cx| thread.write_text_file(path, content, cx))
-            })?
-            .context("Failed to update thread")?
-            .await?;
-
-        Ok(())
-    }
-}
-
-fn into_new_tool_call(id: acp::ToolCallId, request: acp_old::PushToolCallParams) -> acp::ToolCall {
-    acp::ToolCall {
-        id,
-        title: request.label,
-        kind: acp_kind_from_old_icon(request.icon),
-        status: acp::ToolCallStatus::InProgress,
-        content: request
-            .content
-            .into_iter()
-            .map(into_new_tool_call_content)
-            .collect(),
-        locations: request
-            .locations
-            .into_iter()
-            .map(into_new_tool_call_location)
-            .collect(),
-        raw_input: None,
-        raw_output: None,
-    }
-}
-
-fn acp_kind_from_old_icon(icon: acp_old::Icon) -> acp::ToolKind {
-    match icon {
-        acp_old::Icon::FileSearch => acp::ToolKind::Search,
-        acp_old::Icon::Folder => acp::ToolKind::Search,
-        acp_old::Icon::Globe => acp::ToolKind::Search,
-        acp_old::Icon::Hammer => acp::ToolKind::Other,
-        acp_old::Icon::LightBulb => acp::ToolKind::Think,
-        acp_old::Icon::Pencil => acp::ToolKind::Edit,
-        acp_old::Icon::Regex => acp::ToolKind::Search,
-        acp_old::Icon::Terminal => acp::ToolKind::Execute,
-    }
-}
-
-fn into_new_tool_call_status(status: acp_old::ToolCallStatus) -> acp::ToolCallStatus {
-    match status {
-        acp_old::ToolCallStatus::Running => acp::ToolCallStatus::InProgress,
-        acp_old::ToolCallStatus::Finished => acp::ToolCallStatus::Completed,
-        acp_old::ToolCallStatus::Error => acp::ToolCallStatus::Failed,
-    }
-}
-
-fn into_new_tool_call_content(content: acp_old::ToolCallContent) -> acp::ToolCallContent {
-    match content {
-        acp_old::ToolCallContent::Markdown { markdown } => markdown.into(),
-        acp_old::ToolCallContent::Diff { diff } => acp::ToolCallContent::Diff {
-            diff: into_new_diff(diff),
-        },
-    }
-}
-
-fn into_new_diff(diff: acp_old::Diff) -> acp::Diff {
-    acp::Diff {
-        path: diff.path,
-        old_text: diff.old_text,
-        new_text: diff.new_text,
-    }
-}
-
-fn into_new_tool_call_location(location: acp_old::ToolCallLocation) -> acp::ToolCallLocation {
-    acp::ToolCallLocation {
-        path: location.path,
-        line: location.line,
-    }
-}
-
-fn into_new_plan_entry(entry: acp_old::PlanEntry) -> acp::PlanEntry {
-    acp::PlanEntry {
-        content: entry.content,
-        priority: into_new_plan_priority(entry.priority),
-        status: into_new_plan_status(entry.status),
-    }
-}
-
-fn into_new_plan_priority(priority: acp_old::PlanEntryPriority) -> acp::PlanEntryPriority {
-    match priority {
-        acp_old::PlanEntryPriority::Low => acp::PlanEntryPriority::Low,
-        acp_old::PlanEntryPriority::Medium => acp::PlanEntryPriority::Medium,
-        acp_old::PlanEntryPriority::High => acp::PlanEntryPriority::High,
-    }
-}
-
-fn into_new_plan_status(status: acp_old::PlanEntryStatus) -> acp::PlanEntryStatus {
-    match status {
-        acp_old::PlanEntryStatus::Pending => acp::PlanEntryStatus::Pending,
-        acp_old::PlanEntryStatus::InProgress => acp::PlanEntryStatus::InProgress,
-        acp_old::PlanEntryStatus::Completed => acp::PlanEntryStatus::Completed,
-    }
-}
-
-pub struct AcpConnection {
-    pub name: &'static str,
-    pub connection: acp_old::AgentConnection,
-    pub _child_status: Task<Result<()>>,
-    pub current_thread: Rc<RefCell<WeakEntity<AcpThread>>>,
-}
-
-impl AcpConnection {
-    pub fn stdio(
-        name: &'static str,
-        command: AgentServerCommand,
-        root_dir: &Path,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Self>> {
-        let root_dir = root_dir.to_path_buf();
-
-        cx.spawn(async move |cx| {
-            let mut child = util::command::new_smol_command(&command.path)
-                .args(command.args.iter())
-                .current_dir(root_dir)
-                .stdin(std::process::Stdio::piped())
-                .stdout(std::process::Stdio::piped())
-                .stderr(std::process::Stdio::inherit())
-                .kill_on_drop(true)
-                .spawn()?;
-
-            let stdin = child.stdin.take().unwrap();
-            let stdout = child.stdout.take().unwrap();
-            log::trace!("Spawned (pid: {})", child.id());
-
-            let foreground_executor = cx.foreground_executor().clone();
-
-            let thread_rc = Rc::new(RefCell::new(WeakEntity::new_invalid()));
-
-            let (connection, io_fut) = acp_old::AgentConnection::connect_to_agent(
-                OldAcpClientDelegate::new(thread_rc.clone(), cx.clone()),
-                stdin,
-                stdout,
-                move |fut| foreground_executor.spawn(fut).detach(),
-            );
-
-            let io_task = cx.background_spawn(async move {
-                io_fut.await.log_err();
-            });
-
-            let child_status = cx.background_spawn(async move {
-                let result = match child.status().await {
-                    Err(e) => Err(anyhow!(e)),
-                    Ok(result) if result.success() => Ok(()),
-                    Ok(result) => Err(anyhow!(result)),
-                };
-                drop(io_task);
-                result
-            });
-
-            Ok(Self {
-                name,
-                connection,
-                _child_status: child_status,
-                current_thread: thread_rc,
-            })
-        })
-    }
-}
-
-impl AgentConnection for AcpConnection {
-    fn new_thread(
-        self: Rc<Self>,
-        project: Entity<Project>,
-        _cwd: &Path,
-        cx: &mut App,
-    ) -> Task<Result<Entity<AcpThread>>> {
-        let task = self.connection.request_any(
-            acp_old::InitializeParams {
-                protocol_version: acp_old::ProtocolVersion::latest(),
-            }
-            .into_any(),
-        );
-        let current_thread = self.current_thread.clone();
-        cx.spawn(async move |cx| {
-            let result = task.await?;
-            let result = acp_old::InitializeParams::response_from_any(result)?;
-
-            if !result.is_authenticated {
-                anyhow::bail!(AuthRequired::new())
-            }
-
-            cx.update(|cx| {
-                let thread = cx.new(|cx| {
-                    let session_id = acp::SessionId("acp-old-no-id".into());
-                    let action_log = cx.new(|_| ActionLog::new(project.clone()));
-                    AcpThread::new(self.name, self.clone(), project, action_log, session_id)
-                });
-                current_thread.replace(thread.downgrade());
-                thread
-            })
-        })
-    }
-
-    fn auth_methods(&self) -> &[acp::AuthMethod] {
-        &[]
-    }
-
-    fn authenticate(&self, _method_id: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>> {
-        let task = self
-            .connection
-            .request_any(acp_old::AuthenticateParams.into_any());
-        cx.foreground_executor().spawn(async move {
-            task.await?;
-            Ok(())
-        })
-    }
-
-    fn prompt(
-        &self,
-        _id: Option<acp_thread::UserMessageId>,
-        params: acp::PromptRequest,
-        cx: &mut App,
-    ) -> Task<Result<acp::PromptResponse>> {
-        let chunks = params
-            .prompt
-            .into_iter()
-            .filter_map(|block| match block {
-                acp::ContentBlock::Text(text) => {
-                    Some(acp_old::UserMessageChunk::Text { text: text.text })
-                }
-                acp::ContentBlock::ResourceLink(link) => Some(acp_old::UserMessageChunk::Path {
-                    path: link.uri.into(),
-                }),
-                _ => None,
-            })
-            .collect();
-
-        let task = self
-            .connection
-            .request_any(acp_old::SendUserMessageParams { chunks }.into_any());
-        cx.foreground_executor().spawn(async move {
-            task.await?;
-            anyhow::Ok(acp::PromptResponse {
-                stop_reason: acp::StopReason::EndTurn,
-            })
-        })
-    }
-
-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        acp::PromptCapabilities {
-            image: false,
-            audio: false,
-            embedded_context: false,
-        }
-    }
-
-    fn cancel(&self, _session_id: &acp::SessionId, cx: &mut App) {
-        let task = self
-            .connection
-            .request_any(acp_old::CancelSendMessageParams.into_any());
-        cx.foreground_executor()
-            .spawn(async move {
-                task.await?;
-                anyhow::Ok(())
-            })
-            .detach_and_log_err(cx)
-    }
-
-    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
-        self
-    }
-}

crates/agent_servers/src/acp/v1.rs

@@ -1,367 +0,0 @@
-use action_log::ActionLog;
-use agent_client_protocol::{self as acp, Agent as _, ErrorCode};
-use anyhow::anyhow;
-use collections::HashMap;
-use futures::AsyncBufReadExt as _;
-use futures::channel::oneshot;
-use futures::io::BufReader;
-use project::Project;
-use serde::Deserialize;
-use std::path::Path;
-use std::rc::Rc;
-use std::{any::Any, cell::RefCell};
-
-use anyhow::{Context as _, Result};
-use gpui::{App, AppContext as _, AsyncApp, Entity, Task, WeakEntity};
-
-use crate::{AgentServerCommand, acp::UnsupportedVersion};
-use acp_thread::{AcpThread, AgentConnection, AuthRequired, LoadError};
-
-pub struct AcpConnection {
-    server_name: &'static str,
-    connection: Rc<acp::ClientSideConnection>,
-    sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
-    auth_methods: Vec<acp::AuthMethod>,
-    prompt_capabilities: acp::PromptCapabilities,
-    _io_task: Task<Result<()>>,
-}
-
-pub struct AcpSession {
-    thread: WeakEntity<AcpThread>,
-    suppress_abort_err: bool,
-}
-
-const MINIMUM_SUPPORTED_VERSION: acp::ProtocolVersion = acp::V1;
-
-impl AcpConnection {
-    pub async fn stdio(
-        server_name: &'static str,
-        command: AgentServerCommand,
-        root_dir: &Path,
-        cx: &mut AsyncApp,
-    ) -> Result<Self> {
-        let mut child = util::command::new_smol_command(&command.path)
-            .args(command.args.iter().map(|arg| arg.as_str()))
-            .envs(command.env.iter().flatten())
-            .current_dir(root_dir)
-            .stdin(std::process::Stdio::piped())
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::piped())
-            .kill_on_drop(true)
-            .spawn()?;
-
-        let stdout = child.stdout.take().context("Failed to take stdout")?;
-        let stdin = child.stdin.take().context("Failed to take stdin")?;
-        let stderr = child.stderr.take().context("Failed to take stderr")?;
-        log::trace!("Spawned (pid: {})", child.id());
-
-        let sessions = Rc::new(RefCell::new(HashMap::default()));
-
-        let client = ClientDelegate {
-            sessions: sessions.clone(),
-            cx: cx.clone(),
-        };
-        let (connection, io_task) = acp::ClientSideConnection::new(client, stdin, stdout, {
-            let foreground_executor = cx.foreground_executor().clone();
-            move |fut| {
-                foreground_executor.spawn(fut).detach();
-            }
-        });
-
-        let io_task = cx.background_spawn(io_task);
-
-        cx.background_spawn(async move {
-            let mut stderr = BufReader::new(stderr);
-            let mut line = String::new();
-            while let Ok(n) = stderr.read_line(&mut line).await
-                && n > 0
-            {
-                log::warn!("agent stderr: {}", &line);
-                line.clear();
-            }
-        })
-        .detach();
-
-        cx.spawn({
-            let sessions = sessions.clone();
-            async move |cx| {
-                let status = child.status().await?;
-
-                for session in sessions.borrow().values() {
-                    session
-                        .thread
-                        .update(cx, |thread, cx| {
-                            thread.emit_load_error(LoadError::Exited { status }, cx)
-                        })
-                        .ok();
-                }
-
-                anyhow::Ok(())
-            }
-        })
-        .detach();
-
-        let response = connection
-            .initialize(acp::InitializeRequest {
-                protocol_version: acp::VERSION,
-                client_capabilities: acp::ClientCapabilities {
-                    fs: acp::FileSystemCapability {
-                        read_text_file: true,
-                        write_text_file: true,
-                    },
-                },
-            })
-            .await?;
-
-        if response.protocol_version < MINIMUM_SUPPORTED_VERSION {
-            return Err(UnsupportedVersion.into());
-        }
-
-        Ok(Self {
-            auth_methods: response.auth_methods,
-            connection: connection.into(),
-            server_name,
-            sessions,
-            prompt_capabilities: response.agent_capabilities.prompt_capabilities,
-            _io_task: io_task,
-        })
-    }
-}
-
-impl AgentConnection for AcpConnection {
-    fn new_thread(
-        self: Rc<Self>,
-        project: Entity<Project>,
-        cwd: &Path,
-        cx: &mut App,
-    ) -> Task<Result<Entity<AcpThread>>> {
-        let conn = self.connection.clone();
-        let sessions = self.sessions.clone();
-        let cwd = cwd.to_path_buf();
-        cx.spawn(async move |cx| {
-            let response = conn
-                .new_session(acp::NewSessionRequest {
-                    mcp_servers: vec![],
-                    cwd,
-                })
-                .await
-                .map_err(|err| {
-                    if err.code == acp::ErrorCode::AUTH_REQUIRED.code {
-                        let mut error = AuthRequired::new();
-
-                        if err.message != acp::ErrorCode::AUTH_REQUIRED.message {
-                            error = error.with_description(err.message);
-                        }
-
-                        anyhow!(error)
-                    } else {
-                        anyhow!(err)
-                    }
-                })?;
-
-            let session_id = response.session_id;
-            let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
-            let thread = cx.new(|_cx| {
-                AcpThread::new(
-                    self.server_name,
-                    self.clone(),
-                    project,
-                    action_log,
-                    session_id.clone(),
-                )
-            })?;
-
-            let session = AcpSession {
-                thread: thread.downgrade(),
-                suppress_abort_err: false,
-            };
-            sessions.borrow_mut().insert(session_id, session);
-
-            Ok(thread)
-        })
-    }
-
-    fn auth_methods(&self) -> &[acp::AuthMethod] {
-        &self.auth_methods
-    }
-
-    fn authenticate(&self, method_id: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>> {
-        let conn = self.connection.clone();
-        cx.foreground_executor().spawn(async move {
-            let result = conn
-                .authenticate(acp::AuthenticateRequest {
-                    method_id: method_id.clone(),
-                })
-                .await?;
-
-            Ok(result)
-        })
-    }
-
-    fn prompt(
-        &self,
-        _id: Option<acp_thread::UserMessageId>,
-        params: acp::PromptRequest,
-        cx: &mut App,
-    ) -> Task<Result<acp::PromptResponse>> {
-        let conn = self.connection.clone();
-        let sessions = self.sessions.clone();
-        let session_id = params.session_id.clone();
-        cx.foreground_executor().spawn(async move {
-            let result = conn.prompt(params).await;
-
-            let mut suppress_abort_err = false;
-
-            if let Some(session) = sessions.borrow_mut().get_mut(&session_id) {
-                suppress_abort_err = session.suppress_abort_err;
-                session.suppress_abort_err = false;
-            }
-
-            match result {
-                Ok(response) => Ok(response),
-                Err(err) => {
-                    if err.code != ErrorCode::INTERNAL_ERROR.code {
-                        anyhow::bail!(err)
-                    }
-
-                    let Some(data) = &err.data else {
-                        anyhow::bail!(err)
-                    };
-
-                    // Temporary workaround until the following PR is generally available:
-                    // https://github.com/google-gemini/gemini-cli/pull/6656
-
-                    #[derive(Deserialize)]
-                    #[serde(deny_unknown_fields)]
-                    struct ErrorDetails {
-                        details: Box<str>,
-                    }
-
-                    match serde_json::from_value(data.clone()) {
-                        Ok(ErrorDetails { details }) => {
-                            if suppress_abort_err && details.contains("This operation was aborted")
-                            {
-                                Ok(acp::PromptResponse {
-                                    stop_reason: acp::StopReason::Cancelled,
-                                })
-                            } else {
-                                Err(anyhow!(details))
-                            }
-                        }
-                        Err(_) => Err(anyhow!(err)),
-                    }
-                }
-            }
-        })
-    }
-
-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        self.prompt_capabilities
-    }
-
-    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
-        if let Some(session) = self.sessions.borrow_mut().get_mut(session_id) {
-            session.suppress_abort_err = true;
-        }
-        let conn = self.connection.clone();
-        let params = acp::CancelNotification {
-            session_id: session_id.clone(),
-        };
-        cx.foreground_executor()
-            .spawn(async move { conn.cancel(params).await })
-            .detach();
-    }
-
-    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
-        self
-    }
-}
-
-struct ClientDelegate {
-    sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
-    cx: AsyncApp,
-}
-
-impl acp::Client for ClientDelegate {
-    async fn request_permission(
-        &self,
-        arguments: acp::RequestPermissionRequest,
-    ) -> Result<acp::RequestPermissionResponse, acp::Error> {
-        let cx = &mut self.cx.clone();
-        let rx = self
-            .sessions
-            .borrow()
-            .get(&arguments.session_id)
-            .context("Failed to get session")?
-            .thread
-            .update(cx, |thread, cx| {
-                thread.request_tool_call_authorization(arguments.tool_call, arguments.options, cx)
-            })?;
-
-        let result = rx?.await;
-
-        let outcome = match result {
-            Ok(option) => acp::RequestPermissionOutcome::Selected { option_id: option },
-            Err(oneshot::Canceled) => acp::RequestPermissionOutcome::Cancelled,
-        };
-
-        Ok(acp::RequestPermissionResponse { outcome })
-    }
-
-    async fn write_text_file(
-        &self,
-        arguments: acp::WriteTextFileRequest,
-    ) -> Result<(), acp::Error> {
-        let cx = &mut self.cx.clone();
-        let task = self
-            .sessions
-            .borrow()
-            .get(&arguments.session_id)
-            .context("Failed to get session")?
-            .thread
-            .update(cx, |thread, cx| {
-                thread.write_text_file(arguments.path, arguments.content, cx)
-            })?;
-
-        task.await?;
-
-        Ok(())
-    }
-
-    async fn read_text_file(
-        &self,
-        arguments: acp::ReadTextFileRequest,
-    ) -> Result<acp::ReadTextFileResponse, acp::Error> {
-        let cx = &mut self.cx.clone();
-        let task = self
-            .sessions
-            .borrow()
-            .get(&arguments.session_id)
-            .context("Failed to get session")?
-            .thread
-            .update(cx, |thread, cx| {
-                thread.read_text_file(arguments.path, arguments.line, arguments.limit, false, cx)
-            })?;
-
-        let content = task.await?;
-
-        Ok(acp::ReadTextFileResponse { content })
-    }
-
-    async fn session_notification(
-        &self,
-        notification: acp::SessionNotification,
-    ) -> Result<(), acp::Error> {
-        let cx = &mut self.cx.clone();
-        let sessions = self.sessions.borrow();
-        let session = sessions
-            .get(&notification.session_id)
-            .context("Failed to get session")?;
-
-        session.thread.update(cx, |thread, cx| {
-            thread.handle_session_update(notification.update, cx)
-        })??;
-
-        Ok(())
-    }
-}

crates/agent_servers/src/agent_servers.rs

@@ -1,5 +1,6 @@
 mod acp;
 mod claude;
+mod custom;
 mod gemini;
 mod settings;
 
@@ -7,16 +8,24 @@ mod settings;
 pub mod e2e_tests;
 
 pub use claude::*;
+pub use custom::*;
 pub use gemini::*;
 pub use settings::*;
 
 use acp_thread::AgentConnection;
+use acp_thread::LoadError;
 use anyhow::Result;
+use anyhow::anyhow;
+use anyhow::bail;
 use collections::HashMap;
+use gpui::AppContext as _;
 use gpui::{App, AsyncApp, Entity, SharedString, Task};
+use node_runtime::VersionStrategy;
 use project::Project;
 use schemars::JsonSchema;
+use semver::Version;
 use serde::{Deserialize, Serialize};
+use std::str::FromStr as _;
 use std::{
     any::Any,
     path::{Path, PathBuf},
@@ -29,16 +38,114 @@ pub fn init(cx: &mut App) {
     settings::init(cx);
 }
 
+pub struct AgentServerDelegate {
+    project: Entity<Project>,
+    status_tx: watch::Sender<SharedString>,
+}
+
+impl AgentServerDelegate {
+    pub fn new(project: Entity<Project>, status_tx: watch::Sender<SharedString>) -> Self {
+        Self { project, status_tx }
+    }
+
+    pub fn project(&self) -> &Entity<Project> {
+        &self.project
+    }
+
+    fn get_or_npm_install_builtin_agent(
+        self,
+        binary_name: SharedString,
+        package_name: SharedString,
+        entrypoint_path: PathBuf,
+        settings: Option<BuiltinAgentServerSettings>,
+        minimum_version: Option<Version>,
+        cx: &mut App,
+    ) -> Task<Result<AgentServerCommand>> {
+        if let Some(settings) = &settings
+            && let Some(command) = settings.clone().custom_command()
+        {
+            return Task::ready(Ok(command));
+        }
+
+        let project = self.project;
+        let fs = project.read(cx).fs().clone();
+        let Some(node_runtime) = project.read(cx).node_runtime().cloned() else {
+            return Task::ready(Err(anyhow!("Missing node runtime")));
+        };
+        let mut status_tx = self.status_tx;
+
+        cx.spawn(async move |cx| {
+            if let Some(settings) = settings && !settings.ignore_system_version.unwrap_or(true) {
+                if let Some(bin) = find_bin_in_path(binary_name.clone(), &project, cx).await {
+                    return Ok(AgentServerCommand { path: bin, args: Vec::new(), env: Default::default() })
+                }
+            }
+
+            cx.background_spawn(async move {
+                let node_path = node_runtime.binary_path().await?;
+                let dir = paths::data_dir().join("external_agents").join(binary_name.as_str());
+                fs.create_dir(&dir).await?;
+                let local_executable_path = dir.join(entrypoint_path);
+                let command = AgentServerCommand {
+                    path: node_path,
+                    args: vec![local_executable_path.to_string_lossy().to_string()],
+                    env: Default::default(),
+                };
+
+                let installed_version = node_runtime
+                    .npm_package_installed_version(&dir, &package_name)
+                    .await?
+                    .filter(|version| {
+                        Version::from_str(&version)
+                            .is_ok_and(|version| Some(version) >= minimum_version)
+                    });
+
+                status_tx.send("Checking for latest version…".into())?;
+                let latest_version = match node_runtime.npm_package_latest_version(&package_name).await
+                {
+                    Ok(latest_version) => latest_version,
+                    Err(e) => {
+                        if let Some(installed_version) = installed_version {
+                            log::error!("{e}");
+                            log::warn!("failed to fetch latest version of {package_name}, falling back to cached version {installed_version}");
+                            return Ok(command);
+                        } else {
+                            bail!(e);
+                        }
+                    }
+                };
+
+                let should_install = node_runtime
+                    .should_install_npm_package(
+                        &package_name,
+                        &local_executable_path,
+                        &dir,
+                        VersionStrategy::Latest(&latest_version),
+                    )
+                    .await;
+
+                if should_install {
+                    status_tx.send("Installing latest version…".into())?;
+                    node_runtime
+                        .npm_install_packages(&dir, &[(&package_name, &latest_version)])
+                        .await?;
+                }
+
+                Ok(command)
+            }).await.map_err(|e| LoadError::FailedToInstall(e.to_string().into()).into())
+        })
+    }
+}
+
 pub trait AgentServer: Send {
     fn logo(&self) -> ui::IconName;
-    fn name(&self) -> &'static str;
-    fn empty_state_headline(&self) -> &'static str;
-    fn empty_state_message(&self) -> &'static str;
+    fn name(&self) -> SharedString;
+    fn telemetry_id(&self) -> &'static str;
 
     fn connect(
         &self,
         root_dir: &Path,
-        project: &Entity<Project>,
+        delegate: AgentServerDelegate,
         cx: &mut App,
     ) -> Task<Result<Rc<dyn AgentConnection>>>;
 
@@ -76,15 +183,6 @@ impl std::fmt::Debug for AgentServerCommand {
     }
 }
 
-pub enum AgentServerVersion {
-    Supported,
-    Unsupported {
-        error_message: SharedString,
-        upgrade_message: SharedString,
-        upgrade_command: String,
-    },
-}
-
 #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)]
 pub struct AgentServerCommand {
     #[serde(rename = "command")]
@@ -95,27 +193,20 @@ pub struct AgentServerCommand {
 }
 
 impl AgentServerCommand {
-    pub(crate) async fn resolve(
+    pub async fn resolve(
         path_bin_name: &'static str,
         extra_args: &[&'static str],
         fallback_path: Option<&Path>,
-        settings: Option<AgentServerSettings>,
+        settings: Option<BuiltinAgentServerSettings>,
         project: &Entity<Project>,
         cx: &mut AsyncApp,
     ) -> Option<Self> {
-        if let Some(agent_settings) = settings {
-            Some(Self {
-                path: agent_settings.command.path,
-                args: agent_settings
-                    .command
-                    .args
-                    .into_iter()
-                    .chain(extra_args.iter().map(|arg| arg.to_string()))
-                    .collect(),
-                env: agent_settings.command.env,
-            })
+        if let Some(settings) = settings
+            && let Some(command) = settings.custom_command()
+        {
+            Some(command)
         } else {
-            match find_bin_in_path(path_bin_name, project, cx).await {
+            match find_bin_in_path(path_bin_name.into(), project, cx).await {
                 Some(path) => Some(Self {
                     path,
                     args: extra_args.iter().map(|arg| arg.to_string()).collect(),
@@ -138,7 +229,7 @@ impl AgentServerCommand {
 }
 
 async fn find_bin_in_path(
-    bin_name: &'static str,
+    bin_name: SharedString,
     project: &Entity<Project>,
     cx: &mut AsyncApp,
 ) -> Option<PathBuf> {
@@ -168,11 +259,11 @@ async fn find_bin_in_path(
     cx.background_executor()
         .spawn(async move {
             let which_result = if cfg!(windows) {
-                which::which(bin_name)
+                which::which(bin_name.as_str())
             } else {
                 let env = env_task.await.unwrap_or_default();
                 let shell_path = env.get("PATH").cloned();
-                which::which_in(bin_name, shell_path.as_ref(), root_dir.as_ref())
+                which::which_in(bin_name.as_str(), shell_path.as_ref(), root_dir.as_ref())
             };
 
             if let Err(which::Error::CannotFindBinaryPath) = which_result {

crates/agent_servers/src/claude.rs

@@ -30,29 +30,25 @@ use futures::{
     io::BufReader,
     select_biased,
 };
-use gpui::{App, AppContext, AsyncApp, Entity, Task, WeakEntity};
+use gpui::{App, AppContext, AsyncApp, Entity, SharedString, Task, WeakEntity};
 use serde::{Deserialize, Serialize};
 use util::{ResultExt, debug_panic};
 
 use crate::claude::mcp_server::{ClaudeZedMcpServer, McpConfig};
 use crate::claude::tools::ClaudeTool;
-use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings};
+use crate::{AgentServer, AgentServerCommand, AgentServerDelegate, AllAgentServersSettings};
 use acp_thread::{AcpThread, AgentConnection, AuthRequired, LoadError, MentionUri};
 
 #[derive(Clone)]
 pub struct ClaudeCode;
 
 impl AgentServer for ClaudeCode {
-    fn name(&self) -> &'static str {
-        "Claude Code"
+    fn telemetry_id(&self) -> &'static str {
+        "claude-code"
     }
 
-    fn empty_state_headline(&self) -> &'static str {
-        self.name()
-    }
-
-    fn empty_state_message(&self) -> &'static str {
-        "How can I help you today?"
+    fn name(&self) -> SharedString {
+        "Claude Code".into()
     }
 
     fn logo(&self) -> ui::IconName {
@@ -62,7 +58,7 @@ impl AgentServer for ClaudeCode {
     fn connect(
         &self,
         _root_dir: &Path,
-        _project: &Entity<Project>,
+        _delegate: AgentServerDelegate,
         _cx: &mut App,
     ) -> Task<Result<Rc<dyn AgentConnection>>> {
         let connection = ClaudeAgentConnection {
@@ -104,11 +100,7 @@ impl AgentConnection for ClaudeAgentConnection {
             )
             .await
             else {
-                return Err(LoadError::NotInstalled {
-                    error_message: "Failed to find Claude Code binary".into(),
-                    install_message: "Install Claude Code".into(),
-                    install_command: "npm install -g @anthropic-ai/claude-code@latest".into(),
-                }.into());
+                return Err(anyhow!("Failed to find Claude Code binary"));
             };
 
             let api_key =
@@ -226,17 +218,9 @@ impl AgentConnection for ClaudeAgentConnection {
                                         || !help.contains("--session-id"))
                                 {
                                     LoadError::Unsupported {
-                                    error_message: format!(
-                                            "Your installed version of Claude Code ({}, version {}) does not have required features for use with Zed.",
-                                            command.path.to_string_lossy(),
-                                            version,
-                                        )
-                                        .into(),
-                                        upgrade_message: "Upgrade Claude Code to latest".into(),
-                                        upgrade_command: format!(
-                                            "{} update",
-                                            command.path.to_string_lossy()
-                                        ),
+                                        command: command.path.to_string_lossy().to_string().into(),
+                                        current_version: version.to_string().into(),
+                                        minimum_version: "1.0.0".into(),
                                     }
                                 } else {
                                     LoadError::Exited { status }
@@ -249,13 +233,20 @@ impl AgentConnection for ClaudeAgentConnection {
             });
 
             let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
-            let thread = cx.new(|_cx| {
+            let thread = cx.new(|cx| {
                 AcpThread::new(
                     "Claude Code",
                     self.clone(),
                     project,
                     action_log,
                     session_id.clone(),
+                    watch::Receiver::constant(acp::PromptCapabilities {
+                        image: true,
+                        audio: false,
+                        embedded_context: true,
+                        supports_custom_commands: false,
+                    }),
+                    cx,
                 )
             })?;
 
@@ -319,14 +310,6 @@ impl AgentConnection for ClaudeAgentConnection {
         cx.foreground_executor().spawn(async move { end_rx.await? })
     }
 
-    fn prompt_capabilities(&self) -> acp::PromptCapabilities {
-        acp::PromptCapabilities {
-            image: true,
-            audio: false,
-            embedded_context: true,
-        }
-    }
-
     fn cancel(&self, session_id: &acp::SessionId, _cx: &mut App) {
         let sessions = self.sessions.borrow();
         let Some(session) = sessions.get(session_id) else {
@@ -357,6 +340,19 @@ impl AgentConnection for ClaudeAgentConnection {
             .log_err();
     }
 
+    fn list_commands(&self, session_id: &acp::SessionId, _cx: &mut App) -> Task<Result<acp::ListCommandsResponse>> {
+        // Claude agent doesn't support custom commands yet
+        let _session_id = session_id.clone();
+        Task::ready(Ok(acp::ListCommandsResponse {
+            commands: vec![],
+        }))
+    }
+
+    fn run_command(&self, _request: acp::RunCommandRequest, _cx: &mut App) -> Task<Result<()>> {
+        // Claude agent doesn't support custom commands yet
+        Task::ready(Err(anyhow!("Custom commands not supported")))
+    }
+
     fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
         self
     }

crates/agent_servers/src/custom.rs

@@ -0,0 +1,64 @@
+use crate::{AgentServerCommand, AgentServerDelegate};
+use acp_thread::AgentConnection;
+use anyhow::Result;
+use gpui::{App, SharedString, Task};
+use language_models::provider::anthropic::AnthropicLanguageModelProvider;
+use std::{path::Path, rc::Rc};
+use ui::IconName;
+
+/// A generic agent server implementation for custom user-defined agents
+pub struct CustomAgentServer {
+    name: SharedString,
+    command: AgentServerCommand,
+}
+
+impl CustomAgentServer {
+    pub fn new(name: SharedString, command: AgentServerCommand) -> Self {
+        Self { name, command }
+    }
+}
+
+impl crate::AgentServer for CustomAgentServer {
+    fn telemetry_id(&self) -> &'static str {
+        "custom"
+    }
+
+    fn name(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn logo(&self) -> IconName {
+        IconName::Terminal
+    }
+
+    fn connect(
+        &self,
+        root_dir: &Path,
+        _delegate: AgentServerDelegate,
+        cx: &mut App,
+    ) -> Task<Result<Rc<dyn AgentConnection>>> {
+        let server_name = self.name();
+        let mut command = self.command.clone();
+        let root_dir = root_dir.to_path_buf();
+
+        // TODO: Remove this once we have Claude properly
+        cx.spawn(async move |mut cx| {
+            if let Some(api_key) = cx
+                .update(AnthropicLanguageModelProvider::api_key)?
+                .await
+                .ok()
+            {
+                command
+                    .env
+                    .get_or_insert_default()
+                    .insert("ANTHROPIC_API_KEY".to_owned(), api_key.key);
+            }
+
+            crate::acp::connect(server_name, command, &root_dir, &mut cx).await
+        })
+    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn std::any::Any> {
+        self
+    }
+}

crates/agent_servers/src/e2e_tests.rs

@@ -1,17 +1,15 @@
+use crate::{AgentServer, AgentServerDelegate};
+use acp_thread::{AcpThread, AgentThreadEntry, ToolCall, ToolCallStatus};
+use agent_client_protocol as acp;
+use futures::{FutureExt, StreamExt, channel::mpsc, select};
+use gpui::{AppContext, Entity, TestAppContext};
+use indoc::indoc;
+use project::{FakeFs, Project};
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
     time::Duration,
 };
-
-use crate::AgentServer;
-use acp_thread::{AcpThread, AgentThreadEntry, ToolCall, ToolCallStatus};
-use agent_client_protocol as acp;
-
-use futures::{FutureExt, StreamExt, channel::mpsc, select};
-use gpui::{AppContext, Entity, TestAppContext};
-use indoc::indoc;
-use project::{FakeFs, Project};
 use util::path;
 
 pub async fn test_basic<T, F>(server: F, cx: &mut TestAppContext)
@@ -473,12 +471,9 @@ pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
         #[cfg(test)]
         crate::AllAgentServersSettings::override_global(
             crate::AllAgentServersSettings {
-                claude: Some(crate::AgentServerSettings {
-                    command: crate::claude::tests::local_command(),
-                }),
-                gemini: Some(crate::AgentServerSettings {
-                    command: crate::gemini::tests::local_command(),
-                }),
+                claude: Some(crate::claude::tests::local_command().into()),
+                gemini: Some(crate::gemini::tests::local_command().into()),
+                custom: collections::HashMap::default(),
             },
             cx,
         );
@@ -495,8 +490,10 @@ pub async fn new_test_thread(
     current_dir: impl AsRef<Path>,
     cx: &mut TestAppContext,
 ) -> Entity<AcpThread> {
+    let delegate = AgentServerDelegate::new(project.clone(), watch::channel("".into()).0);
+
     let connection = cx
-        .update(|cx| server.connect(current_dir.as_ref(), &project, cx))
+        .update(|cx| server.connect(current_dir.as_ref(), delegate, cx))
         .await
         .unwrap();
 

crates/agent_servers/src/gemini.rs

@@ -1,14 +1,13 @@
 use std::rc::Rc;
 use std::{any::Any, path::Path};
 
-use crate::{AgentServer, AgentServerCommand};
+use crate::acp::AcpConnection;
+use crate::{AgentServer, AgentServerDelegate};
 use acp_thread::{AgentConnection, LoadError};
 use anyhow::Result;
-use gpui::{Entity, Task};
+use gpui::{App, SharedString, Task};
 use language_models::provider::google::GoogleLanguageModelProvider;
-use project::Project;
 use settings::SettingsStore;
-use ui::App;
 
 use crate::AllAgentServersSettings;
 
@@ -18,16 +17,12 @@ pub struct Gemini;
 const ACP_ARG: &str = "--experimental-acp";
 
 impl AgentServer for Gemini {
-    fn name(&self) -> &'static str {
-        "Gemini CLI"
+    fn telemetry_id(&self) -> &'static str {
+        "gemini-cli"
     }
 
-    fn empty_state_headline(&self) -> &'static str {
-        "Welcome to Gemini CLI"
-    }
-
-    fn empty_state_message(&self) -> &'static str {
-        "Ask questions, edit files, run commands"
+    fn name(&self) -> SharedString {
+        "Gemini CLI".into()
     }
 
     fn logo(&self) -> ui::IconName {
@@ -37,10 +32,9 @@ impl AgentServer for Gemini {
     fn connect(
         &self,
         root_dir: &Path,
-        project: &Entity<Project>,
+        delegate: AgentServerDelegate,
         cx: &mut App,
     ) -> Task<Result<Rc<dyn AgentConnection>>> {
-        let project = project.clone();
         let root_dir = root_dir.to_path_buf();
         let server_name = self.name();
         cx.spawn(async move |cx| {
@@ -48,49 +42,80 @@ impl AgentServer for Gemini {
                 settings.get::<AllAgentServersSettings>(None).gemini.clone()
             })?;
 
-            let Some(mut command) =
-                AgentServerCommand::resolve("gemini", &[ACP_ARG], None, settings, &project, cx).await
-            else {
-                return Err(LoadError::NotInstalled {
-                    error_message: "Failed to find Gemini CLI binary".into(),
-                    install_message: "Install Gemini CLI".into(),
-                    install_command: "npm install -g @google/gemini-cli@preview".into()
-                }.into());
-            };
+            let mut command = cx
+                .update(|cx| {
+                    delegate.get_or_npm_install_builtin_agent(
+                        Self::BINARY_NAME.into(),
+                        Self::PACKAGE_NAME.into(),
+                        format!("node_modules/{}/dist/index.js", Self::PACKAGE_NAME).into(),
+                        settings,
+                        Some("0.2.1".parse().unwrap()),
+                        cx,
+                    )
+                })?
+                .await?;
+            command.args.push("--experimental-acp".into());
 
-            if let Some(api_key)= cx.update(GoogleLanguageModelProvider::api_key)?.await.ok() {
-                command.env.get_or_insert_default().insert("GEMINI_API_KEY".to_owned(), api_key.key);
+            if let Some(api_key) = cx.update(GoogleLanguageModelProvider::api_key)?.await.ok() {
+                command
+                    .env
+                    .get_or_insert_default()
+                    .insert("GEMINI_API_KEY".to_owned(), api_key.key);
             }
 
             let result = crate::acp::connect(server_name, command.clone(), &root_dir, cx).await;
-            if result.is_err() {
-                let version_fut = util::command::new_smol_command(&command.path)
-                    .args(command.args.iter())
-                    .arg("--version")
-                    .kill_on_drop(true)
-                    .output();
+            match &result {
+                Ok(connection) => {
+                    if let Some(connection) = connection.clone().downcast::<AcpConnection>()
+                        && !connection.prompt_capabilities().image
+                    {
+                        let version_output = util::command::new_smol_command(&command.path)
+                            .args(command.args.iter())
+                            .arg("--version")
+                            .kill_on_drop(true)
+                            .output()
+                            .await;
+                        let current_version =
+                            String::from_utf8(version_output?.stdout)?.trim().to_owned();
+                        if !connection.prompt_capabilities().image {
+                            return Err(LoadError::Unsupported {
+                                current_version: current_version.into(),
+                                command: command.path.to_string_lossy().to_string().into(),
+                                minimum_version: Self::MINIMUM_VERSION.into(),
+                            }
+                            .into());
+                        }
+                    }
+                }
+                Err(_) => {
+                    let version_fut = util::command::new_smol_command(&command.path)
+                        .args(command.args.iter())
+                        .arg("--version")
+                        .kill_on_drop(true)
+                        .output();
 
-                let help_fut = util::command::new_smol_command(&command.path)
-                    .args(command.args.iter())
-                    .arg("--help")
-                    .kill_on_drop(true)
-                    .output();
+                    let help_fut = util::command::new_smol_command(&command.path)
+                        .args(command.args.iter())
+                        .arg("--help")
+                        .kill_on_drop(true)
+                        .output();
 
-                let (version_output, help_output) = futures::future::join(version_fut, help_fut).await;
+                    let (version_output, help_output) =
+                        futures::future::join(version_fut, help_fut).await;
 
-                let current_version = String::from_utf8(version_output?.stdout)?;
-                let supported = String::from_utf8(help_output?.stdout)?.contains(ACP_ARG);
+                    let current_version = std::str::from_utf8(&version_output?.stdout)?
+                        .trim()
+                        .to_string();
+                    let supported = String::from_utf8(help_output?.stdout)?.contains(ACP_ARG);
 
-                if !supported {
-                    return Err(LoadError::Unsupported {
-                        error_message: format!(
-                            "Your installed version of Gemini CLI ({}, version {}) doesn't support the Agentic Coding Protocol (ACP).",
-                            command.path.to_string_lossy(),
-                            current_version
-                        ).into(),
-                        upgrade_message: "Upgrade Gemini CLI to latest".into(),
-                        upgrade_command: "npm install -g @google/gemini-cli@preview".into(),
-                    }.into())
+                    if !supported {
+                        return Err(LoadError::Unsupported {
+                            current_version: current_version.into(),
+                            command: command.path.to_string_lossy().to_string().into(),
+                            minimum_version: Self::MINIMUM_VERSION.into(),
+                        }
+                        .into());
+                    }
                 }
             }
             result
@@ -102,6 +127,14 @@ impl AgentServer for Gemini {
     }
 }
 
+impl Gemini {
+    const PACKAGE_NAME: &str = "@google/gemini-cli";
+
+    const MINIMUM_VERSION: &str = "0.2.1";
+
+    const BINARY_NAME: &str = "gemini";
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;

crates/agent_servers/src/settings.rs

@@ -1,6 +1,9 @@
+use std::path::PathBuf;
+
 use crate::AgentServerCommand;
 use anyhow::Result;
-use gpui::App;
+use collections::HashMap;
+use gpui::{App, SharedString};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
@@ -11,12 +14,62 @@ pub fn init(cx: &mut App) {
 
 #[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug)]
 pub struct AllAgentServersSettings {
-    pub gemini: Option<AgentServerSettings>,
-    pub claude: Option<AgentServerSettings>,
+    pub gemini: Option<BuiltinAgentServerSettings>,
+    pub claude: Option<BuiltinAgentServerSettings>,
+
+    /// Custom agent servers configured by the user
+    #[serde(flatten)]
+    pub custom: HashMap<SharedString, CustomAgentServerSettings>,
 }
 
-#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug)]
-pub struct AgentServerSettings {
+#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug, PartialEq)]
+pub struct BuiltinAgentServerSettings {
+    /// Absolute path to a binary to be used when launching this agent.
+    ///
+    /// This can be used to run a specific binary without automatic downloads or searching `$PATH`.
+    #[serde(rename = "command")]
+    pub path: Option<PathBuf>,
+    /// If a binary is specified in `command`, it will be passed these arguments.
+    pub args: Option<Vec<String>>,
+    /// If a binary is specified in `command`, it will be passed these environment variables.
+    pub env: Option<HashMap<String, String>>,
+    /// Whether to skip searching `$PATH` for an agent server binary when
+    /// launching this agent.
+    ///
+    /// This has no effect if a `command` is specified. Otherwise, when this is
+    /// `false`, Zed will search `$PATH` for an agent server binary and, if one
+    /// is found, use it for threads with this agent. If no agent binary is
+    /// found on `$PATH`, Zed will automatically install and use its own binary.
+    /// When this is `true`, Zed will not search `$PATH`, and will always use
+    /// its own binary.
+    ///
+    /// Default: true
+    pub ignore_system_version: Option<bool>,
+}
+
+impl BuiltinAgentServerSettings {
+    pub(crate) fn custom_command(self) -> Option<AgentServerCommand> {
+        self.path.map(|path| AgentServerCommand {
+            path,
+            args: self.args.unwrap_or_default(),
+            env: self.env,
+        })
+    }
+}
+
+impl From<AgentServerCommand> for BuiltinAgentServerSettings {
+    fn from(value: AgentServerCommand) -> Self {
+        BuiltinAgentServerSettings {
+            path: Some(value.path),
+            args: Some(value.args),
+            env: value.env,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug, PartialEq)]
+pub struct CustomAgentServerSettings {
     #[serde(flatten)]
     pub command: AgentServerCommand,
 }
@@ -29,13 +82,26 @@ impl settings::Settings for AllAgentServersSettings {
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
         let mut settings = AllAgentServersSettings::default();
 
-        for AllAgentServersSettings { gemini, claude } in sources.defaults_and_customizations() {
+        for AllAgentServersSettings {
+            gemini,
+            claude,
+            custom,
+        } in sources.defaults_and_customizations()
+        {
             if gemini.is_some() {
                 settings.gemini = gemini.clone();
             }
             if claude.is_some() {
                 settings.claude = claude.clone();
             }
+
+            // Merge custom agents
+            for (name, config) in custom {
+                // Skip built-in agent names to avoid conflicts
+                if name != "gemini" && name != "claude" {
+                    settings.custom.insert(name.clone(), config.clone());
+                }
+            }
         }
 
         Ok(settings)

crates/agent_ui/Cargo.toml

@@ -67,6 +67,7 @@ ordered-float.workspace = true
 parking_lot.workspace = true
 paths.workspace = true
 picker.workspace = true
+postage.workspace = true
 project.workspace = true
 prompt_store.workspace = true
 proto.workspace = true

crates/agent_ui/src/acp/completion_provider.rs

@@ -1,10 +1,10 @@
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::ops::Range;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 
-use acp_thread::MentionUri;
+use acp_thread::{AcpThread, MentionUri};
 use agent_client_protocol as acp;
 use agent2::{HistoryEntry, HistoryStore};
 use anyhow::Result;
@@ -15,6 +15,7 @@ use language::{Buffer, CodeLabel, HighlightId};
 use lsp::CompletionContext;
 use project::{
     Completion, CompletionIntent, CompletionResponse, Project, ProjectPath, Symbol, WorktreeId,
+    lsp_store::CompletionDocumentation,
 };
 use prompt_store::PromptStore;
 use rope::Point;
@@ -32,6 +33,12 @@ use crate::context_picker::{
     ContextPickerAction, ContextPickerEntry, ContextPickerMode, selection_ranges,
 };
 
+#[derive(Debug)]
+enum CompletionType {
+    Mention(MentionCompletion),
+    SlashCommand(SlashCommandCompletion),
+}
+
 pub(crate) enum Match {
     File(FileMatch),
     Symbol(SymbolMatch),
@@ -47,6 +54,69 @@ pub struct EntryMatch {
     entry: ContextPickerEntry,
 }
 
+#[derive(Debug, Clone)]
+pub struct SlashCommandCompletion {
+    pub source_range: Range<usize>,
+    pub command_name: String,
+    pub argument: Option<String>,
+}
+
+impl SlashCommandCompletion {
+    fn try_parse(line: &str, offset_to_line: usize) -> Option<Self> {
+        let last_slash_start = line.rfind('/')?;
+        if last_slash_start >= line.len() {
+            return Some(Self {
+                source_range: last_slash_start + offset_to_line..last_slash_start + 1 + offset_to_line,
+                command_name: String::new(),
+                argument: None,
+            });
+        }
+        
+        // Check if slash is at word boundary (not preceded by alphanumeric)
+        if last_slash_start > 0
+            && line
+                .chars()
+                .nth(last_slash_start - 1)
+                .is_some_and(|c| c.is_alphanumeric())
+        {
+            return None;
+        }
+
+        let rest_of_line = &line[last_slash_start + 1..];
+        
+        let mut command_name = String::new();
+        let mut argument = None;
+        
+        let mut parts = rest_of_line.split_whitespace();
+        let mut end = last_slash_start + 1;
+        
+        if let Some(cmd_text) = parts.next() {
+            end += cmd_text.len();
+            command_name = cmd_text.to_string();
+            
+            // Check for arguments after command name
+            match rest_of_line[cmd_text.len()..].find(|c: char| !c.is_whitespace()) {
+                Some(whitespace_count) => {
+                    if let Some(arg_text) = parts.next() {
+                        argument = Some(arg_text.to_string());
+                        end += whitespace_count + arg_text.len();
+                    }
+                }
+                None => {
+                    // Rest of line is entirely whitespace
+                    end += rest_of_line.len() - cmd_text.len();
+                }
+            }
+        }
+        
+        Some(Self {
+            source_range: last_slash_start + offset_to_line..end + offset_to_line,
+            command_name,
+            argument,
+        })
+    }
+}
+
 impl Match {
     pub fn score(&self) -> f64 {
         match self {
@@ -67,6 +137,7 @@ pub struct ContextPickerCompletionProvider {
     history_store: Entity<HistoryStore>,
     prompt_store: Option<Entity<PromptStore>>,
     prompt_capabilities: Rc<Cell<acp::PromptCapabilities>>,
+    thread: Rc<RefCell<Option<WeakEntity<AcpThread>>>>,
 }
 
 impl ContextPickerCompletionProvider {
@@ -83,9 +154,15 @@ impl ContextPickerCompletionProvider {
             history_store,
             prompt_store,
             prompt_capabilities,
+            thread: Rc::new(RefCell::new(None)),
         }
     }
 
+    /// Set the ACP thread for slash command support
+    pub fn set_thread(&self, thread: WeakEntity<AcpThread>) {
+        *self.thread.borrow_mut() = Some(thread);
+    }
+
     fn completion_for_entry(
         entry: ContextPickerEntry,
         source_range: Range<Anchor>,
@@ -247,9 +324,9 @@ impl ContextPickerCompletionProvider {
 
         let abs_path = project.read(cx).absolute_path(&symbol.path, cx)?;
         let uri = MentionUri::Symbol {
-            path: abs_path,
+            abs_path,
             name: symbol.name.clone(),
-            line_range: symbol.range.start.0.row..symbol.range.end.0.row,
+            line_range: symbol.range.start.0.row..=symbol.range.end.0.row,
         };
         let new_text = format!("{} ", uri.as_link());
         let new_text_len = new_text.len();
@@ -645,22 +722,123 @@ impl CompletionProvider for ContextPickerCompletionProvider {
         _window: &mut Window,
         cx: &mut Context<Editor>,
     ) -> Task<Result<Vec<CompletionResponse>>> {
-        let state = buffer.update(cx, |buffer, _cx| {
+        // Get the buffer state first
+        let (line, offset_to_line) = buffer.update(cx, |buffer, _cx| {
             let position = buffer_position.to_point(buffer);
             let line_start = Point::new(position.row, 0);
             let offset_to_line = buffer.point_to_offset(line_start);
             let mut lines = buffer.text_for_range(line_start..position).lines();
-            let line = lines.next()?;
-            MentionCompletion::try_parse(
+            let line = lines.next().unwrap_or("");
+            (line.to_string(), offset_to_line)
+        });
+        
+        // Then check for completions outside of the buffer update
+        let completion_state = {
+            // First try mention completion
+            if let Some(mention) = MentionCompletion::try_parse(
+                self.prompt_capabilities.get().embedded_context,
+                &line,
+                offset_to_line,
+            ) {
+                Some(CompletionType::Mention(mention))
+            } else if let Some(thread) = self.thread.borrow().as_ref().cloned() {
+                // Then try slash command completion (only if thread supports commands)
+                if let Ok(supports_commands) = thread.read_with(cx, |thread, _| {
+                    thread.supports_custom_commands()
+                }) {
+                    if supports_commands {
+                        if let Some(slash) = SlashCommandCompletion::try_parse(&line, offset_to_line) {
+                            Some(CompletionType::SlashCommand(slash))
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        };
+        
+        let Some(completion_type) = completion_state else {
+            return Task::ready(Ok(Vec::new()));
+        };
+        
+        match completion_type {
+            CompletionType::Mention(state) => self.complete_mentions(state, buffer.clone(), buffer_position, cx),
+            CompletionType::SlashCommand(state) => self.complete_slash_commands(state, buffer.clone(), buffer_position, cx),
+        }
+    }
+
+    fn is_completion_trigger(
+        &self,
+        buffer: &Entity<language::Buffer>,
+        position: language::Anchor,
+        _text: &str,
+        _trigger_in_words: bool,
+        _menu_is_open: bool,
+        cx: &mut Context<Editor>,
+    ) -> bool {
+        let buffer = buffer.read(cx);
+        let position = position.to_point(buffer);
+        let line_start = Point::new(position.row, 0);
+        let offset_to_line = buffer.point_to_offset(line_start);
+        let mut lines = buffer.text_for_range(line_start..position).lines();
+        if let Some(line) = lines.next() {
+            // Check for @ mention completions
+            if let Some(completion) = MentionCompletion::try_parse(
                 self.prompt_capabilities.get().embedded_context,
                 line,
                 offset_to_line,
-            )
-        });
-        let Some(state) = state else {
-            return Task::ready(Ok(Vec::new()));
-        };
+            ) {
+                let in_range = completion.source_range.start <= offset_to_line + position.column as usize
+                    && completion.source_range.end >= offset_to_line + position.column as usize;
+                if in_range {
+                    return true;
+                }
+            }
+            
+            // Check for slash command completions (only if thread supports commands)
+            if let Some(thread) = self.thread.borrow().as_ref().cloned() {
+                if let Ok(supports_commands) = thread.read_with(cx, |thread, _| {
+                    thread.supports_custom_commands()
+                }) {
+                    if supports_commands {
+                        if let Some(completion) = SlashCommandCompletion::try_parse(line, offset_to_line) {
+                            let in_range = completion.source_range.start <= offset_to_line + position.column as usize
+                                && completion.source_range.end >= offset_to_line + position.column as usize;
+                            return in_range;
+                        }
+                    }
+                }
+            }
+            
+            false
+        } else {
+            false
+        }
+    }
 
+    fn sort_completions(&self) -> bool {
+        false
+    }
+
+    fn filter_completions(&self) -> bool {
+        false
+    }
+}
+
+impl ContextPickerCompletionProvider {
+    fn complete_mentions(
+        &self,
+        state: MentionCompletion,
+        buffer: Entity<Buffer>,
+        _buffer_position: Anchor,
+        cx: &mut Context<Editor>,
+    ) -> Task<Result<Vec<CompletionResponse>>> {
         let Some(workspace) = self.workspace.upgrade() else {
             return Task::ready(Ok(Vec::new()));
         };
@@ -753,49 +931,85 @@ impl CompletionProvider for ContextPickerCompletionProvider {
 
             Ok(vec![CompletionResponse {
                 completions,
-                // Since this does its own filtering (see `filter_completions()` returns false),
-                // there is no benefit to computing whether this set of completions is incomplete.
                 is_incomplete: true,
             }])
         })
     }
 
-    fn is_completion_trigger(
+    fn complete_slash_commands(
         &self,
-        buffer: &Entity<language::Buffer>,
-        position: language::Anchor,
-        _text: &str,
-        _trigger_in_words: bool,
-        _menu_is_open: bool,
+        state: SlashCommandCompletion,
+        buffer: Entity<Buffer>,
+        _buffer_position: Anchor,
         cx: &mut Context<Editor>,
-    ) -> bool {
-        let buffer = buffer.read(cx);
-        let position = position.to_point(buffer);
-        let line_start = Point::new(position.row, 0);
-        let offset_to_line = buffer.point_to_offset(line_start);
-        let mut lines = buffer.text_for_range(line_start..position).lines();
-        if let Some(line) = lines.next() {
-            MentionCompletion::try_parse(
-                self.prompt_capabilities.get().embedded_context,
-                line,
-                offset_to_line,
-            )
-            .map(|completion| {
-                completion.source_range.start <= offset_to_line + position.column as usize
-                    && completion.source_range.end >= offset_to_line + position.column as usize
-            })
-            .unwrap_or(false)
-        } else {
-            false
-        }
-    }
+    ) -> Task<Result<Vec<CompletionResponse>>> {
+        let Some(thread) = self.thread.borrow().as_ref().cloned() else {
+            return Task::ready(Ok(Vec::new()));
+        };
 
-    fn sort_completions(&self) -> bool {
-        false
-    }
+        let snapshot = buffer.read(cx).snapshot();
+        let source_range = snapshot.anchor_before(state.source_range.start)
+            ..snapshot.anchor_after(state.source_range.end);
 
-    fn filter_completions(&self) -> bool {
-        false
+        let command_prefix = state.command_name.clone();
+
+        cx.spawn(async move |_, cx| {
+            // Get session ID and connection from the thread
+            let (session_id, connection) = thread.read_with(cx, |thread, _| {
+                (thread.session_id().clone(), thread.connection().clone())
+            })?;
+
+            // Fetch commands from the agent
+            let commands_task = cx.update(|cx| {
+                connection.list_commands(&session_id, cx)
+            })?;
+            let response = commands_task.await?;
+
+            // Filter commands matching the typed prefix
+            let matching_commands: Vec<_> = response.commands
+                .into_iter()
+                .filter(|cmd| {
+                    // Support both prefix matching and fuzzy matching
+                    cmd.name.starts_with(&command_prefix) ||
+                    cmd.name.to_lowercase().contains(&command_prefix.to_lowercase())
+                })
+                .collect();
+
+            // Convert to project::Completion following existing patterns
+            let completions: Vec<_> = matching_commands
+                .into_iter()
+                .map(|command| {
+                    let new_text = if command.requires_argument {
+                        format!("/{} ", command.name) // Add space for argument
+                    } else {
+                        format!("/{}", command.name)
+                    };
+
+                    Completion {
+                        replace_range: source_range.clone(),
+                        new_text: new_text.clone(),
+                        label: CodeLabel::plain(command.name.clone(), None),
+                        icon_path: Some(IconName::ZedAssistant.path().into()),
+                        documentation: if !command.description.is_empty() {
+                            Some(CompletionDocumentation::SingleLine(command.description.clone().into()))
+                        } else {
+                            None
+                        },
+                        source: project::CompletionSource::Custom,
+                        insert_text_mode: None,
+                        confirm: Some(Arc::new(move |_, _, _| {
+                            // For now, just insert the text - command execution will be handled later
+                            false
+                        })),
+                    }
+                })
+                .collect();
+
+            Ok(vec![CompletionResponse {
+                completions,
+                is_incomplete: false,
+            }])
+        })
     }
 }
 
@@ -805,7 +1019,7 @@ pub(crate) fn search_threads(
     history_store: &Entity<HistoryStore>,
     cx: &mut App,
 ) -> Task<Vec<HistoryEntry>> {
-    let threads = history_store.read(cx).entries(cx);
+    let threads = history_store.read(cx).entries().collect();
     if query.is_empty() {
         return Task::ready(threads);
     }
@@ -928,6 +1142,7 @@ impl MentionCompletion {
     }
 }
 
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/agent_ui/src/acp/entry_view_state.rs

@@ -1,13 +1,13 @@
-use std::ops::Range;
+use std::{cell::Cell, ops::Range, rc::Rc};
 
 use acp_thread::{AcpThread, AgentThreadEntry};
-use agent_client_protocol::ToolCallId;
+use agent_client_protocol::{PromptCapabilities, ToolCallId};
 use agent2::HistoryStore;
 use collections::HashMap;
 use editor::{Editor, EditorMode, MinimapVisibility};
 use gpui::{
-    AnyEntity, App, AppContext as _, Entity, EntityId, EventEmitter, Focusable,
-    TextStyleRefinement, WeakEntity, Window,
+    AnyEntity, App, AppContext as _, Entity, EntityId, EventEmitter, FocusHandle, Focusable,
+    ScrollHandle, TextStyleRefinement, WeakEntity, Window,
 };
 use language::language_settings::SoftWrap;
 use project::Project;
@@ -27,6 +27,7 @@ pub struct EntryViewState {
     prompt_store: Option<Entity<PromptStore>>,
     entries: Vec<Entry>,
     prevent_slash_commands: bool,
+    prompt_capabilities: Rc<Cell<PromptCapabilities>>,
 }
 
 impl EntryViewState {
@@ -35,6 +36,7 @@ impl EntryViewState {
         project: Entity<Project>,
         history_store: Entity<HistoryStore>,
         prompt_store: Option<Entity<PromptStore>>,
+        prompt_capabilities: Rc<Cell<PromptCapabilities>>,
         prevent_slash_commands: bool,
     ) -> Self {
         Self {
@@ -44,6 +46,7 @@ impl EntryViewState {
             prompt_store,
             entries: Vec::new(),
             prevent_slash_commands,
+            prompt_capabilities,
         }
     }
 
@@ -81,6 +84,7 @@ impl EntryViewState {
                             self.project.clone(),
                             self.history_store.clone(),
                             self.prompt_store.clone(),
+                            self.prompt_capabilities.clone(),
                             "Edit message － @ to include context",
                             self.prevent_slash_commands,
                             editor::EditorMode::AutoHeight {
@@ -150,10 +154,22 @@ impl EntryViewState {
                     });
                 }
             }
-            AgentThreadEntry::AssistantMessage(_) => {
-                if index == self.entries.len() {
-                    self.entries.push(Entry::empty())
-                }
+            AgentThreadEntry::AssistantMessage(message) => {
+                let entry = if let Some(Entry::AssistantMessage(entry)) =
+                    self.entries.get_mut(index)
+                {
+                    entry
+                } else {
+                    self.set_entry(
+                        index,
+                        Entry::AssistantMessage(AssistantMessageEntry::default()),
+                    );
+                    let Some(Entry::AssistantMessage(entry)) = self.entries.get_mut(index) else {
+                        unreachable!()
+                    };
+                    entry
+                };
+                entry.sync(message);
             }
         };
     }
@@ -173,7 +189,7 @@ impl EntryViewState {
     pub fn settings_changed(&mut self, cx: &mut App) {
         for entry in self.entries.iter() {
             match entry {
-                Entry::UserMessage { .. } => {}
+                Entry::UserMessage { .. } | Entry::AssistantMessage { .. } => {}
                 Entry::Content(response_views) => {
                     for view in response_views.values() {
                         if let Ok(diff_editor) = view.clone().downcast::<Editor>() {
@@ -204,17 +220,44 @@ pub enum ViewEvent {
     MessageEditorEvent(Entity<MessageEditor>, MessageEditorEvent),
 }
 
+#[derive(Default, Debug)]
+pub struct AssistantMessageEntry {
+    scroll_handles_by_chunk_index: HashMap<usize, ScrollHandle>,
+}
+
+impl AssistantMessageEntry {
+    pub fn scroll_handle_for_chunk(&self, ix: usize) -> Option<ScrollHandle> {
+        self.scroll_handles_by_chunk_index.get(&ix).cloned()
+    }
+
+    pub fn sync(&mut self, message: &acp_thread::AssistantMessage) {
+        if let Some(acp_thread::AssistantMessageChunk::Thought { .. }) = message.chunks.last() {
+            let ix = message.chunks.len() - 1;
+            let handle = self.scroll_handles_by_chunk_index.entry(ix).or_default();
+            handle.scroll_to_bottom();
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum Entry {
     UserMessage(Entity<MessageEditor>),
+    AssistantMessage(AssistantMessageEntry),
     Content(HashMap<EntityId, AnyEntity>),
 }
 
 impl Entry {
+    pub fn focus_handle(&self, cx: &App) -> Option<FocusHandle> {
+        match self {
+            Self::UserMessage(editor) => Some(editor.read(cx).focus_handle(cx)),
+            Self::AssistantMessage(_) | Self::Content(_) => None,
+        }
+    }
+
     pub fn message_editor(&self) -> Option<&Entity<MessageEditor>> {
         match self {
             Self::UserMessage(editor) => Some(editor),
-            Entry::Content(_) => None,
+            Self::AssistantMessage(_) | Self::Content(_) => None,
         }
     }
 
@@ -235,6 +278,16 @@ impl Entry {
             .map(|entity| entity.downcast::<TerminalView>().unwrap())
     }
 
+    pub fn scroll_handle_for_assistant_message_chunk(
+        &self,
+        chunk_ix: usize,
+    ) -> Option<ScrollHandle> {
+        match self {
+            Self::AssistantMessage(message) => message.scroll_handle_for_chunk(chunk_ix),
+            Self::UserMessage(_) | Self::Content(_) => None,
+        }
+    }
+
     fn content_map(&self) -> Option<&HashMap<EntityId, AnyEntity>> {
         match self {
             Self::Content(map) => Some(map),
@@ -250,7 +303,7 @@ impl Entry {
     pub fn has_content(&self) -> bool {
         match self {
             Self::Content(map) => !map.is_empty(),
-            Self::UserMessage(_) => false,
+            Self::UserMessage(_) | Self::AssistantMessage(_) => false,
         }
     }
 }
@@ -403,6 +456,7 @@ mod tests {
                 project.clone(),
                 history_store,
                 None,
+                Default::default(),
                 false,
             )
         });

crates/agent_ui/src/acp/model_selector.rs

@@ -73,11 +73,8 @@ impl AcpModelPickerDelegate {
                     this.update_in(cx, |this, window, cx| {
                         this.delegate.models = models.ok();
                         this.delegate.selected_model = selected_model.ok();
-                        this.delegate.update_matches(this.query(cx), window, cx)
-                    })?
-                    .await;
-
-                    Ok(())
+                        this.refresh(window, cx)
+                    })
                 }
 
                 refresh(&this, &session_id, cx).await.log_err();

crates/agent_ui/src/acp/thread_history.rs

@@ -3,18 +3,18 @@ use crate::{AgentPanel, RemoveSelectedThread};
 use agent2::{HistoryEntry, HistoryStore};
 use chrono::{Datelike as _, Local, NaiveDate, TimeDelta};
 use editor::{Editor, EditorEvent};
-use fuzzy::{StringMatch, StringMatchCandidate};
+use fuzzy::StringMatchCandidate;
 use gpui::{
-    App, Empty, Entity, EventEmitter, FocusHandle, Focusable, ScrollStrategy, Stateful, Task,
+    App, Entity, EventEmitter, FocusHandle, Focusable, ScrollStrategy, Stateful, Task,
     UniformListScrollHandle, WeakEntity, Window, uniform_list,
 };
-use std::{fmt::Display, ops::Range, sync::Arc};
+use std::{fmt::Display, ops::Range};
+use text::Bias;
 use time::{OffsetDateTime, UtcOffset};
 use ui::{
     HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Scrollbar, ScrollbarState,
     Tooltip, prelude::*,
 };
-use util::ResultExt;
 
 pub struct AcpThreadHistory {
     pub(crate) history_store: Entity<HistoryStore>,
@@ -22,38 +22,38 @@ pub struct AcpThreadHistory {
     selected_index: usize,
     hovered_index: Option<usize>,
     search_editor: Entity<Editor>,
-    all_entries: Arc<Vec<HistoryEntry>>,
-    // When the search is empty, we display date separators between history entries
-    // This vector contains an enum of either a separator or an actual entry
-    separated_items: Vec<ListItemType>,
-    // Maps entry indexes to list item indexes
-    separated_item_indexes: Vec<u32>,
-    _separated_items_task: Option<Task<()>>,
-    search_state: SearchState,
+    search_query: SharedString,
+
+    visible_items: Vec<ListItemType>,
+
     scrollbar_visibility: bool,
     scrollbar_state: ScrollbarState,
     local_timezone: UtcOffset,
-    _subscriptions: Vec<gpui::Subscription>,
-}
 
-enum SearchState {
-    Empty,
-    Searching {
-        query: SharedString,
-        _task: Task<()>,
-    },
-    Searched {
-        query: SharedString,
-        matches: Vec<StringMatch>,
-    },
+    _update_task: Task<()>,
+    _subscriptions: Vec<gpui::Subscription>,
 }
 
 enum ListItemType {
     BucketSeparator(TimeBucket),
     Entry {
-        index: usize,
+        entry: HistoryEntry,
         format: EntryTimeFormat,
     },
+    SearchResult {
+        entry: HistoryEntry,
+        positions: Vec<usize>,
+    },
+}
+
+impl ListItemType {
+    fn history_entry(&self) -> Option<&HistoryEntry> {
+        match self {
+            ListItemType::Entry { entry, .. } => Some(entry),
+            ListItemType::SearchResult { entry, .. } => Some(entry),
+            _ => None,
+        }
+    }
 }
 
 pub enum ThreadHistoryEvent {
@@ -78,12 +78,15 @@ impl AcpThreadHistory {
             cx.subscribe(&search_editor, |this, search_editor, event, cx| {
                 if let EditorEvent::BufferEdited = event {
                     let query = search_editor.read(cx).text(cx);
-                    this.search(query.into(), cx);
+                    if this.search_query != query {
+                        this.search_query = query.into();
+                        this.update_visible_items(false, cx);
+                    }
                 }
             });
 
         let history_store_subscription = cx.observe(&history_store, |this, _, cx| {
-            this.update_all_entries(cx);
+            this.update_visible_items(true, cx);
         });
 
         let scroll_handle = UniformListScrollHandle::default();
@@ -94,10 +97,7 @@ impl AcpThreadHistory {
             scroll_handle,
             selected_index: 0,
             hovered_index: None,
-            search_state: SearchState::Empty,
-            all_entries: Default::default(),
-            separated_items: Default::default(),
-            separated_item_indexes: Default::default(),
+            visible_items: Default::default(),
             search_editor,
             scrollbar_visibility: true,
             scrollbar_state,
@@ -105,29 +105,61 @@ impl AcpThreadHistory {
                 chrono::Local::now().offset().local_minus_utc(),
             )
             .unwrap(),
+            search_query: SharedString::default(),
             _subscriptions: vec![search_editor_subscription, history_store_subscription],
-            _separated_items_task: None,
+            _update_task: Task::ready(()),
         };
-        this.update_all_entries(cx);
+        this.update_visible_items(false, cx);
         this
     }
 
-    fn update_all_entries(&mut self, cx: &mut Context<Self>) {
-        let new_entries: Arc<Vec<HistoryEntry>> = self
+    fn update_visible_items(&mut self, preserve_selected_item: bool, cx: &mut Context<Self>) {
+        let entries = self
             .history_store
-            .update(cx, |store, cx| store.entries(cx))
-            .into();
+            .update(cx, |store, _| store.entries().collect());
+        let new_list_items = if self.search_query.is_empty() {
+            self.add_list_separators(entries, cx)
+        } else {
+            self.filter_search_results(entries, cx)
+        };
+        let selected_history_entry = if preserve_selected_item {
+            self.selected_history_entry().cloned()
+        } else {
+            None
+        };
 
-        self._separated_items_task.take();
+        self._update_task = cx.spawn(async move |this, cx| {
+            let new_visible_items = new_list_items.await;
+            this.update(cx, |this, cx| {
+                let new_selected_index = if let Some(history_entry) = selected_history_entry {
+                    let history_entry_id = history_entry.id();
+                    new_visible_items
+                        .iter()
+                        .position(|visible_entry| {
+                            visible_entry
+                                .history_entry()
+                                .is_some_and(|entry| entry.id() == history_entry_id)
+                        })
+                        .unwrap_or(0)
+                } else {
+                    0
+                };
 
-        let mut items = Vec::with_capacity(new_entries.len() + 1);
-        let mut indexes = Vec::with_capacity(new_entries.len() + 1);
+                this.visible_items = new_visible_items;
+                this.set_selected_index(new_selected_index, Bias::Right, cx);
+                cx.notify();
+            })
+            .ok();
+        });
+    }
 
-        let bg_task = cx.background_spawn(async move {
+    fn add_list_separators(&self, entries: Vec<HistoryEntry>, cx: &App) -> Task<Vec<ListItemType>> {
+        cx.background_spawn(async move {
+            let mut items = Vec::with_capacity(entries.len() + 1);
             let mut bucket = None;
             let today = Local::now().naive_local().date();
 
-            for (index, entry) in new_entries.iter().enumerate() {
+            for entry in entries.into_iter() {
                 let entry_date = entry
                     .updated_at()
                     .with_timezone(&Local)
@@ -140,75 +172,33 @@ impl AcpThreadHistory {
                     items.push(ListItemType::BucketSeparator(entry_bucket));
                 }
 
-                indexes.push(items.len() as u32);
                 items.push(ListItemType::Entry {
-                    index,
+                    entry,
                     format: entry_bucket.into(),
                 });
             }
-            (new_entries, items, indexes)
-        });
-
-        let task = cx.spawn(async move |this, cx| {
-            let (new_entries, items, indexes) = bg_task.await;
-            this.update(cx, |this, cx| {
-                let previously_selected_entry =
-                    this.all_entries.get(this.selected_index).map(|e| e.id());
-
-                this.all_entries = new_entries;
-                this.separated_items = items;
-                this.separated_item_indexes = indexes;
-
-                match &this.search_state {
-                    SearchState::Empty => {
-                        if this.selected_index >= this.all_entries.len() {
-                            this.set_selected_entry_index(
-                                this.all_entries.len().saturating_sub(1),
-                                cx,
-                            );
-                        } else if let Some(prev_id) = previously_selected_entry
-                            && let Some(new_ix) = this
-                                .all_entries
-                                .iter()
-                                .position(|probe| probe.id() == prev_id)
-                        {
-                            this.set_selected_entry_index(new_ix, cx);
-                        }
-                    }
-                    SearchState::Searching { query, .. } | SearchState::Searched { query, .. } => {
-                        this.search(query.clone(), cx);
-                    }
-                }
-
-                cx.notify();
-            })
-            .log_err();
-        });
-        self._separated_items_task = Some(task);
+            items
+        })
     }
 
-    fn search(&mut self, query: SharedString, cx: &mut Context<Self>) {
-        if query.is_empty() {
-            self.search_state = SearchState::Empty;
-            cx.notify();
-            return;
-        }
-
-        let all_entries = self.all_entries.clone();
-
-        let fuzzy_search_task = cx.background_spawn({
-            let query = query.clone();
+    fn filter_search_results(
+        &self,
+        entries: Vec<HistoryEntry>,
+        cx: &App,
+    ) -> Task<Vec<ListItemType>> {
+        let query = self.search_query.clone();
+        cx.background_spawn({
             let executor = cx.background_executor().clone();
             async move {
-                let mut candidates = Vec::with_capacity(all_entries.len());
+                let mut candidates = Vec::with_capacity(entries.len());
 
-                for (idx, entry) in all_entries.iter().enumerate() {
+                for (idx, entry) in entries.iter().enumerate() {
                     candidates.push(StringMatchCandidate::new(idx, entry.title()));
                 }
 
                 const MAX_MATCHES: usize = 100;
 
-                fuzzy::match_strings(
+                let matches = fuzzy::match_strings(
                     &candidates,
                     &query,
                     false,
@@ -217,74 +207,61 @@ impl AcpThreadHistory {
                     &Default::default(),
                     executor,
                 )
-                .await
+                .await;
+
+                matches
+                    .into_iter()
+                    .map(|search_match| ListItemType::SearchResult {
+                        entry: entries[search_match.candidate_id].clone(),
+                        positions: search_match.positions,
+                    })
+                    .collect()
             }
-        });
-
-        let task = cx.spawn({
-            let query = query.clone();
-            async move |this, cx| {
-                let matches = fuzzy_search_task.await;
-
-                this.update(cx, |this, cx| {
-                    let SearchState::Searching {
-                        query: current_query,
-                        _task,
-                    } = &this.search_state
-                    else {
-                        return;
-                    };
-
-                    if &query == current_query {
-                        this.search_state = SearchState::Searched {
-                            query: query.clone(),
-                            matches,
-                        };
-
-                        this.set_selected_entry_index(0, cx);
-                        cx.notify();
-                    };
-                })
-                .log_err();
-            }
-        });
-
-        self.search_state = SearchState::Searching { query, _task: task };
-        cx.notify();
-    }
-
-    fn matched_count(&self) -> usize {
-        match &self.search_state {
-            SearchState::Empty => self.all_entries.len(),
-            SearchState::Searching { .. } => 0,
-            SearchState::Searched { matches, .. } => matches.len(),
-        }
-    }
-
-    fn list_item_count(&self) -> usize {
-        match &self.search_state {
-            SearchState::Empty => self.separated_items.len(),
-            SearchState::Searching { .. } => 0,
-            SearchState::Searched { matches, .. } => matches.len(),
-        }
+        })
     }
 
     fn search_produced_no_matches(&self) -> bool {
-        match &self.search_state {
-            SearchState::Empty => false,
-            SearchState::Searching { .. } => false,
-            SearchState::Searched { matches, .. } => matches.is_empty(),
-        }
+        self.visible_items.is_empty() && !self.search_query.is_empty()
     }
 
-    fn get_match(&self, ix: usize) -> Option<&HistoryEntry> {
-        match &self.search_state {
-            SearchState::Empty => self.all_entries.get(ix),
-            SearchState::Searching { .. } => None,
-            SearchState::Searched { matches, .. } => matches
-                .get(ix)
-                .and_then(|m| self.all_entries.get(m.candidate_id)),
+    fn selected_history_entry(&self) -> Option<&HistoryEntry> {
+        self.get_history_entry(self.selected_index)
+    }
+
+    fn get_history_entry(&self, visible_items_ix: usize) -> Option<&HistoryEntry> {
+        self.visible_items.get(visible_items_ix)?.history_entry()
+    }
+
+    fn set_selected_index(&mut self, mut index: usize, bias: Bias, cx: &mut Context<Self>) {
+        if self.visible_items.len() == 0 {
+            self.selected_index = 0;
+            return;
         }
+        while matches!(
+            self.visible_items.get(index),
+            None | Some(ListItemType::BucketSeparator(..))
+        ) {
+            index = match bias {
+                Bias::Left => {
+                    if index == 0 {
+                        self.visible_items.len() - 1
+                    } else {
+                        index - 1
+                    }
+                }
+                Bias::Right => {
+                    if index >= self.visible_items.len() - 1 {
+                        0
+                    } else {
+                        index + 1
+                    }
+                }
+            };
+        }
+        self.selected_index = index;
+        self.scroll_handle
+            .scroll_to_item(index, ScrollStrategy::Top);
+        cx.notify()
     }
 
     pub fn select_previous(
@@ -293,13 +270,10 @@ impl AcpThreadHistory {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self.matched_count();
-        if count > 0 {
-            if self.selected_index == 0 {
-                self.set_selected_entry_index(count - 1, cx);
-            } else {
-                self.set_selected_entry_index(self.selected_index - 1, cx);
-            }
+        if self.selected_index == 0 {
+            self.set_selected_index(self.visible_items.len() - 1, Bias::Left, cx);
+        } else {
+            self.set_selected_index(self.selected_index - 1, Bias::Left, cx);
         }
     }
 
@@ -309,13 +283,10 @@ impl AcpThreadHistory {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self.matched_count();
-        if count > 0 {
-            if self.selected_index == count - 1 {
-                self.set_selected_entry_index(0, cx);
-            } else {
-                self.set_selected_entry_index(self.selected_index + 1, cx);
-            }
+        if self.selected_index == self.visible_items.len() - 1 {
+            self.set_selected_index(0, Bias::Right, cx);
+        } else {
+            self.set_selected_index(self.selected_index + 1, Bias::Right, cx);
         }
     }
 
@@ -325,35 +296,47 @@ impl AcpThreadHistory {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self.matched_count();
-        if count > 0 {
-            self.set_selected_entry_index(0, cx);
-        }
+        self.set_selected_index(0, Bias::Right, cx);
     }
 
     fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
-        let count = self.matched_count();
-        if count > 0 {
-            self.set_selected_entry_index(count - 1, cx);
-        }
+        self.set_selected_index(self.visible_items.len() - 1, Bias::Left, cx);
     }
 
-    fn set_selected_entry_index(&mut self, entry_index: usize, cx: &mut Context<Self>) {
-        self.selected_index = entry_index;
+    fn confirm(&mut self, _: &menu::Confirm, _window: &mut Window, cx: &mut Context<Self>) {
+        self.confirm_entry(self.selected_index, cx);
+    }
 
-        let scroll_ix = match self.search_state {
-            SearchState::Empty | SearchState::Searching { .. } => self
-                .separated_item_indexes
-                .get(entry_index)
-                .map(|ix| *ix as usize)
-                .unwrap_or(entry_index + 1),
-            SearchState::Searched { .. } => entry_index,
+    fn confirm_entry(&mut self, ix: usize, cx: &mut Context<Self>) {
+        let Some(entry) = self.get_history_entry(ix) else {
+            return;
+        };
+        cx.emit(ThreadHistoryEvent::Open(entry.clone()));
+    }
+
+    fn remove_selected_thread(
+        &mut self,
+        _: &RemoveSelectedThread,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.remove_thread(self.selected_index, cx)
+    }
+
+    fn remove_thread(&mut self, visible_item_ix: usize, cx: &mut Context<Self>) {
+        let Some(entry) = self.get_history_entry(visible_item_ix) else {
+            return;
         };
 
-        self.scroll_handle
-            .scroll_to_item(scroll_ix, ScrollStrategy::Top);
-
-        cx.notify();
+        let task = match entry {
+            HistoryEntry::AcpThread(thread) => self
+                .history_store
+                .update(cx, |this, cx| this.delete_thread(thread.id.clone(), cx)),
+            HistoryEntry::TextThread(context) => self.history_store.update(cx, |this, cx| {
+                this.delete_text_thread(context.path.clone(), cx)
+            }),
+        };
+        task.detach_and_log_err(cx);
     }
 
     fn render_scrollbar(&self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
@@ -393,91 +376,33 @@ impl AcpThreadHistory {
         )
     }
 
-    fn confirm(&mut self, _: &menu::Confirm, _window: &mut Window, cx: &mut Context<Self>) {
-        self.confirm_entry(self.selected_index, cx);
-    }
-
-    fn confirm_entry(&mut self, ix: usize, cx: &mut Context<Self>) {
-        let Some(entry) = self.get_match(ix) else {
-            return;
-        };
-        cx.emit(ThreadHistoryEvent::Open(entry.clone()));
-    }
-
-    fn remove_selected_thread(
-        &mut self,
-        _: &RemoveSelectedThread,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.remove_thread(self.selected_index, cx)
-    }
-
-    fn remove_thread(&mut self, ix: usize, cx: &mut Context<Self>) {
-        let Some(entry) = self.get_match(ix) else {
-            return;
-        };
-
-        let task = match entry {
-            HistoryEntry::AcpThread(thread) => self
-                .history_store
-                .update(cx, |this, cx| this.delete_thread(thread.id.clone(), cx)),
-            HistoryEntry::TextThread(context) => self.history_store.update(cx, |this, cx| {
-                this.delete_text_thread(context.path.clone(), cx)
-            }),
-        };
-        task.detach_and_log_err(cx);
-    }
-
-    fn list_items(
+    fn render_list_items(
         &mut self,
         range: Range<usize>,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Vec<AnyElement> {
-        match &self.search_state {
-            SearchState::Empty => self
-                .separated_items
-                .get(range)
-                .iter()
-                .flat_map(|items| {
-                    items
-                        .iter()
-                        .map(|item| self.render_list_item(item, vec![], cx))
-                })
-                .collect(),
-            SearchState::Searched { matches, .. } => matches[range]
-                .iter()
-                .filter_map(|m| {
-                    let entry = self.all_entries.get(m.candidate_id)?;
-                    Some(self.render_history_entry(
-                        entry,
-                        EntryTimeFormat::DateAndTime,
-                        m.candidate_id,
-                        m.positions.clone(),
-                        cx,
-                    ))
-                })
-                .collect(),
-            SearchState::Searching { .. } => {
-                vec![]
-            }
-        }
+        self.visible_items
+            .get(range.clone())
+            .into_iter()
+            .flatten()
+            .enumerate()
+            .map(|(ix, item)| self.render_list_item(item, range.start + ix, cx))
+            .collect()
     }
 
-    fn render_list_item(
-        &self,
-        item: &ListItemType,
-        highlight_positions: Vec<usize>,
-        cx: &Context<Self>,
-    ) -> AnyElement {
+    fn render_list_item(&self, item: &ListItemType, ix: usize, cx: &Context<Self>) -> AnyElement {
         match item {
-            ListItemType::Entry { index, format } => match self.all_entries.get(*index) {
-                Some(entry) => self
-                    .render_history_entry(entry, *format, *index, highlight_positions, cx)
-                    .into_any(),
-                None => Empty.into_any_element(),
-            },
+            ListItemType::Entry { entry, format } => self
+                .render_history_entry(entry, *format, ix, Vec::default(), cx)
+                .into_any(),
+            ListItemType::SearchResult { entry, positions } => self.render_history_entry(
+                entry,
+                EntryTimeFormat::DateAndTime,
+                ix,
+                positions.clone(),
+                cx,
+            ),
             ListItemType::BucketSeparator(bucket) => div()
                 .px(DynamicSpacing::Base06.rems(cx))
                 .pt_2()
@@ -495,12 +420,12 @@ impl AcpThreadHistory {
         &self,
         entry: &HistoryEntry,
         format: EntryTimeFormat,
-        list_entry_ix: usize,
+        ix: usize,
         highlight_positions: Vec<usize>,
         cx: &Context<Self>,
     ) -> AnyElement {
-        let selected = list_entry_ix == self.selected_index;
-        let hovered = Some(list_entry_ix) == self.hovered_index;
+        let selected = ix == self.selected_index;
+        let hovered = Some(ix) == self.hovered_index;
         let timestamp = entry.updated_at().timestamp();
         let thread_timestamp = format.format_timestamp(timestamp, self.local_timezone);
 
@@ -508,7 +433,7 @@ impl AcpThreadHistory {
             .w_full()
             .pb_1()
             .child(
-                ListItem::new(list_entry_ix)
+                ListItem::new(ix)
                     .rounded()
                     .toggle_state(selected)
                     .spacing(ListItemSpacing::Sparse)
@@ -530,14 +455,14 @@ impl AcpThreadHistory {
                     )
                     .on_hover(cx.listener(move |this, is_hovered, _window, cx| {
                         if *is_hovered {
-                            this.hovered_index = Some(list_entry_ix);
-                        } else if this.hovered_index == Some(list_entry_ix) {
+                            this.hovered_index = Some(ix);
+                        } else if this.hovered_index == Some(ix) {
                             this.hovered_index = None;
                         }
 
                         cx.notify();
                     }))
-                    .end_slot::<IconButton>(if hovered || selected {
+                    .end_slot::<IconButton>(if hovered {
                         Some(
                             IconButton::new("delete", IconName::Trash)
                                 .shape(IconButtonShape::Square)
@@ -546,16 +471,14 @@ impl AcpThreadHistory {
                                 .tooltip(move |window, cx| {
                                     Tooltip::for_action("Delete", &RemoveSelectedThread, window, cx)
                                 })
-                                .on_click(cx.listener(move |this, _, _, cx| {
-                                    this.remove_thread(list_entry_ix, cx)
-                                })),
+                                .on_click(
+                                    cx.listener(move |this, _, _, cx| this.remove_thread(ix, cx)),
+                                ),
                         )
                     } else {
                         None
                     })
-                    .on_click(
-                        cx.listener(move |this, _, _, cx| this.confirm_entry(list_entry_ix, cx)),
-                    ),
+                    .on_click(cx.listener(move |this, _, _, cx| this.confirm_entry(ix, cx))),
             )
             .into_any_element()
     }
@@ -578,7 +501,7 @@ impl Render for AcpThreadHistory {
             .on_action(cx.listener(Self::select_last))
             .on_action(cx.listener(Self::confirm))
             .on_action(cx.listener(Self::remove_selected_thread))
-            .when(!self.all_entries.is_empty(), |parent| {
+            .when(!self.history_store.read(cx).is_empty(cx), |parent| {
                 parent.child(
                     h_flex()
                         .h(px(41.)) // Match the toolbar perfectly
@@ -604,7 +527,7 @@ impl Render for AcpThreadHistory {
                     .overflow_hidden()
                     .flex_grow();
 
-                if self.all_entries.is_empty() {
+                if self.history_store.read(cx).is_empty(cx) {
                     view.justify_center()
                         .child(
                             h_flex().w_full().justify_center().child(
@@ -623,9 +546,9 @@ impl Render for AcpThreadHistory {
                         .child(
                             uniform_list(
                                 "thread-history",
-                                self.list_item_count(),
+                                self.visible_items.len(),
                                 cx.processor(|this, range: Range<usize>, window, cx| {
-                                    this.list_items(range, window, cx)
+                                    this.render_list_items(range, window, cx)
                                 }),
                             )
                             .p_1()

crates/agent_ui/src/active_thread.rs

@@ -1595,11 +1595,6 @@ impl ActiveThread {
             return;
         };
 
-        if model.provider.must_accept_terms(cx) {
-            cx.notify();
-            return;
-        }
-
         let edited_text = state.editor.read(cx).text(cx);
 
         let creases = state.editor.update(cx, extract_message_creases);

crates/agent_ui/src/agent_configuration.rs

@@ -3,19 +3,23 @@ mod configure_context_server_modal;
 mod manage_profiles_modal;
 mod tool_picker;
 
-use std::{sync::Arc, time::Duration};
+use std::{ops::Range, sync::Arc, time::Duration};
 
+use agent_servers::{AgentServerCommand, AllAgentServersSettings, CustomAgentServerSettings};
 use agent_settings::AgentSettings;
+use anyhow::Result;
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use cloud_llm_client::Plan;
 use collections::HashMap;
 use context_server::ContextServerId;
+use editor::{Editor, SelectionEffects, scroll::Autoscroll};
 use extension::ExtensionManifest;
 use extension_host::ExtensionStore;
 use fs::Fs;
 use gpui::{
-    Action, Animation, AnimationExt as _, AnyView, App, Corner, Entity, EventEmitter, FocusHandle,
-    Focusable, ScrollHandle, Subscription, Task, Transformation, WeakEntity, percentage,
+    Action, Animation, AnimationExt as _, AnyView, App, AsyncWindowContext, Corner, Entity,
+    EventEmitter, FocusHandle, Focusable, Hsla, ScrollHandle, Subscription, Task, Transformation,
+    WeakEntity, percentage,
 };
 use language::LanguageRegistry;
 use language_model::{
@@ -26,20 +30,20 @@ use project::{
     context_server_store::{ContextServerConfiguration, ContextServerStatus, ContextServerStore},
     project_settings::{ContextServerSettings, ProjectSettings},
 };
-use settings::{Settings, update_settings_file};
+use settings::{Settings, SettingsStore, update_settings_file};
 use ui::{
     Chip, ContextMenu, Disclosure, Divider, DividerColor, ElevationIndex, Indicator, PopoverMenu,
     Scrollbar, ScrollbarState, Switch, SwitchColor, SwitchField, Tooltip, prelude::*,
 };
 use util::ResultExt as _;
-use workspace::Workspace;
+use workspace::{Workspace, create_and_open_local_file};
 use zed_actions::ExtensionCategoryFilter;
 
 pub(crate) use configure_context_server_modal::ConfigureContextServerModal;
 pub(crate) use manage_profiles_modal::ManageProfilesModal;
 
 use crate::{
-    AddContextServer,
+    AddContextServer, ExternalAgent, NewExternalAgentThread,
     agent_configuration::add_llm_provider_modal::{AddLlmProviderModal, LlmCompatibleProvider},
 };
 
@@ -56,6 +60,7 @@ pub struct AgentConfiguration {
     _registry_subscription: Subscription,
     scroll_handle: ScrollHandle,
     scrollbar_state: ScrollbarState,
+    _check_for_gemini: Task<()>,
 }
 
 impl AgentConfiguration {
@@ -93,14 +98,6 @@ impl AgentConfiguration {
         let scroll_handle = ScrollHandle::new();
         let scrollbar_state = ScrollbarState::new(scroll_handle.clone());
 
-        let mut expanded_provider_configurations = HashMap::default();
-        if LanguageModelRegistry::read_global(cx)
-            .provider(&ZED_CLOUD_PROVIDER_ID)
-            .is_some_and(|cloud_provider| cloud_provider.must_accept_terms(cx))
-        {
-            expanded_provider_configurations.insert(ZED_CLOUD_PROVIDER_ID, true);
-        }
-
         let mut this = Self {
             fs,
             language_registry,
@@ -109,11 +106,12 @@ impl AgentConfiguration {
             configuration_views_by_provider: HashMap::default(),
             context_server_store,
             expanded_context_server_tools: HashMap::default(),
-            expanded_provider_configurations,
+            expanded_provider_configurations: HashMap::default(),
             tools,
             _registry_subscription: registry_subscription,
             scroll_handle,
             scrollbar_state,
+            _check_for_gemini: Task::ready(()),
         };
         this.build_provider_configuration_views(window, cx);
         this
@@ -219,7 +217,6 @@ impl AgentConfiguration {
                     .child(
                         h_flex()
                             .id(provider_id_string.clone())
-                            .cursor_pointer()
                             .px_2()
                             .py_0p5()
                             .w_full()
@@ -239,10 +236,7 @@ impl AgentConfiguration {
                                         h_flex()
                                             .w_full()
                                             .gap_1()
-                                            .child(
-                                                Label::new(provider_name.clone())
-                                                    .size(LabelSize::Large),
-                                            )
+                                            .child(Label::new(provider_name.clone()))
                                             .map(|this| {
                                                 if is_zed_provider && is_signed_in {
                                                     this.child(
@@ -287,7 +281,7 @@ impl AgentConfiguration {
                                 "Start New Thread",
                             )
                             .icon_position(IconPosition::Start)
-                            .icon(IconName::Plus)
+                            .icon(IconName::Thread)
                             .icon_size(IconSize::Small)
                             .icon_color(Color::Muted)
                             .label_size(LabelSize::Small)
@@ -386,7 +380,7 @@ impl AgentConfiguration {
                                     ),
                             )
                             .child(
-                                Label::new("Add at least one provider to use AI-powered features.")
+                                Label::new("Add at least one provider to use AI-powered features with Zed's native agent.")
                                     .color(Color::Muted),
                             ),
                     ),
@@ -527,6 +521,14 @@ impl AgentConfiguration {
         }
     }
 
+    fn card_item_bg_color(&self, cx: &mut Context<Self>) -> Hsla {
+        cx.theme().colors().background.opacity(0.25)
+    }
+
+    fn card_item_border_color(&self, cx: &mut Context<Self>) -> Hsla {
+        cx.theme().colors().border.opacity(0.6)
+    }
+
     fn render_context_servers_section(
         &mut self,
         window: &mut Window,
@@ -544,7 +546,12 @@ impl AgentConfiguration {
                 v_flex()
                     .gap_0p5()
                     .child(Headline::new("Model Context Protocol (MCP) Servers"))
-                    .child(Label::new("Connect to context servers through the Model Context Protocol, either using Zed extensions or directly.").color(Color::Muted)),
+                    .child(
+                        Label::new(
+                            "All context servers connected through the Model Context Protocol.",
+                        )
+                        .color(Color::Muted),
+                    ),
             )
             .children(
                 context_server_ids.into_iter().map(|context_server_id| {
@@ -554,7 +561,7 @@ impl AgentConfiguration {
             .child(
                 h_flex()
                     .justify_between()
-                    .gap_2()
+                    .gap_1p5()
                     .child(
                         h_flex().w_full().child(
                             Button::new("add-context-server", "Add Custom Server")
@@ -645,8 +652,6 @@ impl AgentConfiguration {
             .map_or([].as_slice(), |tools| tools.as_slice());
         let tool_count = tools.len();
 
-        let border_color = cx.theme().colors().border.opacity(0.6);
-
         let (source_icon, source_tooltip) = if is_from_extension {
             (
                 IconName::ZedMcpExtension,
@@ -789,8 +794,8 @@ impl AgentConfiguration {
             .id(item_id.clone())
             .border_1()
             .rounded_md()
-            .border_color(border_color)
-            .bg(cx.theme().colors().background.opacity(0.2))
+            .border_color(self.card_item_border_color(cx))
+            .bg(self.card_item_bg_color(cx))
             .overflow_hidden()
             .child(
                 h_flex()
@@ -798,7 +803,11 @@ impl AgentConfiguration {
                     .justify_between()
                     .when(
                         error.is_some() || are_tools_expanded && tool_count >= 1,
-                        |element| element.border_b_1().border_color(border_color),
+                        |element| {
+                            element
+                                .border_b_1()
+                                .border_color(self.card_item_border_color(cx))
+                        },
                     )
                     .child(
                         h_flex()
@@ -980,6 +989,132 @@ impl AgentConfiguration {
                 ))
             })
     }
+
+    fn render_agent_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
+        let settings = AllAgentServersSettings::get_global(cx).clone();
+        let user_defined_agents = settings
+            .custom
+            .iter()
+            .map(|(name, settings)| {
+                self.render_agent_server(
+                    IconName::Ai,
+                    name.clone(),
+                    ExternalAgent::Custom {
+                        name: name.clone(),
+                        command: settings.command.clone(),
+                    },
+                    cx,
+                )
+                .into_any_element()
+            })
+            .collect::<Vec<_>>();
+
+        v_flex()
+            .border_b_1()
+            .border_color(cx.theme().colors().border)
+            .child(
+                v_flex()
+                    .p(DynamicSpacing::Base16.rems(cx))
+                    .pr(DynamicSpacing::Base20.rems(cx))
+                    .gap_2()
+                    .child(
+                        v_flex()
+                            .gap_0p5()
+                            .child(
+                                h_flex()
+                                    .w_full()
+                                    .gap_2()
+                                    .justify_between()
+                                    .child(Headline::new("External Agents"))
+                                    .child(
+                                        Button::new("add-agent", "Add Agent")
+                                            .icon_position(IconPosition::Start)
+                                            .icon(IconName::Plus)
+                                            .icon_size(IconSize::Small)
+                                            .icon_color(Color::Muted)
+                                            .label_size(LabelSize::Small)
+                                            .on_click(
+                                                move |_, window, cx| {
+                                                    if let Some(workspace) = window.root().flatten() {
+                                                        let workspace = workspace.downgrade();
+                                                        window
+                                                            .spawn(cx, async |cx| {
+                                                                open_new_agent_servers_entry_in_settings_editor(
+                                                                    workspace,
+                                                                    cx,
+                                                                ).await
+                                                            })
+                                                            .detach_and_log_err(cx);
+                                                    }
+                                                }
+                                            ),
+                                    )
+                            )
+                            .child(
+                                Label::new(
+                                    "Bring the agent of your choice to Zed via our new Agent Client Protocol.",
+                                )
+                                .color(Color::Muted),
+                            ),
+                    )
+                    .child(self.render_agent_server(
+                        IconName::AiGemini,
+                        "Gemini CLI",
+                        ExternalAgent::Gemini,
+                        cx,
+                    ))
+                    // TODO add CC
+                    .children(user_defined_agents),
+            )
+    }
+
+    fn render_agent_server(
+        &self,
+        icon: IconName,
+        name: impl Into<SharedString>,
+        agent: ExternalAgent,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let name = name.into();
+        h_flex()
+            .p_1()
+            .pl_2()
+            .gap_1p5()
+            .justify_between()
+            .border_1()
+            .rounded_md()
+            .border_color(self.card_item_border_color(cx))
+            .bg(self.card_item_bg_color(cx))
+            .overflow_hidden()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted))
+                    .child(Label::new(name.clone())),
+            )
+            .child(
+                h_flex().gap_1().child(
+                    Button::new(
+                        SharedString::from(format!("start_acp_thread-{name}")),
+                        "Start New Thread",
+                    )
+                    .label_size(LabelSize::Small)
+                    .icon(IconName::Thread)
+                    .icon_position(IconPosition::Start)
+                    .icon_size(IconSize::XSmall)
+                    .icon_color(Color::Muted)
+                    .on_click(move |_, window, cx| {
+                        window.dispatch_action(
+                            NewExternalAgentThread {
+                                agent: Some(agent.clone()),
+                            }
+                            .boxed_clone(),
+                            cx,
+                        );
+                    }),
+                ),
+            )
+    }
 }
 
 impl Render for AgentConfiguration {
@@ -999,6 +1134,7 @@ impl Render for AgentConfiguration {
                     .size_full()
                     .overflow_y_scroll()
                     .child(self.render_general_settings_section(cx))
+                    .child(self.render_agent_servers_section(cx))
                     .child(self.render_context_servers_section(window, cx))
                     .child(self.render_provider_configuration_section(cx)),
             )
@@ -1117,3 +1253,109 @@ fn show_unable_to_uninstall_extension_with_context_server(
 
     workspace.toggle_status_toast(status_toast, cx);
 }
+
+async fn open_new_agent_servers_entry_in_settings_editor(
+    workspace: WeakEntity<Workspace>,
+    cx: &mut AsyncWindowContext,
+) -> Result<()> {
+    let settings_editor = workspace
+        .update_in(cx, |_, window, cx| {
+            create_and_open_local_file(paths::settings_file(), window, cx, || {
+                settings::initial_user_settings_content().as_ref().into()
+            })
+        })?
+        .await?
+        .downcast::<Editor>()
+        .unwrap();
+
+    settings_editor
+        .downgrade()
+        .update_in(cx, |item, window, cx| {
+            let text = item.buffer().read(cx).snapshot(cx).text();
+
+            let settings = cx.global::<SettingsStore>();
+
+            let mut unique_server_name = None;
+            let edits = settings.edits_for_update::<AllAgentServersSettings>(&text, |file| {
+                let server_name: Option<SharedString> = (0..u8::MAX)
+                    .map(|i| {
+                        if i == 0 {
+                            "your_agent".into()
+                        } else {
+                            format!("your_agent_{}", i).into()
+                        }
+                    })
+                    .find(|name| !file.custom.contains_key(name));
+                if let Some(server_name) = server_name {
+                    unique_server_name = Some(server_name.clone());
+                    file.custom.insert(
+                        server_name,
+                        CustomAgentServerSettings {
+                            command: AgentServerCommand {
+                                path: "path_to_executable".into(),
+                                args: vec![],
+                                env: Some(HashMap::default()),
+                            },
+                        },
+                    );
+                }
+            });
+
+            if edits.is_empty() {
+                return;
+            }
+
+            let ranges = edits
+                .iter()
+                .map(|(range, _)| range.clone())
+                .collect::<Vec<_>>();
+
+            item.edit(edits, cx);
+            if let Some((unique_server_name, buffer)) =
+                unique_server_name.zip(item.buffer().read(cx).as_singleton())
+            {
+                let snapshot = buffer.read(cx).snapshot();
+                if let Some(range) =
+                    find_text_in_buffer(&unique_server_name, ranges[0].start, &snapshot)
+                {
+                    item.change_selections(
+                        SelectionEffects::scroll(Autoscroll::newest()),
+                        window,
+                        cx,
+                        |selections| {
+                            selections.select_ranges(vec![range]);
+                        },
+                    );
+                }
+            }
+        })
+}
+
+fn find_text_in_buffer(
+    text: &str,
+    start: usize,
+    snapshot: &language::BufferSnapshot,
+) -> Option<Range<usize>> {
+    let chars = text.chars().collect::<Vec<char>>();
+
+    let mut offset = start;
+    let mut char_offset = 0;
+    for c in snapshot.chars_at(start) {
+        if char_offset >= chars.len() {
+            break;
+        }
+        offset += 1;
+
+        if c == chars[char_offset] {
+            char_offset += 1;
+        } else {
+            char_offset = 0;
+        }
+    }
+
+    if char_offset == chars.len() {
+        Some(offset.saturating_sub(chars.len())..offset)
+    } else {
+        None
+    }
+}

crates/agent_ui/src/agent_diff.rs

@@ -1529,6 +1529,7 @@ impl AgentDiff {
             | AcpThreadEvent::TokenUsageUpdated
             | AcpThreadEvent::EntriesRemoved(_)
             | AcpThreadEvent::ToolAuthorizationRequired
+            | AcpThreadEvent::PromptCapabilitiesUpdated
             | AcpThreadEvent::Retry(_) => {}
         }
     }