ima2-gen 1.1.21 → 1.1.23

package/lib/agentGenerationPlanner.ts

@@ -1,273 +0,0 @@
-import type {
-  AgentGenerationPlan,
-  AgentGenerationPlanSource,
-  AgentGenerationSettings,
-  AgentSlashCommand,
-} from "./agentTypes.js";
-
-const HARD_MAX_VARIANTS = 8;
-const AMBIGUOUS_MULTI_VARIANTS = 3;
-const KOREAN_COUNT_WORDS: Array<[RegExp, number]> = [
-  [/(?:한|하나|1)\s*(?:장|개|가지|컷|시안|버전)/u, 1],
-  [/(?:두|둘|2)\s*(?:장|개|가지|컷|시안|버전)/u, 2],
-  [/(?:세|셋|3)\s*(?:장|개|가지|컷|시안|버전)/u, 3],
-  [/(?:네|넷|4)\s*(?:장|개|가지|컷|시안|버전)/u, 4],
-  [/(?:다섯|5)\s*(?:장|개|가지|컷|시안|버전)/u, 5],
-  [/(?:여섯|6)\s*(?:장|개|가지|컷|시안|버전)/u, 6],
-  [/(?:일곱|7)\s*(?:장|개|가지|컷|시안|버전)/u, 7],
-  [/(?:여덟|8)\s*(?:장|개|가지|컷|시안|버전)/u, 8],
-];
-const ENGLISH_COUNT_WORDS: Array<[RegExp, number]> = [
-  [/\b(?:one|1)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 1],
-  [/\b(?:two|2)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 2],
-  [/\b(?:three|3)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 3],
-  [/\b(?:four|4)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 4],
-  [/\b(?:five|5)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 5],
-  [/\b(?:six|6)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 6],
-  [/\b(?:seven|7)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 7],
-  [/\b(?:eight|8)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 8],
-];
-
-type PlanningInput = {
-  prompt: string;
-  settings: AgentGenerationSettings;
-  command?: AgentSlashCommand | null;
-};
-
-type VariantDecision = {
-  count: number;
-  requested: number;
-  source: AgentGenerationPlanSource;
-  reason: string;
-};
-
-export function deriveAgentGenerationPlan({ prompt, settings, command = null }: PlanningInput): AgentGenerationPlan {
-  if (command?.name === "question" || command?.name === "help") {
-    return {
-      mode: "question",
-      prompts: [],
-      requestedVariants: 0,
-      plannedVariants: 0,
-      plannedParallelism: 0,
-      source: "question-command",
-      reason: command.name === "help" ? "Slash help answered without image generation." : "Question command answered without image generation.",
-      command: command.name,
-      assistantText: null,
-    };
-  }
-
-  if (isVideoIntent(prompt)) {
-    return {
-      mode: "video",
-      prompts: [prompt],
-      requestedVariants: 1,
-      plannedVariants: 1,
-      plannedParallelism: 1,
-      source: "auto-request",
-      reason: "Video generation detected from prompt keywords.",
-      command: command?.name ?? null,
-      assistantText: null,
-    };
-  }
-
-  const variantDecision = decideVariantCount(prompt, settings, command);
-  const plannedParallelism = resolvePlannedParallelism(settings, variantDecision.count, command);
-  const prompts = buildGenerationPrompts(prompt, variantDecision.count);
-  return {
-    mode: prompts.length > 1 ? "fanout" : "single",
-    prompts,
-    requestedVariants: variantDecision.requested,
-    plannedVariants: prompts.length,
-    plannedParallelism,
-    source: variantDecision.source,
-    reason: variantDecision.reason,
-    command: command?.name ?? null,
-    assistantText: null,
-  };
-}
-
-export function normalizeAgentGenerationPlan(
-  prompt: string,
-  value: unknown,
-  settings: AgentGenerationSettings,
-): AgentGenerationPlan {
-  const input = value && typeof value === "object" ? value as Record<string, unknown> : {};
-  const prompts = cleanPromptArray(input.prompts);
-  if (prompts.length === 0) return deriveAgentGenerationPlan({ prompt, settings, command: cleanCommand(input.command) });
-
-  const plannedVariants = cleanCount(input.plannedVariants, prompts.length, 0, HARD_MAX_VARIANTS);
-  const requestedParallelism = cleanCount(input.plannedParallelism, settings.parallelism, 1, HARD_MAX_VARIANTS);
-  const plannedParallelism = resolvePlannedParallelism({ ...settings, parallelism: requestedParallelism }, plannedVariants, null);
-  return {
-    mode: input.mode === "question" ? "question" : input.mode === "video" ? "video" : prompts.length > 1 ? "fanout" : "single",
-    prompts,
-    requestedVariants: cleanCount(input.requestedVariants, plannedVariants, 0, HARD_MAX_VARIANTS),
-    plannedVariants,
-    plannedParallelism,
-    source: cleanPlanSource(input.source),
-    reason: cleanReason(input.reason, prompts.length > 1 ? "Stored fanout plan." : "Stored single-image plan."),
-    command: cleanCommandName(input.command),
-    assistantText: typeof input.assistantText === "string" ? input.assistantText : null,
-  };
-}
-
-function decideVariantCount(
-  prompt: string,
-  settings: AgentGenerationSettings,
-  command: AgentSlashCommand | null,
-): VariantDecision {
-  if (command?.name === "variants" || command?.name === "generate") {
-    const count = clampCount(command.value ?? AMBIGUOUS_MULTI_VARIANTS, HARD_MAX_VARIANTS);
-    return {
-      count,
-      requested: count,
-      source: "slash-command",
-      reason: `Slash command requested ${count} variant${count === 1 ? "" : "s"}.`,
-    };
-  }
-
-  if (settings.generationStrategy === "manual") {
-    const count = clampCount(settings.variants, HARD_MAX_VARIANTS);
-    return {
-      count,
-      requested: count,
-      source: "manual-settings",
-      reason: `Manual settings requested ${count} variant${count === 1 ? "" : "s"}.`,
-    };
-  }
-
-  const inferred = inferRequestedVariantCount(prompt);
-  const capped = Math.min(inferred.count, clampCount(settings.maxAutoVariants, HARD_MAX_VARIANTS));
-  return {
-    count: capped,
-    requested: inferred.count,
-    source: inferred.count > 1 ? "auto-request" : "auto-default",
-    reason: capped < inferred.count
-      ? `User request implied ${inferred.count} variants; capped at ${capped}.`
-      : inferred.reason,
-  };
-}
-
-function inferRequestedVariantCount(prompt: string): { count: number; reason: string } {
-  const text = prompt.trim();
-  for (const [pattern, count] of [...KOREAN_COUNT_WORDS, ...ENGLISH_COUNT_WORDS]) {
-    if (pattern.test(text)) {
-      return { count, reason: `User request explicitly implies ${count} variant${count === 1 ? "" : "s"}.` };
-    }
-  }
-  if (/(?:여러|몇\s*가지|시안|후보|버전|다양하게|several|multiple|options|variants|versions|candidates|alternatives)/iu.test(text)) {
-    return { count: AMBIGUOUS_MULTI_VARIANTS, reason: `User request asks for multiple options; planning ${AMBIGUOUS_MULTI_VARIANTS} variants.` };
-  }
-  if (/(?:비교|대안|a\/b|compare|comparison)/iu.test(text)) {
-    return { count: 2, reason: "User request implies comparison; planning 2 variants." };
-  }
-  return { count: 1, reason: "Defaulting to one image because the request did not ask for multiple variants." };
-}
-
-function resolvePlannedParallelism(
-  settings: AgentGenerationSettings,
-  plannedVariants: number,
-  command: AgentSlashCommand | null,
-): number {
-  if (plannedVariants <= 0) return 0;
-  const requested = command?.name === "parallelism" && command.value ? command.value : settings.parallelism;
-  const providerCap = settings.provider === "oauth" ? 2 : HARD_MAX_VARIANTS;
-  const qualityCap = settings.quality === "high" ? 2 : HARD_MAX_VARIANTS;
-  return Math.max(1, Math.min(plannedVariants, clampCount(requested, HARD_MAX_VARIANTS), providerCap, qualityCap));
-}
-
-function buildGenerationPrompts(prompt: string, count: number): string[] {
-  if (count <= 1) return [prompt];
-  return Array.from({ length: count }, (_, index) => [
-    prompt,
-    "",
-    `Variant ${index + 1}/${count}: explore a distinct composition while preserving the request.`,
-  ].join("\n"));
-}
-
-function cleanPromptArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return value.filter((item): item is string => typeof item === "string" && item.trim().length > 0)
-    .slice(0, HARD_MAX_VARIANTS)
-    .map((item) => item.trim());
-}
-
-function cleanPlanSource(value: unknown): AgentGenerationPlanSource {
-  if (
-    value === "auto-default" ||
-    value === "auto-request" ||
-    value === "manual-settings" ||
-    value === "slash-command" ||
-    value === "question-command"
-  ) return value;
-  return "auto-default";
-}
-
-function cleanCommandName(value: unknown): AgentGenerationPlan["command"] {
-  if (
-    value === "question" ||
-    value === "help" ||
-    value === "variants" ||
-    value === "generate" ||
-    value === "parallelism"
-  ) return value;
-  return null;
-}
-
-function cleanCommand(value: unknown): AgentSlashCommand | null {
-  if (!value || typeof value !== "object") return null;
-  const input = value as Record<string, unknown>;
-  const name = cleanCommandName(input.name);
-  if (!name) return null;
-  return {
-    name,
-    rawName: typeof input.rawName === "string" ? input.rawName : name,
-    raw: typeof input.raw === "string" ? input.raw : "",
-    prompt: typeof input.prompt === "string" ? input.prompt : "",
-    ...(typeof input.value === "number" ? { value: input.value } : {}),
-  };
-}
-
-function cleanReason(value: unknown, fallback: string): string {
-  return typeof value === "string" && value.trim() ? value.trim().slice(0, 240) : fallback;
-}
-
-function cleanCount(value: unknown, fallback: number, min: number, max: number): number {
-  const numeric = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(numeric)) return fallback;
-  return Math.max(min, Math.min(max, Math.round(numeric)));
-}
-
-function clampCount(value: number, max: number): number {
-  return Math.max(1, Math.min(max, Math.round(value)));
-}
-
-const VIDEO_INTENT_PATTERN = /(?:^|\s|[^\p{L}])(?:video|animate|animation)(?:\s|[^\p{L}]|$)|(?:동영상|비디오|영상|애니메이트|움직이|클립)/iu;
-
-function isVideoIntent(prompt: string): boolean {
-  return VIDEO_INTENT_PATTERN.test(prompt);
-}
-
-export interface VideoParamsFromPrompt {
-  duration?: number;
-  resolution?: "480p" | "720p";
-  aspectRatio?: string;
-}
-
-const DURATION_PATTERN = /(\d{1,2})\s*(?:s|sec|seconds?|초)/i;
-const RESOLUTION_PATTERN = /(720p|480p)/i;
-const ASPECT_PATTERN = /(16:9|9:16|4:3|3:4|3:2|2:3|1:1)/;
-
-export function parseVideoParams(prompt: string): VideoParamsFromPrompt {
-  const params: VideoParamsFromPrompt = {};
-  const durMatch = DURATION_PATTERN.exec(prompt);
-  if (durMatch) {
-    const d = parseInt(durMatch[1]);
-    if (d >= 1 && d <= 15) params.duration = d;
-  }
-  const resMatch = RESOLUTION_PATTERN.exec(prompt);
-  if (resMatch) params.resolution = resMatch[1].toLowerCase() as "480p" | "720p";
-  const aspMatch = ASPECT_PATTERN.exec(prompt);
-  if (aspMatch) params.aspectRatio = aspMatch[1];
-  return params;
-}

