feat: 实现分层架构，包含 domain、service、repository 和 pkg 层

- 新增 domain 层：model、provider、route、stats 实体
- 新增 service 层：models、providers、routing、stats 业务逻辑
- 新增 repository 层：models、providers、stats 数据访问
- 新增 pkg 工具包：errors、logger、validator
- 新增中间件：CORS、logging、recovery、request ID
- 新增数据库迁移：初始 schema 和索引
- 新增单元测试和集成测试
- 新增规范文档：config-management、database-migration、error-handling、layered-architecture、middleware-system、request-validation、structured-logging、test-coverage
- 移除 config 子包和 model_router（已迁移至分层架构）

backend/pkg/errors/errors.go

@@ -0,0 +1,74 @@
+package errors
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// AppError 结构化应用错误
+type AppError struct {
+	Code       string                 `json:"code"`
+	Message    string                 `json:"message"`
+	HTTPStatus int                    `json:"-"`
+	Cause      error                  `json:"-"`
+	Context    map[string]interface{} `json:"-"`
+}
+
+// Error implements error interface
+func (e *AppError) Error() string {
+	if e.Cause != nil {
+		return fmt.Sprintf("%s: %s (%v)", e.Code, e.Message, e.Cause)
+	}
+	return fmt.Sprintf("%s: %s", e.Code, e.Message)
+}
+
+// Unwrap returns the underlying error
+func (e *AppError) Unwrap() error {
+	return e.Cause
+}
+
+// NewAppError creates a new AppError
+func NewAppError(code, message string, httpStatus int) *AppError {
+	return &AppError{
+		Code:       code,
+		Message:    message,
+		HTTPStatus: httpStatus,
+	}
+}
+
+// Predefined errors
+var (
+	ErrModelNotFound    = NewAppError("model_not_found", "模型未找到", http.StatusNotFound)
+	ErrModelDisabled    = NewAppError("model_disabled", "模型已禁用", http.StatusNotFound)
+	ErrProviderNotFound = NewAppError("provider_not_found", "供应商未找到", http.StatusNotFound)
+	ErrProviderDisabled = NewAppError("provider_disabled", "供应商已禁用", http.StatusNotFound)
+	ErrInvalidRequest   = NewAppError("invalid_request", "无效的请求", http.StatusBadRequest)
+	ErrInternal         = NewAppError("internal_error", "内部错误", http.StatusInternalServerError)
+	ErrDatabaseNotInit  = NewAppError("database_not_initialized", "数据库未初始化", http.StatusInternalServerError)
+	ErrConflict         = NewAppError("conflict", "资源已存在", http.StatusConflict)
+)
+
+// AsAppError 尝试将 error 转换为 *AppError
+func AsAppError(err error) (*AppError, bool) {
+	if err == nil {
+		return nil, false
+	}
+	var appErr *AppError
+	if ok := is(err, &appErr); ok {
+		return appErr, true
+	}
+	return nil, false
+}
+
+func is(err error, target interface{}) bool {
+	// 简单的类型断言
+	if e, ok := err.(*AppError); ok {
+		// 直接赋值
+		switch t := target.(type) {
+		case **AppError:
+			*t = e
+			return true
+		}
+	}
+	return false
+}

backend/pkg/errors/errors_test.go

