chore: bump ACP schema to v0.6.2

Updates the ACP schema from v0.4.9 to v0.6.2, incorporating latest
protocol changes and type definitions. Enhances code generation with
smart nested type naming that applies multiple heuristics to create
idiomatic Go type names while preventing collisions.

Key improvements:
- Implements word-boundary deduplication for nested types
- Strips RPC suffixes (Request/Response/Notification) when generating
  nested type names for cleaner identifiers
- Adds defensive programming with panic-based collision detection to
  catch codegen bugs early
- Generates proper nested structs for inline object properties

Breaking changes:
- Renames ToolCallUpdate to RequestPermissionToolCall in permission
  request contexts for schema consistency
- Renames SessionUpdateToolCallUpdate to SessionToolCallUpdate
- Changes EmbeddedResource.Resource field to direct
  EmbeddedResourceResource type

Author: ThomasK33

.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(jj log:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

README.md

@@ -14,7 +14,7 @@ Learn more about the protocol itself at <https://agentclientprotocol.com>.
 <!-- `$ printf 'go get github.com/coder/acp-go-sdk@v%s\n' "$(cat schema/version)"` as bash -->
 
 ```bash
-go get github.com/coder/acp-go-sdk@v0.4.9
+go get github.com/coder/acp-go-sdk@v0.6.2
 ```
 
 ## Get Started

acp_test.go

@@ -352,7 +352,7 @@ func TestConnectionHandlesMessageOrdering(t *testing.T) {
 	}
 	if _, err := as.RequestPermission(context.Background(), RequestPermissionRequest{
 		SessionId: "test-session",
-		ToolCall: ToolCallUpdate{
+		ToolCall: RequestPermissionToolCall{
 			Title:      Ptr("Execute command"),
 			Kind:       ptr(ToolKindExecute),
 			Status:     ptr(ToolCallStatusPending),

cmd/generate/internal/emit/types.go

@@ -9,17 +9,104 @@ import (
 	"slices"
 	"sort"
 	"strings"
+	"unicode"
 
 	"github.com/coder/acp-go-sdk/cmd/generate/internal/ir"
 	"github.com/coder/acp-go-sdk/cmd/generate/internal/load"
 	"github.com/coder/acp-go-sdk/cmd/generate/internal/util"
 )
 
+// splitCamelCase splits a CamelCase string into words.
+// Example: "RequestPermissionRequest" -> ["Request", "Permission", "Request"]
+func splitCamelCase(s string) []string {
+	if s == "" {
+		return nil
+	}
+	var words []string
+	var current strings.Builder
+
+	for i, r := range s {
+		if i > 0 && unicode.IsUpper(r) {
+			// Start new word on uppercase letter
+			if current.Len() > 0 {
+				words = append(words, current.String())
+				current.Reset()
+			}
+		}
+		current.WriteRune(r)
+	}
+	if current.Len() > 0 {
+		words = append(words, current.String())
+	}
+	return words
+}
+
+// generateNestedTypeName applies multiple heuristics to create idiomatic nested type names
+// while guaranteeing stability (name depends only on parent, field, and collision check).
+// Panics if a collision is detected to catch codegen bugs early.
+func generateNestedTypeName(parentName, rawFieldName string, usedNames map[string]bool) string {
+	// Heuristic 1: Ensure field name is properly capitalized first
+	fieldName := util.ToExportedField(rawFieldName)
+
+	// Heuristic 2: Try RPC suffix stripping for Request/Response/Notification parents
+	// This handles cases like RequestPermissionRequest + ToolCall → RequestPermissionToolCall
+	for _, suffix := range []string{"Request", "Response", "Notification"} {
+		if strings.HasSuffix(parentName, suffix) {
+			baseName := strings.TrimSuffix(parentName, suffix)
+			if len(baseName) > 0 {
+				candidate := baseName + fieldName
+				if !usedNames[candidate] {
+					return candidate
+				}
+			}
+		}
+	}
+
+	// Heuristic 3: Try word-boundary deduplication
+	// This handles cases like AgentNotification + ExtNotification → AgentExtNotification
+	parentWords := splitCamelCase(parentName)
+	fieldWords := splitCamelCase(fieldName)
+
+	// Need at least 2 words in parent to consider deduplication
+	if len(parentWords) >= 2 && len(fieldWords) > 0 {
+		lastParentWord := parentWords[len(parentWords)-1]
+		firstFieldWord := fieldWords[0]
+		lastFieldWord := fieldWords[len(fieldWords)-1]
+
+		if strings.EqualFold(lastParentWord, firstFieldWord) || strings.EqualFold(lastParentWord, lastFieldWord) {
+			// Remove last word from parent, then concatenate
+			parentWithoutLast := strings.Join(parentWords[:len(parentWords)-1], "")
+			if len(parentWithoutLast) > 0 {
+				candidate := parentWithoutLast + fieldName
+				if !usedNames[candidate] {
+					return candidate
+				}
+			}
+		}
+	}
+
+	// Heuristic 4: Fall back to full concatenation
+	fullName := parentName + fieldName
+	if usedNames[fullName] {
+		// DEFENSIVE PROGRAMMING: This should never happen if we're tracking names correctly.
+		// If it does, it indicates a bug in the codegen logic.
+		panic(fmt.Sprintf("type name collision detected: %q already exists (parent: %q, field: %q)",
+			fullName, parentName, rawFieldName))
+	}
+	return fullName
+}
+
 // WriteTypesJen emits go/types_gen.go with all types and the Agent/Client interfaces.
 func WriteTypesJen(outDir string, schema *load.Schema, meta *load.Meta) error {
 	f := NewFile("acp")
 	f.HeaderComment("Code generated by acp-go-generator; DO NOT EDIT.")
 
+	// Track all type names to avoid collisions when generating nested types
+	usedTypeNames := make(map[string]bool)
+	for k := range schema.Defs {
+		usedTypeNames[k] = true
+	}
+
 	// Deterministic order
 	keys := make([]string, 0, len(schema.Defs))
 	for k := range schema.Defs {
@@ -33,6 +120,16 @@ func WriteTypesJen(outDir string, schema *load.Schema, meta *load.Meta) error {
 			continue
 		}
 
+		// DEFENSIVE PROGRAMMING: Ensure we're not about to emit a type that conflicts
+		// with a previously generated nested type. This should never happen since we
+		// pre-populate usedTypeNames with all schema definitions.
+		if usedTypeNames[name] && name != "" {
+			// This is expected for schema-defined types, but verify it's in the schema
+			if _, inSchema := schema.Defs[name]; !inSchema {
+				panic(fmt.Sprintf("BUG: attempting to emit type %q that was already generated as a nested type", name))
+			}
+		}
+
 		if def.Description != "" {
 			f.Comment(util.SanitizeComment(def.Description))
 		}
@@ -63,11 +160,11 @@ func WriteTypesJen(outDir string, schema *load.Schema, meta *load.Meta) error {
 			}
 			f.Line()
 		case len(def.AnyOf) > 0:
-			emitUnion(f, name, def.AnyOf, false)
+			emitUnion(f, name, def.AnyOf, false, usedTypeNames)
 		case len(def.OneOf) > 0 && !isStringConstUnion(def):
 			// Generic union generation for non-enum oneOf
 			// Use the same implementation, but require exactly one variant
-			emitUnion(f, name, def.OneOf, true)
+			emitUnion(f, name, def.OneOf, true, usedTypeNames)
 		case ir.PrimaryType(def) == "object" && len(def.Properties) > 0:
 			st := []Code{}
 			req := map[string]struct{}{}
@@ -79,6 +176,54 @@ func WriteTypesJen(outDir string, schema *load.Schema, meta *load.Meta) error {
 				pkeys = append(pkeys, pk)
 			}
 			sort.Strings(pkeys)
+
+			// Pre-generate nested struct types for inline object properties
+			nestedTypes := map[string]string{} // property name -> generated type name
+			for _, pk := range pkeys {
+				prop := def.Properties[pk]
+				// Detect inline objects: no $ref, type is object, has properties
+				if prop.Ref == "" && ir.PrimaryType(prop) == "object" && len(prop.Properties) > 0 {
+					nestedTypeName := generateNestedTypeName(name, pk, usedTypeNames)
+					nestedTypes[pk] = nestedTypeName
+
+					// DEFENSIVE PROGRAMMING: Assert no collision before registering
+					if usedTypeNames[nestedTypeName] {
+						panic(fmt.Sprintf("BUG: nested type name collision: %q already registered", nestedTypeName))
+					}
+					usedTypeNames[nestedTypeName] = true
+
+					// Generate the nested struct type
+					if prop.Description != "" {
+						f.Comment(util.SanitizeComment(prop.Description))
+					}
+					nestedFields := []Code{}
+					nestedReq := map[string]struct{}{}
+					for _, r := range prop.Required {
+						nestedReq[r] = struct{}{}
+					}
+					nestedPkeys := make([]string, 0, len(prop.Properties))
+					for npk := range prop.Properties {
+						nestedPkeys = append(nestedPkeys, npk)
+					}
+					sort.Strings(nestedPkeys)
+
+					for _, npk := range nestedPkeys {
+						nprop := prop.Properties[npk]
+						nfield := util.ToExportedField(npk)
+						if nprop.Description != "" {
+							nestedFields = append(nestedFields, Comment(util.SanitizeComment(nprop.Description)))
+						}
+						ntag := npk
+						if _, ok := nestedReq[npk]; !ok {
+							ntag = npk + ",omitempty"
+						}
+						nestedFields = append(nestedFields, Id(nfield).Add(jenTypeForOptional(nprop)).Tag(map[string]string{"json": ntag}))
+					}
+					f.Type().Id(nestedTypeName).Struct(nestedFields...)
+					f.Line()
+				}
+			}
+
 			// Track fields with schema defaults for generic (de)serialization
 			type DefaultKind int
 			const (
@@ -142,7 +287,14 @@ func WriteTypesJen(outDir string, schema *load.Schema, meta *load.Meta) error {
 					}
 					st = append(st, Comment(util.SanitizeComment(fmt.Sprintf("Defaults to %s if unset.", dp.defaultJSON))))
 				}
-				st = append(st, Id(field).Add(jenTypeForOptional(prop)).Tag(map[string]string{"json": tag}))
+				// Use generated nested type if available, otherwise use jenTypeForOptional
+				var fieldType Code
+				if nestedTypeName, hasNested := nestedTypes[pk]; hasNested {
+					fieldType = Id(nestedTypeName)
+				} else {
+					fieldType = jenTypeForOptional(prop)
+				}
+				st = append(st, Id(field).Add(fieldType).Tag(map[string]string{"json": tag}))
 			}
 			f.Type().Id(name).Struct(st...)
 			f.Line()
@@ -544,7 +696,7 @@ func jenTypeForOptional(d *load.Definition) Code {
 // emitAvailableCommandInputJen generates a concrete variant type for anyOf and a thin union wrapper
 // that supports JSON unmarshal by probing object shape. Currently the schema defines one variant
 // (title: UnstructuredCommandInput) with a required 'hint' field.
-func emitUnion(f *File, name string, defs []*load.Definition, exactlyOne bool) {
+func emitUnion(f *File, name string, defs []*load.Definition, exactlyOne bool, usedTypeNames map[string]bool) {
 	type variantInfo struct {
 		fieldName   string
 		typeName    string
@@ -586,16 +738,35 @@ func emitUnion(f *File, name string, defs []*load.Definition, exactlyOne bool) {
 		if v.Ref != "" && strings.HasPrefix(v.Ref, "#/$defs/") {
 			tname = v.Ref[len("#/$defs/"):]
 		} else if v.Title != "" {
-			tname = v.Title
+			// Scope inline variant titles to parent union name with smart naming
+			tname = generateNestedTypeName(name, v.Title, usedTypeNames)
+			// DEFENSIVE PROGRAMMING: Assert no collision before registering
+			if usedTypeNames[tname] {
+				panic(fmt.Sprintf("BUG: variant type name collision: %q already registered (parent: %q, title: %q)",
+					tname, name, v.Title))
+			}
+			usedTypeNames[tname] = true
 		} else {
 			if discKey != "" {
 				if pd := v.Properties[discKey]; pd != nil && pd.Const != nil {
 					s := fmt.Sprint(pd.Const)
-					tname = name + util.ToExportedField(s)
+					tname = generateNestedTypeName(name, s, usedTypeNames)
+					// DEFENSIVE PROGRAMMING: Assert no collision before registering
+					if usedTypeNames[tname] {
+						panic(fmt.Sprintf("BUG: variant type name collision: %q already registered (parent: %q, discriminator: %q)",
+							tname, name, s))
+					}
+					usedTypeNames[tname] = true
 				}
 			}
 			if tname == "" {
 				tname = name + fmt.Sprintf("Variant%d", idx+1)
+				// DEFENSIVE PROGRAMMING: Assert no collision before registering
+				if usedTypeNames[tname] {
+					panic(fmt.Sprintf("BUG: variant type name collision: %q already registered (parent: %q)",
+						tname, name))
+				}
+				usedTypeNames[tname] = true
 			}
 		}
 		// Ensure Title-derived names are exported (e.g., "stdio" -> "Stdio").
@@ -610,8 +781,9 @@ func emitUnion(f *File, name string, defs []*load.Definition, exactlyOne bool) {
 			}
 		}
 		isObj := len(v.Properties) > 0
-		// Skip phantom variants that have neither $ref nor object shape nor null (e.g., placeholders with only a title)
-		if !isObj && v.Ref == "" && !isNull {
+		// Skip phantom variants that have neither $ref nor object shape nor null nor title
+		// (but allow title-only variants like ExtMethodRequest to generate as empty structs)
+		if !isObj && v.Ref == "" && !isNull && v.Title == "" {
 			continue
 		}
 		// collect const properties (e.g., type, outcome)
@@ -623,9 +795,15 @@ func emitUnion(f *File, name string, defs []*load.Definition, exactlyOne bool) {
 				}
 			}
 		}
-		if (isObj || isNull) && v.Ref == "" {
+		// Emit struct for inline variants (non-$ref)
+		if (isObj || isNull || v.Title != "") && v.Ref == "" {
+			// DEFENSIVE PROGRAMMING: Verify tname is registered before emitting
+			if !usedTypeNames[tname] {
+				panic(fmt.Sprintf("BUG: attempting to emit unregistered type: %q (parent union: %q)", tname, name))
+			}
+
 			st := []Code{}
-			if !isNull {
+			if !isNull && isObj {
 				req := map[string]struct{}{}
 				for _, r := range v.Required {
 					req[r] = struct{}{}
@@ -650,6 +828,11 @@ func emitUnion(f *File, name string, defs []*load.Definition, exactlyOne bool) {
 					}
 					st = append(st, Id(field).Add(jenTypeForOptional(pDef)).Tag(map[string]string{"json": tag}))
 				}
+			} else if !isNull && !isObj && v.Title != "" {
+				// Title-only extension types: emit description as comment
+				if v.Description != "" {
+					f.Comment(util.SanitizeComment(v.Description))
+				}
 			}
 			f.Type().Id(tname).Struct(st...)
 			f.Line()

example/agent/main.go

@@ -205,7 +205,7 @@ func (a *exampleAgent) simulateTurn(ctx context.Context, sid string) error {
 	// request permission for sensitive operation
 	permResp, err := a.conn.RequestPermission(ctx, acp.RequestPermissionRequest{
 		SessionId: acp.SessionId(sid),
-		ToolCall: acp.ToolCallUpdate{
+		ToolCall: acp.RequestPermissionToolCall{
 			ToolCallId: acp.ToolCallId("call_2"),
 			Title:      acp.Ptr("Modifying critical configuration file"),
 			Kind:       acp.Ptr(acp.ToolKindEdit),

example_agent_test.go

@@ -57,7 +57,7 @@ func (a *agentExample) Prompt(ctx context.Context, p PromptRequest) (PromptRespo
 	// Ask the client for permission to proceed with the change.
 	resp, _ := a.conn.RequestPermission(ctx, RequestPermissionRequest{
 		SessionId: p.SessionId,
-		ToolCall: ToolCallUpdate{
+		ToolCall: RequestPermissionToolCall{
 			ToolCallId: ToolCallId("call_1"),
 			Title:      Ptr("Modifying configuration"),
 			Kind:       Ptr(ToolKindEdit),