draftgo-cli 4.0.1 → 4.0.23

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

@@ -0,0 +1,520 @@
+package sdk
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+// AIRequest is the future-compatible escape hatch for AI endpoints that have
+// not yet gained a typed helper. Path must target a DraftGo AI API route.
+type AIRequest struct {
+	Method string         `json:"method"`
+	Path   string         `json:"path"`
+	Query  map[string]any `json:"query,omitempty"`
+	Body   any            `json:"body,omitempty"`
+}
+
+type AIChatRequest struct {
+	AgentID   int64            `json:"agent_id,omitempty"`
+	Message   string           `json:"message,omitempty"`
+	Messages  []map[string]any `json:"messages,omitempty"`
+	Model     string           `json:"model,omitempty"`
+	Context   map[string]any   `json:"context,omitempty"`
+	SessionID string           `json:"session_id,omitempty"`
+	RunID     string           `json:"run_id,omitempty"`
+	Options   map[string]any   `json:"options,omitempty"`
+}
+
+type AIImageRequest struct {
+	AgentID int64          `json:"agent_id,omitempty"`
+	Prompt  string         `json:"prompt"`
+	Model   string         `json:"model,omitempty"`
+	Options map[string]any `json:"options,omitempty"`
+}
+
+type AIEmbeddingRequest struct {
+	Model   string         `json:"model"`
+	Input   any            `json:"input"`
+	Options map[string]any `json:"options,omitempty"`
+}
+
+// AIResponsesRequest is the synchronous typed helper for the OpenAI-compatible
+// Responses and Responses Compact APIs. Streaming remains available through
+// AIHub.Request because the custom-service RPC transport returns decoded values.
+type AIResponsesRequest struct {
+	Model              string           `json:"model"`
+	Input              any              `json:"input,omitempty"`
+	Instructions       string           `json:"instructions,omitempty"`
+	PreviousResponseID string           `json:"previous_response_id,omitempty"`
+	Tools              []map[string]any `json:"tools,omitempty"`
+	Options            map[string]any   `json:"options,omitempty"`
+}
+
+type AIRerankRequest struct {
+	Model           string         `json:"model"`
+	Query           string         `json:"query"`
+	Documents       []string       `json:"documents"`
+	TopN            int            `json:"top_n,omitempty"`
+	ReturnDocuments bool           `json:"return_documents,omitempty"`
+	Options         map[string]any `json:"options,omitempty"`
+}
+
+type AITTSRequest struct {
+	Model               string         `json:"model"`
+	Input               string         `json:"input"`
+	Voice               string         `json:"voice,omitempty"`
+	Instructions        string         `json:"instructions,omitempty"`
+	ResponseFormat      string         `json:"response_format,omitempty"`
+	OptimizeTextPreview bool           `json:"optimize_text_preview,omitempty"`
+	Options             map[string]any `json:"options,omitempty"`
+}
+
+type AIAudioResponse struct {
+	Content  []byte
+	MIMEType string
+}
+
+type AITranscriptionRequest struct {
+	Model          string         `json:"model"`
+	Content        []byte         `json:"-"`
+	MIMEType       string         `json:"mime_type"`
+	Language       string         `json:"language,omitempty"`
+	ResponseFormat string         `json:"response_format,omitempty"`
+	Options        map[string]any `json:"options,omitempty"`
+}
+
+type SkillInstallRequest struct {
+	Repository string `json:"repo"`
+	Ref        string `json:"ref,omitempty"`
+}
+
+type SkillArchive struct {
+	Filename string `json:"filename"`
+	Content  []byte `json:"-"`
+}
+
+type KnowledgeDocumentUpload struct {
+	Filename       string         `json:"filename"`
+	MIMEType       string         `json:"mime_type,omitempty"`
+	Content        []byte         `json:"-"`
+	Metadata       map[string]any `json:"metadata,omitempty"`
+	AutoTag        bool           `json:"auto_tag,omitempty"`
+	TaggingModelID int64          `json:"tagging_model_id,omitempty"`
+}
+
+// AIHub covers inference plus the complete AI asset and model-management API.
+// Asset CRUD is used for agent, prompt, skill and MCP records.
+type AIHub interface {
+	Request(context.Context, AIRequest) (any, error)
+	Chat(context.Context, AIChatRequest) (map[string]any, error)
+	GenerateImage(context.Context, AIImageRequest) (map[string]any, error)
+	Responses(context.Context, AIResponsesRequest) (map[string]any, error)
+	CompactResponse(context.Context, AIResponsesRequest) (map[string]any, error)
+	Embeddings(context.Context, AIEmbeddingRequest) (map[string]any, error)
+	Rerank(context.Context, AIRerankRequest) (map[string]any, error)
+	TextToSpeech(context.Context, AITTSRequest) (AIAudioResponse, error)
+	Transcribe(context.Context, AITranscriptionRequest) (map[string]any, error)
+
+	ListCallableAgents(context.Context) ([]map[string]any, error)
+	AgentSelectableModels(context.Context, int64) (map[string]any, error)
+	PreviewAgentChat(context.Context, int64, AIChatRequest) (map[string]any, error)
+	ListAssetTypes(context.Context) ([]map[string]any, error)
+	ListAssets(context.Context, map[string]any) (map[string]any, error)
+	GetAsset(context.Context, int64) (map[string]any, error)
+	CreateAsset(context.Context, map[string]any) ([]map[string]any, error)
+	UpdateAsset(context.Context, int64, map[string]any) ([]map[string]any, error)
+	UpdateAssets(context.Context, []map[string]any) ([]map[string]any, error)
+	DeleteAsset(context.Context, int64, bool) error
+	AgentReadiness(context.Context, int64) (map[string]any, error)
+	PublishAgent(context.Context, int64) (map[string]any, error)
+	DiscoverMCPTools(context.Context, map[string]any) (map[string]any, error)
+
+	ListProviderKinds(context.Context) (map[string]any, error)
+	ListProviders(context.Context, map[string]any) (map[string]any, error)
+	GetProvider(context.Context, int64) (map[string]any, error)
+	CreateProvider(context.Context, map[string]any) (map[string]any, error)
+	UpdateProvider(context.Context, int64, map[string]any) (map[string]any, error)
+	DeleteProvider(context.Context, int64) error
+	DiscoverProvider(context.Context, int64) (map[string]any, error)
+	SyncProvider(context.Context, int64) (map[string]any, error)
+
+	ListModels(context.Context, map[string]any) (map[string]any, error)
+	GetModel(context.Context, int64) (map[string]any, error)
+	CreateModel(context.Context, map[string]any) (map[string]any, error)
+	UpdateModel(context.Context, int64, map[string]any) (map[string]any, error)
+	DeleteModel(context.Context, int64) error
+	ProbeModelRoute(context.Context, int64, string) (map[string]any, error)
+	UpdateModelRoute(context.Context, int64, map[string]any) (map[string]any, error)
+	DeleteModelRoute(context.Context, int64) (map[string]any, error)
+
+	InstallSkill(context.Context, SkillInstallRequest) (map[string]any, error)
+	InstallSkillArchive(context.Context, SkillArchive) (map[string]any, error)
+	ListSkillVersions(context.Context, int64) ([]map[string]any, error)
+	RollbackSkill(context.Context, int64, int) (map[string]any, error)
+	ListRuns(context.Context, map[string]any) (map[string]any, error)
+	GetRun(context.Context, string) (map[string]any, error)
+	DeleteRuns(context.Context, map[string]any) (map[string]any, error)
+}
+
+type Knowledge interface {
+	List(context.Context, map[string]any) (map[string]any, error)
+	Get(context.Context, int64) (map[string]any, error)
+	Create(context.Context, map[string]any) (map[string]any, error)
+	Update(context.Context, int64, map[string]any) (map[string]any, error)
+	Delete(context.Context, int64) error
+	ListDocuments(context.Context, int64) ([]map[string]any, error)
+	GetDocument(context.Context, int64, int64) (map[string]any, error)
+	UploadDocument(context.Context, int64, KnowledgeDocumentUpload) (map[string]any, error)
+	UpdateDocument(context.Context, int64, int64, map[string]any) (map[string]any, error)
+	DeleteDocument(context.Context, int64, int64) error
+	ReindexDocument(context.Context, int64, int64) (map[string]any, error)
+	ListChunks(context.Context, int64, map[string]any) ([]map[string]any, error)
+	UpdateChunk(context.Context, int64, int64, map[string]any) (map[string]any, error)
+	Retrieve(context.Context, int64, map[string]any) (map[string]any, error)
+	RebuildIndex(context.Context, int64) (map[string]any, error)
+}
+
+type Memory interface {
+	List(context.Context, map[string]any) (map[string]any, error)
+	Get(context.Context, int64) (map[string]any, error)
+	Create(context.Context, map[string]any) (map[string]any, error)
+	Update(context.Context, int64, map[string]any) (map[string]any, error)
+	Delete(context.Context, int64) error
+	GetConfig(context.Context) (map[string]any, error)
+	UpdateConfig(context.Context, map[string]any) (map[string]any, error)
+}
+
+func (p aiHubClient) Request(ctx context.Context, request AIRequest) (any, error) {
+	return p.call(ctx, "ai.request", request)
+}
+
+func (p aiHubClient) requestMap(ctx context.Context, method, path string, query map[string]any, body any) (map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: method, Path: path, Query: query, Body: body})
+	return mapResult(value), err
+}
+
+func (p aiHubClient) Chat(ctx context.Context, request AIChatRequest) (map[string]any, error) {
+	value, err := p.call(ctx, "aihub.chat", map[string]any{"agent_id": request.AgentID, "message": request.Message, "messages": request.Messages, "model": request.Model, "context": request.Context, "session_id": request.SessionID, "run_id": request.RunID, "kwargs": request.Options})
+	return mapResult(value), err
+}
+
+func (p aiHubClient) GenerateImage(ctx context.Context, request AIImageRequest) (map[string]any, error) {
+	value, err := p.call(ctx, "aihub.image", map[string]any{"agent_id": request.AgentID, "prompt": request.Prompt, "model": request.Model, "kwargs": request.Options})
+	return mapResult(value), err
+}
+
+func (p aiHubClient) Responses(ctx context.Context, request AIResponsesRequest) (map[string]any, error) {
+	value, err := p.call(ctx, "aihub.responses", responsesRequestBody(request))
+	return mapResult(value), err
+}
+
+func (p aiHubClient) CompactResponse(ctx context.Context, request AIResponsesRequest) (map[string]any, error) {
+	value, err := p.call(ctx, "aihub.responses.compact", responsesRequestBody(request))
+	return mapResult(value), err
+}
+
+func responsesRequestBody(request AIResponsesRequest) map[string]any {
+	body := cloneSDKMap(request.Options)
+	body["model"], body["input"] = request.Model, request.Input
+	body["stream"] = false
+	if request.Instructions != "" {
+		body["instructions"] = request.Instructions
+	}
+	if request.PreviousResponseID != "" {
+		body["previous_response_id"] = request.PreviousResponseID
+	}
+	if len(request.Tools) > 0 {
+		body["tools"] = request.Tools
+	}
+	return body
+}
+
+func (p aiHubClient) Embeddings(ctx context.Context, request AIEmbeddingRequest) (map[string]any, error) {
+	body := cloneSDKMap(request.Options)
+	body["model"], body["input"] = request.Model, request.Input
+	value, err := p.call(ctx, "aihub.embeddings", body)
+	return mapResult(value), err
+}
+
+func (p aiHubClient) Rerank(ctx context.Context, request AIRerankRequest) (map[string]any, error) {
+	body := cloneSDKMap(request.Options)
+	body["model"], body["query"], body["documents"] = request.Model, request.Query, request.Documents
+	if request.TopN > 0 {
+		body["top_n"] = request.TopN
+	}
+	body["return_documents"] = request.ReturnDocuments
+	value, err := p.call(ctx, "aihub.rerank", body)
+	return mapResult(value), err
+}
+
+func (p aiHubClient) TextToSpeech(ctx context.Context, request AITTSRequest) (AIAudioResponse, error) {
+	body := cloneSDKMap(request.Options)
+	body["model"], body["input"], body["voice"] = request.Model, request.Input, request.Voice
+	body["instructions"], body["response_format"] = request.Instructions, request.ResponseFormat
+	body["optimize_text_preview"] = request.OptimizeTextPreview
+	value, err := p.call(ctx, "aihub.tts", body)
+	if err != nil {
+		return AIAudioResponse{}, err
+	}
+	result := mapResult(value)
+	content, err := base64.StdEncoding.DecodeString(fmt.Sprint(result["audio_base64"]))
+	if err != nil {
+		return AIAudioResponse{}, fmt.Errorf("decode TTS audio: %w", err)
+	}
+	return AIAudioResponse{Content: content, MIMEType: fmt.Sprint(result["mime_type"])}, nil
+}
+
+func (p aiHubClient) Transcribe(ctx context.Context, request AITranscriptionRequest) (map[string]any, error) {
+	body := cloneSDKMap(request.Options)
+	body["model"], body["audio_base64"], body["audio_mime_type"] = request.Model, base64.StdEncoding.EncodeToString(request.Content), request.MIMEType
+	body["language"], body["response_format"] = request.Language, request.ResponseFormat
+	value, err := p.call(ctx, "aihub.transcribe", body)
+	return mapResult(value), err
+}
+
+func (p aiHubClient) ListCallableAgents(ctx context.Context) ([]map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: http.MethodGet, Path: "/api/agents"})
+	return mapSlice(value), err
+}
+func (p aiHubClient) AgentSelectableModels(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, idPath("/api/agents", id)+"/selectable-models", nil, nil)
+}
+func (p aiHubClient) PreviewAgentChat(ctx context.Context, id int64, request AIChatRequest) (map[string]any, error) {
+	body := cloneSDKMap(request.Options)
+	body["message"], body["messages"], body["model"], body["context"] = request.Message, request.Messages, request.Model, request.Context
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/agents", id)+"/preview-chat", nil, body)
+}
+func (p aiHubClient) ListAssetTypes(ctx context.Context) ([]map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: http.MethodGet, Path: "/api/aihub/types"})
+	return mapSlice(value), err
+}
+func (p aiHubClient) ListAssets(ctx context.Context, query map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/aihub", query, nil)
+}
+func (p aiHubClient) GetAsset(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, idPath("/api/aihub", id), nil, nil)
+}
+func (p aiHubClient) CreateAsset(ctx context.Context, data map[string]any) ([]map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: http.MethodPost, Path: "/api/aihub", Body: data})
+	return mapSlice(value), err
+}
+func (p aiHubClient) UpdateAsset(ctx context.Context, id int64, data map[string]any) ([]map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: http.MethodPut, Path: idPath("/api/aihub", id), Body: data})
+	return mapSlice(value), err
+}
+func (p aiHubClient) UpdateAssets(ctx context.Context, data []map[string]any) ([]map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: http.MethodPatch, Path: "/api/aihub/batch", Body: data})
+	return mapSlice(value), err
+}
+func (p aiHubClient) DeleteAsset(ctx context.Context, id int64, force bool) error {
+	_, err := p.Request(ctx, AIRequest{Method: http.MethodDelete, Path: idPath("/api/aihub", id), Query: map[string]any{"force": force}})
+	return err
+}
+func (p aiHubClient) AgentReadiness(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, idPath("/api/aihub", id)+"/readiness", nil, nil)
+}
+func (p aiHubClient) PublishAgent(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/aihub", id)+"/publish", nil, nil)
+}
+func (p aiHubClient) DiscoverMCPTools(ctx context.Context, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, "/api/aihub/mcp/discover-tools", nil, data)
+}
+
+func (p aiHubClient) ListProviderKinds(ctx context.Context) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/aihub/provider-kinds", nil, nil)
+}
+func (p aiHubClient) ListProviders(ctx context.Context, query map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/aihub/providers", query, nil)
+}
+func (p aiHubClient) GetProvider(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, idPath("/api/aihub/providers", id), nil, nil)
+}
+func (p aiHubClient) CreateProvider(ctx context.Context, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, "/api/aihub/providers", nil, data)
+}
+func (p aiHubClient) UpdateProvider(ctx context.Context, id int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, idPath("/api/aihub/providers", id), nil, data)
+}
+func (p aiHubClient) DeleteProvider(ctx context.Context, id int64) error {
+	_, err := p.Request(ctx, AIRequest{Method: http.MethodDelete, Path: idPath("/api/aihub/providers", id)})
+	return err
+}
+func (p aiHubClient) DiscoverProvider(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/aihub/providers", id)+"/discover", nil, nil)
+}
+func (p aiHubClient) SyncProvider(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/aihub/providers", id)+"/sync", nil, nil)
+}
+func (p aiHubClient) ListModels(ctx context.Context, query map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/aihub/models", query, nil)
+}
+func (p aiHubClient) GetModel(ctx context.Context, id int64) (map[string]any, error) {
+	result, err := p.ListModels(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	for _, model := range mapSlice(result["items"]) {
+		if int64(asInt(model["id"])) == id {
+			return model, nil
+		}
+	}
+	return nil, fmt.Errorf("AI model %d was not found", id)
+}
+func (p aiHubClient) CreateModel(ctx context.Context, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, "/api/aihub/models/manual", nil, data)
+}
+func (p aiHubClient) UpdateModel(ctx context.Context, id int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, idPath("/api/aihub/models", id), nil, data)
+}
+func (p aiHubClient) DeleteModel(ctx context.Context, id int64) error {
+	_, err := p.Request(ctx, AIRequest{Method: http.MethodDelete, Path: idPath("/api/aihub/models", id)})
+	return err
+}
+func (p aiHubClient) ProbeModelRoute(ctx context.Context, id int64, task string) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/aihub/model-routes", id)+"/probe", nil, map[string]any{"task": task})
+}
+func (p aiHubClient) UpdateModelRoute(ctx context.Context, id int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, idPath("/api/aihub/model-routes", id), nil, data)
+}
+func (p aiHubClient) DeleteModelRoute(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodDelete, idPath("/api/aihub/model-routes", id), nil, nil)
+}
+func (p aiHubClient) InstallSkill(ctx context.Context, request SkillInstallRequest) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, "/api/skills/install", nil, map[string]any{"source": "github", "repo": request.Repository, "ref": request.Ref})
+}
+func (p aiHubClient) InstallSkillArchive(ctx context.Context, archive SkillArchive) (map[string]any, error) {
+	value, err := p.call(ctx, "ai.skill.install_archive", map[string]any{"filename": archive.Filename, "content_base64": base64.StdEncoding.EncodeToString(archive.Content)})
+	return mapResult(value), err
+}
+func (p aiHubClient) ListSkillVersions(ctx context.Context, id int64) ([]map[string]any, error) {
+	value, err := p.Request(ctx, AIRequest{Method: http.MethodGet, Path: idPath("/api/skills", id) + "/versions"})
+	return mapSlice(value), err
+}
+func (p aiHubClient) RollbackSkill(ctx context.Context, id int64, version int) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/skills", id)+"/rollback", nil, map[string]any{"version": version})
+}
+func (p aiHubClient) ListRuns(ctx context.Context, query map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/aihub/runs", query, nil)
+}
+func (p aiHubClient) GetRun(ctx context.Context, traceID string) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/aihub/runs/"+traceID, nil, nil)
+}
+func (p aiHubClient) DeleteRuns(ctx context.Context, query map[string]any) (map[string]any, error) {
+	query = cloneSDKMap(query)
+	switch values := query["trace_ids"].(type) {
+	case []string:
+		query["trace_ids"] = strings.Join(values, ",")
+	case []any:
+		items := make([]string, 0, len(values))
+		for _, value := range values {
+			items = append(items, fmt.Sprint(value))
+		}
+		query["trace_ids"] = strings.Join(items, ",")
+	}
+	return p.requestMap(ctx, http.MethodDelete, "/api/aihub/runs", query, nil)
+}
+
+func (p knowledgeClient) requestMap(ctx context.Context, method, path string, query map[string]any, body any) (map[string]any, error) {
+	value, err := p.call(ctx, "ai.request", AIRequest{Method: method, Path: path, Query: query, Body: body})
+	return mapResult(value), err
+}
+func (p knowledgeClient) requestSlice(ctx context.Context, method, path string, query map[string]any) ([]map[string]any, error) {
+	value, err := p.call(ctx, "ai.request", AIRequest{Method: method, Path: path, Query: query})
+	if object := mapResult(value); object != nil {
+		value = object["items"]
+	}
+	return mapSlice(value), err
+}
+func (p knowledgeClient) List(ctx context.Context, query map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/knowledge-bases", query, nil)
+}
+func (p knowledgeClient) Get(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, idPath("/api/knowledge-bases", id), nil, nil)
+}
+func (p knowledgeClient) Create(ctx context.Context, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, "/api/knowledge-bases", nil, data)
+}
+func (p knowledgeClient) Update(ctx context.Context, id int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, idPath("/api/knowledge-bases", id), nil, data)
+}
+func (p knowledgeClient) Delete(ctx context.Context, id int64) error {
+	_, err := p.call(ctx, "ai.request", AIRequest{Method: http.MethodDelete, Path: idPath("/api/knowledge-bases", id)})
+	return err
+}
+func (p knowledgeClient) ListDocuments(ctx context.Context, baseID int64) ([]map[string]any, error) {
+	return p.requestSlice(ctx, http.MethodGet, idPath("/api/knowledge-bases", baseID)+"/documents", nil)
+}
+func (p knowledgeClient) GetDocument(ctx context.Context, baseID, documentID int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, nestedIDPath("/api/knowledge-bases", baseID, "documents", documentID), nil, nil)
+}
+func (p knowledgeClient) UploadDocument(ctx context.Context, baseID int64, upload KnowledgeDocumentUpload) (map[string]any, error) {
+	value, err := p.call(ctx, "ai.knowledge.upload", map[string]any{"base_id": baseID, "filename": upload.Filename, "mime_type": upload.MIMEType, "content_base64": base64.StdEncoding.EncodeToString(upload.Content), "metadata": upload.Metadata, "auto_tag": upload.AutoTag, "tagging_model_id": upload.TaggingModelID})
+	return mapResult(value), err
+}
+func (p knowledgeClient) UpdateDocument(ctx context.Context, baseID, documentID int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, nestedIDPath("/api/knowledge-bases", baseID, "documents", documentID), nil, data)
+}
+func (p knowledgeClient) DeleteDocument(ctx context.Context, baseID, documentID int64) error {
+	_, err := p.call(ctx, "ai.request", AIRequest{Method: http.MethodDelete, Path: nestedIDPath("/api/knowledge-bases", baseID, "documents", documentID)})
+	return err
+}
+func (p knowledgeClient) ReindexDocument(ctx context.Context, baseID, documentID int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, nestedIDPath("/api/knowledge-bases", baseID, "documents", documentID)+"/reindex", nil, nil)
+}
+func (p knowledgeClient) ListChunks(ctx context.Context, baseID int64, query map[string]any) ([]map[string]any, error) {
+	return p.requestSlice(ctx, http.MethodGet, idPath("/api/knowledge-bases", baseID)+"/chunks", query)
+}
+func (p knowledgeClient) UpdateChunk(ctx context.Context, baseID, chunkID int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, nestedIDPath("/api/knowledge-bases", baseID, "chunks", chunkID), nil, data)
+}
+func (p knowledgeClient) Retrieve(ctx context.Context, baseID int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/knowledge-bases", baseID)+"/retrieve", nil, data)
+}
+func (p knowledgeClient) RebuildIndex(ctx context.Context, baseID int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, idPath("/api/knowledge-bases", baseID)+"/rebuild-index", nil, nil)
+}
+
+func (p memoryClient) requestMap(ctx context.Context, method, path string, query map[string]any, body any) (map[string]any, error) {
+	value, err := p.call(ctx, "ai.request", AIRequest{Method: method, Path: path, Query: query, Body: body})
+	return mapResult(value), err
+}
+func (p memoryClient) List(ctx context.Context, query map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/memories", query, nil)
+}
+func (p memoryClient) Get(ctx context.Context, id int64) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, idPath("/api/memories", id), nil, nil)
+}
+func (p memoryClient) Create(ctx context.Context, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPost, "/api/memories", nil, data)
+}
+func (p memoryClient) Update(ctx context.Context, id int64, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, idPath("/api/memories", id), nil, data)
+}
+func (p memoryClient) Delete(ctx context.Context, id int64) error {
+	_, err := p.call(ctx, "ai.request", AIRequest{Method: http.MethodDelete, Path: idPath("/api/memories", id)})
+	return err
+}
+func (p memoryClient) GetConfig(ctx context.Context) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodGet, "/api/memories/config", nil, nil)
+}
+func (p memoryClient) UpdateConfig(ctx context.Context, data map[string]any) (map[string]any, error) {
+	return p.requestMap(ctx, http.MethodPatch, "/api/memories/config", nil, data)
+}
+
+func cloneSDKMap(value map[string]any) map[string]any {
+	result := make(map[string]any, len(value)+2)
+	for key, item := range value {
+		result[key] = item
+	}
+	return result
+}
+func idPath(base string, id int64) string {
+	return strings.TrimRight(base, "/") + "/" + strconv.FormatInt(id, 10)
+}
+func nestedIDPath(base string, parentID int64, collection string, id int64) string {
+	return fmt.Sprintf("%s/%d/%s/%d", strings.TrimRight(base, "/"), parentID, collection, id)
+}

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