package/lib/agentQuestionResponder.ts

@@ -1,266 +0,0 @@
-import { errInfo } from "./errInfo.js";
-import { logEvent } from "./logger.js";
-import { waitForOAuthReady } from "./oauthProxy/runtime.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "./runtimeContext.js";
-
-const AGENT_QUESTION_DEVELOPER_PROMPT = [
-  "You are the text-only question mode for ima2-gen Agent.",
-  "Answer the user's question directly and naturally in the user's language.",
-  "Do not generate images, do not call image tools, and do not turn the question into an image prompt.",
-  "Do not simply repeat the user's question unless the user explicitly asks you to repeat text.",
-  "Keep the answer concise and useful for an image-generation workflow when relevant.",
-].join(" ");
-
-type AgentQuestionOptions = {
-  provider?: string;
-  model?: string;
-  reasoningEffort?: string;
-  requestId?: string;
-  signal?: AbortSignal | null;
-};
-
-type AgentQuestionResult = {
-  text: string;
-  usage: Record<string, unknown> | null;
-};
-
-type QuestionEndpoint = {
-  url: string;
-  headers: Record<string, string>;
-};
-
-type TextContentPart = {
-  type?: string;
-  text?: string | { value?: string };
-  value?: string;
-  refusal?: string;
-};
-
-type TextResponseBody = {
-  output_text?: string;
-  output?: Array<{
-    type?: string;
-    content?: TextContentPart[];
-  }>;
-  usage?: Record<string, unknown>;
-};
-
-type SseEvent = {
-  type?: string;
-  delta?: string;
-  text?: string;
-  item?: {
-    type?: string;
-    content?: TextContentPart[];
-  };
-  response?: { usage?: Record<string, unknown> };
-  error?: { code?: string; message?: string };
-};
-
-export async function requestAgentQuestionAnswer(
-  ctxRaw: RouteRuntimeContext,
-  question: string,
-  options: AgentQuestionOptions = {},
-): Promise<AgentQuestionResult> {
-  try {
-    const ctx = requireRuntimeContext(ctxRaw);
-    const endpoint = await resolveQuestionEndpoint(ctx, options.provider);
-    const timeoutMs = ctx.config.oauth?.generationTimeoutMs ?? 120_000;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    const signal = options.signal ? combineSignals([controller.signal, options.signal]) : controller.signal;
-    try {
-      const res = await fetch(endpoint.url, {
-        method: "POST",
-        headers: endpoint.headers,
-        signal,
-        body: JSON.stringify({
-          model: options.model || ctx.config.imageModels?.default || "gpt-5.4-mini",
-          input: [
-            { role: "developer", content: AGENT_QUESTION_DEVELOPER_PROMPT },
-            { role: "user", content: question },
-          ],
-          reasoning: { effort: options.reasoningEffort || "low" },
-          stream: true,
-        }),
-      });
-      logEvent("agent_question", "response", {
-        requestId: options.requestId,
-        provider: options.provider,
-        status: res.status,
-        contentType: res.headers.get("content-type"),
-      });
-      if (!res.ok) throw await questionHttpError(res, options.provider);
-      const parsed = res.headers.get("content-type")?.includes("text/event-stream")
-        ? await readTextStream(res)
-        : readTextBody(await res.json() as TextResponseBody);
-      if (!parsed.text.trim()) throw questionError("Agent question returned an empty response", "AGENT_QUESTION_EMPTY", 502);
-      return { text: parsed.text.trim().slice(0, 4_000), usage: parsed.usage };
-    } finally {
-      clearTimeout(timer);
-    }
-  } catch (error) {
-    const err = errInfo(error);
-    if (err.name === "AbortError") {
-      throw questionError("Agent question timed out", "AGENT_QUESTION_TIMEOUT", 504, err.raw);
-    }
-    throw err.raw;
-  }
-}
-
-async function resolveQuestionEndpoint(
-  ctx: ReturnType<typeof requireRuntimeContext>,
-  provider: string | undefined,
-): Promise<QuestionEndpoint> {
-  try {
-    if (provider === "api") {
-      if (!ctx.apiKey) throw questionError("API key is required for Agent question mode", "API_KEY_REQUIRED", 401);
-      return {
-        url: "https://api.openai.com/v1/responses",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "text/event-stream",
-          Authorization: `Bearer ${ctx.apiKey}`,
-        },
-      };
-    }
-    await waitForOAuthReady(ctx);
-    return {
-      url: `${ctx.oauthUrl}/v1/responses`,
-      headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
-    };
-  } catch (error) {
-    throw errInfo(error).raw;
-  }
-}
-
-async function questionHttpError(res: Response, provider: string | undefined): Promise<Error> {
-  try {
-    const text = await res.text();
-    const err = questionError(
-      `${provider === "api" ? "OpenAI API" : "OAuth proxy"} rejected Agent question mode`,
-      "AGENT_QUESTION_UPSTREAM_FAILED",
-      res.status >= 400 && res.status < 600 ? res.status : 502,
-    );
-    err.upstreamBodyChars = text.length;
-    return err;
-  } catch (error) {
-    throw errInfo(error).raw;
-  }
-}
-
-async function readTextStream(res: Response): Promise<AgentQuestionResult> {
-  try {
-    const reader = res.body?.getReader();
-    if (!reader) return { text: "", usage: null };
-    const decoder = new TextDecoder();
-    const parts: string[] = [];
-    let usage: Record<string, unknown> | null = null;
-    let buffer = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let boundary = buffer.indexOf("\n\n");
-      while (boundary !== -1) {
-        const block = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        const event = parseSseEvent(block);
-        if (event) collectTextEvent(event, parts, (nextUsage) => {
-          usage = nextUsage;
-        });
-        boundary = buffer.indexOf("\n\n");
-      }
-    }
-    const finalEvent = parseSseEvent(buffer);
-    if (finalEvent) collectTextEvent(finalEvent, parts, (nextUsage) => {
-      usage = nextUsage;
-    });
-    return { text: parts.join("").trim(), usage };
-  } catch (error) {
-    throw errInfo(error).raw;
-  }
-}
-
-function readTextBody(body: TextResponseBody): AgentQuestionResult {
-  if (typeof body.output_text === "string" && body.output_text.trim()) {
-    return { text: body.output_text, usage: body.usage ?? null };
-  }
-  const parts: string[] = [];
-  for (const item of body.output ?? []) {
-    appendContentText(item.content, parts);
-  }
-  return { text: parts.join("\n\n").trim(), usage: body.usage ?? null };
-}
-
-function parseSseEvent(block: string): SseEvent | null {
-  const data = block
-    .split("\n")
-    .filter((line) => line.startsWith("data:"))
-    .map((line) => line.slice(5).trimStart())
-    .join("\n");
-  if (!data || data === "[DONE]") return null;
-  try {
-    const parsed = JSON.parse(data) as unknown;
-    return parsed && typeof parsed === "object" ? parsed as SseEvent : null;
-  } catch {
-    return null;
-  }
-}
-
-function collectTextEvent(
-  event: SseEvent,
-  parts: string[],
-  setUsage: (usage: Record<string, unknown>) => void,
-) {
-  if (event.type === "response.output_text.delta" && typeof event.delta === "string") parts.push(event.delta);
-  if (event.type === "response.output_text.done" && typeof event.text === "string" && parts.length === 0) parts.push(event.text);
-  if (event.type === "response.output_item.done" && event.item?.type === "message" && parts.length === 0) {
-    appendContentText(event.item.content, parts);
-  }
-  if ((event.type === "response.completed" || event.type === "response.incomplete") && event.response?.usage) {
-    setUsage(event.response.usage);
-  }
-  if (event.type === "error") {
-    throw questionError(
-      event.error?.message || "Agent question stream failed",
-      event.error?.code || "AGENT_QUESTION_STREAM_ERROR",
-      502,
-    );
-  }
-}
-
-function appendContentText(content: TextContentPart[] | undefined, parts: string[]) {
-  for (const part of content ?? []) {
-    if (typeof part.text === "string" && part.text.trim()) parts.push(part.text);
-    else if (part.text && typeof part.text === "object" && typeof part.text.value === "string") parts.push(part.text.value);
-    else if (typeof part.value === "string" && part.value.trim()) parts.push(part.value);
-    else if (typeof part.refusal === "string" && part.refusal.trim()) parts.push(part.refusal);
-  }
-}
-
-function combineSignals(signals: AbortSignal[]): AbortSignal {
-  if (signals.length === 1) return signals[0];
-  const controller = new AbortController();
-  for (const signal of signals) {
-    if (signal.aborted) {
-      controller.abort();
-      break;
-    }
-    signal.addEventListener("abort", () => controller.abort(), { once: true });
-  }
-  return controller.signal;
-}
-
-function questionError(message: string, code: string, status: number, cause?: unknown) {
-  const err = new Error(message) as Error & {
-    code?: string;
-    status?: number;
-    cause?: unknown;
-    upstreamBodyChars?: number;
-  };
-  err.code = code;
-  err.status = status;
-  if (cause) err.cause = cause;
-  return err;
-}