ima2-gen 1.1.21 → 1.1.23

package/lib/cardNewsPlanner.ts

@@ -1,236 +0,0 @@
-import { ulid } from "ulid";
-import { getRoleTemplate } from "./cardNewsRoleTemplateStore.js";
-import { getImageTemplate } from "./cardNewsTemplateStore.js";
-import { buildCardNewsPlannerMessages } from "./cardNewsPlannerPrompt.js";
-import { requestCardNewsPlannerJson } from "./cardNewsPlannerClient.js";
-import { repairPlannerOutput, validatePlannerOutput } from "./cardNewsPlannerSchema.js";
-import { waitForOAuthReady } from "./oauthProxy.js";
-import type { RouteRuntimeContext } from "./runtimeContext.js";
-
-import { errInfo } from "./errInfo.js";
-
-interface RoleEntry {
-  role: string;
-  required: boolean;
-  promptHint: string;
-  preferredSlots: string[];
-}
-
-interface RoleTemplate {
-  id: string;
-  name: string;
-  defaultCount: number;
-  roles: RoleEntry[];
-}
-
-interface CardNewsBriefInput {
-  setId?: string;
-  topic?: string;
-  title?: string;
-  audience?: string;
-  goal?: string;
-  contentBrief?: string;
-  imageTemplateId?: string;
-  roleTemplateId?: string;
-  size?: string;
-}
-
-interface BriefForBody {
-  audience?: string;
-  goal?: string;
-  content?: string;
-}
-
-interface PlannerCardOutput {
-  role: string;
-  headline: string;
-  body: string;
-  visualPrompt: string;
-  textFields?: unknown;
-  references?: unknown[];
-  order?: number;
-}
-
-interface PlannerOutput {
-  title: string;
-  topic: string;
-  audience?: string;
-  goal?: string;
-  cards: PlannerCardOutput[];
-}
-
-function compactText(value: unknown, fallback: string): string {
-  const text = typeof value === "string" ? value.trim() : "";
-  return text || fallback;
-}
-
-function detectBriefLanguage(input: CardNewsBriefInput): "ko" | "en" | "und" {
-  const text = [input.topic, input.audience, input.goal, input.contentBrief].filter(Boolean).join(" ");
-  if (/[가-힣]/.test(text)) return "ko";
-  if (/[A-Za-z]/.test(text)) return "en";
-  return "und";
-}
-
-function fallbackLabel(role: string, lang: string): string {
-  const ko: Record<string, string> = {
-    cta: "다음 행동",
-    problem: "왜 중요한가",
-    insight: "핵심 인사이트",
-    example: "예시로 보기",
-    data: "숫자로 확인",
-    summary: "요약",
-  };
-  const en: Record<string, string> = {
-    cta: "Next action",
-    problem: "Why it matters",
-    insight: "Key insight",
-    example: "Example",
-    data: "By the numbers",
-    summary: "Summary",
-  };
-  if (lang === "ko") return ko[role] || role;
-  if (lang === "en") return en[role] || role;
-  return "";
-}
-
-function headlineFor(role: string, topic: string, lang: string): string {
-  const label = compactText(topic, "Card news");
-  if (role === "cover" || role === "hook") return label;
-  return fallbackLabel(role, lang) || label;
-}
-
-function bodyFor(role: string, brief: BriefForBody, lang: string): string {
-  const content = compactText(brief.content, "");
-  if (content) return content;
-  const target = compactText(brief.audience, lang === "ko" ? "독자" : "reader");
-  const goal = compactText(brief.goal, lang === "ko" ? "핵심 메시지" : "the key message");
-  if (lang === "ko") {
-    if (role === "cta") return `${target}가 바로 실행할 수 있는 다음 단계를 제안합니다.`;
-    if (role === "problem") return `${target}가 겪는 문제를 짧고 분명하게 보여줍니다.`;
-    if (role === "insight") return `${goal}을 이해하기 쉬운 한 문장으로 정리합니다.`;
-    return `${goal}을 카드 역할에 맞춰 전달합니다.`;
-  }
-  if (role === "cta") return `Suggest a next step ${target} can take immediately.`;
-  if (role === "problem") return `Show the problem ${target} faces in a concise way.`;
-  if (role === "insight") return `Explain ${goal} in one clear sentence.`;
-  return `Present ${goal} for this card.`;
-}
-
-function normalizeTextFields(fields: unknown): unknown[] {
-  return Array.isArray(fields) ? fields : [];
-}
-
-function toCardNewsPlan(plannerOutput: PlannerOutput, input: CardNewsBriefInput, roleTemplate: RoleTemplate) {
-  const topic = compactText(plannerOutput.topic, compactText(input.topic, input.title || "Untitled card news"));
-  return {
-    setId: input.setId || `cs_${ulid()}`,
-    title: compactText(plannerOutput.title, topic),
-    topic,
-    imageTemplateId: input.imageTemplateId || "academy-lesson-square",
-    roleTemplateId: roleTemplate.id,
-    size: input.size || "2048x2048",
-    generationStrategy: "parallel-template-i2i",
-    cards: plannerOutput.cards.map((card, index) => ({
-      id: `card_${index + 1}`,
-      order: index + 1,
-      role: card.role,
-      headline: card.headline,
-      body: card.body,
-      visualPrompt: card.visualPrompt,
-      textFields: normalizeTextFields(card.textFields),
-      templateSlotAssignments: {
-        title: "headline",
-        body: "body",
-        image: "visual",
-      },
-      references: card.references || [],
-      locked: false,
-      status: "draft",
-    })),
-  };
-}
-
-export function createDeterministicCardNewsDraft(input: CardNewsBriefInput = {}) {
-  const roleTemplate = getRoleTemplate(input.roleTemplateId) as RoleTemplate;
-  const topic = compactText(input.topic, input.title || "Untitled card news");
-  const title = compactText(input.title, topic);
-  const brief: BriefForBody = {
-    audience: input.audience,
-    goal: input.goal,
-    content: input.contentBrief,
-  };
-  const lang = detectBriefLanguage(input);
-  const output: PlannerOutput = {
-    title,
-    topic,
-    audience: compactText(input.audience, ""),
-    goal: compactText(input.goal, ""),
-    cards: roleTemplate.roles.map((role, idx) => ({
-      order: idx + 1,
-      role: role.role,
-      headline: headlineFor(role.role, topic, lang),
-      body: bodyFor(role.role, brief, lang),
-      visualPrompt: `${role.promptHint}, ${topic}`,
-      textFields: [],
-      references: [],
-    })),
-  };
-  return toCardNewsPlan(output, input, roleTemplate);
-}
-
-type PlannerError = Error & { code?: string; status?: number };
-
-function plannerError(message: string, code: string, status: number): PlannerError {
-  const err = new Error(message) as PlannerError;
-  err.code = code;
-  err.status = status;
-  return err;
-}
-
-export async function createCardNewsDraft(ctxOrInput: RouteRuntimeContext | CardNewsBriefInput = {} as CardNewsBriefInput, maybeInput: CardNewsBriefInput = {}) {
-  const hasCtx = Boolean((ctxOrInput as RouteRuntimeContext | undefined)?.config);
-  const ctx = hasCtx ? (ctxOrInput as RouteRuntimeContext) : null;
-  const input = hasCtx ? maybeInput : (ctxOrInput as CardNewsBriefInput);
-  const roleTemplate = getRoleTemplate(input.roleTemplateId) as RoleTemplate;
-
-  if (!ctx) return createDeterministicCardNewsDraft(input);
-  const planner = (ctx.config as { cardNewsPlanner?: { enabled?: boolean; model?: string; timeoutMs?: number; deterministicFallback?: boolean } } | undefined)?.cardNewsPlanner;
-  if (!planner?.enabled) {
-    return {
-      plan: createDeterministicCardNewsDraft(input),
-      planner: { mode: "deterministic-fallback", model: "none", repaired: false },
-    };
-  }
-
-  const imageTemplate = await getImageTemplate(ctx, input.imageTemplateId || "academy-lesson-square");
-  try {
-    await waitForOAuthReady(ctx);
-    const messages = buildCardNewsPlannerMessages({ ...input, roleTemplate, imageTemplate });
-    const raw = await requestCardNewsPlannerJson({ messages }, {
-      oauthUrl: (ctx as RouteRuntimeContext & { oauthUrl?: string }).oauthUrl,
-      model: planner.model,
-      timeoutMs: planner.timeoutMs,
-    });
-    let result = validatePlannerOutput(raw.output, roleTemplate);
-    if (!result.ok) result = repairPlannerOutput(raw.output, { ...input, roleTemplate });
-    if (!result.ok) throw plannerError("Planner schema invalid", "PLANNER_SCHEMA_INVALID", 422);
-    return {
-      plan: toCardNewsPlan(result.plan as PlannerOutput, input, roleTemplate),
-      planner: { mode: raw.mode, model: raw.model, repaired: result.repaired },
-    };
-  } catch (e) {
-    const err = errInfo(e);
-    if (planner.deterministicFallback) {
-      return {
-        plan: createDeterministicCardNewsDraft(input),
-        planner: {
-          mode: "deterministic-fallback",
-          model: planner.model,
-          repaired: true,
-        },
-      };
-    }
-    if (err.code) throw err.raw;
-    throw plannerError(err.message || "Planner unavailable", "PLANNER_UNAVAILABLE", 503);
-  }
-}

