CON-112: Campaign Assistant — per-campaign chat over content_plan + enrich_brief

src/config/config.go

@@ -56,6 +56,13 @@ type Config struct {
 	MaxContextAssets int    `envconfig:"MAX_ASSET_CONTEXT"     default:"15"`
 	MaxContextChars  int    `envconfig:"MAX_CONTEXT_CHARS"     default:"10000"`
 
+	// PlanningModelID (CON-112) backs the cheap/fast "planning" role used by
+	// the Campaign Assistant's orchestration + intent-routing loop. Prose
+	// generation happens inside the content_plan / enrich_brief sub-flows it
+	// invokes as tools, which stay on ModelID (Sonnet-tier) — so the assistant
+	// routes cheaply on Haiku while the heavy writing stays capable.
+	PlanningModelID string `envconfig:"PLANNING_MODEL_ID" default:"claude-haiku-4-5-20251001"`
+
 	// 64K matches Claude 4.x Haiku/Sonnet's max output. Anthropic charges
 	// only for tokens actually emitted, so a generous cap costs nothing on
 	// short responses but prevents truncation on long rewrites (assistant

src/database/migrations/20260714000001_campaign_assistant_messages.down.sql

@@ -0,0 +1,2 @@
+-- CON-112: drop the Campaign Assistant conversation history table.
+DROP TABLE IF EXISTS campaign_assistant_messages;

src/database/migrations/20260714000001_campaign_assistant_messages.up.sql

@@ -0,0 +1,14 @@
+-- CON-112: per-campaign conversation history between the user and the
+-- Campaign Assistant. Mirrors post_assistant_messages, tenant-scoped from the
+-- start (CON-97) since it is created after the tenant foundation migrations.
+CREATE TABLE campaign_assistant_messages (
+    id          TEXT        PRIMARY KEY,
+    campaign_id TEXT        NOT NULL REFERENCES campaigns (id) ON DELETE CASCADE,
+    role        TEXT        NOT NULL CHECK (role IN ('user', 'model')),
+    content     TEXT        NOT NULL,
+    tenant_id   TEXT        NOT NULL REFERENCES tenants (id),
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_campaign_assistant_messages_campaign_id ON campaign_assistant_messages (campaign_id);
+CREATE INDEX idx_campaign_assistant_messages_tenant_id ON campaign_assistant_messages (tenant_id);

src/genkit/flows/campaign_assistant/context.go

@@ -0,0 +1,69 @@
+package campaign_assistant
+
+import (
+	"bytes"
+	"text/template"
+
+	"github.com/ogen-app/ogen/src/models"
+)
+
+// assistantContext holds the rendered prompts ready for the model call.
+type assistantContext struct {
+	SystemPrompt string // stable system instructions (cacheable prefix)
+	ContextBlock string // the campaign's current brief (stable within a turn)
+}
+
+// contextTemplateData is the view model for the prompt template. It carries
+// only fields already loaded on the campaign, so context assembly costs no
+// extra query — the planner stays fast (CON-112 execution-time optimisation).
+type contextTemplateData struct {
+	CampaignName   string
+	Status         string
+	CampaignType   string
+	Language       string
+	Description    string
+	TargetPersona  string
+	KeyMessages    string
+	ToneGuidelines string
+}
+
+// assembleContext renders the system + context blocks from the campaign. The
+// brief is placed in the context block so grounded Q&A ("summarise the brief")
+// needs no tool round-trip. The rendered strings are deterministic, so an
+// unchanged brief produces an identical prefix and Anthropic prompt caching
+// still applies without an in-process cache.
+func assembleContext(campaign *models.Campaign, systemTmpl, contextTmpl *template.Template) (*assistantContext, error) {
+	campaignType := campaign.CampaignTypeID
+	if campaign.CampaignType != nil && campaign.CampaignType.Name != "" {
+		campaignType = campaign.CampaignType.Name
+	}
+
+	data := contextTemplateData{
+		CampaignName:   campaign.Name,
+		Status:         string(campaign.Status),
+		CampaignType:   campaignType,
+		Language:       campaign.Language,
+		Description:    campaign.Description,
+		TargetPersona:  campaign.TargetPersona,
+		KeyMessages:    campaign.KeyMessages,
+		ToneGuidelines: campaign.ToneGuidelines,
+	}
+
+	systemPrompt, err := renderTemplate(systemTmpl, data)
+	if err != nil {
+		return nil, err
+	}
+	contextBlock, err := renderTemplate(contextTmpl, data)
+	if err != nil {
+		return nil, err
+	}
+	return &assistantContext{SystemPrompt: systemPrompt, ContextBlock: contextBlock}, nil
+}
+
+func renderTemplate(tmpl *template.Template, data any) (string, error) {
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		return "", err
+	}
+	return buf.String(), nil
+}

src/genkit/flows/campaign_assistant/flow.go

@@ -0,0 +1,121 @@
+package campaign_assistant
+
+import (
+	"context"
+	"embed"
+	"fmt"
+	"log/slog"
+	"text/template"
+
+	"github.com/firebase/genkit/go/core"
+	"github.com/firebase/genkit/go/genkit"
+
+	"github.com/ogen-app/ogen/src/eventhub"
+	"github.com/ogen-app/ogen/src/logging"
+	"github.com/ogen-app/ogen/src/models"
+)
+
+//go:embed prompts/campaign_assistant.tmpl
+var promptFS embed.FS
+
+// CampaignAssistantFlow is the singleton Genkit flow. Set by
+// InitCampaignAssistant. Registered for Dev-UI discovery; the SSE path uses the
+// runner closure below so it can stream events.
+var CampaignAssistantFlow *core.Flow[CampaignAssistantRequest, *CampaignAssistantResponse, struct{}]
+
+// campaignAssistantRunner is the direct closure that threads an OnEventFunc for
+// SSE streaming. Set by InitCampaignAssistant.
+var campaignAssistantRunner func(ctx context.Context, req CampaignAssistantRequest, onEvent OnEventFunc) (*CampaignAssistantResponse, error)
+
+// InitCampaignAssistant parses the prompt template, registers the tools, and
+// registers the campaignAssistant Genkit flow. Must be called after the Genkit
+// instance has been initialised with the Anthropic plugin.
+func InitCampaignAssistant(g *genkit.Genkit, cfg CampaignAssistantFlowConfig, repos CampaignAssistantRepos) error {
+	raw, err := promptFS.ReadFile("prompts/campaign_assistant.tmpl")
+	if err != nil {
+		return fmt.Errorf("load campaign_assistant.tmpl: %w", err)
+	}
+	tmpl, err := template.New("campaign_assistant").Parse(string(raw))
+	if err != nil {
+		return fmt.Errorf("parse campaign_assistant.tmpl: %w", err)
+	}
+	systemTmpl := tmpl.Lookup("system")
+	contextTmpl := tmpl.Lookup("context")
+	if systemTmpl == nil || contextTmpl == nil {
+		return fmt.Errorf("campaign_assistant.tmpl must define both {{define \"system\"}} and {{define \"context\"}} blocks")
+	}
+
+	tools := defineTools(g)
+
+	CampaignAssistantFlow = genkit.DefineFlow(g, "campaignAssistant",
+		func(ctx context.Context, req CampaignAssistantRequest) (*CampaignAssistantResponse, error) {
+			return runCampaignAssistant(ctx, g, req, cfg, repos, systemTmpl, contextTmpl, tools, nil)
+		},
+	)
+
+	campaignAssistantRunner = func(ctx context.Context, req CampaignAssistantRequest, onEvent OnEventFunc) (*CampaignAssistantResponse, error) {
+		return runCampaignAssistant(ctx, g, req, cfg, repos, systemTmpl, contextTmpl, tools, onEvent)
+	}
+
+	return nil
+}
+
+// NewCampaignAssistantCallback returns a callback suitable for passing to the
+// campaigns handler. onEvent is forwarded to the flow for SSE streaming; pass
+// nil for a silent, non-streaming call.
+func NewCampaignAssistantCallback() func(ctx context.Context, req CampaignAssistantRequest, onEvent OnEventFunc) (*CampaignAssistantResponse, error) {
+	return func(ctx context.Context, req CampaignAssistantRequest, onEvent OnEventFunc) (*CampaignAssistantResponse, error) {
+		return campaignAssistantRunner(ctx, req, onEvent)
+	}
+}
+
+// emit calls onEvent when it is non-nil. It is a safe no-op otherwise.
+func emit(onEvent OnEventFunc, name SSEEventKind, data any) {
+	if onEvent != nil {
+		onEvent(name, data)
+	}
+}
+
+// publishAssistantFinalised announces the end of an assistant run on the shared
+// event hub. Topic is "entity:campaign:<id>"; type is "assistant_completed" on
+// success, "assistant_failed" on error — driving cross-tab notifications.
+func publishAssistantFinalised(
+	hub eventhub.Hub,
+	campaignID, ownerID string,
+	resp *CampaignAssistantResponse,
+	err error,
+) {
+	if hub == nil {
+		return
+	}
+	id, idErr := models.NewID()
+	if idErr != nil {
+		slog.Error("cannot mint event id", logging.AttrComponent, "genkit.campaign_assistant", logging.AttrError, idErr)
+		return
+	}
+	ev := eventhub.Event{
+		ID:     id,
+		Topic:  "entity:campaign:" + campaignID,
+		UserID: ownerID,
+	}
+	if err != nil {
+		ev.Type = "assistant_failed"
+		ev.Payload = map[string]any{
+			"campaignId": campaignID,
+			"error":      err.Error(),
+		}
+	} else {
+		action := ""
+		if resp != nil {
+			action = resp.Action
+		}
+		ev.Type = "assistant_completed"
+		ev.Payload = map[string]any{
+			"campaignId": campaignID,
+			"action":     action,
+		}
+	}
+	if pubErr := hub.Publish(context.Background(), ev); pubErr != nil {
+		slog.Error("hub publish failed", logging.AttrComponent, "genkit.campaign_assistant", "campaign_id", campaignID, logging.AttrError, pubErr)
+	}
+}

src/genkit/flows/campaign_assistant/prompts/campaign_assistant.tmpl

@@ -0,0 +1,44 @@
+{{define "system"}}
+You are the Campaign Assistant for Ogen, a social-media content platform. You help a user work on ONE campaign through a chat conversation. You are focused, concise, and never invent facts about the campaign.
+
+You can do three things:
+1. Generate a content plan — a set of draft posts across the campaign's platforms.
+2. Enrich the campaign brief — improve its description, target persona, key messages, and tone guidelines.
+3. Answer questions about the campaign, grounded in the brief and its posts.
+
+## Tools
+- runContentPlan: Call this when the user asks to generate, create, build, or regenerate a content plan (e.g. "generate a content plan", "make me some posts for this campaign"). It creates and saves the draft posts. Takes no arguments.
+- enrichBrief: Call this when the user asks to enrich, improve, refine, sharpen, or rewrite the brief (e.g. "enrich the brief", "improve the brief", "make the brief more B2B"). Pass the user's steering as the `instruction` argument when they give any. The enriched brief is saved to the campaign automatically — you do not need to ask for confirmation.
+- listCampaignPosts: Call this when you need to know what posts already exist in the campaign to answer a question. Takes no arguments.
+
+Use a tool only when the user's request clearly matches it. For a general question you can answer from the campaign brief already shown below, answer directly without a tool.
+
+## Response format
+After any tool calls, reply with a SINGLE JSON object and nothing else — no markdown fences, no prose before or after:
+
+{
+  "explanation": "<a short, friendly reply to the user in their language>",
+  "action": "<answered | content_plan_generated | brief_enriched | declined>"
+}
+
+Rules for `action`:
+- "content_plan_generated" — you called runContentPlan this turn.
+- "brief_enriched" — you called enrichBrief this turn.
+- "answered" — you answered a question or made small talk without changing anything.
+- "declined" — the request is out of scope (anything other than the three capabilities above, e.g. deleting posts, publishing, billing). Explain briefly what you can help with instead.
+
+Keep `explanation` to a few sentences. Never put the full generated posts or the full brief into `explanation` — the client already receives those through their own channels.
+{{end}}
+{{define "context"}}
+## Campaign
+- Name: {{.CampaignName}}
+- Status: {{.Status}}
+- Type: {{.CampaignType}}
+- Language: {{.Language}}
+
+## Current brief
+Description: {{.Description}}
+Target persona: {{.TargetPersona}}
+Key messages: {{.KeyMessages}}
+Tone guidelines: {{.ToneGuidelines}}
+{{end}}