draftgo-cli 4.0.1 → 4.0.22

package/resources/custom-service-sdk/billing_test.go

@@ -0,0 +1,150 @@
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+)
+
+func TestBillingSDKCarriesStableOperationsAndIdempotency(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+
+	_, err := draftgo.Billing.CreatePaymentOrder(draftgo.Context(), PaymentOrderRequest{
+		BusinessOrderID: "biz-1", AmountMinor: 100, Provider: "wechat", IdempotencyKey: "pay-1",
+	})
+	if err != nil || client.op != "billing.payment.create" {
+		t.Fatalf("create operation=%q err=%v", client.op, err)
+	}
+	if client.args["idempotency_key"] != "pay-1" || client.args["business_order_id"] != "biz-1" {
+		t.Fatalf("payment contract lost stable fields: %#v", client.args)
+	}
+	_, err = draftgo.Billing.RefundPaymentOrder(draftgo.Context(), RefundRequest{PaymentOrderID: "42", AmountMinor: 50, IdempotencyKey: "refund-42"})
+	if err != nil || client.op != "billing.payment.refund" || client.args["payment_order_id"] != "42" || client.args["idempotency_key"] != "refund-42" {
+		t.Fatalf("refund operation=%q args=%#v err=%v", client.op, client.args, err)
+	}
+	_, err = draftgo.Billing.ListPaymentRefunds(draftgo.Context(), "42")
+	if err != nil || client.op != "billing.payment.refunds.list" || client.args["payment_order_id"] != "42" {
+		t.Fatalf("refund list operation=%q err=%v", client.op, err)
+	}
+
+	_, err = draftgo.Billing.StartAIBilling(draftgo.Context(), AIBillingStartRequest{
+		IdempotencyKey: "ai-1", RequestID: "request-1", Model: "model-a", EstimatedMinor: 20,
+	})
+	if err != nil || client.op != "billing.ai.session.start" {
+		t.Fatalf("AI start operation=%q err=%v", client.op, err)
+	}
+	if client.args["idempotency_key"] != "ai-1" || client.args["request_id"] != "request-1" {
+		t.Fatalf("AI billing contract lost idempotency/request fields: %#v", client.args)
+	}
+
+	_, err = draftgo.Billing.SettleAIBilling(draftgo.Context(), AISettlementRequest{
+		SessionID: "session-1", Usage: map[string]any{"requests": 1}, IdempotencyKey: "settle-1",
+	})
+	if err != nil || client.op != "billing.ai.session.settle" {
+		t.Fatalf("AI settle operation=%q err=%v", client.op, err)
+	}
+	if client.args["session_id"] != "session-1" || client.args["idempotency_key"] != "settle-1" {
+		t.Fatalf("AI settlement contract lost stable fields: %#v", client.args)
+	}
+}
+
+// Keep this test tied to JSON-compatible SDK payloads: custom services cross
+// an RPC boundary and must not depend on Go-only values.
+func TestBillingSDKRequestsAreJSONCompatible(t *testing.T) {
+	payload := PaymentOrderRequest{BusinessOrderID: "biz-1", AmountMinor: 1, IdempotencyKey: "k"}
+	if _, err := json.Marshal(payload); err != nil {
+		t.Fatalf("payment request is not JSON compatible: %v", err)
+	}
+	settlement := AISettlementRequest{SessionID: "s-1", Usage: map[string]any{"input_tokens": int64(2)}, IdempotencyKey: "k"}
+	if _, err := json.Marshal(settlement); err != nil {
+		t.Fatalf("AI settlement is not JSON compatible: %v", err)
+	}
+}
+
+func TestPaymentOrderParserPreservesFulfillmentMetadata(t *testing.T) {
+	order := paymentOrder(map[string]any{
+		"id": "42", "business_order_id": "biz-42", "ownership_type": "space", "workspace_id": float64(2), "space_id": float64(8), "owner_user_id": float64(7),
+		"payer_user_id": float64(9), "created_by": float64(7), "provider": "wechat", "provider_trade_no": "trade-42", "status": "paid",
+		"amount_minor": float64(1288), "product_ref": "product:pro", "fulfillment_ref": "subscription:3",
+		"metadata": map[string]any{"sku": "pro"}, "created_at": "2026-08-14T10:00:00Z", "paid_at": "2026-08-14T10:01:00Z",
+	})
+	if order.Ownership.ScopeType != ScopeSpace || order.Ownership.WorkspaceID != 2 || order.Ownership.SpaceID != 8 || order.Ownership.OwnerUserID != 7 || order.PayerUserID != 9 || order.ProductRef != "product:pro" || order.FulfillmentRef != "subscription:3" || order.Metadata["sku"] != "pro" || order.ProviderTradeNo != "trade-42" {
+		t.Fatalf("payment order=%#v", order)
+	}
+}
+
+func TestBillingSDKPriceVersionOperations(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+	created, err := draftgo.Admin.Billing.CreateAIPriceVersion(draftgo.Context(), AIPriceVersionRequest{Model: "model-a", Version: "v1", BillingMode: "per_call", BillingEnabled: true, RequestPriceMinor: 8})
+	if err != nil || client.op != "billing.ai.pricing.create" {
+		t.Fatalf("create = %+v, operation=%q, err=%v", created, client.op, err)
+	}
+	if client.args["__draftgo_admin"] != true || client.args["request_price_minor"] != float64(8) {
+		t.Fatalf("create args = %#v", client.args)
+	}
+}
+
+func TestBillingSDKAICostsAndProviderCost(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+	_, err := draftgo.Admin.Billing.GetAICosts(draftgo.Context(), map[string]any{"model_key": "model-a"})
+	if err != nil || client.op != "billing.ai.costs.list" || client.args["__draftgo_admin"] != true {
+		t.Fatalf("cost operation=%q args=%#v err=%v", client.op, client.args, err)
+	}
+	_, err = draftgo.Admin.Billing.CreateAIPriceVersion(draftgo.Context(), AIPriceVersionRequest{Model: "model-a", Version: "v1", ProviderCostMode: "per_call", ProviderRequestCostMinor: 3})
+	if err != nil || client.args["provider_cost_mode"] != "per_call" || client.args["provider_request_cost_minor"] != float64(3) {
+		t.Fatalf("provider cost args=%#v err=%v", client.args, err)
+	}
+}
+
+func TestBillingSDKPlanAndSubscriptionOperations(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+
+	_, err := draftgo.Admin.Billing.CreatePlan(draftgo.Context(), PlanRequest{
+		Code: "pro", Name: "Pro", PriceMinor: 9900, BillingCycle: "monthly",
+		Entitlements: map[string]any{"ai.requests": 1000},
+	})
+	if err != nil || client.op != "billing.plan.create" || client.args["__draftgo_admin"] != true {
+		t.Fatalf("create plan operation=%q args=%#v err=%v", client.op, client.args, err)
+	}
+	if client.args["code"] != "pro" || client.args["price_minor"] != float64(9900) {
+		t.Fatalf("create plan args=%#v", client.args)
+	}
+
+	_, err = draftgo.Billing.ListPlans(draftgo.Context(), PlanQuery{Status: "active"})
+	if err != nil || client.op != "billing.plan.list" {
+		t.Fatalf("list plans operation=%q err=%v", client.op, err)
+	}
+	query, _ := client.args["query"].(map[string]any)
+	if query["status"] != "active" {
+		t.Fatalf("list plan query=%#v", query)
+	}
+
+	_, err = draftgo.Admin.Billing.CreateSubscription(draftgo.Context(), SubscriptionRequest{
+		PlanID: 3, Subject: BillingSubject{Type: "space", ID: "8"}, SourceType: "payment_order", SourceID: "88", IdempotencyKey: "subscription-88",
+	})
+	if err != nil || client.op != "billing.subscription.create" || client.args["idempotency_key"] != "subscription-88" {
+		t.Fatalf("create subscription operation=%q args=%#v err=%v", client.op, client.args, err)
+	}
+
+	_, err = draftgo.Billing.ListSubscriptions(draftgo.Context(), SubscriptionQuery{Status: "active"})
+	if err != nil || client.op != "billing.subscription.list" {
+		t.Fatalf("list subscriptions operation=%q err=%v", client.op, err)
+	}
+
+	_, err = draftgo.Admin.Billing.ChangeSubscriptionPlan(draftgo.Context(), 9, SubscriptionChangeRequest{PlanID: 4})
+	if err != nil || client.op != "billing.subscription.change_plan" || client.args["id"] != float64(9) {
+		t.Fatalf("change subscription operation=%q args=%#v err=%v", client.op, client.args, err)
+	}
+	_, err = draftgo.Admin.Billing.CancelSubscription(draftgo.Context(), 9)
+	if err != nil || client.op != "billing.subscription.cancel" {
+		t.Fatalf("cancel subscription operation=%q err=%v", client.op, err)
+	}
+	_, err = draftgo.Admin.Billing.FulfillSubscriptionPayment(draftgo.Context(), SubscriptionPaymentFulfillmentRequest{PaymentOrderID: "88", PlanID: 3})
+	if err != nil || client.op != "billing.subscription.fulfill_payment" || client.args["payment_order_id"] != "88" || client.args["plan_id"] != float64(3) {
+		t.Fatalf("fulfill subscription operation=%q args=%#v err=%v", client.op, client.args, err)
+	}
+}