package/lib/cardNewsPlannerClient.ts

@@ -1,155 +0,0 @@
-import { config } from "../config.js";
-import { CARD_NEWS_PLANNER_SCHEMA } from "./cardNewsPlannerSchema.js";
-import { logEvent } from "./logger.js";
-
-type PlannerError = Error & {
-  code?: string;
-  status?: number;
-  upstreamStatus?: number;
-  upstreamBodyChars?: number;
-};
-
-interface PlannerMessage {
-  role: string;
-  content: unknown;
-}
-
-interface PlannerRequestOptions {
-  oauthUrl: string;
-  model: string;
-  messages: PlannerMessage[];
-  timeoutMs: number;
-  structured?: boolean;
-  reasoningEffort?: string;
-}
-
-interface PlannerInput {
-  messages: PlannerMessage[];
-}
-
-interface PlannerCallOptions {
-  oauthUrl?: string;
-  model?: string;
-  timeoutMs?: number;
-  reasoningEffort?: string;
-}
-
-function plannerError(message: string, code: string, status = 502): PlannerError {
-  const err = new Error(message) as PlannerError;
-  err.code = code;
-  err.status = status;
-  return err;
-}
-
-function extractText(json: unknown): string {
-  if (!json || typeof json !== "object") return "";
-  const obj = json as Record<string, unknown>;
-  if (typeof obj.output_text === "string") return obj.output_text;
-  const output = Array.isArray(obj.output) ? (obj.output as unknown[]) : [];
-  for (const item of output) {
-    if (!item || typeof item !== "object") continue;
-    const contents = (item as Record<string, unknown>).content;
-    if (!Array.isArray(contents)) continue;
-    for (const content of contents as unknown[]) {
-      if (!content || typeof content !== "object") continue;
-      const c = content as Record<string, unknown>;
-      if (typeof c.text === "string") return c.text;
-      if (typeof c.value === "string") return c.value;
-    }
-  }
-  return "";
-}
-
-async function requestJson({ oauthUrl, model, messages, timeoutMs, structured, reasoningEffort }: PlannerRequestOptions): Promise<string> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const body = {
-      model,
-      input: messages,
-      stream: false,
-      ...(reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {}),
-      ...(structured
-        ? {
-            text: {
-              format: {
-                type: "json_schema",
-                name: "card_news_planner_output",
-                strict: true,
-                schema: CARD_NEWS_PLANNER_SCHEMA,
-              },
-            },
-          }
-        : { text: { format: { type: "json_object" } } }),
-    };
-    const res = await fetch(`${oauthUrl}/v1/responses`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      signal: controller.signal,
-      body: JSON.stringify(body),
-    });
-    logEvent("card-news-planner", "response", { model, status: res.status, structured });
-    if (!res.ok) {
-      const text = await res.text();
-      const err = plannerError("Planner upstream failed", "PLANNER_UPSTREAM_FAILED", 502);
-      err.upstreamStatus = res.status;
-      err.upstreamBodyChars = text.length;
-      throw err;
-    }
-    const json: unknown = await res.json();
-    return extractText(json);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function requestChatJson({ oauthUrl, model, messages, timeoutMs }: Omit<PlannerRequestOptions, "structured" | "reasoningEffort">): Promise<string> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const res = await fetch(`${oauthUrl}/v1/chat/completions`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      signal: controller.signal,
-      body: JSON.stringify({
-        model,
-        messages,
-        response_format: { type: "json_object" },
-      }),
-    });
-    logEvent("card-news-planner", "chat_response", { model, status: res.status });
-    if (!res.ok) {
-      const text = await res.text();
-      const err = plannerError("Planner upstream failed", "PLANNER_UPSTREAM_FAILED", 502);
-      err.upstreamStatus = res.status;
-      err.upstreamBodyChars = text.length;
-      throw err;
-    }
-    const json = (await res.json()) as { choices?: Array<{ message?: { content?: string } }> };
-    return json.choices?.[0]?.message?.content || "";
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export async function requestCardNewsPlannerJson(input: PlannerInput, options: PlannerCallOptions = {}) {
-  const oauthUrl = options.oauthUrl || `http://127.0.0.1:${config.oauth.proxyPort}`;
-  const model = options.model || config.cardNewsPlanner.model;
-  const timeoutMs = options.timeoutMs || config.cardNewsPlanner.timeoutMs;
-  const reasoningEffort = options.reasoningEffort || config.imageModels?.reasoningEffort || "medium";
-  let text = "";
-  let mode = "structured-output";
-  try {
-    text = await requestJson({ oauthUrl, model, messages: input.messages, timeoutMs, structured: true, reasoningEffort });
-  } catch (err) {
-    const code = (err as { code?: unknown })?.code;
-    if (code !== "PLANNER_UPSTREAM_FAILED") throw err;
-    mode = "json-mode";
-    text = await requestChatJson({ oauthUrl, model, messages: input.messages, timeoutMs });
-  }
-  try {
-    return { output: JSON.parse(text), mode, model };
-  } catch {
-    throw plannerError("Planner returned invalid JSON", "PLANNER_INVALID_JSON", 502);
-  }
-}

