初始化第一版

internal/integration/superagent/chat.go

@@ -0,0 +1,100 @@
+package superagent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"fire-safety-ymd/internal/service"
+)
+
+// ChatAgentAdapter projects the SuperAgent-specific client into the
+// provider-neutral service boundary.
+type ChatAgentAdapter struct {
+	client Client
+}
+
+var _ service.ChatAgent = (*ChatAgentAdapter)(nil)
+
+// NewChatAgentAdapter constructs the chat service adapter.
+func NewChatAgentAdapter(client Client) (*ChatAgentAdapter, error) {
+	if client == nil {
+		return nil, errors.New("superagent client is required")
+	}
+	return &ChatAgentAdapter{client: client}, nil
+}
+
+// CreateSession maps only the server-controlled fields required by SuperAgent.
+func (a *ChatAgentAdapter) CreateSession(ctx context.Context, request service.AgentCreateSessionRequest) (service.AgentSession, error) {
+	session, err := a.client.CreateSession(ctx, CreateSessionRequest{
+		ExternalSubjectID: request.ExternalSubjectID,
+		IdempotencyKey:    request.IdempotencyKey,
+		RequestID:         request.RequestID,
+		Metadata:          request.Metadata,
+	})
+	if err != nil {
+		return service.AgentSession{}, mapChatError("create session", err)
+	}
+	return service.AgentSession{ID: session.ID}, nil
+}
+
+// StreamMessage removes provider identifiers, text deltas, and raw trace data
+// from progress events. The final answer is returned only when the underlying
+// strict SuperAgent client reports success.
+func (a *ChatAgentAdapter) StreamMessage(
+	ctx context.Context,
+	request service.AgentMessageRequest,
+	traceHandler func(service.AgentTraceEvent),
+) (service.AgentMessageResult, error) {
+	result, err := a.client.StreamMessage(ctx, StreamMessageRequest{
+		SessionID:      request.SessionID,
+		Message:        request.Message,
+		IdempotencyKey: request.IdempotencyKey,
+		RequestID:      request.RequestID,
+		Metadata:       request.Metadata,
+	}, func(event TraceEvent) {
+		if traceHandler == nil {
+			return
+		}
+		traceHandler(service.AgentTraceEvent{
+			Event:    safeValue(event.Event),
+			ToolName: safeValue(event.ToolName),
+			Status:   safeValue(event.Status),
+		})
+	})
+	if err != nil {
+		return service.AgentMessageResult{}, mapChatError("stream message", err)
+	}
+	return service.AgentMessageResult{
+		RunID:   result.RunID,
+		ModelID: safeValue(result.ModelName),
+		Answer:  result.Answer,
+		Usage: service.ChatTokenUsage{
+			Input:  result.Usage.Input,
+			Output: result.Usage.Output,
+			Total:  result.Usage.Total,
+		},
+	}, nil
+}
+
+func mapChatError(operation string, err error) error {
+	if err == nil {
+		return nil
+	}
+	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+		return err
+	}
+	var public error
+	switch {
+	case errors.Is(err, ErrRunFailed):
+		public = service.ErrChatRunFailed
+	case errors.Is(err, ErrProtocol), errors.Is(err, ErrStreamIncomplete), errors.Is(err, ErrStreamRead),
+		errors.Is(err, ErrRecoveryExhausted), errors.Is(err, ErrInvalidRequest):
+		public = service.ErrChatUpstreamProtocol
+	case errors.Is(err, ErrDisabled), errors.Is(err, ErrHTTPStatus):
+		public = service.ErrChatUpstreamUnavailable
+	default:
+		public = service.ErrChatUpstreamUnavailable
+	}
+	return fmt.Errorf("superagent %s: %w", operation, public)
+}