package/resources/custom-service-sdk/go.mod

@@ -0,0 +1,3 @@
+module draftgo/sdk
+
+go 1.26.0

package/resources/custom-service-sdk/manifest.json

@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "module": "draftgo/sdk",
+  "fingerprint": "c750610f8d4b1652da259ea436d47d9856104261c9af1b0e3753c073d36d4693",
+  "files": [
+    {
+      "path": "ai.go",
+      "sha256": "0d45e652f96769c1f2d371a1c25b03903d09356c600fbd0e6d67190466259248",
+      "bytes": 26627
+    },
+    {
+      "path": "ai_test.go",
+      "sha256": "d5a906ea3d9d0451f116d2acac54bfb83669e5e471d1d5ada7c0e1fdabef13b6",
+      "bytes": 6531
+    },
+    {
+      "path": "billing.go",
+      "sha256": "9ce87c80885aa8b8996710622ec0f14cc7a74d3ca78e5ed4168b6c135994d583",
+      "bytes": 30976
+    },
+    {
+      "path": "billing_test.go",
+      "sha256": "d6632b31d385fe3658dd1fbc74e31a87cc69b23bf97422d8339c5a46bf2d1aa2",
+      "bytes": 8009
+    },
+    {
+      "path": "go.mod",
+      "sha256": "b89c04833ac41ea06dfbc8c60ebdc1c2e3e628243cf5adbb36b7320acfe2a3ef",
+      "bytes": 30
+    },
+    {
+      "path": "platform.go",
+      "sha256": "ec0d8621a8bb677578001d029fe191af58df9d275204eced5e8061b339ad085b",
+      "bytes": 12373
+    },
+    {
+      "path": "platform_logger_test.go",
+      "sha256": "e8eb02e668c62bb317506f0197cfab3e520fd53534f3bb1f99f55155fa24218d",
+      "bytes": 540
+    },
+    {
+      "path": "registration_test.go",
+      "sha256": "e9fd4ab60a2b6b28c997019ce76b224f7cec52b934d080ebfd94298448acd4f0",
+      "bytes": 1031
+    },
+    {
+      "path": "resources.go",
+      "sha256": "e633aa1431beddd25b2c999370a770f77c3de7a2d7123687eca75c9ed0d3838f",
+      "bytes": 9708
+    },
+    {
+      "path": "resources_billing_test.go",
+      "sha256": "3fadeb8b7af0fad43f34e2479e4331a18f022bcdabdcb3b4ba921768c6b6a7ec",
+      "bytes": 4859
+    },
+    {
+      "path": "resources_files_test.go",
+      "sha256": "f77a3b6e421e20b528a1bfca5e2b164b63b3599bf3566b8f3998fdf72c4c0aa6",
+      "bytes": 2551
+    },
+    {
+      "path": "resources_scope_test.go",
+      "sha256": "bba3243f348e9418888f37ee2d5b487fc26a31e4a646e75bef46d5d807938cee",
+      "bytes": 3592
+    },
+    {
+      "path": "sdk.go",
+      "sha256": "95ffcc335416ac842e06ea51b75e6739a04ddd5573a946e4175d6c5f8c110a67",
+      "bytes": 8167
+    }
+  ]
+}

