Add KiloCode support

[v-karbovnichy]

https://kilo.ai/

It has CLI too (forked from OpenCode recently but probably slightly modified)
https://kilo.ai/cli

[1code-async]

Task completed.

The enrichment comment has been posted on issue #166: #166 (comment)

Here's a summary of what the comment covers:

1. KiloCode CLI overview — npm package @kilocode/cli, built on OpenCode (MIT), supports 500+ models with BYOK
2. Current architecture analysis — the app is tightly coupled to @anthropic-ai/claude-agent-sdk with no provider abstraction layer, identifying the key integration points in claude.ts, offline-handler.ts, and the database schema
3. Key challenge — KiloCode is a standalone CLI tool (not an SDK), so integration requires a fundamentally different approach than the current Claude SDK usage
4. Three integration options — CLI wrapper, OpenCode SDK investigation, or a provider abstraction layer
5. Five related issues — [Feature request ] Add multi model provider support #146 (multi-provider support, most relevant), Bug: API Key mode prompts for OAuth login when starting chat #165 (API key bug), Support 'Anthropic Console account' #119, Claude code through AWS bedrock key #51, and [FEAT] Allow users to connect GLM model instead of Claude subscriptions #7 showing recurring community demand for provider flexibility
6. Suggested approach — define a provider interface, implement Claude as the first adapter, add KiloCode as a second adapter, and leverage the fork work from [Feature request ] Add multi model provider support #146
7. Files that would need changes — specific file paths and what would change in each

---

View full conversation

Powered by 1Code

[1code-async]

Task completed.

I've posted a detailed analysis and implementation plan as a comment on issue #166. Here's a summary of the key findings:

KiloCode CLI (@kilocode/cli) is a fork of OpenCode — a TypeScript-based agentic coding tool supporting 500+ models. It has an npm package but does not yet support ACP (Agent Client Protocol), which is how Codex is currently integrated.

Three integration approaches were evaluated:

1. OpenCode SDK (Recommended) — Use @opencode-ai/sdk to communicate with a locally spawned KiloCode server over HTTP + SSE. Type-safe, well-suited for Electron streaming, doesn't require ACP.

2. ACP Integration (Blocked) — Would reuse existing Codex infrastructure, but KiloCode hasn't shipped ACP support yet (only an open discussion requesting it).

3. CLI Wrapper (Not recommended) — Spawning the CLI and parsing output. Fragile and poor UX.

The plan covers 4 phases with ~13 files to create or modify:

• Phase 1: Backend tRPC router (kilo.ts), process manager, stream transformer
• Phase 2: Frontend transport, model selector extension, provider switching updates across active-chat.tsx, chat-input-area.tsx, and agent-model-selector.tsx
• Phase 3: Auth flow and settings UI for KiloCode API keys
• Phase 4: Package dependencies and CLI installation detection