@@ -0,0 +1,125 @@
+package errors
+
+import (
+	"errors"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewAppError(t *testing.T) {
+	err := NewAppError("test_code", "测试消息", http.StatusBadRequest)
+	assert.Equal(t, "test_code", err.Code)
+	assert.Equal(t, "测试消息", err.Message)
+	assert.Equal(t, http.StatusBadRequest, err.HTTPStatus)
+	assert.Nil(t, err.Cause)
+	assert.Nil(t, err.Context)
+}
+
+func TestAppError_Error(t *testing.T) {
+	tests := []struct {
+		name     string
+		err      *AppError
+		expected string
+	}{
+		{
+			name:     "无原因错误",
+			err:      NewAppError("code1", "消息1", 400),
+			expected: "code1: 消息1",
+		},
+		{
+			name:     "带原因错误",
+			err:      Wrap(NewAppError("code2", "消息2", 500), errors.New("原始错误")),
+			expected: "code2: 消息2 (原始错误)",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, tt.err.Error())
+		})
+	}
+}
+
+func TestAppError_Unwrap(t *testing.T) {
+	cause := errors.New("原始错误")
+	err := Wrap(ErrInternal, cause)
+	assert.Equal(t, cause, err.Unwrap())
+}
+
+func TestWrap(t *testing.T) {
+	cause := errors.New("网络超时")
+	wrapped := Wrap(ErrInternal, cause)
+	assert.Equal(t, "internal_error", wrapped.Code)
+	assert.Equal(t, "内部错误", wrapped.Message)
+	assert.Equal(t, http.StatusInternalServerError, wrapped.HTTPStatus)
+	assert.Equal(t, cause, wrapped.Cause)
+}
+
+func TestWithContext(t *testing.T) {
+	err := WithContext(ErrModelNotFound, "model", "gpt-4")
+	assert.Equal(t, "model_not_found", err.Code)
+	assert.NotNil(t, err.Context)
+	assert.Equal(t, "gpt-4", err.Context["model"])
+
+	// 测试链式添加上下文
+	err2 := WithContext(err, "provider", "openai")
+	assert.Equal(t, "gpt-4", err2.Context["model"])
+	assert.Equal(t, "openai", err2.Context["provider"])
+}
+
+func TestWithMessage(t *testing.T) {
+	err := WithMessage(ErrInvalidRequest, "自定义错误消息")
+	assert.Equal(t, "invalid_request", err.Code)
+	assert.Equal(t, "自定义错误消息", err.Message)
+	assert.Equal(t, http.StatusBadRequest, err.HTTPStatus)
+}
+
+func TestPredefinedErrors(t *testing.T) {
+	tests := []struct {
+		name       string
+		err        *AppError
+		code       string
+		httpStatus int
+	}{
+		{"ErrModelNotFound", ErrModelNotFound, "model_not_found", http.StatusNotFound},
+		{"ErrModelDisabled", ErrModelDisabled, "model_disabled", http.StatusNotFound},
+		{"ErrProviderNotFound", ErrProviderNotFound, "provider_not_found", http.StatusNotFound},
+		{"ErrProviderDisabled", ErrProviderDisabled, "provider_disabled", http.StatusNotFound},
+		{"ErrInvalidRequest", ErrInvalidRequest, "invalid_request", http.StatusBadRequest},
+		{"ErrInternal", ErrInternal, "internal_error", http.StatusInternalServerError},
+		{"ErrDatabaseNotInit", ErrDatabaseNotInit, "database_not_initialized", http.StatusInternalServerError},
+		{"ErrConflict", ErrConflict, "conflict", http.StatusConflict},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.code, tt.err.Code)
+			assert.Equal(t, tt.httpStatus, tt.err.HTTPStatus)
+		})
+	}
+}
+
+func TestAsAppError(t *testing.T) {
+	t.Run("nil输入", func(t *testing.T) {
+		_, ok := AsAppError(nil)
+		assert.False(t, ok)
+	})
+
+	t.Run("AppError类型", func(t *testing.T) {
+		appErr, ok := AsAppError(ErrModelNotFound)
+		assert.True(t, ok)
+		assert.Equal(t, ErrModelNotFound, appErr)
+	})
+
+	t.Run("Wrapped AppError", func(t *testing.T) {
+		wrapped := Wrap(ErrInternal, errors.New("cause"))
+		appErr, ok := AsAppError(wrapped)
+		assert.True(t, ok)
+		assert.Equal(t, "internal_error", appErr.Code)
+	})
+
+	t.Run("非AppError类型", func(t *testing.T) {
+		_, ok := AsAppError(errors.New("普通错误"))
+		assert.False(t, ok)
+	})
+}

backend/pkg/errors/wrap.go

@@ -0,0 +1,42 @@
+package errors
+
+// Wrap wraps an error with cause
+func Wrap(err *AppError, cause error) *AppError {
+	return &AppError{
+		Code:       err.Code,
+		Message:    err.Message,
+		HTTPStatus: err.HTTPStatus,
+		Cause:      cause,
+	}
+}
+
+// WithContext adds context to an AppError
+func WithContext(err *AppError, key string, value interface{}) *AppError {
+	newErr := &AppError{
+		Code:       err.Code,
+		Message:    err.Message,
+		HTTPStatus: err.HTTPStatus,
+		Cause:      err.Cause,
+	}
+	if err.Context != nil {
+		newErr.Context = make(map[string]interface{})
+		for k, v := range err.Context {
+			newErr.Context[k] = v
+		}
+	} else {
+		newErr.Context = make(map[string]interface{})
+	}
+	newErr.Context[key] = value
+	return newErr
+}
+
+// WithMessage creates a new AppError with a custom message
+func WithMessage(err *AppError, message string) *AppError {
+	return &AppError{
+		Code:       err.Code,
+		Message:    message,
+		HTTPStatus: err.HTTPStatus,
+		Cause:      err.Cause,
+		Context:    err.Context,
+	}
+}