package/resources/custom-service-sdk/platform.go

@@ -0,0 +1,360 @@
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+)
+
+// Client is implemented by the isolated runner protocol. It is deliberately
+// generic so new platform capabilities do not require exposing host handles.
+type Client interface {
+	Call(context.Context, string, any) (any, error)
+}
+
+type Database interface {
+	Create(string, map[string]any, ...int64) (map[string]any, error)
+	CreateMany(string, []map[string]any) ([]map[string]any, error)
+	Get(string, int64) (map[string]any, error)
+	Update(string, int64, map[string]any) (map[string]any, error)
+	UpdateMany(string, []map[string]any) ([]map[string]any, error)
+	Delete(string, int64) (bool, error)
+	Query(string, QueryOptions) (QueryResult, error)
+}
+
+type QueryOptions struct {
+	Filters  map[string]any
+	Page     int
+	PageSize int
+	OrderBy  string
+	Order    string
+}
+
+type QueryResult struct {
+	Items    []map[string]any `json:"items"`
+	Total    int              `json:"total"`
+	Page     int              `json:"page"`
+	PageSize int              `json:"page_size"`
+}
+
+type Users interface {
+	Get(int64) (map[string]any, error)
+	List(QueryOptions) (QueryResult, error)
+	Update(int64, map[string]any) (map[string]any, error)
+}
+
+type Auth interface {
+	RequireLogin() error
+	RequireAdmin() error
+	RequireRole(string) error
+	CurrentUser() map[string]any
+}
+
+type Notifier interface {
+	Send(int64, string, string, string) error
+}
+
+type Cache interface {
+	Get(string) (any, error)
+	Set(string, any, time.Duration) error
+	Delete(string) (bool, error)
+}
+
+type Config interface {
+	Get(string, any) (any, error)
+}
+
+type HTTPClient interface {
+	Get(context.Context, string, http.Header, time.Duration) (HTTPResponse, error)
+	Post(context.Context, string, any, http.Header, time.Duration) (HTTPResponse, error)
+	Put(context.Context, string, any, http.Header, time.Duration) (HTTPResponse, error)
+	Patch(context.Context, string, any, http.Header, time.Duration) (HTTPResponse, error)
+	Delete(context.Context, string, http.Header, time.Duration) (HTTPResponse, error)
+}
+
+type HTTPResponse struct {
+	StatusCode int         `json:"status_code"`
+	Headers    http.Header `json:"headers,omitempty"`
+	Data       any         `json:"data,omitempty"`
+}
+
+type LogEntry struct {
+	Level     string    `json:"level"`
+	Message   string    `json:"message"`
+	Timestamp time.Time `json:"timestamp"`
+}
+
+// Logger is local to one invocation and becomes part of the audited result.
+type Logger struct {
+	mu        sync.Mutex
+	entries   []LogEntry
+	truncated bool
+}
+
+func (log *Logger) append(level, message string) {
+	if log == nil {
+		return
+	}
+	log.mu.Lock()
+	defer log.mu.Unlock()
+	if len(log.entries) < 500 {
+		if characters := []rune(message); len(characters) > 4096 {
+			message = string(characters[:4096])
+			log.truncated = true
+		}
+		log.entries = append(log.entries, LogEntry{Level: level, Message: message, Timestamp: time.Now()})
+	} else {
+		log.truncated = true
+	}
+}
+
+func (log *Logger) Truncated() bool {
+	if log == nil {
+		return false
+	}
+	log.mu.Lock()
+	defer log.mu.Unlock()
+	return log.truncated
+}
+func (log *Logger) Debug(message string) { log.append("debug", message) }
+func (log *Logger) Info(message string)  { log.append("info", message) }
+func (log *Logger) Warn(message string)  { log.append("warn", message) }
+func (log *Logger) Error(message string) { log.append("error", message) }
+func (log *Logger) Entries() []LogEntry {
+	if log == nil {
+		return nil
+	}
+	log.mu.Lock()
+	defer log.mu.Unlock()
+	out := make([]LogEntry, len(log.entries))
+	copy(out, log.entries)
+	return out
+}
+
+type platformClient struct {
+	client  Client
+	context context.Context
+	admin   bool
+}
+type dbClient struct{ platformClient }
+type usersClient struct{ platformClient }
+type notifierClient struct{ platformClient }
+type cacheClient struct{ platformClient }
+type configClient struct{ platformClient }
+type httpClient struct{ platformClient }
+type aiHubClient struct{ platformClient }
+type knowledgeClient struct{ platformClient }
+type memoryClient struct{ platformClient }
+
+func (p platformClient) call(draftgo context.Context, operation string, args any) (any, error) {
+	if p.client == nil {
+		return nil, errors.New("DraftGo platform RPC is unavailable")
+	}
+	if draftgo == nil {
+		draftgo = p.context
+	}
+	if p.admin {
+		values, ok := args.(map[string]any)
+		if !ok {
+			raw, err := json.Marshal(args)
+			if err == nil {
+				ok = json.Unmarshal(raw, &values) == nil
+			}
+		}
+		if ok {
+			cloned := make(map[string]any, len(values)+1)
+			for key, value := range values {
+				cloned[key] = value
+			}
+			cloned["__draftgo_admin"] = true
+			args = cloned
+		}
+	}
+	return p.client.Call(draftgo, operation, args)
+}
+func mapResult(value any) map[string]any { result, _ := value.(map[string]any); return result }
+func mapSlice(value any) []map[string]any {
+	raw, _ := value.([]any)
+	result := make([]map[string]any, 0, len(raw))
+	for _, item := range raw {
+		if object, ok := item.(map[string]any); ok {
+			result = append(result, object)
+		}
+	}
+	return result
+}
+func (p dbClient) Create(kind string, data map[string]any, userID ...int64) (map[string]any, error) {
+	args := map[string]any{"db_type": kind, "data": data}
+	if len(userID) > 0 {
+		args["owner_user_id"] = userID[0]
+	}
+	value, err := p.call(p.context, "db.create", args)
+	return mapResult(value), err
+}
+func (p dbClient) CreateMany(kind string, items []map[string]any) ([]map[string]any, error) {
+	value, err := p.call(p.context, "db.create_many", map[string]any{"db_type": kind, "items": items})
+	return mapSlice(value), err
+}
+func (p dbClient) Get(kind string, id int64) (map[string]any, error) {
+	value, err := p.call(p.context, "db.get", map[string]any{"db_type": kind, "record_id": id})
+	return mapResult(value), err
+}
+func (p dbClient) Update(kind string, id int64, data map[string]any) (map[string]any, error) {
+	value, err := p.call(p.context, "db.update", map[string]any{"db_type": kind, "record_id": id, "data": data})
+	return mapResult(value), err
+}
+func (p dbClient) UpdateMany(kind string, items []map[string]any) ([]map[string]any, error) {
+	value, err := p.call(p.context, "db.update_many", map[string]any{"db_type": kind, "items": items})
+	return mapSlice(value), err
+}
+func (p dbClient) Delete(kind string, id int64) (bool, error) {
+	value, err := p.call(p.context, "db.delete", map[string]any{"db_type": kind, "record_id": id})
+	ok, _ := value.(bool)
+	return ok, err
+}
+func (p dbClient) Query(kind string, options QueryOptions) (QueryResult, error) {
+	value, err := p.call(p.context, "db.query", map[string]any{"db_type": kind, "filters": options.Filters, "page": nullablePositive(options.Page), "page_size": nullablePositive(options.PageSize), "order_by": options.OrderBy, "order": options.Order})
+	return queryResult(value), err
+}
+func (p usersClient) GetUser(id int64) (map[string]any, error) {
+	value, err := p.call(p.context, "users.get", map[string]any{"user_id": id})
+	return mapResult(value), err
+}
+func (p usersClient) List(options QueryOptions) (QueryResult, error) {
+	value, err := p.call(p.context, "users.list", map[string]any{"filters": options.Filters, "page": nullablePositive(options.Page), "page_size": nullablePositive(options.PageSize)})
+	return queryResult(value), err
+}
+func (p usersClient) UpdateUser(id int64, data map[string]any) (map[string]any, error) {
+	value, err := p.call(p.context, "users.update", map[string]any{"user_id": id, "data": data})
+	return mapResult(value), err
+}
+func (p usersClient) Get(id int64) (map[string]any, error) { return p.GetUser(id) }
+func (p usersClient) Update(id int64, data map[string]any) (map[string]any, error) {
+	return p.UpdateUser(id, data)
+}
+func (p notifierClient) Send(userID int64, title, content, noticeType string) error {
+	_, err := p.call(p.context, "notify.send", map[string]any{"user_id": userID, "title": title, "content": content, "notice_type": noticeType})
+	return err
+}
+func (p cacheClient) GetCache(key string) (any, error) {
+	return p.call(p.context, "cache.get", map[string]any{"key": key})
+}
+func (p cacheClient) SetCache(key string, value any, ttl time.Duration) error {
+	_, err := p.call(p.context, "cache.set", map[string]any{"key": key, "value": value, "ttl": int(ttl.Seconds())})
+	return err
+}
+func (p cacheClient) DeleteCache(key string) (bool, error) {
+	value, err := p.call(p.context, "cache.delete", map[string]any{"key": key})
+	ok, _ := value.(bool)
+	return ok, err
+}
+func (p configClient) GetConfig(key string, defaultValue any) (any, error) {
+	return p.call(p.context, "config.get", map[string]any{"key": key, "default": defaultValue})
+}
+func (p cacheClient) Get(key string) (any, error) { return p.GetCache(key) }
+func (p cacheClient) Set(key string, value any, ttl time.Duration) error {
+	return p.SetCache(key, value, ttl)
+}
+func (p cacheClient) Delete(key string) (bool, error) { return p.DeleteCache(key) }
+func (p configClient) Get(key string, defaultValue any) (any, error) {
+	return p.GetConfig(key, defaultValue)
+}
+func (p httpClient) request(draftgo context.Context, method, url string, body any, headers http.Header, timeout time.Duration) (HTTPResponse, error) {
+	value, err := p.call(draftgo, "http.request", map[string]any{"method": method, "url": url, "body": body, "headers": headers, "timeout_ms": int(timeout.Milliseconds())})
+	response := HTTPResponse{}
+	if raw, ok := value.(map[string]any); ok {
+		if status, ok := raw["status_code"].(float64); ok {
+			response.StatusCode = int(status)
+		}
+		response.Data = raw["data"]
+		if rawHeaders, ok := raw["headers"].(map[string]any); ok {
+			response.Headers = http.Header{}
+			for key, value := range rawHeaders {
+				response.Headers.Set(key, fmt.Sprint(value))
+			}
+		}
+	}
+	return response, err
+}
+func (p httpClient) Get(draftgo context.Context, url string, headers http.Header, timeout time.Duration) (HTTPResponse, error) {
+	return p.request(draftgo, http.MethodGet, url, nil, headers, timeout)
+}
+func (p httpClient) Post(draftgo context.Context, url string, body any, headers http.Header, timeout time.Duration) (HTTPResponse, error) {
+	return p.request(draftgo, http.MethodPost, url, body, headers, timeout)
+}
+func (p httpClient) Put(draftgo context.Context, url string, body any, headers http.Header, timeout time.Duration) (HTTPResponse, error) {
+	return p.request(draftgo, http.MethodPut, url, body, headers, timeout)
+}
+func (p httpClient) Patch(draftgo context.Context, url string, body any, headers http.Header, timeout time.Duration) (HTTPResponse, error) {
+	return p.request(draftgo, http.MethodPatch, url, body, headers, timeout)
+}
+func (p httpClient) Delete(draftgo context.Context, url string, headers http.Header, timeout time.Duration) (HTTPResponse, error) {
+	return p.request(draftgo, http.MethodDelete, url, nil, headers, timeout)
+}
+func nullablePositive(value int) any {
+	if value <= 0 {
+		return nil
+	}
+	return value
+}
+func queryResult(value any) QueryResult {
+	object := mapResult(value)
+	result := QueryResult{Total: asInt(object["total"]), Page: asInt(object["page"]), PageSize: asInt(object["page_size"])}
+	result.Items = mapSlice(object["items"])
+	return result
+}
+func asInt(value any) int {
+	switch typed := value.(type) {
+	case int:
+		return typed
+	case int64:
+		return int(typed)
+	case float64:
+		return int(typed)
+	default:
+		return 0
+	}
+}
+
+type authClient struct{ user map[string]any }
+
+func (a authClient) CurrentUser() map[string]any { return a.user }
+func (a authClient) RequireLogin() error {
+	if a.user == nil {
+		return errors.New("require_login failed: user is not authenticated")
+	}
+	return nil
+}
+func (a authClient) RequireAdmin() error {
+	if err := a.RequireLogin(); err != nil {
+		return err
+	}
+	if a.user["is_admin"] == true || a.user["role_code"] == "admin" {
+		return nil
+	}
+	for _, role := range asSlice(a.user["roles"]) {
+		if item, ok := role.(map[string]any); ok && item["code"] == "admin" {
+			return nil
+		}
+	}
+	return errors.New("require_admin failed: user is not an administrator")
+}
+func (a authClient) RequireRole(role string) error {
+	if err := a.RequireLogin(); err != nil {
+		return err
+	}
+	if a.user["role_code"] == role {
+		return nil
+	}
+	for _, raw := range asSlice(a.user["roles"]) {
+		if item, ok := raw.(map[string]any); ok && item["code"] == role {
+			return nil
+		}
+	}
+	return fmt.Errorf("require_role failed: missing role %q", role)
+}
+func asSlice(value any) []any { items, _ := value.([]any); return items }