The comment also identifies 5 open questions around auto-spawning the server, model catalog UX (500+ models don't fit in a dropdown), tool rendering compatibility, session resume behavior, and whether to wait for ACP support upstream.

---

View full conversation

Powered by 1Code

[1code-async]

Issue Analysis: Add KiloCode Support

What is KiloCode CLI?

KiloCode CLI (@kilocode/cli on npm) is an agentic coding CLI built on top of OpenCode (MIT-licensed). It provides access to 500+ AI models, supports BYOK (Bring Your Own Key), and includes free usage via MiniMax M2.1. It's installed via npm install -g @kilocode/cli and invoked with kilo in any directory.

Current Architecture

The app is currently tightly coupled to the Anthropic Claude SDK (@anthropic-ai/claude-agent-sdk v0.2.32). There is no provider abstraction layer — the Claude SDK is directly imported and used throughout:

• SDK integration: src/main/lib/trpc/routers/claude.ts — dynamic import and caching of the query function (~lines 248-258), streaming loop (~lines 1949-2350)
• Session management: Sessions are tied to Claude SDK's sessionId concept, stored in sub_chats.sessionId (src/main/lib/db/schema/index.ts:77)
• Mode system: Plan vs Agent modes with tool restrictions are implemented directly against Claude SDK tool names (~lines 1789-1812)
• Auth flow: OAuth tokens stored via safeStorage, with fallback chain in src/main/lib/claude/offline-handler.ts:31-110
• Offline support: Ollama is the only alternative backend, used exclusively for offline mode (src/main/lib/trpc/routers/ollama.ts)

The existing CustomClaudeConfig type (src/main/lib/claude/offline-handler.ts:7-11) supports custom model, token, and baseUrl — but this is designed for API-compatible endpoints, not alternative CLI tools.

Key Challenge

KiloCode CLI is a separate CLI tool (not an SDK library), which means integration would need a fundamentally different approach compared to the current Claude SDK integration. Options include:

1. CLI wrapper approach: Spawn kilo as a child process and parse its output — similar to how some editors integrate with CLI tools. This would require adapting the streaming/message format.
2. OpenCode SDK approach: Since KiloCode is built on OpenCode, investigate whether OpenCode exposes a programmatic Node.js API that could be used directly (similar to how @anthropic-ai/claude-agent-sdk is used).
3. Provider abstraction layer: Create a common interface that both Claude SDK and KiloCode can implement, then swap providers based on user configuration.

Related Issues

This request fits into a broader pattern of community demand for multi-provider support:

• [Feature request ] Add multi model provider support #146 — [Feature request] Add multi model provider support (OPEN) — directly related, requests per-workspace/per-chat provider switching. The author mentions having a working implementation in a fork.
• Bug: API Key mode prompts for OAuth login when starting chat #165 — Bug: API Key mode prompts for OAuth login (OPEN) — related bug in existing custom API key support
• Support 'Anthropic Console account' #119 — Support 'Anthropic Console account' (CLOSED) — alternative auth methods
• Claude code through AWS bedrock key #51 — Claude code through AWS Bedrock key (CLOSED) — alternative backend
• [FEAT] Allow users to connect GLM model instead of Claude subscriptions #7 — Allow users to connect GLM model (CLOSED) — alternative provider

Suggested Approach

Given the recurring demand, the most sustainable path would be to:

1. Define a provider interface abstracting the core operations: startSession, streamMessage, resumeSession, canUseTool — decoupling src/main/lib/trpc/routers/claude.ts from the Anthropic SDK
2. Implement the Claude adapter as the first concrete provider (preserving current behavior)
3. Add KiloCode as a second adapter — this would clarify the right abstraction boundaries
4. Leverage [Feature request ] Add multi model provider support #146's fork work — the author of that issue claims a working multi-provider implementation

Files That Would Need Changes

File	What Changes
src/main/lib/trpc/routers/claude.ts	Extract provider-agnostic logic; refactor streaming loop (~lines 1949-2350)
src/main/lib/claude/offline-handler.ts	Expand provider selection beyond Claude/Ollama
src/renderer/features/agents/lib/ipc-chat-transport.ts	May need message format normalization
src/main/lib/db/schema/index.ts	Possibly add provider column to sub_chats
src/renderer/features/agents/main/active-chat.tsx	UI for provider selection
New: src/main/lib/providers/	Provider interface + adapters

[1code-async]

Issue Analysis: Add KiloCode Support

What is KiloCode CLI?

KiloCode CLI (@kilocode/cli) is a command-line AI coding assistant built on top of OpenCode (MIT-licensed). It offers access to 500+ models (Claude, GPT-5, Gemini, etc.), free unlimited usage via MiniMax M2.1, and BYOK (Bring Your Own Key) support. It is installed via npm install -g @kilocode/cli and run with the kilo command. The GitHub repo is here.

Based on the available documentation, KiloCode is currently a CLI-only tool with no separate SDK or programmatic API exposed for embedding.

---

Related Issues

• [Feature request ] Add multi model provider support #146 — [Feature request] Add multi model provider support (OPEN) — Requests a provider abstraction layer for arbitrary AI backends. Directly overlaps with this request.
• [FEAT] Allow users to connect GLM model instead of Claude subscriptions #7 — Allow users to connect GLM model instead of Claude subscriptions (CLOSED, implemented) — Established the ai_providers table pattern for switching between Anthropic OAuth and custom API key providers via env var injection.

---

Current Architecture & Integration Points

The app already supports two distinct AI backends — Claude Code and OpenAI Codex — with a clean transport abstraction. Here's how it works:

Renderer layer — Three transport implementations all conform to the AI SDK ChatTransport<UIMessage> interface:

• IPCChatTransport → Claude Code (default)
• ACPChatTransport → OpenAI Codex (via ACP binary)
• RemoteChatTransport → Remote/sandbox sessions

Transport selection happens in src/renderer/features/agents/main/active-chat.tsx based on a chatProvider discriminator ("claude-code" | "codex").

Main process layer — Each backend has its own tRPC router registered in src/main/lib/trpc/routers/index.ts:

• claude → src/main/lib/trpc/routers/claude.ts — Uses @anthropic-ai/claude-agent-sdk with a bundled claude binary
• codex → src/main/lib/trpc/routers/codex.ts — Uses @mcpc-tech/acp-ai-provider with a bundled Codex ACP binary

Key convergence point — Both backends emit UIMessageChunk events. The renderer is completely agnostic about which backend produced a given message. This is the single integration contract any new provider must satisfy.

---

What Adding KiloCode Would Require

Following the pattern established by the Codex integration:

1. Backend tRPC router — Create src/main/lib/trpc/routers/kilocode.ts with a chat subscription procedure that spawns/communicates with the KiloCode CLI and emits UIMessageChunk events. The Codex router (codex.ts) is the closest template.

2. Binary resolution — Bundle the kilo CLI binary (or resolve from PATH) similar to resolveBundledCodexCliPath() in codex.ts.

3. Message transformer — Convert KiloCode's output format into UIMessageChunk events. Since KiloCode is built on OpenCode, its message/streaming format would need investigation. If it supports ACP (Agent Communication Protocol), the existing @mcpc-tech/acp-ai-provider could potentially be reused.

4. Renderer transport — Create src/renderer/features/agents/lib/kilocode-chat-transport.ts implementing ChatTransport<UIMessage>.

5. Provider enum expansion — Extend "claude-code" | "codex" to include "kilocode" in:

   • src/renderer/features/agents/main/chat-input-area.tsx
   • src/renderer/features/agents/main/active-chat.tsx (transport selection)

6. Model definitions — Add KiloCode models to src/renderer/features/agents/lib/models.ts.

7. Router registration — Register the new router in src/main/lib/trpc/routers/index.ts.

8. Auth flow — Add Jotai atoms and onboarding UI for KiloCode authentication (API key or Kilo account login).

---

Key Challenges

• No SDK: KiloCode appears to be CLI-only with no programmatic SDK. The integration would need to either: (a) spawn the kilo CLI as a subprocess and parse its stdout/stderr, or (b) wait for KiloCode to expose an SDK or ACP-compatible interface. The Codex integration uses ACP as an intermediate protocol — if KiloCode/OpenCode adopted ACP, integration would be significantly simpler.

• Output format: The streaming message format from KiloCode's CLI would need reverse-engineering to build a proper transformer into UIMessageChunk. OpenCode's source (github.com/sst/opencode) could help here.

• Overlap with [Feature request ] Add multi model provider support #146: This request is a specific instance of the broader multi-provider support requested in [Feature request ] Add multi model provider support #146. A general provider abstraction layer would make adding KiloCode (and future providers) much easier.

---

Suggested Approach

The most pragmatic path would be:

1. Investigate whether KiloCode/OpenCode exposes any programmatic interface (ACP, SDK, or structured JSON output mode)
2. If yes → Follow the Codex integration pattern with a dedicated tRPC router and transport
3. If no → Consider contributing ACP support upstream to OpenCode/KiloCode, or implement a CLI-subprocess adapter that parses terminal output (fragile but possible)

The existing multi-backend architecture is well-suited for this — the UIMessageChunk contract and transport abstraction mean the renderer needs zero changes beyond provider selection UI.

[1code-async]

Analysis & Implementation Plan for KiloCode Support

What is KiloCode CLI?

KiloCode CLI (@kilocode/cli) is an agentic coding tool forked from OpenCode. It provides a terminal-based AI coding agent with access to 500+ models from 60+ providers, dual agent modes (build/plan), MCP server support, and autonomous execution capabilities.

Key technical details:

• npm package: @kilocode/cli (v1.0.21)
• Architecture: Fork of OpenCode — TypeScript monorepo, uses the same Task class and tool execution pipeline
• OpenCode SDK: OpenCode exposes a JS/TS SDK (@opencode-ai/sdk) with HTTP + SSE for real-time streaming, type-safe client from OpenAPI spec
• ACP status: OpenCode supports ACP (Agent Client Protocol) via opencode acp command (JSON-RPC over stdio). KiloCode does not yet support ACP — there's an open discussion (#4063) requesting it

---

Current Architecture (How Codex Was Added)

The app already supports two providers — Claude Code and OpenAI Codex. Understanding this pattern is critical:

Layer	Claude Code	Codex
Backend router	src/main/lib/trpc/routers/claude.ts	src/main/lib/trpc/routers/codex.ts
Transport	IPCChatTransport (dynamic import of @anthropic-ai/claude-agent-sdk)	ACPChatTransport (via @mcpc-tech/acp-ai-provider + @zed-industries/codex-acp binary)
Protocol	SDK query function with streaming callbacks	ACP over stdio (JSON-RPC) with streamText() from ai package
Models	src/renderer/features/agents/lib/models.ts (Opus, Sonnet, Haiku)	Same file (GPT 5.x Codex variants)
UI selector	src/renderer/features/agents/components/agent-model-selector.tsx	Same component — separate section
Provider type	"claude-code" in AgentProviderId union	"codex" in same union
Auth	Anthropic OAuth + API key	ChatGPT subscription or OpenAI API key
Session resume	sessionId stored in DB	sessionId via ACP provider

Provider selection flow: AgentModelSelector → subChatProviderOverrides state → inferProviderFromMessages() → transport selection in active-chat.tsx (lines 6250-6295).

---

Integration Options

There are three possible approaches to integrate KiloCode, each with different trade-offs:

Option A: OpenCode SDK Integration (Recommended)

Use the @opencode-ai/sdk package to communicate with a locally running KiloCode/OpenCode server over HTTP + SSE.

Pros:

• Type-safe client generated from OpenAPI spec
• HTTP + SSE is well-suited for streaming in Electron
• Full session management, file operations, tool execution
• Works with KiloCode since it's an OpenCode fork
• No need for ACP support from KiloCode

Cons:

• Requires KiloCode/OpenCode server to be running (need to spawn as child process)
• May need adaptation if KiloCode has diverged from OpenCode SDK compatibility

Implementation:

1. New tRPC router: src/main/lib/trpc/routers/kilo.ts
   • Spawn kilo or opencode process as HTTP server (child process management)
   • Use @opencode-ai/sdk to create sessions, send messages, stream responses
   • Transform SDK events into UIMessageChunk format (similar to src/main/lib/claude/transform.ts)
2. New transport: src/renderer/features/agents/lib/kilo-chat-transport.ts
   • Implement ChatTransport<UIMessage> interface
   • Subscribe to tRPC kilo.chat subscription
3. Extend provider system in UI

Option B: ACP Integration (Future-proof, but blocked)

Use ACP protocol (same as Codex), if/when KiloCode adds support.

Pros:

• Reuses existing @mcpc-tech/acp-ai-provider infrastructure
• Closest to how Codex is already integrated
• Standardized protocol across multiple agents

Cons:

• Blocked: KiloCode does not support ACP yet (discussion #4063)
• OpenCode's opencode acp exists but KiloCode hasn't shipped kilo acp

Option C: CLI Wrapper (Quick & Dirty)

Spawn kilo CLI and parse its output.

Pros:

• Simplest to implement
• Works with @kilocode/cli as-is via --json and --auto flags

Cons:

• Fragile parsing, no type safety
• Limited session management
• Poor streaming UX
• Not suitable for production

---

Recommended Implementation Plan (Option A)

Phase 1: Backend — tRPC Router & Process Management

Files to create/modify:

1. src/main/lib/kilo/process-manager.ts (new)

   • Spawn and manage KiloCode server as a child process
   • Health check endpoint polling
   • Auto-restart on crash
   • Graceful shutdown on app quit

2. src/main/lib/trpc/routers/kilo.ts (new)

   • chat subscription: Create/resume session, stream messages, emit UIMessageChunk
   • cancel mutation: Abort active stream
   • cleanup mutation: Teardown session
   • getIntegration query: Check if kilo CLI is installed and which version
   • getModels query: Fetch available models from running server
   • Pattern: Follow codex.ts router structure (~950 lines)

3. src/main/lib/kilo/transform.ts (new)

   • Transform OpenCode SDK events → UIMessageChunk format
   • Map tool calls (bash, file edit, search) to existing tool part types
   • Handle session metadata (tokens, cost, duration)

4. src/main/lib/trpc/routers/index.ts (modify)

   • Register kilo: kiloRouter in the app router

Phase 2: Frontend — Transport & Provider UI

5. src/renderer/features/agents/lib/kilo-chat-transport.ts (new)

   • Implement ChatTransport<UIMessage> (same interface as ACPChatTransport and IPCChatTransport)
   • Subscribe to trpcClient.kilo.chat
   • Handle auth errors, streaming chunks, finish events

6. src/renderer/features/agents/lib/models.ts (modify)

   • Add KILO_MODELS array — dynamically populated or with sensible defaults
   • KiloCode supports 500+ models, so consider a different UI pattern (searchable list vs. static dropdown)

7. src/renderer/features/agents/components/agent-model-selector.tsx (modify)

   • Extend AgentProviderId type: "claude-code" | "codex" | "kilo"
   • Add KiloCode section with icon, model list, and provider config
   • Consider a model search/filter for the large model catalog

8. src/renderer/features/agents/main/active-chat.tsx (modify)

   • Update inferProviderFromMessages() to detect KiloCode messages (line ~6137)
   • Update transport selection logic to include KiloChatTransport (line ~6250)
   • Update subChatProviderOverrides type to include "kilo"
   • Update handleProviderChange callback

9. src/renderer/features/agents/main/chat-input-area.tsx (modify)

   • Update provider type references
   • Add KiloCode model label logic

Phase 3: Auth & Settings

10. Auth flow — KiloCode supports:

    • Kilo account login (OAuth-like)
    • BYOK (Bring Your Own Key) for any provider
    • Need a settings UI for API key management
    • Follow the pattern from src/renderer/features/agents/hooks/use-codex-login-flow.ts

11. Settings page — Add KiloCode configuration section:

    • Connection status (is CLI installed?)
    • API key management
    • Default model selection

Phase 4: Package & Distribution

12. package.json (modify)

    • Add @opencode-ai/sdk dependency
    • Consider bundling @kilocode/cli or requiring user to install globally

13. Installation detection

    • Check for kilo in PATH (like how Claude binary is detected)
    • Prompt user to install if not found: npm install -g @kilocode/cli

---

Key Files Reference

Existing File	Purpose	Relevant Lines
src/main/lib/trpc/routers/codex.ts	Best template for new router	Full file — session mgmt, streaming, auth
src/renderer/features/agents/lib/acp-chat-transport.ts	Transport pattern	ACPChatTransport class
src/renderer/features/agents/components/agent-model-selector.tsx:28	Provider type definition	AgentProviderId union
src/renderer/features/agents/main/active-chat.tsx:6137-6176	Provider inference	inferProviderFromMessages()
src/renderer/features/agents/main/active-chat.tsx:6250-6295	Transport selection	Provider → transport mapping
src/renderer/features/agents/main/active-chat.tsx:6397-6425	Provider switch handler	handleProviderChange()
src/renderer/features/agents/lib/models.ts	Model definitions	CLAUDE_MODELS, CODEX_MODELS
src/main/lib/claude/types.ts	Message chunk types	UIMessageChunk union
src/main/lib/claude/transform.ts	Stream transformer	SDK events → UI chunks

Open Questions

1. Should KiloCode server be auto-spawned or require manual start? Auto-spawning (like Codex ACP binary) is better UX but adds process management complexity.
2. Model catalog: With 500+ models, the current dropdown pattern won't scale. Need a searchable model picker or a "configure in KiloCode" approach.
3. Tool rendering: KiloCode tools may not map 1:1 to existing tool renderers (AgentBashTool, AgentPlanFileTool, etc.). Need to audit KiloCode's tool set and map to existing UI components or create new ones.
4. Session compatibility: Does KiloCode's session resume work the same way as OpenCode's? The fork may have diverged.
5. ACP timeline: If KiloCode adds ACP support soon, Option B becomes viable and would be simpler (reuses Codex infrastructure). Worth monitoring discussion #4063.