@@ -0,0 +1,156 @@
+package sdk
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"testing"
+)
+
+type recordingClient struct {
+	op   string
+	args map[string]any
+}
+
+func (client *recordingClient) Call(_ context.Context, operation string, args any) (any, error) {
+	client.op = operation
+	raw, _ := json.Marshal(args)
+	_ = json.Unmarshal(raw, &client.args)
+	switch operation {
+	case "aihub.tts":
+		return map[string]any{"audio_base64": base64.StdEncoding.EncodeToString([]byte("audio")), "mime_type": "audio/wav"}, nil
+	case "aihub.transcribe":
+		return map[string]any{"text": "hello"}, nil
+	case "ai.request":
+		path, _ := client.args["path"].(string)
+		if path == "/api/knowledge-bases/7/documents" {
+			return map[string]any{"items": []any{map[string]any{"id": float64(3)}}}, nil
+		}
+		return map[string]any{"ok": true}, nil
+	default:
+		return map[string]any{"ok": true}, nil
+	}
+}
+
+func TestAIHubInferenceOperations(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+
+	if _, err := draftgo.AIHub.Chat(draftgo.Context(), AIChatRequest{AgentID: 12, Message: "hello", SessionID: "session-1", RunID: "run-1"}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "aihub.chat" || client.args["agent_id"] != float64(12) {
+		t.Fatalf("unexpected chat call: %s %#v", client.op, client.args)
+	}
+	if client.args["session_id"] != "session-1" || client.args["run_id"] != "run-1" {
+		t.Fatalf("chat session metadata missing: %#v", client.args)
+	}
+
+	if _, err := draftgo.AIHub.Responses(draftgo.Context(), AIResponsesRequest{
+		Model: "responses", Input: "hello", Instructions: "be concise", PreviousResponseID: "resp_previous",
+		Tools: []map[string]any{{"type": "web_search"}}, Options: map[string]any{"reasoning": map[string]any{"effort": "high"}, "stream": true},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "aihub.responses" || client.args["model"] != "responses" || client.args["stream"] != false || client.args["previous_response_id"] != "resp_previous" || client.args["reasoning"] == nil {
+		t.Fatalf("unexpected Responses call: %s %#v", client.op, client.args)
+	}
+	if _, err := draftgo.AIHub.CompactResponse(draftgo.Context(), AIResponsesRequest{Model: "responses", Input: []any{"one"}}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "aihub.responses.compact" || client.args["stream"] != false {
+		t.Fatalf("unexpected compact Responses call: %s %#v", client.op, client.args)
+	}
+
+	if _, err := draftgo.AIHub.Embeddings(draftgo.Context(), AIEmbeddingRequest{Model: "embed", Input: []string{"one"}}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "aihub.embeddings" || client.args["model"] != "embed" {
+		t.Fatalf("unexpected embeddings call: %s %#v", client.op, client.args)
+	}
+
+	if _, err := draftgo.AIHub.Rerank(draftgo.Context(), AIRerankRequest{Model: "rerank", Query: "query", Documents: []string{"one", "two"}, TopN: 1, ReturnDocuments: true}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "aihub.rerank" || client.args["model"] != "rerank" || client.args["top_n"] != float64(1) || client.args["return_documents"] != true {
+		t.Fatalf("unexpected rerank call: %s %#v", client.op, client.args)
+	}
+
+	audio, err := draftgo.AIHub.TextToSpeech(draftgo.Context(), AITTSRequest{Model: "tts", Input: "hello", Voice: "Mia"})
+	if err != nil || string(audio.Content) != "audio" || audio.MIMEType != "audio/wav" {
+		t.Fatalf("unexpected TTS result: %+v %v", audio, err)
+	}
+	if client.op != "aihub.tts" || client.args["model"] != "tts" {
+		t.Fatalf("unexpected TTS call: %s %#v", client.op, client.args)
+	}
+	transcript, err := draftgo.AIHub.Transcribe(draftgo.Context(), AITranscriptionRequest{Model: "asr", Content: []byte("audio"), MIMEType: "audio/wav", Language: "zh"})
+	if err != nil || transcript["text"] != "hello" {
+		t.Fatalf("unexpected ASR result: %#v %v", transcript, err)
+	}
+	if client.op != "aihub.transcribe" || client.args["audio_base64"] != base64.StdEncoding.EncodeToString([]byte("audio")) {
+		t.Fatalf("unexpected ASR call: %s %#v", client.op, client.args)
+	}
+}
+
+func TestAIHubChatUsesCanonicalRPCOperationAndLogicalModel(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+
+	result, err := draftgo.AIHub.Chat(draftgo.Context(), AIChatRequest{
+		Model:    "shared-logical-model",
+		Messages: []map[string]any{{"role": "user", "content": "hello"}},
+		Options:  map[string]any{"temperature": 0.2},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result == nil || client.op != "aihub.chat" {
+		t.Fatalf("result=%#v operation=%q", result, client.op)
+	}
+	if client.args["model"] != "shared-logical-model" || client.args["agent_id"] != float64(0) {
+		t.Fatalf("canonical chat target = %#v", client.args)
+	}
+	kwargs, _ := client.args["kwargs"].(map[string]any)
+	if kwargs["temperature"] != float64(0.2) {
+		t.Fatalf("chat options = %#v", kwargs)
+	}
+}
+
+func TestAdminAIRequestCarriesElevationMarker(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+	if _, err := draftgo.Admin.AIHub.ListModels(draftgo.Context(), map[string]any{"provider_id": 4}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "ai.request" || client.args["__draftgo_admin"] != true {
+		t.Fatalf("admin marker missing: %s %#v", client.op, client.args)
+	}
+	if client.args["path"] != "/api/aihub/models" {
+		t.Fatalf("unexpected path: %#v", client.args["path"])
+	}
+}
+
+func TestKnowledgeAndArchiveEncoding(t *testing.T) {
+	client := &recordingClient{}
+	draftgo := NewContext(context.Background(), nil, nil, nil, client)
+
+	documents, err := draftgo.Knowledge.ListDocuments(draftgo.Context(), 7)
+	if err != nil || len(documents) != 1 || documents[0]["id"] != float64(3) {
+		t.Fatalf("unexpected documents: %#v, %v", documents, err)
+	}
+
+	content := []byte{0, 1, 2, 255}
+	if _, err = draftgo.Knowledge.UploadDocument(draftgo.Context(), 7, KnowledgeDocumentUpload{Filename: "data.pdf", Content: content}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "ai.knowledge.upload" || client.args["content_base64"] != base64.StdEncoding.EncodeToString(content) {
+		t.Fatalf("document encoding mismatch: %s %#v", client.op, client.args)
+	}
+
+	if _, err = draftgo.AIHub.InstallSkillArchive(draftgo.Context(), SkillArchive{Filename: "skill.zip", Content: content}); err != nil {
+		t.Fatal(err)
+	}
+	if client.op != "ai.skill.install_archive" || client.args["content_base64"] != base64.StdEncoding.EncodeToString(content) {
+		t.Fatalf("archive encoding mismatch: %s %#v", client.op, client.args)
+	}
+}