Add Go SDK and generator

.github/workflows/ci.yml

@@ -31,6 +31,14 @@ jobs:
           node-version: latest
           cache: "npm"
 
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: stable
+          cache: true
+          cache-dependency-path: |
+            go/cmd/generate/go.sum
+
       - name: Setup Rust
         uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48
         with:

.gitignore

@@ -13,3 +13,12 @@ typescript/*.js.map
 
 # TypeDoc generated documentation
 typescript/docs/
+
+# Go files
+.gocache
+.gopath
+
+.envrc
+.direnv
+.rustup/
+.cargo/

README.md

@@ -29,6 +29,7 @@ Learn more at [agentclientprotocol.com](https://agentclientprotocol.com/).
 
 - **Rust**: [`agent-client-protocol`](https://crates.io/crates/agent-client-protocol) - See [examples/agent.rs](./rust/examples/agent.rs) and [examples/client.rs](./rust/examples/client.rs)
 - **TypeScript**: [`@zed-industries/agent-client-protocol`](https://www.npmjs.com/package/@zed-industries/agent-client-protocol) - See [examples/](./typescript/examples/)
+- **Go**: [`github.com/zed-industries/agent-client-protocol/go`](https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go) - See [example/](./go/example/) and the [Go README](./go/README.md)
 - **JSON Schema**: [schema.json](./schema/schema.json)
 - [**use-acp**](https://github.com/marimo-team/use-acp): React hooks for connecting to Agent Client Protocol (ACP) servers.
 

docs/docs.json

@@ -69,6 +69,7 @@
         "pages": [
           "libraries/typescript",
           "libraries/rust",
+          "libraries/go",
           "libraries/community"
         ]
       },

docs/libraries/go.mdx

@@ -0,0 +1,33 @@
+---
+title: "Go"
+description: "Go library for the Agent Client Protocol"
+---
+
+The [`github.com/zed-industries/agent-client-protocol/go`](https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go)
+package provides implementations of both sides of the Agent Client Protocol that
+you can use to build your own agent server or client.
+
+To get started, add the module to your project:
+
+```bash
+go get github.com/zed-industries/agent-client-protocol/go@latest
+```
+
+Depending on what kind of tool you're building, you'll create either the
+[AgentSideConnection](https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go#NewAgentSideConnection)
+or the
+[ClientSideConnection](https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go#NewClientSideConnection)
+and implement the corresponding interfaces (`Agent`, `Client`).
+
+You can find example implementations of both sides in the
+[main repository](https://github.com/zed-industries/agent-client-protocol/tree/main/go/example).
+These can be run from your terminal or connected to external ACP agents, making
+them great starting points for your own integration!
+
+Browse the Go package docs on
+[pkg.go.dev](https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go)
+for detailed API documentation.
+
+For a complete, production-ready implementation of an ACP agent, see the
+[Gemini CLI](https://github.com/google-gemini/gemini-cli) which exposes an ACP
+interface. The Go example client demonstrates connecting to it via stdio.

flake.nix

@@ -0,0 +1,78 @@
+{
+  description = "Devshell for ACP";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
+    flake-utils.url = "github:numtide/flake-utils";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+      rust-overlay,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = import nixpkgs {
+          inherit system;
+          overlays = [ rust-overlay.overlays.default ];
+        };
+
+        formatter = pkgs.nixfmt-rfc-style;
+
+        # Use rustup to manage toolchains so `cargo +nightly` works in dev shell
+        rustup = pkgs.rustup;
+      in
+      {
+        inherit formatter;
+
+        devShells.default = pkgs.mkShell {
+          packages = with pkgs; [
+            # Rustup manages stable/nightly toolchains according to rust-toolchain.toml
+            rustup
+            pkg-config
+            openssl
+
+            # Node.js toolchain
+            nodejs_24
+
+            # Go toolchain
+            go_1_24
+
+            # Nix formatter
+            formatter
+          ];
+
+          RUST_BACKTRACE = "1";
+
+          # Ensure rustup shims are used and install required toolchains on first entry
+          shellHook = ''
+            export RUSTUP_HOME="$PWD/.rustup"
+            export CARGO_HOME="$PWD/.cargo"
+            export PATH="$CARGO_HOME/bin:$PATH"
+
+            if ! command -v rustup >/dev/null 2>&1; then
+              echo "rustup not found in PATH" 1>&2
+            else
+              # Install toolchains if missing; respect pinned channel from rust-toolchain.toml
+              if ! rustup toolchain list | grep -q nightly; then
+                rustup toolchain install nightly --profile minimal >/dev/null 2>&1 || true
+              fi
+              # Ensure stable toolchain from rust-toolchain.toml exists (rustup will auto-select it)
+              # Attempt to install channel specified in rust-toolchain.toml (fallback to stable)
+              TOOLCHAIN_CHANNEL=$(sed -n 's/^channel\s*=\s*"\(.*\)"/\1/p' rust-toolchain.toml || true)
+              if [ -n "$TOOLCHAIN_CHANNEL" ]; then
+                if ! rustup toolchain list | grep -q "$TOOLCHAIN_CHANNEL"; then
+                  rustup toolchain install "$TOOLCHAIN_CHANNEL" --profile minimal --component rustfmt clippy >/dev/null 2>&1 || true
+                fi
+              fi
+            fi
+          '';
+        };
+      }
+    );
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/zed-industries/agent-client-protocol
+
+go 1.21

go/README.md

@@ -0,0 +1,74 @@
+<a href="https://agentclientprotocol.com/" >
+  <img alt="Agent Client Protocol" src="https://zed.dev/img/acp/banner-dark.webp">
+</a>
+
+# ACP Go Library
+
+The official Go implementation of the Agent Client Protocol (ACP) — a standardized communication protocol between code editors and AI‑powered coding agents.
+
+Learn more at <https://agentclientprotocol.com>
+
+## Installation
+
+```bash
+go get github.com/zed-industries/agent-client-protocol/go@latest
+```
+
+## Get Started
+
+### Understand the Protocol
+
+Start by reading the [official ACP documentation](https://agentclientprotocol.com) to understand the core concepts and protocol specification.
+
+### Try the Examples
+
+The [examples directory](https://github.com/zed-industries/agent-client-protocol/tree/main/go/example) contains simple implementations of both Agents and Clients in Go. You can run them from your terminal or connect to external ACP agents.
+
+- Run the example Agent:
+  - `cd go && go run ./example/agent`
+- Run the example Client (connects to the example Agent):
+  - `cd go && go run ./example/client`
+- Connect to the Gemini CLI (ACP mode):
+  - `cd go && go run ./example/gemini -yolo`
+  - Optional flags: `-model`, `-sandbox`, `-debug`, `-gemini /path/to/gemini`
+- Connect to Claude Code (via npx):
+  - `cd go && go run ./example/claude-code -yolo`
+
+### Explore the API
+
+Browse the Go package docs on pkg.go.dev for detailed API documentation:
+
+- <https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go>
+
+If you're building an [Agent](https://agentclientprotocol.com/protocol/overview#agent):
+
+- Implement the `acp.Agent` interface (and optionally `acp.AgentLoader` for `session/load`).
+- Create a connection with `acp.NewAgentSideConnection(agent, os.Stdout, os.Stdin)`.
+- Send updates and make client requests using the returned connection.
+
+If you're building a [Client](https://agentclientprotocol.com/protocol/overview#client):
+
+- Implement the `acp.Client` interface (and optionally `acp.ClientTerminal` for terminal features).
+- Launch or connect to your Agent process (stdio), then create a connection with `acp.NewClientSideConnection(client, stdin, stdout)`.
+- Call `Initialize`, `NewSession`, and `Prompt` to run a turn and stream updates.
+
+Helper constructors are provided to reduce boilerplate when working with union types:
+
+- Content blocks: `acp.TextBlock`, `acp.ImageBlock`, `acp.AudioBlock`, `acp.ResourceLinkBlock`, `acp.ResourceBlock`.
+- Tool content: `acp.ToolContent`, `acp.ToolDiffContent`, `acp.ToolTerminalRef`.
+- Utility: `acp.Ptr[T]` for pointer fields in request/update structs.
+
+### Study a Production Implementation
+
+For a complete, production‑ready integration, see the [Gemini CLI Agent](https://github.com/google-gemini/gemini-cli) which exposes an ACP interface. The Go example client `go/example/gemini` demonstrates connecting to it via stdio.
+
+## Resources
+
+- [Go package docs](https://pkg.go.dev/github.com/zed-industries/agent-client-protocol/go)
+- [Examples (Go)](https://github.com/zed-industries/agent-client-protocol/tree/main/go/example)
+- [Protocol Documentation](https://agentclientprotocol.com)
+- [GitHub Repository](https://github.com/zed-industries/agent-client-protocol)
+
+## Contributing
+
+See the main [repository](https://github.com/zed-industries/agent-client-protocol) for contribution guidelines.