640 lines
21 KiB
Go
640 lines
21 KiB
Go
package processing
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/descrybe/descrybe-v2/apps/api/internal/company"
|
|
"github.com/descrybe/descrybe-v2/apps/api/internal/eprel"
|
|
)
|
|
|
|
// StepPolicy controls entitlement-gated steps (AI / EPREL).
|
|
type StepPolicy struct {
|
|
AllowAI bool
|
|
AllowEPREL bool
|
|
}
|
|
|
|
// RunSteps executes the multi-step product pipeline.
|
|
// OpenAI enhance runs only when Completer is configured, Enabled(), and policy.AllowAI.
|
|
// EPREL runs only when enricher enabled and policy.AllowEPREL.
|
|
func (e *Engine) RunSteps(ctx context.Context, companyID string, in ProductInput, processingType string, categoryNames []string, policy StepPolicy) (StepResult, error) {
|
|
steps := resolveSteps(processingType)
|
|
out := StepResult{
|
|
Attributes: map[string]any{},
|
|
ProcessedAttributes: map[string]any{},
|
|
FieldSources: map[string]any{},
|
|
EPREL: map[string]any{},
|
|
GPTResponse: map[string]any{"steps": []any{}},
|
|
Notes: []string{},
|
|
}
|
|
|
|
normalized := map[string]any{}
|
|
attrs := map[string]any{}
|
|
|
|
for _, step := range steps {
|
|
switch step {
|
|
case StepNormalize:
|
|
normalized = NormalizeMapped(in.Mapped, in.Raw)
|
|
out.Name = preferredProductTitle(in.GTIN,
|
|
stringFromAny(normalized["name"]),
|
|
stringFromAny(normalized["title"]),
|
|
in.Name,
|
|
in.PriorProcessedName,
|
|
)
|
|
out.Description = preferredProductDescription(
|
|
stringFromAny(normalized["description"]),
|
|
in.Description,
|
|
in.PriorProcessedDescription,
|
|
)
|
|
out.Category = stringFromAny(normalized["category"])
|
|
// mapped_data.category wins; otherwise keep existing processed category
|
|
// so enhance_only / reprocess cannot blank A1 legacy categories.
|
|
preserveCategoryIfEmpty(&out, in.PriorCategory)
|
|
out.FieldSources["normalize"] = "mapped+raw"
|
|
appendStepLog(out.GPTResponse, StepNormalize, map[string]any{
|
|
"keys": len(normalized),
|
|
})
|
|
|
|
case StepParseSpecs:
|
|
specVal := normalized["specifications"]
|
|
if specVal == nil {
|
|
specVal = in.Mapped["specifications"]
|
|
}
|
|
if specVal == nil {
|
|
specVal = in.Raw["specifications"]
|
|
}
|
|
parsed := ParseSpecifications(specVal)
|
|
// Also accept pre-mapped attributes map
|
|
if am, ok := normalized["attributes"].(map[string]any); ok {
|
|
for k, v := range ParseSpecifications(am) {
|
|
if _, exists := parsed[k]; !exists {
|
|
parsed[k] = v
|
|
}
|
|
}
|
|
}
|
|
attrs = parsed
|
|
out.Attributes = SanitizeProductAttributes(attrs)
|
|
out.ProcessedAttributes = out.Attributes
|
|
attrs = out.Attributes
|
|
out.FieldSources["attributes"] = "specifications"
|
|
appendStepLog(out.GPTResponse, StepParseSpecs, map[string]any{
|
|
"count": len(attrs),
|
|
})
|
|
|
|
case StepFillFields:
|
|
normalized = FillMissingFields(normalized, attrs)
|
|
if len(in.StandardFields) > 0 {
|
|
normalized = FillMissingStandardFields(normalized, in.Raw, in.StandardFields)
|
|
}
|
|
out.Name = preferredProductTitle(in.GTIN,
|
|
stringFromAny(normalized["name"]),
|
|
stringFromAny(normalized["title"]),
|
|
out.Name,
|
|
in.Name,
|
|
in.PriorProcessedName,
|
|
)
|
|
out.Description = preferredProductDescription(
|
|
stringFromAny(normalized["description"]),
|
|
out.Description,
|
|
in.Description,
|
|
)
|
|
out.Category = stringFromAny(normalized["category"])
|
|
// Promote characteristic fields only — never core product identity/content
|
|
// (those belong on the V1 item root: title, description, ean, images, …).
|
|
promote := []string{"brand", "width", "height", "depth", "weight", "product_model", "warranty"}
|
|
for _, f := range in.StandardFields {
|
|
k := strings.TrimSpace(f.Key)
|
|
if k == "" || isReservedProductKey(k) || isInvalidAttributeKey(k) {
|
|
continue
|
|
}
|
|
promote = append(promote, k)
|
|
}
|
|
seen := map[string]bool{}
|
|
for _, k := range promote {
|
|
if seen[k] {
|
|
continue
|
|
}
|
|
seen[k] = true
|
|
if v := stringFromAny(normalized[k]); v != "" {
|
|
if _, exists := attrs[k]; !exists {
|
|
attrs[k] = v
|
|
}
|
|
out.FieldSources[k] = "fill_fields"
|
|
}
|
|
}
|
|
attrs = SanitizeProductAttributes(attrs)
|
|
out.Attributes = attrs
|
|
out.ProcessedAttributes = attrs
|
|
appendStepLog(out.GPTResponse, StepFillFields, map[string]any{
|
|
"brand": stringFromAny(normalized["brand"]),
|
|
})
|
|
if out.Category == "" && e != nil && e.Vector != nil && e.Vector.Enabled() {
|
|
text := strings.TrimSpace(out.Name + " " + out.Description)
|
|
if text != "" {
|
|
if cat, err := e.Vector.SuggestCategory(ctx, companyID, text, categoryNames); err == nil && strings.TrimSpace(cat) != "" {
|
|
out.Category = SanitizeOutput(cat)
|
|
out.FieldSources["category"] = "vector"
|
|
out.Notes = append(out.Notes, "category: vector")
|
|
appendStepLog(out.GPTResponse, "vector_categorize", map[string]any{
|
|
"status": "ok",
|
|
"category": out.Category,
|
|
})
|
|
} else if err != nil {
|
|
out.Notes = append(out.Notes, "vector_categorize: "+TruncateError(err))
|
|
appendStepLog(out.GPTResponse, "vector_categorize", map[string]any{
|
|
"status": "failed",
|
|
"error": TruncateError(err),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
preserveCategoryIfEmpty(&out, in.PriorCategory)
|
|
|
|
case StepEPREL:
|
|
if !policy.AllowEPREL {
|
|
out.Notes = append(out.Notes, "eprel: skipped (not allowed for this job)")
|
|
appendStepLog(out.GPTResponse, StepEPREL, map[string]any{
|
|
"status": "skipped",
|
|
"reason": "entitlement_can_use_eprel",
|
|
})
|
|
break
|
|
}
|
|
id := eprel.ExtractID(normalized, in.Mapped, in.Raw)
|
|
if id == "" {
|
|
out.Notes = append(out.Notes, "eprel: no id")
|
|
appendStepLog(out.GPTResponse, StepEPREL, map[string]any{"status": "skipped", "reason": "no_id"})
|
|
break
|
|
}
|
|
enricher := e.EPREL
|
|
if enricher == nil {
|
|
enricher = eprel.Disabled{}
|
|
}
|
|
if !enricher.Enabled() {
|
|
out.Notes = append(out.Notes, "eprel: enricher disabled")
|
|
out.EPREL = map[string]any{"eprel_id": id, "status": "skipped"}
|
|
appendStepLog(out.GPTResponse, StepEPREL, map[string]any{"status": "skipped", "eprel_id": id, "reason": "disabled"})
|
|
break
|
|
}
|
|
data, err := enricher.Fetch(ctx, id)
|
|
if err != nil {
|
|
out.Notes = append(out.Notes, "eprel: "+TruncateError(err))
|
|
attrs["eprel_id"] = id
|
|
out.Attributes = attrs
|
|
out.ProcessedAttributes = attrs
|
|
appendStepLog(out.GPTResponse, StepEPREL, map[string]any{"status": "failed", "error": TruncateError(err)})
|
|
// Non-fatal: continue pipeline
|
|
break
|
|
}
|
|
if data == nil {
|
|
attrs["eprel_id"] = id
|
|
out.Attributes = attrs
|
|
out.ProcessedAttributes = attrs
|
|
out.EPREL = map[string]any{"eprel_id": id, "status": "empty"}
|
|
appendStepLog(out.GPTResponse, StepEPREL, map[string]any{"status": "empty", "eprel_id": id})
|
|
break
|
|
}
|
|
attrs = eprel.MergeInto(attrs, data)
|
|
out.Attributes = attrs
|
|
out.ProcessedAttributes = attrs
|
|
out.EPREL = map[string]any{
|
|
"eprel_id": data.ID,
|
|
"label": data.Label,
|
|
"pdf": data.PDF,
|
|
"energy_class": data.EnergyClass,
|
|
"energy_scale": data.EnergyScale,
|
|
}
|
|
out.FieldSources["eprel"] = "eprel_api"
|
|
appendStepLog(out.GPTResponse, StepEPREL, map[string]any{"status": "ok", "eprel_id": data.ID})
|
|
|
|
case StepAIEnhance:
|
|
preservePriorEnhanceHash := func() {
|
|
if in.PriorEnhanceHash != "" {
|
|
out.FieldSources[FieldEnhanceInputHash] = in.PriorEnhanceHash
|
|
}
|
|
}
|
|
if !policy.AllowAI {
|
|
out.ProcessedName = out.Name
|
|
out.ProcessedDescription = out.Description
|
|
out.Notes = append(out.Notes, "ai_enhance: skipped (Free plan — upgrade for AI titles/descriptions)")
|
|
preservePriorEnhanceHash()
|
|
appendStepLog(out.GPTResponse, StepAIEnhance, map[string]any{
|
|
"status": "skipped",
|
|
"reason": "entitlement_can_use_ai",
|
|
})
|
|
break
|
|
}
|
|
if !e.CompleterEnabled() {
|
|
out.ProcessedName = out.Name
|
|
out.ProcessedDescription = out.Description
|
|
out.Notes = append(out.Notes, "ai_enhance: skipped (platform OpenAI unset; configure admin settings or company BYOK)")
|
|
preservePriorEnhanceHash()
|
|
appendStepLog(out.GPTResponse, StepAIEnhance, map[string]any{
|
|
"status": "skipped",
|
|
"reason": "openai_not_configured",
|
|
})
|
|
break
|
|
}
|
|
langs := in.ContentLanguages
|
|
if len(langs) == 0 {
|
|
langs = []string{in.Language}
|
|
}
|
|
if len(langs) == 0 {
|
|
langs = []string{company.DefaultLanguage}
|
|
}
|
|
primary := in.Language
|
|
if primary == "" {
|
|
primary = langs[0]
|
|
}
|
|
localized := company.LocalizedContent{}
|
|
if in.PriorLocalized != nil {
|
|
for k, v := range in.PriorLocalized {
|
|
localized[k] = v
|
|
}
|
|
}
|
|
anyFailed := false
|
|
anyOK := false
|
|
allUnchanged := true
|
|
langMetas := make([]any, 0, len(langs))
|
|
for _, lang := range langs {
|
|
tpl := in.EnhanceByLang[lang]
|
|
if tpl.System == "" && tpl.User == "" && lang == primary {
|
|
tpl = PromptTemplates{System: in.EnhanceSystemTemplate, User: in.EnhanceUserTemplate}
|
|
}
|
|
catPrompt := in.CategoryEnhancePrompt
|
|
if lang != primary || catPrompt == "" {
|
|
catPrompt = categoryEnhancePromptFor(in.CategoryPromptsByLang, out.Category, lang)
|
|
}
|
|
priorFields := company.FieldsForLanguage(in.PriorLocalized, lang)
|
|
priorHash := priorFields.EnhanceInputHash
|
|
priorName := priorFields.ProcessedName
|
|
priorDesc := priorFields.ProcessedDescription
|
|
if lang == primary {
|
|
if priorHash == "" {
|
|
priorHash = in.PriorEnhanceHash
|
|
}
|
|
if priorName == "" {
|
|
priorName = in.PriorProcessedName
|
|
}
|
|
if priorDesc == "" {
|
|
priorDesc = in.PriorProcessedDescription
|
|
}
|
|
}
|
|
name, desc, tokens, raw, err := e.enhance(ctx, ProductInput{
|
|
GTIN: in.GTIN,
|
|
Name: out.Name,
|
|
Description: out.Description,
|
|
Mapped: normalized,
|
|
BrandPrompt: in.BrandPrompt,
|
|
Language: lang,
|
|
EnhanceSystemTemplate: tpl.System,
|
|
EnhanceUserTemplate: tpl.User,
|
|
CategoryEnhancePrompt: catPrompt,
|
|
PriorEnhanceHash: priorHash,
|
|
PriorProcessedName: priorName,
|
|
PriorProcessedDescription: priorDesc,
|
|
}, out.Category, attrs)
|
|
out.TotalTokens += tokens
|
|
status := enhanceStatusFromMeta(raw)
|
|
meta := map[string]any{"language": lang, "raw": raw}
|
|
if err != nil {
|
|
anyFailed = true
|
|
allUnchanged = false
|
|
meta["status"] = "failed"
|
|
meta["error"] = TruncateError(err)
|
|
out.Notes = append(out.Notes, "ai_enhance: "+TruncateError(err))
|
|
if lang == primary {
|
|
name, desc = out.Name, out.Description
|
|
} else if priorName != "" || priorDesc != "" {
|
|
name, desc = priorName, priorDesc
|
|
} else {
|
|
langMetas = append(langMetas, meta)
|
|
continue
|
|
}
|
|
} else if status == "unchanged" {
|
|
meta["status"] = "unchanged"
|
|
} else {
|
|
allUnchanged = false
|
|
anyOK = true
|
|
meta["status"] = status
|
|
}
|
|
hash := enhanceHashFromMeta(raw)
|
|
localized[lang] = company.LocalizedFields{
|
|
ProcessedName: name,
|
|
ProcessedDescription: desc,
|
|
EnhanceInputHash: hash,
|
|
MetaTitle: company.FieldsForLanguage(localized, lang).MetaTitle,
|
|
MetaDescription: company.FieldsForLanguage(localized, lang).MetaDescription,
|
|
}
|
|
// Preserve existing meta when re-enhancing titles only.
|
|
if prev := company.FieldsForLanguage(in.PriorLocalized, lang); prev.MetaTitle != "" || prev.MetaDescription != "" {
|
|
f := localized[lang]
|
|
if f.MetaTitle == "" {
|
|
f.MetaTitle = prev.MetaTitle
|
|
}
|
|
if f.MetaDescription == "" {
|
|
f.MetaDescription = prev.MetaDescription
|
|
}
|
|
localized[lang] = f
|
|
}
|
|
langMetas = append(langMetas, meta)
|
|
if lang == primary {
|
|
name = preferredProductTitle(in.GTIN, name, out.Name, in.PriorProcessedName)
|
|
desc = preferredProductDescription(desc, out.Description, in.PriorProcessedDescription)
|
|
out.ProcessedName = name
|
|
out.ProcessedDescription = desc
|
|
if name != "" {
|
|
out.Name = name
|
|
}
|
|
if desc != "" {
|
|
out.Description = desc
|
|
}
|
|
if hash != "" && (status == "ok" || status == "unchanged") {
|
|
out.FieldSources[FieldEnhanceInputHash] = hash
|
|
} else if err != nil {
|
|
preservePriorEnhanceHash()
|
|
}
|
|
}
|
|
}
|
|
out.LocalizedContent = localized
|
|
if anyFailed && !anyOK {
|
|
if out.ProcessedName == "" {
|
|
out.ProcessedName = out.Name
|
|
}
|
|
if out.ProcessedDescription == "" {
|
|
out.ProcessedDescription = out.Description
|
|
}
|
|
preservePriorEnhanceHash()
|
|
errNote := ""
|
|
for _, m := range langMetas {
|
|
if mm, ok := m.(map[string]any); ok {
|
|
if e, ok := mm["error"].(string); ok && e != "" {
|
|
errNote = e
|
|
break
|
|
}
|
|
}
|
|
}
|
|
appendStepLog(out.GPTResponse, StepAIEnhance, map[string]any{
|
|
"status": "failed",
|
|
"error": errNote,
|
|
"languages": langMetas,
|
|
})
|
|
break
|
|
}
|
|
if allUnchanged {
|
|
out.SkipCreditDebit = true
|
|
out.FieldSources["name"] = "ai_enhance_unchanged"
|
|
out.FieldSources["description"] = "ai_enhance_unchanged"
|
|
out.Notes = append(out.Notes, "ai_enhance: skipped (inputs unchanged)")
|
|
} else {
|
|
out.AIProviderMode = e.EngineProviderMode()
|
|
out.FieldSources["name"] = "ai_enhance"
|
|
out.FieldSources["description"] = "ai_enhance"
|
|
}
|
|
appendStepLog(out.GPTResponse, StepAIEnhance, map[string]any{
|
|
"status": map[string]any{"unchanged": allUnchanged, "ok": anyOK, "failed": anyFailed},
|
|
"languages": langMetas,
|
|
})
|
|
|
|
default:
|
|
appendStepLog(out.GPTResponse, step, map[string]any{"status": "unknown"})
|
|
}
|
|
}
|
|
|
|
preserveCategoryIfEmpty(&out, in.PriorCategory)
|
|
out.Name = preferredProductTitle(in.GTIN, out.Name, out.ProcessedName, in.Name, in.PriorProcessedName)
|
|
out.ProcessedName = preferredProductTitle(in.GTIN, out.ProcessedName, out.Name, in.PriorProcessedName, in.Name)
|
|
out.Description = preferredProductDescription(out.Description, out.ProcessedDescription, in.Description)
|
|
out.ProcessedDescription = preferredProductDescription(out.ProcessedDescription, out.Description, in.PriorProcessedDescription)
|
|
if out.ProcessedName == "" {
|
|
out.ProcessedName = out.Name
|
|
}
|
|
if out.ProcessedDescription == "" {
|
|
out.ProcessedDescription = out.Description
|
|
}
|
|
if out.Attributes == nil {
|
|
out.Attributes = map[string]any{}
|
|
}
|
|
out.Attributes = SanitizeProductAttributes(out.Attributes)
|
|
out.ProcessedAttributes = SanitizeProductAttributes(out.ProcessedAttributes)
|
|
if len(out.ProcessedAttributes) == 0 {
|
|
out.ProcessedAttributes = out.Attributes
|
|
}
|
|
if out.AIProviderMode == "" {
|
|
if out.TotalTokens > 0 {
|
|
out.AIProviderMode = e.EngineProviderMode()
|
|
} else {
|
|
out.AIProviderMode = AIProviderUnknown
|
|
}
|
|
}
|
|
if len(out.Notes) > 0 {
|
|
out.GPTResponse["notes"] = out.Notes
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// preserveCategoryIfEmpty keeps an existing processed category when normalize/AI
|
|
// left Category empty (common for A1 feeds where category lives only on processed).
|
|
func preserveCategoryIfEmpty(out *StepResult, prior string) {
|
|
if out == nil || strings.TrimSpace(out.Category) != "" {
|
|
return
|
|
}
|
|
prior = strings.TrimSpace(prior)
|
|
if prior == "" {
|
|
return
|
|
}
|
|
out.Category = SanitizeText(prior)
|
|
if out.FieldSources == nil {
|
|
out.FieldSources = map[string]any{}
|
|
}
|
|
out.FieldSources["category"] = "prior_processed"
|
|
}
|
|
|
|
func resolveSteps(processingType string) []string {
|
|
switch strings.ToLower(strings.TrimSpace(processingType)) {
|
|
case "enhance", "enhance_only", "enhance-only", "title", "description":
|
|
return []string{StepNormalize, StepAIEnhance}
|
|
case "attributes", "attributes_only", "specs", "specifications":
|
|
return []string{StepNormalize, StepParseSpecs, StepFillFields}
|
|
case "eprel", "eprel_only":
|
|
return []string{StepNormalize, StepEPREL}
|
|
case "normalize_only":
|
|
return []string{StepNormalize}
|
|
case "categorize", "categorize_only", "categorize_enhance":
|
|
// Legacy aliases → full deterministic + optional AI
|
|
return append([]string{}, CanonicalSteps...)
|
|
default: // full
|
|
return append([]string{}, CanonicalSteps...)
|
|
}
|
|
}
|
|
|
|
// InitialStepProgress builds pending step_progress rows for a job.
|
|
func InitialStepProgress(processingType string) []StepProgress {
|
|
steps := resolveSteps(processingType)
|
|
out := make([]StepProgress, 0, len(steps))
|
|
for _, s := range steps {
|
|
out = append(out, StepProgress{Step: s, Status: "pending"})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func appendStepLog(gpt map[string]any, name string, raw any) {
|
|
steps, _ := gpt["steps"].([]any)
|
|
gpt["steps"] = append(steps, map[string]any{"step": name, "raw": raw})
|
|
}
|
|
|
|
func (e *Engine) enhance(ctx context.Context, in ProductInput, category string, attrs map[string]any) (string, string, int, any, error) {
|
|
sysTpl, userTpl := resolveProductPromptTemplates(in)
|
|
hash := HashEnhanceInput(category, in.Name, in.Description, in.BrandPrompt, in.Language, sysTpl, userTpl, attrs)
|
|
if e == nil || e.Completer == nil {
|
|
return preferredProductTitle(in.GTIN, in.Name, in.PriorProcessedName),
|
|
preferredProductDescription(in.Description, in.PriorProcessedDescription),
|
|
0, map[string]any{"status": "skipped", "input_hash": hash}, nil
|
|
}
|
|
// Skip LLM when inputs match the last successful enhance (before any credit debit).
|
|
if in.PriorEnhanceHash != "" && in.PriorEnhanceHash == hash &&
|
|
(in.PriorProcessedName != "" || in.PriorProcessedDescription != "") {
|
|
name := preferredProductTitle(in.GTIN, in.PriorProcessedName, in.Name)
|
|
desc := preferredProductDescription(in.PriorProcessedDescription, in.Description)
|
|
return name, desc, 0, map[string]any{
|
|
"status": "unchanged",
|
|
"input_hash": hash,
|
|
}, nil
|
|
}
|
|
system, user := RenderProductEnhancePrompts(sysTpl, userTpl, category, in.Name, in.Description, in.GTIN, in.BrandPrompt, in.Language, attrs)
|
|
comp, obj, err := CompleteJSON(ctx, e.Completer, system, user, CompleteOptions{
|
|
MaxTokens: MaxTokensEnhance,
|
|
Temperature: DefaultStructuredTemp,
|
|
})
|
|
if err != nil {
|
|
// Network/provider failure vs parse failure after retry
|
|
if obj == nil && comp.Text == "" {
|
|
return preferredProductTitle(in.GTIN, in.Name, in.PriorProcessedName),
|
|
preferredProductDescription(in.Description, in.PriorProcessedDescription),
|
|
0, map[string]any{
|
|
"provider": "passthrough",
|
|
"error": TruncateError(err),
|
|
"input_hash": hash,
|
|
}, err
|
|
}
|
|
// Parse failed after retry — keep original copy (avoid garbage titles)
|
|
return preferredProductTitle(in.GTIN, in.Name, in.PriorProcessedName),
|
|
preferredProductDescription(in.Description, in.PriorProcessedDescription),
|
|
comp.TotalTokens, map[string]any{
|
|
"status": "parse_failed",
|
|
"error": "AI returned invalid JSON; kept original title/description",
|
|
"raw": truncateRunes(comp.Text, 200),
|
|
"input_hash": hash,
|
|
}, nil
|
|
}
|
|
name := preferredProductTitle(in.GTIN, SanitizeOutput(fmt.Sprint(obj["name"])), in.Name, in.PriorProcessedName)
|
|
desc := preferredProductDescription(SanitizeOutput(fmt.Sprint(obj["description"])), in.Description, in.PriorProcessedDescription)
|
|
return name, desc, comp.TotalTokens, map[string]any{
|
|
"status": "ok",
|
|
"input_hash": hash,
|
|
"raw": comp.Raw,
|
|
}, nil
|
|
}
|
|
|
|
func sanitizeJSON(v any) string {
|
|
if v == nil {
|
|
return "{}"
|
|
}
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
return "{}"
|
|
}
|
|
return SanitizeText(string(b))
|
|
}
|
|
|
|
func firstLine(s string) string {
|
|
s = strings.TrimSpace(s)
|
|
if i := strings.IndexByte(s, '\n'); i >= 0 {
|
|
s = s[:i]
|
|
}
|
|
return SanitizeOutput(strings.Trim(s, "\"'` "))
|
|
}
|
|
|
|
// labeledPromptValue returns the first line after any of the given labels
|
|
// (case-insensitive), e.g. "Name:" / "Desc:" from ProductEnhanceUser.
|
|
func labeledPromptValue(user string, labels ...string) string {
|
|
lower := strings.ToLower(user)
|
|
bestAt := -1
|
|
bestLabel := ""
|
|
for _, label := range labels {
|
|
label = strings.ToLower(strings.TrimSpace(label))
|
|
if label == "" {
|
|
continue
|
|
}
|
|
at := strings.Index(lower, label)
|
|
if at < 0 {
|
|
continue
|
|
}
|
|
if bestAt < 0 || at < bestAt {
|
|
bestAt = at
|
|
bestLabel = label
|
|
}
|
|
}
|
|
if bestAt < 0 {
|
|
return ""
|
|
}
|
|
rest := user[bestAt+len(bestLabel):]
|
|
if j := strings.Index(strings.ToLower(rest), "attrs:"); j >= 0 {
|
|
rest = rest[:j]
|
|
}
|
|
if j := strings.Index(strings.ToLower(rest), "attributes:"); j >= 0 {
|
|
rest = rest[:j]
|
|
}
|
|
return firstLine(rest)
|
|
}
|
|
|
|
// isPromptLabelTitle detects enhance pollution where the model echoed a
|
|
// prompt header ("Category:" / "Category: 120") as the product title.
|
|
func isPromptLabelTitle(s string) bool {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" || s == "<nil>" {
|
|
return false
|
|
}
|
|
lower := strings.ToLower(s)
|
|
for _, label := range []string{
|
|
"category", "name", "desc", "description",
|
|
"attrs", "attributes", "current name", "current description",
|
|
} {
|
|
if lower == label || lower == label+":" {
|
|
return true
|
|
}
|
|
if strings.HasPrefix(lower, label+":") || strings.HasPrefix(lower, label+" :") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// preferredProductTitle picks the first usable title, skipping empty values and
|
|
// prompt-label echoes like "Category:" (seen on A1 Elkotex reprocess).
|
|
func preferredProductTitle(gtin string, candidates ...string) string {
|
|
for _, c := range candidates {
|
|
c = strings.TrimSpace(c)
|
|
if c == "" || c == "<nil>" || isPromptLabelTitle(c) {
|
|
continue
|
|
}
|
|
return SanitizeOutput(c)
|
|
}
|
|
if strings.TrimSpace(gtin) != "" {
|
|
return SanitizeText("Product " + strings.TrimSpace(gtin))
|
|
}
|
|
return "Product"
|
|
}
|
|
|
|
func preferredProductDescription(candidates ...string) string {
|
|
for _, c := range candidates {
|
|
c = strings.TrimSpace(c)
|
|
if c == "" || c == "<nil>" || isPromptLabelTitle(c) {
|
|
continue
|
|
}
|
|
return SanitizeOutput(c)
|
|
}
|
|
return ""
|
|
}
|