package/lib/cardNewsPlannerPrompt.ts

@@ -1,62 +0,0 @@
-export function buildCardNewsPlannerMessages(input: any = {}) {
-  const roleTemplate: any = input.roleTemplate || {};
-  const imageTemplate: any = input.imageTemplate || {};
-  return [
-    {
-      role: "developer",
-      content: [
-        "You are a Card News planning assistant.",
-        "Return JSON only. Do not call image tools. Do not generate images.",
-        "Keep the selected card count and role order exactly.",
-        "Preserve the user's original language for headline, body, textFields, and visualPrompt.",
-        "Do not translate to English unless explicitly requested.",
-        "If the user mixes languages, preserve the mix.",
-        "If the user provides exact text, preserve it exactly.",
-        "Role names such as cover/problem/cta are structural labels, not visible design text.",
-        "Keep headline and body as UI/manifest text.",
-        "Only textFields[].text with renderMode=\"in-image\" is intended to appear inside the image.",
-        "When visible text needs a specific language, textFields[].text must contain the exact words in that language/script.",
-        "Do not translate, romanize, summarize, or replace visible text.",
-        "Create textFields only for text that should be readable inside the image.",
-        "Prefer template slot ids and placements when assigning textFields.",
-        "Use headline textFields for hook/cover cards, body or caption textFields for explanation cards, and cta textFields only for action cards.",
-        "Never put structural role labels such as CTA, cover, problem, insight, or example into textFields unless the user explicitly requested that exact visible wording.",
-        "Placement examples: top-right badge, top-center headline, center-left supporting caption, bottom-center CTA.",
-        "Make visualPrompt describe scene, layout, style, spatial composition, and text-box placement only.",
-        "Do not duplicate visible text in visualPrompt except to reference a text box position.",
-        "visualPrompt may mention a text box location, but the exact readable copy must live only in textFields[].text.",
-      ].join("\n"),
-    },
-    {
-      role: "user",
-      content: JSON.stringify({
-        topic: input.topic || "",
-        audience: input.audience || "",
-        goal: input.goal || "",
-        contentBrief: input.contentBrief || "",
-        size: input.size || "2048x2048",
-        imageTemplate: {
-          id: imageTemplate.id,
-          name: imageTemplate.name,
-          stylePrompt: imageTemplate.stylePrompt,
-          recommendedOutputSizes: imageTemplate.recommendedOutputSizes || [],
-          slots: imageTemplate.slots || [],
-          palette: imageTemplate.palette || [],
-        },
-        roleTemplate: {
-          id: roleTemplate.id,
-          roles: (roleTemplate.roles || []).map((role: any) => ({
-            role: role.role,
-            promptHint: role.promptHint,
-            preferredSlots: role.preferredSlots || [],
-          })),
-        },
-        textFieldPolicy: {
-          visibleTextSource: "textFields[].text",
-          renderableMode: "in-image",
-          structuralRoleLabelsAreNotVisibleText: true,
-        },
-      }),
-    },
-  ];
-}