feat: add multi-platform adapter interface with OpenClaw, IronClaw, and Bridge adapters

Refactor OpenClaw-specific integration into a platform-agnostic adapter
interface (platform.Adapter) supporting multiple AI orchestration platforms.

- Add platform.Adapter interface: Connect, SendChat, InjectNotification, SetOutboundHandler
- Move agent/openclaw/ → agent/platform/openclaw/ implementing Adapter
- Add agent/platform/ironclaw/ adapter (HTTP/SSE for Axum gateway)
- Add agent/platform/bridge/ adapter (local WebSocket for nanobot/PicoClaw)
- Add shared helpers: SessionKeyForPeer, ParsePeerFromSessionKey, FormatNotification
- Update agent.go to use platform.Adapter instead of openclaw.Client

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

Author: gcmsg

agent.go

@@ -13,9 +13,8 @@ import (
 	"github.com/peerclaw/peerclaw-agent/conn"
 	"github.com/peerclaw/peerclaw-agent/discovery"
 	"github.com/peerclaw/peerclaw-agent/filetransfer"
-	"github.com/peerclaw/peerclaw-agent/openclaw"
 	"github.com/peerclaw/peerclaw-agent/peer"
-	"github.com/peerclaw/peerclaw-agent/sdkversion"
+	"github.com/peerclaw/peerclaw-agent/platform"
 	"github.com/peerclaw/peerclaw-agent/security"
 	pcsignaling "github.com/peerclaw/peerclaw-agent/signaling"
 	"github.com/peerclaw/peerclaw-agent/transport"
@@ -119,10 +118,10 @@ type Options struct {
 	// (done, failed, or cancelled).
 	OnFileTransferComplete func(info filetransfer.TransferInfo)
 
-	// OpenClaw holds optional OpenClaw gateway integration settings.
-	// When set, the agent connects to OpenClaw and forwards P2P messages
-	// and server notifications to OpenClaw conversations.
-	OpenClaw *openclaw.Config
+	// Platform is an optional AI orchestration platform adapter.
+	// When set, the agent forwards P2P messages and server notifications
+	// to the platform and routes AI responses back via P2P.
+	Platform platform.Adapter
 
 	// SkipRegistration skips server registration on Start(). Use when the agent
 	// is already registered and you only need P2P connectivity.
@@ -155,7 +154,7 @@ type Agent struct {
 	handler              MessageHandler
 	connRequestHandler   ConnectionRequestHandler
 	notificationHandler  func(n *NotificationPayload)
-	openclawClient       *openclaw.Client
+	platformAdapter      platform.Adapter
 	connManager        *conn.Manager
 	mailbox            *transport.Mailbox
 	fileTransfer       *filetransfer.Manager
@@ -536,37 +535,37 @@ func (a *Agent) Start(ctx context.Context) error {
 		}
 	}
 
-	// Initialize OpenClaw gateway integration.
-	if a.opts.OpenClaw != nil {
-		oc := openclaw.NewClient(*a.opts.OpenClaw, a.agentID, a.opts.Name, sdkversion.Version, a.logger)
-		oc.SetOutboundHandler(func(sessionKey, text string) {
-			peerID := openclaw.ParsePeerFromSessionKey(sessionKey)
+	// Initialize platform adapter integration.
+	if a.opts.Platform != nil {
+		pa := a.opts.Platform
+		pa.SetOutboundHandler(func(sessionKey, text string) {
+			peerID := platform.ParsePeerFromSessionKey(sessionKey)
 			if peerID == "" {
 				return
 			}
 			env := envelope.New(a.agentID, peerID, "peerclaw", []byte(text))
 			_ = a.Send(context.Background(), env)
 		})
-		if err := oc.Connect(ctx); err != nil {
-			a.logger.Warn("openclaw connect failed", "error", err)
+		if err := pa.Connect(ctx); err != nil {
+			a.logger.Warn("platform connect failed", "platform", pa.Name(), "error", err)
 		} else {
-			a.openclawClient = oc
+			a.platformAdapter = pa
 		}
 
-		// Forward notifications to OpenClaw.
-		if a.openclawClient != nil {
+		// Forward notifications to platform.
+		if a.platformAdapter != nil {
 			a.OnNotification(func(n *NotificationPayload) {
-				text := openclaw.FormatNotification(n.Severity, n.Title, n.Body)
-				_ = a.openclawClient.ChatInject(ctx, "peerclaw:notifications", text, "peerclaw-notification")
+				text := platform.FormatNotification(n.Severity, n.Title, n.Body)
+				_ = a.platformAdapter.InjectNotification(ctx, platform.NotificationSessionKey, text, "peerclaw-notification")
 			})
 		}
 
-		// Forward P2P messages to OpenClaw.
-		if a.openclawClient != nil {
+		// Forward P2P messages to platform.
+		if a.platformAdapter != nil {
 			prevHandler := a.handler
 			a.OnMessage(func(msgCtx context.Context, env *envelope.Envelope) {
-				sessionKey := openclaw.SessionKeyForPeer(env.Source)
-				_ = a.openclawClient.ChatSend(msgCtx, sessionKey, string(env.Payload))
+				sessionKey := platform.SessionKeyForPeer(env.Source)
+				_ = a.platformAdapter.SendChat(msgCtx, sessionKey, string(env.Payload))
 				if prevHandler != nil {
 					prevHandler(msgCtx, env)
 				}
@@ -630,9 +629,9 @@ func (a *Agent) Stop(ctx context.Context) error {
 		}
 	}
 
-	// Close OpenClaw gateway.
-	if a.openclawClient != nil {
-		a.openclawClient.Close()
+	// Close platform adapter.
+	if a.platformAdapter != nil {
+		a.platformAdapter.Close()
 	}
 
 	// Close signaling and peers.

openclaw/format.go

@@ -0,0 +1,74 @@
+// Package platform defines the adapter interface for integrating the PeerClaw
+// agent with AI orchestration platforms (OpenClaw, IronClaw, etc.).
+package platform
+
+import "context"
+
+// OutboundHandler is called when the platform produces a final AI response.
+// sessionKey identifies the conversation; text is the response content.
+type OutboundHandler func(sessionKey, text string)
+
+// Adapter is the interface that all platform integrations must implement.
+// It abstracts the bidirectional bridge between PeerClaw P2P messaging
+// and an AI orchestration platform's conversation system.
+type Adapter interface {
+	// Name returns the platform identifier (e.g., "openclaw", "ironclaw", "bridge").
+	Name() string
+
+	// Connect establishes the connection to the platform.
+	Connect(ctx context.Context) error
+
+	// Close shuts down the platform connection.
+	Close() error
+
+	// SendChat forwards a P2P message into the platform for AI processing.
+	// The response arrives asynchronously via the OutboundHandler.
+	SendChat(ctx context.Context, sessionKey, message string) error
+
+	// InjectNotification inserts a notification into a platform conversation
+	// without triggering AI processing.
+	InjectNotification(ctx context.Context, sessionKey, message, label string) error
+
+	// SetOutboundHandler registers the callback for AI responses from the platform.
+	SetOutboundHandler(handler OutboundHandler)
+}
+
+// SessionKeyForPeer returns the platform session key for a DM with the given peer.
+func SessionKeyForPeer(peerAgentID string) string {
+	return "peerclaw:dm:" + peerAgentID
+}
+
+// ParsePeerFromSessionKey extracts the peer agent ID from a session key.
+// Returns empty string if the key doesn't match the expected prefix.
+func ParsePeerFromSessionKey(key string) string {
+	const prefix = "peerclaw:dm:"
+	if len(key) > len(prefix) && key[:len(prefix)] == prefix {
+		return key[len(prefix):]
+	}
+	return ""
+}
+
+// NotificationSessionKey is the session key used for server notification messages.
+const NotificationSessionKey = "peerclaw:notifications"
+
+// FormatNotification formats a notification for display in a platform conversation.
+func FormatNotification(severity, title, body string) string {
+	tag := severity
+	if tag == "" {
+		tag = "INFO"
+	}
+	// Use uppercase for the tag.
+	result := make([]byte, 0, len(tag)+len(title)+len(body)+6)
+	result = append(result, '[')
+	for _, b := range []byte(tag) {
+		if b >= 'a' && b <= 'z' {
+			b -= 'a' - 'A'
+		}
+		result = append(result, b)
+	}
+	result = append(result, "] "...)
+	result = append(result, title...)
+	result = append(result, ": "...)
+	result = append(result, body...)
+	return string(result)
+}