ACP Agent Integration

package ai.coding.agent

import ai.koog.agents.core.agent.AIAgent
import ai.koog.agents.ext.acp.support.AcpKoogAgentSupport
import com.agentclientprotocol.agent.AgentServer
import com.agentclientprotocol.transport.StdioTransport
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val token = System.getenv("OPENAI_API_KEY")
        ?: error("OPENAI_API_KEY environment variable is not set")

    val agentSupport = AcpKoogAgentSupport(
        name = "Koog Code Agent",
        description = "AI coding assistant powered by Koog framework",
        createAgent = { sessionId ->
            createKoogAgent(
                token = token,
                sessionId = sessionId
            )
        }
    )

    val transport = StdioTransport(
        parentScope = this,
        ioDispatcher = Dispatchers.IO
    )

    val server = AgentServer(
        agentSupport = agentSupport,
        transport = transport
    )

    server.start()
    transport.waitForClose()
}

private fun createKoogAgent(
    token: String,
    sessionId: String
): AIAgent<String, String> {
    val executor = simpleOpenAIExecutor(token)
    
    val toolRegistry = ToolRegistry {
        tool(ListDirectoryTool(JVMFileSystemProvider.ReadWrite))
        tool(ReadFileTool(JVMFileSystemProvider.ReadWrite))
        tool(EditFileTool(JVMFileSystemProvider.ReadWrite))
    }

    return AIAgent(
        promptExecutor = executor,
        llmModel = OpenAIModels.Chat.GPT5Codex,
        toolRegistry = toolRegistry,
        systemPrompt = """
            You are an AI coding assistant integrated with IntelliJ IDEA.
            You have access to the user's codebase through file operations.
            
            When making code changes:
            - Read files to understand context
            - Make minimal, targeted edits
            - Explain your changes clearly
            - Consider the broader codebase architecture
            
            You can:
            - List directories to explore project structure
            - Read files to understand code
            - Edit files to make changes
        """.trimIndent(),
        strategy = singleRunStrategy(),
        maxIterations = 100
    ) {
        handleEvents {
            onToolCallStarting { ctx ->
                println("[Session $sessionId] Tool called: ${ctx.toolName}")
            }
        }
    }
}

import ai.koog.agents.ext.tool.file.EditFileTool
import ai.koog.agents.ext.tool.file.ListDirectoryTool
import ai.koog.agents.ext.tool.file.ReadFileTool
import ai.koog.rag.base.files.JVMFileSystemProvider

val toolRegistry = ToolRegistry {
    // List files and directories
    tool(ListDirectoryTool(JVMFileSystemProvider.ReadWrite))
    
    // Read file contents
    tool(ReadFileTool(JVMFileSystemProvider.ReadWrite))
    
    // Edit files with string replacement
    tool(EditFileTool(JVMFileSystemProvider.ReadWrite))
}

package ai.coding.app

import ai.coding.client.runTerminalClient
import com.agentclientprotocol.transport.PipeTransport
import kotlinx.coroutines.coroutineScope

suspend fun main() = coroutineScope {
    val token = System.getenv("OPENAI_API_KEY")
        ?: error("OPENAI_API_KEY env variable is not set")

    val pipe = PipeTransport.create(this)
    
    // Start agent server
    val agentSupport = createAgentSupport(token)
    val server = AgentServer(agentSupport, pipe.serverTransport)
    server.start()

    // Start client
    runTerminalClient(pipe.clientTransport)
}

package ai.coding.app

import ai.coding.client.runTerminalClient
import com.agentclientprotocol.transport.StdioTransport
import kotlinx.coroutines.coroutineScope

suspend fun main() = coroutineScope {
    val token = System.getenv("OPENAI_API_KEY")
        ?: error("OPENAI_API_KEY env variable is not set")
    val agentPath = System.getenv("AGENT_PATH")
        ?: error("AGENT_PATH env variable is not set")

    val process = ProcessBuilder(agentPath)
        .apply {
            environment()["OPENAI_API_KEY"] = token
        }
        .redirectInput(ProcessBuilder.Redirect.PIPE)
        .redirectOutput(ProcessBuilder.Redirect.PIPE)
        .start()

    val stdin = process.outputStream.asSink().buffered()
    val stdout = process.inputStream.asSource().buffered()

    val clientTransport = StdioTransport(
        parentScope = this,
        ioDispatcher = Dispatchers.IO,
        input = stdout,
        output = stdin
    )

    try {
        runTerminalClient(clientTransport)
    } finally {
        clientTransport.close()
    }
}

{
    "agent_servers": {
        "Koog Agent": {
            "command": "/Users/yourname/koog/examples/acp-agent/build/install/acp-agent/bin/acp-agent",
            "args": [],
            "env": {
                "OPENAI_API_KEY": "sk-proj-...",
                "OPENAI_BASE_URL": "https://api.openai.com/v1"
            }
        },
        "Koog Agent (Claude)": {
            "command": "/Users/yourname/koog/examples/acp-agent/build/install/acp-agent/bin/acp-agent",
            "args": [],
            "env": {
                "ANTHROPIC_API_KEY": "sk-ant-...",
                "USE_CLAUDE": "true"
            }
        }
    }
}