package/resources/custom-service-sdk/platform_logger_test.go

@@ -0,0 +1,24 @@
+package sdk
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestLoggerReportsEntryAndMessageTruncation(t *testing.T) {
+	logger := &Logger{}
+	logger.Info(strings.Repeat("界", 4097))
+	for index := 1; index <= 500; index++ {
+		logger.Info("entry")
+	}
+	entries := logger.Entries()
+	if len(entries) != 500 {
+		t.Fatalf("entries = %d, want 500", len(entries))
+	}
+	if got := len([]rune(entries[0].Message)); got != 4096 {
+		t.Fatalf("message characters = %d, want 4096", got)
+	}
+	if !logger.Truncated() {
+		t.Fatal("Truncated() = false, want true")
+	}
+}

package/resources/custom-service-sdk/registration_test.go

@@ -0,0 +1,39 @@
+package sdk
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestRouteCanonicalizesRuntimePath(t *testing.T) {
+	app := NewApp()
+	app.Route(" get ", "//health//", func(*Context) (any, error) { return nil, nil })
+
+	registrations := app.Registrations()
+	if len(registrations) != 1 || registrations[0].Method != "GET" || registrations[0].Path != "/health" {
+		t.Fatalf("canonical route registration = %#v", registrations)
+	}
+}
+
+func TestRouteRejectsCanonicalDuplicate(t *testing.T) {
+	app := NewApp()
+	app.Route("GET", "/health", func(*Context) (any, error) { return nil, nil })
+
+	deferred := recoverValue(func() {
+		app.Route(" get ", "/health/", func(*Context) (any, error) { return nil, nil })
+	})
+	if message := strings.TrimSpace(asPanicString(deferred)); message != "duplicate route GET /health" {
+		t.Fatalf("duplicate route panic = %q", message)
+	}
+}
+
+func recoverValue(run func()) (value any) {
+	defer func() { value = recover() }()
+	run()
+	return nil
+}
+
+func asPanicString(value any) string {
+	text, _ := value.(string)
+	return text
+}