603 lines
22 KiB
Go
603 lines
22 KiB
Go
// SPDX-License-Identifier: EUPL-1.2
|
|
|
|
package agentic
|
|
|
|
import (
|
|
"context"
|
|
|
|
core "dappco.re/go/core"
|
|
"github.com/modelcontextprotocol/go-sdk/mcp"
|
|
)
|
|
|
|
// result := agentic.ContentResult{Provider: "claude", Model: "claude-3.7-sonnet", Content: "Draft ready"}
|
|
type ContentResult struct {
|
|
ID string `json:"id,omitempty"`
|
|
BatchID string `json:"batch_id,omitempty"`
|
|
Prompt string `json:"prompt,omitempty"`
|
|
Provider string `json:"provider,omitempty"`
|
|
Model string `json:"model,omitempty"`
|
|
Content string `json:"content,omitempty"`
|
|
Status string `json:"status,omitempty"`
|
|
InputTokens int `json:"input_tokens,omitempty"`
|
|
OutputTokens int `json:"output_tokens,omitempty"`
|
|
DurationMS int `json:"duration_ms,omitempty"`
|
|
StopReason string `json:"stop_reason,omitempty"`
|
|
Metadata map[string]any `json:"metadata,omitempty"`
|
|
Raw map[string]any `json:"raw,omitempty"`
|
|
}
|
|
|
|
// brief := agentic.ContentBrief{ID: "brief_1", Slug: "host-link", Title: "LinkHost", Category: "product"}
|
|
type ContentBrief struct {
|
|
ID string `json:"id,omitempty"`
|
|
Slug string `json:"slug,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
Title string `json:"title,omitempty"`
|
|
Product string `json:"product,omitempty"`
|
|
Category string `json:"category,omitempty"`
|
|
Brief string `json:"brief,omitempty"`
|
|
Summary string `json:"summary,omitempty"`
|
|
Metadata map[string]any `json:"metadata,omitempty"`
|
|
CreatedAt string `json:"created_at,omitempty"`
|
|
UpdatedAt string `json:"updated_at,omitempty"`
|
|
}
|
|
|
|
// input := agentic.ContentGenerateInput{
|
|
// BriefID: "brief_1",
|
|
// Template: "help-article",
|
|
// Provider: "claude",
|
|
// }
|
|
type ContentGenerateInput struct {
|
|
Prompt string `json:"prompt,omitempty"`
|
|
BriefID string `json:"brief_id,omitempty"`
|
|
Template string `json:"template,omitempty"`
|
|
Provider string `json:"provider,omitempty"`
|
|
Config map[string]any `json:"config,omitempty"`
|
|
}
|
|
|
|
// input := agentic.ContentBatchGenerateInput{BatchID: "batch_123", Provider: "gemini"}
|
|
type ContentBatchGenerateInput struct {
|
|
BatchID string `json:"batch_id"`
|
|
Provider string `json:"provider,omitempty"`
|
|
DryRun bool `json:"dry_run,omitempty"`
|
|
}
|
|
|
|
// input := agentic.ContentBriefCreateInput{Title: "LinkHost brief", Product: "LinkHost"}
|
|
type ContentBriefCreateInput struct {
|
|
Title string `json:"title,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
Slug string `json:"slug,omitempty"`
|
|
Product string `json:"product,omitempty"`
|
|
Category string `json:"category,omitempty"`
|
|
Brief string `json:"brief,omitempty"`
|
|
Summary string `json:"summary,omitempty"`
|
|
Metadata map[string]any `json:"metadata,omitempty"`
|
|
Context map[string]any `json:"context,omitempty"`
|
|
Payload map[string]any `json:"payload,omitempty"`
|
|
}
|
|
|
|
// input := agentic.ContentBriefGetInput{BriefID: "host-link"}
|
|
type ContentBriefGetInput struct {
|
|
BriefID string `json:"brief_id"`
|
|
}
|
|
|
|
// input := agentic.ContentBriefListInput{Category: "product", Limit: 10}
|
|
type ContentBriefListInput struct {
|
|
Category string `json:"category,omitempty"`
|
|
Product string `json:"product,omitempty"`
|
|
Limit int `json:"limit,omitempty"`
|
|
}
|
|
|
|
// input := agentic.ContentStatusInput{BatchID: "batch_123"}
|
|
type ContentStatusInput struct {
|
|
BatchID string `json:"batch_id"`
|
|
}
|
|
|
|
// input := agentic.ContentUsageStatsInput{Provider: "claude", Period: "week"}
|
|
type ContentUsageStatsInput struct {
|
|
Provider string `json:"provider,omitempty"`
|
|
Period string `json:"period,omitempty"`
|
|
Since string `json:"since,omitempty"`
|
|
Until string `json:"until,omitempty"`
|
|
}
|
|
|
|
// input := agentic.ContentFromPlanInput{PlanSlug: "release-notes", Provider: "openai"}
|
|
type ContentFromPlanInput struct {
|
|
PlanSlug string `json:"plan_slug"`
|
|
Provider string `json:"provider,omitempty"`
|
|
Prompt string `json:"prompt,omitempty"`
|
|
Template string `json:"template,omitempty"`
|
|
Config map[string]any `json:"config,omitempty"`
|
|
Payload map[string]any `json:"payload,omitempty"`
|
|
}
|
|
|
|
// out := agentic.ContentGenerateOutput{Success: true, Result: agentic.ContentResult{Provider: "claude"}}
|
|
type ContentGenerateOutput struct {
|
|
Success bool `json:"success"`
|
|
Result ContentResult `json:"result"`
|
|
}
|
|
|
|
// out := agentic.ContentBatchOutput{Success: true, Batch: map[string]any{"batch_id": "batch_123"}}
|
|
type ContentBatchOutput struct {
|
|
Success bool `json:"success"`
|
|
Batch map[string]any `json:"batch"`
|
|
}
|
|
|
|
// out := agentic.ContentBriefOutput{Success: true, Brief: agentic.ContentBrief{Slug: "host-link"}}
|
|
type ContentBriefOutput struct {
|
|
Success bool `json:"success"`
|
|
Brief ContentBrief `json:"brief"`
|
|
}
|
|
|
|
// out := agentic.ContentBriefListOutput{Success: true, Total: 1, Briefs: []agentic.ContentBrief{{Slug: "host-link"}}}
|
|
type ContentBriefListOutput struct {
|
|
Success bool `json:"success"`
|
|
Total int `json:"total"`
|
|
Briefs []ContentBrief `json:"briefs"`
|
|
}
|
|
|
|
// out := agentic.ContentStatusOutput{Success: true, Status: map[string]any{"status": "running"}}
|
|
type ContentStatusOutput struct {
|
|
Success bool `json:"success"`
|
|
Status map[string]any `json:"status"`
|
|
}
|
|
|
|
// out := agentic.ContentUsageStatsOutput{Success: true, Usage: map[string]any{"calls": 4}}
|
|
type ContentUsageStatsOutput struct {
|
|
Success bool `json:"success"`
|
|
Usage map[string]any `json:"usage"`
|
|
}
|
|
|
|
// out := agentic.ContentFromPlanOutput{Success: true, Result: agentic.ContentResult{BatchID: "batch_123"}}
|
|
type ContentFromPlanOutput struct {
|
|
Success bool `json:"success"`
|
|
Result ContentResult `json:"result"`
|
|
}
|
|
|
|
// result := c.Action("content.generate").Run(ctx, core.NewOptions(core.Option{Key: "prompt", Value: "Draft a release note"}))
|
|
func (s *PrepSubsystem) handleContentGenerate(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentGenerate(ctx, nil, ContentGenerateInput{
|
|
Prompt: optionStringValue(options, "prompt"),
|
|
BriefID: optionStringValue(options, "brief_id", "brief-id"),
|
|
Template: optionStringValue(options, "template"),
|
|
Provider: optionStringValue(options, "provider"),
|
|
Config: optionAnyMapValue(options, "config"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.batch.generate").Run(ctx, core.NewOptions(core.Option{Key: "batch_id", Value: "batch_123"}))
|
|
func (s *PrepSubsystem) handleContentBatchGenerate(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentBatchGenerate(ctx, nil, ContentBatchGenerateInput{
|
|
BatchID: optionStringValue(options, "batch_id", "batch-id", "_arg"),
|
|
Provider: optionStringValue(options, "provider"),
|
|
DryRun: optionBoolValue(options, "dry_run", "dry-run"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.brief.create").Run(ctx, core.NewOptions(core.Option{Key: "title", Value: "LinkHost brief"}))
|
|
func (s *PrepSubsystem) handleContentBriefCreate(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentBriefCreate(ctx, nil, ContentBriefCreateInput{
|
|
Title: optionStringValue(options, "title"),
|
|
Name: optionStringValue(options, "name"),
|
|
Slug: optionStringValue(options, "slug"),
|
|
Product: optionStringValue(options, "product"),
|
|
Category: optionStringValue(options, "category"),
|
|
Brief: optionStringValue(options, "brief"),
|
|
Summary: optionStringValue(options, "summary"),
|
|
Metadata: optionAnyMapValue(options, "metadata"),
|
|
Context: optionAnyMapValue(options, "context"),
|
|
Payload: optionAnyMapValue(options, "payload"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.brief.get").Run(ctx, core.NewOptions(core.Option{Key: "brief_id", Value: "host-link"}))
|
|
func (s *PrepSubsystem) handleContentBriefGet(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentBriefGet(ctx, nil, ContentBriefGetInput{
|
|
BriefID: optionStringValue(options, "brief_id", "brief-id", "id", "slug", "_arg"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.brief.list").Run(ctx, core.NewOptions(core.Option{Key: "category", Value: "product"}))
|
|
func (s *PrepSubsystem) handleContentBriefList(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentBriefList(ctx, nil, ContentBriefListInput{
|
|
Category: optionStringValue(options, "category"),
|
|
Product: optionStringValue(options, "product"),
|
|
Limit: optionIntValue(options, "limit"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.status").Run(ctx, core.NewOptions(core.Option{Key: "batch_id", Value: "batch_123"}))
|
|
func (s *PrepSubsystem) handleContentStatus(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentStatus(ctx, nil, ContentStatusInput{
|
|
BatchID: optionStringValue(options, "batch_id", "batch-id", "_arg"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.usage.stats").Run(ctx, core.NewOptions(core.Option{Key: "provider", Value: "claude"}))
|
|
func (s *PrepSubsystem) handleContentUsageStats(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentUsageStats(ctx, nil, ContentUsageStatsInput{
|
|
Provider: optionStringValue(options, "provider"),
|
|
Period: optionStringValue(options, "period"),
|
|
Since: optionStringValue(options, "since"),
|
|
Until: optionStringValue(options, "until"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Action("content.from.plan").Run(ctx, core.NewOptions(core.Option{Key: "plan_slug", Value: "release-notes"}))
|
|
func (s *PrepSubsystem) handleContentFromPlan(ctx context.Context, options core.Options) core.Result {
|
|
_, output, err := s.contentFromPlan(ctx, nil, ContentFromPlanInput{
|
|
PlanSlug: optionStringValue(options, "plan_slug", "plan", "slug", "_arg"),
|
|
Provider: optionStringValue(options, "provider"),
|
|
Prompt: optionStringValue(options, "prompt"),
|
|
Template: optionStringValue(options, "template"),
|
|
Config: optionAnyMapValue(options, "config"),
|
|
Payload: optionAnyMapValue(options, "payload"),
|
|
})
|
|
if err != nil {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) registerContentTools(server *mcp.Server) {
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_generate",
|
|
Description: "Generate content from a prompt or a brief/template pair using the platform AI provider abstraction.",
|
|
}, s.contentGenerate)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_batch_generate",
|
|
Description: "Generate content for a stored batch specification.",
|
|
}, s.contentBatchGenerate)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_batch",
|
|
Description: "Generate content for a stored batch specification using the legacy MCP alias.",
|
|
}, s.contentBatchGenerate)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_brief_create",
|
|
Description: "Create a reusable content brief for later generation work.",
|
|
}, s.contentBriefCreate)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_brief_get",
|
|
Description: "Read a reusable content brief by ID or slug.",
|
|
}, s.contentBriefGet)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_brief_list",
|
|
Description: "List reusable content briefs with optional category and product filters.",
|
|
}, s.contentBriefList)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_status",
|
|
Description: "Read batch content generation status by batch ID.",
|
|
}, s.contentStatus)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_usage_stats",
|
|
Description: "Read AI usage statistics for the content pipeline.",
|
|
}, s.contentUsageStats)
|
|
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "content_from_plan",
|
|
Description: "Generate content using stored plan context and an optional provider override.",
|
|
}, s.contentFromPlan)
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentGenerate(ctx context.Context, _ *mcp.CallToolRequest, input ContentGenerateInput) (*mcp.CallToolResult, ContentGenerateOutput, error) {
|
|
hasPrompt := core.Trim(input.Prompt) != ""
|
|
hasBrief := core.Trim(input.BriefID) != ""
|
|
hasTemplate := core.Trim(input.Template) != ""
|
|
if !hasPrompt && !(hasBrief && hasTemplate) {
|
|
return nil, ContentGenerateOutput{}, core.E("contentGenerate", "prompt or brief_id plus template is required", nil)
|
|
}
|
|
|
|
body := map[string]any{}
|
|
if hasPrompt {
|
|
body["prompt"] = input.Prompt
|
|
}
|
|
if input.BriefID != "" {
|
|
body["brief_id"] = input.BriefID
|
|
}
|
|
if input.Template != "" {
|
|
body["template"] = input.Template
|
|
}
|
|
if input.Provider != "" {
|
|
body["provider"] = input.Provider
|
|
}
|
|
if len(input.Config) > 0 {
|
|
body["config"] = input.Config
|
|
}
|
|
|
|
result := s.platformPayload(ctx, "content.generate", "POST", "/v1/content/generate", body)
|
|
if !result.OK {
|
|
return nil, ContentGenerateOutput{}, resultErrorValue("content.generate", result)
|
|
}
|
|
|
|
return nil, ContentGenerateOutput{
|
|
Success: true,
|
|
Result: parseContentResult(payloadResourceMap(result.Value.(map[string]any), "result", "content", "generation")),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentBatchGenerate(ctx context.Context, _ *mcp.CallToolRequest, input ContentBatchGenerateInput) (*mcp.CallToolResult, ContentBatchOutput, error) {
|
|
if core.Trim(input.BatchID) == "" {
|
|
return nil, ContentBatchOutput{}, core.E("contentBatchGenerate", "batch_id is required", nil)
|
|
}
|
|
|
|
body := map[string]any{
|
|
"batch_id": input.BatchID,
|
|
}
|
|
if input.Provider != "" {
|
|
body["provider"] = input.Provider
|
|
}
|
|
if input.DryRun {
|
|
body["dry_run"] = true
|
|
}
|
|
|
|
result := s.platformPayload(ctx, "content.batch.generate", "POST", "/v1/content/batch/generate", body)
|
|
if !result.OK {
|
|
return nil, ContentBatchOutput{}, resultErrorValue("content.batch.generate", result)
|
|
}
|
|
|
|
return nil, ContentBatchOutput{
|
|
Success: true,
|
|
Batch: payloadResourceMap(result.Value.(map[string]any), "batch", "result", "status"),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentBriefCreate(ctx context.Context, _ *mcp.CallToolRequest, input ContentBriefCreateInput) (*mcp.CallToolResult, ContentBriefOutput, error) {
|
|
body := map[string]any{}
|
|
if input.Title != "" {
|
|
body["title"] = input.Title
|
|
}
|
|
if input.Name != "" {
|
|
body["name"] = input.Name
|
|
}
|
|
if input.Slug != "" {
|
|
body["slug"] = input.Slug
|
|
}
|
|
if input.Product != "" {
|
|
body["product"] = input.Product
|
|
}
|
|
if input.Category != "" {
|
|
body["category"] = input.Category
|
|
}
|
|
if input.Brief != "" {
|
|
body["brief"] = input.Brief
|
|
}
|
|
if input.Summary != "" {
|
|
body["summary"] = input.Summary
|
|
}
|
|
if len(input.Metadata) > 0 {
|
|
body["metadata"] = input.Metadata
|
|
}
|
|
if len(input.Context) > 0 {
|
|
body["context"] = input.Context
|
|
}
|
|
body = mergeContentPayload(body, input.Payload)
|
|
if len(body) == 0 {
|
|
return nil, ContentBriefOutput{}, core.E("contentBriefCreate", "content brief data is required", nil)
|
|
}
|
|
|
|
result := s.platformPayload(ctx, "content.brief.create", "POST", "/v1/content/briefs", body)
|
|
if !result.OK {
|
|
return nil, ContentBriefOutput{}, resultErrorValue("content.brief.create", result)
|
|
}
|
|
|
|
return nil, ContentBriefOutput{
|
|
Success: true,
|
|
Brief: parseContentBrief(payloadResourceMap(result.Value.(map[string]any), "brief", "item")),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentBriefGet(ctx context.Context, _ *mcp.CallToolRequest, input ContentBriefGetInput) (*mcp.CallToolResult, ContentBriefOutput, error) {
|
|
if core.Trim(input.BriefID) == "" {
|
|
return nil, ContentBriefOutput{}, core.E("contentBriefGet", "brief_id is required", nil)
|
|
}
|
|
|
|
result := s.platformPayload(ctx, "content.brief.get", "GET", core.Concat("/v1/content/briefs/", input.BriefID), nil)
|
|
if !result.OK {
|
|
return nil, ContentBriefOutput{}, resultErrorValue("content.brief.get", result)
|
|
}
|
|
|
|
return nil, ContentBriefOutput{
|
|
Success: true,
|
|
Brief: parseContentBrief(payloadResourceMap(result.Value.(map[string]any), "brief", "item")),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentBriefList(ctx context.Context, _ *mcp.CallToolRequest, input ContentBriefListInput) (*mcp.CallToolResult, ContentBriefListOutput, error) {
|
|
path := "/v1/content/briefs"
|
|
path = appendQueryParam(path, "category", input.Category)
|
|
path = appendQueryParam(path, "product", input.Product)
|
|
if input.Limit > 0 {
|
|
path = appendQueryParam(path, "limit", core.Sprint(input.Limit))
|
|
}
|
|
|
|
result := s.platformPayload(ctx, "content.brief.list", "GET", path, nil)
|
|
if !result.OK {
|
|
return nil, ContentBriefListOutput{}, resultErrorValue("content.brief.list", result)
|
|
}
|
|
|
|
return nil, parseContentBriefListOutput(result.Value.(map[string]any)), nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentStatus(ctx context.Context, _ *mcp.CallToolRequest, input ContentStatusInput) (*mcp.CallToolResult, ContentStatusOutput, error) {
|
|
if core.Trim(input.BatchID) == "" {
|
|
return nil, ContentStatusOutput{}, core.E("contentStatus", "batch_id is required", nil)
|
|
}
|
|
|
|
result := s.platformPayload(ctx, "content.status", "GET", core.Concat("/v1/content/status/", input.BatchID), nil)
|
|
if !result.OK {
|
|
return nil, ContentStatusOutput{}, resultErrorValue("content.status", result)
|
|
}
|
|
|
|
return nil, ContentStatusOutput{
|
|
Success: true,
|
|
Status: payloadResourceMap(result.Value.(map[string]any), "status", "batch"),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentUsageStats(ctx context.Context, _ *mcp.CallToolRequest, input ContentUsageStatsInput) (*mcp.CallToolResult, ContentUsageStatsOutput, error) {
|
|
path := "/v1/content/usage/stats"
|
|
path = appendQueryParam(path, "provider", input.Provider)
|
|
path = appendQueryParam(path, "period", input.Period)
|
|
path = appendQueryParam(path, "since", input.Since)
|
|
path = appendQueryParam(path, "until", input.Until)
|
|
|
|
result := s.platformPayload(ctx, "content.usage.stats", "GET", path, nil)
|
|
if !result.OK {
|
|
return nil, ContentUsageStatsOutput{}, resultErrorValue("content.usage.stats", result)
|
|
}
|
|
|
|
return nil, ContentUsageStatsOutput{
|
|
Success: true,
|
|
Usage: payloadResourceMap(result.Value.(map[string]any), "usage", "stats"),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PrepSubsystem) contentFromPlan(ctx context.Context, _ *mcp.CallToolRequest, input ContentFromPlanInput) (*mcp.CallToolResult, ContentFromPlanOutput, error) {
|
|
if core.Trim(input.PlanSlug) == "" {
|
|
return nil, ContentFromPlanOutput{}, core.E("contentFromPlan", "plan_slug is required", nil)
|
|
}
|
|
|
|
body := map[string]any{
|
|
"plan_slug": input.PlanSlug,
|
|
}
|
|
if input.Provider != "" {
|
|
body["provider"] = input.Provider
|
|
}
|
|
if input.Prompt != "" {
|
|
body["prompt"] = input.Prompt
|
|
}
|
|
if input.Template != "" {
|
|
body["template"] = input.Template
|
|
}
|
|
if len(input.Config) > 0 {
|
|
body["config"] = input.Config
|
|
}
|
|
body = mergeContentPayload(body, input.Payload)
|
|
|
|
result := s.platformPayload(ctx, "content.from.plan", "POST", "/v1/content/from-plan", body)
|
|
if !result.OK {
|
|
return nil, ContentFromPlanOutput{}, resultErrorValue("content.from.plan", result)
|
|
}
|
|
|
|
return nil, ContentFromPlanOutput{
|
|
Success: true,
|
|
Result: parseContentResult(payloadResourceMap(result.Value.(map[string]any), "result", "content", "generation")),
|
|
}, nil
|
|
}
|
|
|
|
func mergeContentPayload(target, extra map[string]any) map[string]any {
|
|
if len(target) == 0 {
|
|
target = map[string]any{}
|
|
}
|
|
for key, value := range extra {
|
|
if value != nil {
|
|
target[key] = value
|
|
}
|
|
}
|
|
return target
|
|
}
|
|
|
|
func parseContentResult(values map[string]any) ContentResult {
|
|
result := ContentResult{
|
|
ID: contentMapStringValue(values, "id"),
|
|
BatchID: contentMapStringValue(values, "batch_id", "batchId"),
|
|
Prompt: contentMapStringValue(values, "prompt"),
|
|
Provider: contentMapStringValue(values, "provider"),
|
|
Model: contentMapStringValue(values, "model", "model_name"),
|
|
Content: contentMapStringValue(values, "content", "text", "output"),
|
|
Status: contentMapStringValue(values, "status"),
|
|
InputTokens: mapIntValue(values, "input_tokens", "inputTokens"),
|
|
OutputTokens: mapIntValue(values, "output_tokens", "outputTokens"),
|
|
DurationMS: mapIntValue(values, "duration_ms", "durationMs", "duration"),
|
|
StopReason: contentMapStringValue(values, "stop_reason", "stopReason"),
|
|
Metadata: anyMapValue(values["metadata"]),
|
|
Raw: anyMapValue(values["raw"]),
|
|
}
|
|
if len(result.Raw) == 0 && len(values) > 0 {
|
|
result.Raw = values
|
|
}
|
|
return result
|
|
}
|
|
|
|
func parseContentBrief(values map[string]any) ContentBrief {
|
|
return ContentBrief{
|
|
ID: contentMapStringValue(values, "id"),
|
|
Slug: contentMapStringValue(values, "slug"),
|
|
Name: contentMapStringValue(values, "name"),
|
|
Title: contentMapStringValue(values, "title"),
|
|
Product: contentMapStringValue(values, "product"),
|
|
Category: contentMapStringValue(values, "category"),
|
|
Brief: contentMapStringValue(values, "brief", "content", "body"),
|
|
Summary: contentMapStringValue(values, "summary", "description"),
|
|
Metadata: anyMapValue(values["metadata"]),
|
|
CreatedAt: contentMapStringValue(values, "created_at"),
|
|
UpdatedAt: contentMapStringValue(values, "updated_at"),
|
|
}
|
|
}
|
|
|
|
func parseContentBriefListOutput(payload map[string]any) ContentBriefListOutput {
|
|
values := payloadDataSlice(payload, "briefs", "items")
|
|
briefs := make([]ContentBrief, 0, len(values))
|
|
for _, value := range values {
|
|
briefs = append(briefs, parseContentBrief(value))
|
|
}
|
|
|
|
total := mapIntValue(payload, "total", "count")
|
|
if total == 0 {
|
|
total = mapIntValue(payloadDataMap(payload), "total", "count")
|
|
}
|
|
if total == 0 {
|
|
total = len(briefs)
|
|
}
|
|
|
|
return ContentBriefListOutput{
|
|
Success: true,
|
|
Total: total,
|
|
Briefs: briefs,
|
|
}
|
|
}
|
|
|
|
func contentMapStringValue(values map[string]any, keys ...string) string {
|
|
for _, key := range keys {
|
|
if value, ok := values[key]; ok {
|
|
if text := stringValue(value); text != "" {
|
|
return text
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|