@unlimiting/unlimitgen 0.1.0

package/src/core/catalog.ts

@@ -0,0 +1,141 @@
+import { Modality, Provider } from './types.js';
+
+export interface ModelCatalogItem {
+  provider: Provider;
+  modality: Modality;
+  model: string;
+  supportsText: boolean;
+  supportsImageInput: boolean;
+  options: string[];
+  notes?: string;
+}
+
+export const MODEL_CATALOG: ModelCatalogItem[] = [
+  {
+    provider: 'gemini',
+    modality: 'image',
+    model: 'gemini-3-pro-image-preview',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['responseModalities', 'temperature', 'topP', 'topK', 'seed']
+  },
+  {
+    provider: 'gemini',
+    modality: 'image',
+    model: 'gemini-2.5-flash-image-preview',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['responseModalities', 'temperature', 'topP', 'topK', 'seed']
+  },
+  {
+    provider: 'gemini',
+    modality: 'image',
+    model: 'imagen-4.0-generate-001',
+    supportsText: true,
+    supportsImageInput: false,
+    options: ['negativePrompt', 'numberOfImages', 'aspectRatio', 'guidanceScale', 'seed', 'outputMimeType', 'imageSize', 'enhancePrompt']
+  },
+  {
+    provider: 'gemini',
+    modality: 'image',
+    model: 'imagen-4.0-ultra-generate-001',
+    supportsText: true,
+    supportsImageInput: false,
+    options: ['negativePrompt', 'numberOfImages', 'aspectRatio', 'guidanceScale', 'seed', 'outputMimeType', 'imageSize', 'enhancePrompt']
+  },
+  {
+    provider: 'gemini',
+    modality: 'image',
+    model: 'imagen-4.0-fast-generate-001',
+    supportsText: true,
+    supportsImageInput: false,
+    options: ['negativePrompt', 'numberOfImages', 'aspectRatio', 'guidanceScale', 'seed', 'outputMimeType', 'imageSize', 'enhancePrompt']
+  },
+  {
+    provider: 'openai',
+    modality: 'image',
+    model: 'gpt-image-1.5',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['background', 'moderation', 'n', 'output_format', 'output_compression', 'quality', 'size', 'stream']
+  },
+  {
+    provider: 'openai',
+    modality: 'image',
+    model: 'gpt-image-1',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['background', 'moderation', 'n', 'output_format', 'output_compression', 'quality', 'size', 'stream', 'input_fidelity']
+  },
+  {
+    provider: 'openai',
+    modality: 'image',
+    model: 'gpt-image-1-mini',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['background', 'moderation', 'n', 'output_format', 'output_compression', 'quality', 'size', 'stream']
+  },
+  {
+    provider: 'grok',
+    modality: 'image',
+    model: 'grok-imagine-image',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['n', 'output_format', 'quality', 'size'],
+    notes: 'xAI는 OpenAI 호환 SDK 경로를 사용'
+  },
+  {
+    provider: 'grok',
+    modality: 'image',
+    model: 'grok-imagine-image-pro',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['n', 'output_format', 'quality', 'size'],
+    notes: 'xAI는 OpenAI 호환 SDK 경로를 사용'
+  },
+  {
+    provider: 'gemini',
+    modality: 'video',
+    model: 'veo-3.1-generate-preview',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['numberOfVideos', 'fps', 'durationSeconds', 'seed', 'aspectRatio', 'resolution', 'negativePrompt', 'enhancePrompt', 'generateAudio']
+  },
+  {
+    provider: 'gemini',
+    modality: 'video',
+    model: 'veo-3.1-fast-generate-preview',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['numberOfVideos', 'fps', 'durationSeconds', 'seed', 'aspectRatio', 'resolution', 'negativePrompt', 'enhancePrompt', 'generateAudio']
+  },
+  {
+    provider: 'openai',
+    modality: 'video',
+    model: 'sora-2',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['seconds', 'size']
+  },
+  {
+    provider: 'openai',
+    modality: 'video',
+    model: 'sora-2-pro',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['seconds', 'size']
+  },
+  {
+    provider: 'grok',
+    modality: 'video',
+    model: 'grok-imagine-video',
+    supportsText: true,
+    supportsImageInput: true,
+    options: ['seconds', 'size'],
+    notes: 'xAI는 OpenAI 호환 SDK 경로를 사용'
+  }
+];
+
+export function getModelItem(provider: Provider, modality: Modality, model: string): ModelCatalogItem | undefined {
+  return MODEL_CATALOG.find((item) => item.provider === provider && item.modality === modality && item.model === model);
+}

package/src/core/generate.ts

@@ -0,0 +1,31 @@
+import { generateImageWithGemini, generateVideoWithGemini } from '../providers/gemini.js';
+import { generateImageWithOpenAILike, generateVideoWithOpenAILike } from '../providers/openaiLike.js';
+import { GenerateImageRequest, GenerateResult, GenerateVideoRequest } from './types.js';
+
+export async function generateImage(req: GenerateImageRequest, apiKey: string): Promise<GenerateResult> {
+  if (req.provider === 'gemini') {
+    return generateImageWithGemini(req, apiKey);
+  }
+  if (req.provider === 'openai') {
+    return generateImageWithOpenAILike(req, { provider: 'openai', apiKey });
+  }
+  return generateImageWithOpenAILike(req, {
+    provider: 'grok',
+    apiKey,
+    baseURL: 'https://api.x.ai/v1'
+  });
+}
+
+export async function generateVideo(req: GenerateVideoRequest, apiKey: string): Promise<GenerateResult> {
+  if (req.provider === 'gemini') {
+    return generateVideoWithGemini(req, apiKey);
+  }
+  if (req.provider === 'openai') {
+    return generateVideoWithOpenAILike(req, { provider: 'openai', apiKey });
+  }
+  return generateVideoWithOpenAILike(req, {
+    provider: 'grok',
+    apiKey,
+    baseURL: 'https://api.x.ai/v1'
+  });
+}

package/src/core/types.ts

@@ -0,0 +1,31 @@
+export type Provider = 'gemini' | 'openai' | 'grok';
+export type Modality = 'image' | 'video';
+export type InputPart =
+  | { type: 'text'; value: string }
+  | { type: 'image'; value: string };
+
+export interface GenerateImageRequest {
+  provider: Provider;
+  model: string;
+  parts: InputPart[];
+  outDir: string;
+  options: Record<string, unknown>;
+}
+
+export interface GenerateVideoRequest {
+  provider: Provider;
+  model: string;
+  parts: InputPart[];
+  outDir: string;
+  options: Record<string, unknown>;
+  pollIntervalMs: number;
+  timeoutMs: number;
+}
+
+export interface GenerateResult {
+  provider: Provider;
+  model: string;
+  modality: Modality;
+  outputs: string[];
+  meta?: Record<string, unknown>;
+}

package/src/providers/gemini.ts

@@ -0,0 +1,142 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { GoogleGenAI, createPartFromUri } from '@google/genai';
+import { GenerateImageRequest, GenerateResult, GenerateVideoRequest } from '../core/types.js';
+import { detectMimeTypeFromPath, fileExists, writeBase64File } from '../utils/io.js';
+import { imageParts, joinTextParts } from '../utils/parts.js';
+
+export async function generateImageWithGemini(req: GenerateImageRequest, apiKey: string): Promise<GenerateResult> {
+  const ai = new GoogleGenAI({ apiKey });
+  const text = joinTextParts(req.parts);
+  const images = imageParts(req.parts);
+
+  if (req.model.startsWith('imagen-')) {
+    if (!text) {
+      throw new Error('Imagen 계열은 text 파트가 필요합니다.');
+    }
+    if (images.length > 0) {
+      throw new Error(`${req.model}은 이 CLI에서 text-to-image만 지원합니다. (image 입력 불가)`);
+    }
+
+    const response = await ai.models.generateImages({
+      model: req.model,
+      prompt: text,
+      config: req.options as any
+    });
+
+    const outputs: string[] = [];
+    for (const image of response.generatedImages ?? []) {
+      const b64 = image.image?.imageBytes;
+      if (!b64) continue;
+      const mime = (req.options.outputMimeType as string | undefined) ?? 'image/png';
+      const ext = mime === 'image/jpeg' ? 'jpg' : mime === 'image/webp' ? 'webp' : 'png';
+      outputs.push(await writeBase64File(b64, req.outDir, 'gemini-image', ext));
+    }
+
+    return { provider: 'gemini', model: req.model, modality: 'image', outputs };
+  }
+
+  const contentParts: any[] = [];
+  for (const part of req.parts) {
+    if (part.type === 'text') {
+      contentParts.push({ text: part.value });
+      continue;
+    }
+
+    if (!(await fileExists(part.value))) {
+      throw new Error(`이미지 파일을 찾을 수 없습니다: ${part.value}`);
+    }
+    const uploaded = await ai.files.upload({ file: part.value });
+    if (!uploaded.uri || !uploaded.mimeType) {
+      throw new Error(`Gemini 파일 업로드 결과에 uri/mimeType이 없습니다: ${part.value}`);
+    }
+    contentParts.push(createPartFromUri(uploaded.uri, uploaded.mimeType));
+  }
+
+  const response = await ai.models.generateContent({
+    model: req.model,
+    contents: [{ role: 'user', parts: contentParts }],
+    config: {
+      responseModalities: ['IMAGE', 'TEXT'],
+      ...(req.options as Record<string, unknown>)
+    }
+  });
+
+  const outputs: string[] = [];
+  const candidates = (response as any).candidates ?? [];
+  for (const candidate of candidates) {
+    const parts = candidate?.content?.parts ?? [];
+    for (const part of parts) {
+      const b64 = part?.inlineData?.data;
+      const mime = part?.inlineData?.mimeType as string | undefined;
+      if (!b64) continue;
+      const ext = mime === 'image/jpeg' ? 'jpg' : mime === 'image/webp' ? 'webp' : 'png';
+      outputs.push(await writeBase64File(b64, req.outDir, 'gemini-image', ext));
+    }
+  }
+
+  return { provider: 'gemini', model: req.model, modality: 'image', outputs };
+}
+
+export async function generateVideoWithGemini(req: GenerateVideoRequest, apiKey: string): Promise<GenerateResult> {
+  const ai = new GoogleGenAI({ apiKey });
+  const text = joinTextParts(req.parts);
+  const images = imageParts(req.parts);
+
+  if (!text && images.length === 0) {
+    throw new Error('Gemini 비디오는 text 또는 image 입력이 필요합니다.');
+  }
+
+  if (images.length > 1) {
+    throw new Error('Gemini 비디오는 현재 이미지 입력 1개만 지원합니다.');
+  }
+
+  const source: Record<string, unknown> = {};
+  if (text) source.prompt = text;
+
+  if (images[0]) {
+    if (!(await fileExists(images[0]))) {
+      throw new Error(`이미지 파일을 찾을 수 없습니다: ${images[0]}`);
+    }
+    const bytes = await fs.readFile(images[0]);
+    source.image = {
+      imageBytes: bytes.toString('base64'),
+      mimeType: await detectMimeTypeFromPath(images[0])
+    };
+  }
+
+  let operation = await ai.models.generateVideos({
+    model: req.model,
+    source,
+    config: req.options as any
+  });
+
+  const started = Date.now();
+  while (!operation.done) {
+    if (Date.now() - started > req.timeoutMs) {
+      throw new Error('Gemini 비디오 생성 대기 시간이 초과되었습니다. --timeout-ms를 늘려주세요.');
+    }
+    await new Promise((resolve) => setTimeout(resolve, req.pollIntervalMs));
+    operation = await ai.operations.getVideosOperation({ operation });
+  }
+
+  const generated = operation.response?.generatedVideos ?? [];
+  if (generated.length === 0) {
+    throw new Error('Gemini 비디오 생성 결과가 비어 있습니다.');
+  }
+
+  const outputs: string[] = [];
+  for (let i = 0; i < generated.length; i += 1) {
+    const downloadPath = path.resolve(req.outDir, `gemini-video-${Date.now()}-${i + 1}.mp4`);
+    await ai.files.download({ file: generated[i], downloadPath });
+    outputs.push(downloadPath);
+  }
+
+  return {
+    provider: 'gemini',
+    model: req.model,
+    modality: 'video',
+    outputs,
+    meta: { operationName: operation.name }
+  };
+}

package/src/providers/openaiLike.ts

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import OpenAI from 'openai';
+import { GenerateImageRequest, GenerateResult, GenerateVideoRequest, Provider } from '../core/types.js';
+import { imageParts, joinTextParts } from '../utils/parts.js';
+import { fileExists, writeBase64File, writeBufferFile } from '../utils/io.js';
+
+interface OpenAILikeConfig {
+  provider: Provider;
+  apiKey: string;
+  baseURL?: string;
+}
+
+function makeClient(config: OpenAILikeConfig): OpenAI {
+  return new OpenAI({
+    apiKey: config.apiKey,
+    baseURL: config.baseURL
+  });
+}
+
+export async function generateImageWithOpenAILike(req: GenerateImageRequest, config: OpenAILikeConfig): Promise<GenerateResult> {
+  const client = makeClient(config);
+  const prompt = joinTextParts(req.parts);
+  const images = imageParts(req.parts);
+
+  if (!prompt) {
+    throw new Error('이미지 생성에는 최소 1개의 text 파트가 필요합니다.');
+  }
+
+  if (images.length === 0) {
+    const result = await client.images.generate({
+      model: req.model,
+      prompt,
+      ...(req.options as Record<string, never>)
+    });
+
+    const outputs: string[] = [];
+    for (const image of result.data ?? []) {
+      if (!image.b64_json) continue;
+      const ext = ((req.options.output_format as string | undefined) ?? 'png').replace('jpeg', 'jpg');
+      outputs.push(await writeBase64File(image.b64_json, req.outDir, `${config.provider}-image`, ext));
+    }
+
+    return { provider: config.provider, model: req.model, modality: 'image', outputs };
+  }
+
+  const uploadables: fs.ReadStream[] = [];
+  for (const imagePath of images) {
+    if (!(await fileExists(imagePath))) {
+      throw new Error(`이미지 파일을 찾을 수 없습니다: ${imagePath}`);
+    }
+    uploadables.push(fs.createReadStream(imagePath));
+  }
+
+  const edited = await client.images.edit({
+    model: req.model,
+    prompt,
+    image: uploadables as unknown as fs.ReadStream,
+    ...(req.options as Record<string, never>)
+  } as any);
+
+  const outputs: string[] = [];
+  for (const image of edited.data ?? []) {
+    if (!image.b64_json) continue;
+    const ext = ((req.options.output_format as string | undefined) ?? 'png').replace('jpeg', 'jpg');
+    outputs.push(await writeBase64File(image.b64_json, req.outDir, `${config.provider}-image`, ext));
+  }
+
+  return { provider: config.provider, model: req.model, modality: 'image', outputs };
+}
+
+export async function generateVideoWithOpenAILike(req: GenerateVideoRequest, config: OpenAILikeConfig): Promise<GenerateResult> {
+  const client = makeClient(config);
+  const prompt = joinTextParts(req.parts);
+  const images = imageParts(req.parts);
+
+  if (!prompt) {
+    throw new Error('동영상 생성에는 최소 1개의 text 파트가 필요합니다.');
+  }
+
+  if (images.length > 1) {
+    throw new Error('OpenAI/xAI 비디오는 현재 이미지 참조 1개만 지원합니다.');
+  }
+
+  const createReq: Record<string, unknown> = {
+    model: req.model,
+    prompt,
+    ...(req.options as Record<string, unknown>)
+  };
+
+  if (images[0]) {
+    if (!(await fileExists(images[0]))) {
+      throw new Error(`이미지 파일을 찾을 수 없습니다: ${images[0]}`);
+    }
+    createReq.input_reference = fs.createReadStream(images[0]);
+  }
+
+  let job = await client.videos.create(createReq as any);
+
+  const started = Date.now();
+  while (job.status !== 'completed') {
+    if (job.status === 'failed') {
+      throw new Error(`비디오 생성 실패: ${job.error?.message ?? '알 수 없는 오류'}`);
+    }
+    if (Date.now() - started > req.timeoutMs) {
+      throw new Error('비디오 생성 대기 시간이 초과되었습니다. --timeout-ms를 늘려주세요.');
+    }
+    await new Promise((resolve) => setTimeout(resolve, req.pollIntervalMs));
+    job = await client.videos.retrieve(job.id);
+  }
+
+  const response = await client.videos.downloadContent(job.id, { variant: 'video' });
+  const arrayBuffer = await response.arrayBuffer();
+  const outputPath = await writeBufferFile(Buffer.from(arrayBuffer), req.outDir, `${config.provider}-video`, 'mp4');
+
+  return {
+    provider: config.provider,
+    model: req.model,
+    modality: 'video',
+    outputs: [outputPath],
+    meta: { jobId: job.id }
+  };
+}

package/src/utils/auth.ts

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import inquirer from 'inquirer';
+import { Provider } from '../core/types.js';
+
+const ENV_KEYS: Record<Provider, string[]> = {
+  gemini: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+  openai: ['OPENAI_API_KEY'],
+  grok: ['XAI_API_KEY']
+};
+
+const TOKEN_DIR = path.join(os.homedir(), '.config', 'unlimitgen');
+const TOKEN_FILE = path.join(TOKEN_DIR, 'tokens.json');
+
+type TokenStore = Partial<Record<Provider, string>>;
+
+export async function resolveApiKey(provider: Provider): Promise<string> {
+  const fromEnv = resolveFromEnv(provider);
+  if (fromEnv) return fromEnv;
+
+  const stored = await getStoredToken(provider);
+  if (stored) return stored;
+
+  return promptForToken(provider);
+}
+
+export async function authAndStoreToken(provider: Provider): Promise<void> {
+  const token = await promptForToken(provider);
+  await setStoredToken(provider, token);
+}
+
+export async function getStoredToken(provider: Provider): Promise<string | undefined> {
+  const store = await readTokenStore();
+  const token = store[provider];
+  return token && token.trim().length > 0 ? token : undefined;
+}
+
+export async function setStoredToken(provider: Provider, token: string): Promise<void> {
+  await fs.mkdir(TOKEN_DIR, { recursive: true });
+
+  const current = await readTokenStore();
+  current[provider] = token.trim();
+
+  await fs.writeFile(TOKEN_FILE, `${JSON.stringify(current, null, 2)}\n`, { mode: 0o600 });
+  await fs.chmod(TOKEN_FILE, 0o600);
+}
+
+export function getTokenFilePath(): string {
+  return TOKEN_FILE;
+}
+
+function resolveFromEnv(provider: Provider): string | undefined {
+  const keys = ENV_KEYS[provider];
+  for (const key of keys) {
+    const value = process.env[key];
+    if (value) return value;
+  }
+  return undefined;
+}
+
+async function readTokenStore(): Promise<TokenStore> {
+  try {
+    const raw = await fs.readFile(TOKEN_FILE, 'utf8');
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed as TokenStore;
+  } catch {
+    return {};
+  }
+}
+
+async function promptForToken(provider: Provider): Promise<string> {
+  const answer = await inquirer.prompt<{ token: string }>([
+    {
+      type: 'password',
+      name: 'token',
+      message: `${provider.toUpperCase()} API 토큰을 입력하세요 (입력 내용 숨김):`,
+      mask: '*',
+      validate: (input: string) => (input.trim().length > 0 ? true : '토큰이 비어 있습니다.')
+    }
+  ]);
+
+  return answer.token.trim();
+}

package/src/utils/io.ts

@@ -0,0 +1,40 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function writeBase64File(base64: string, outDir: string, prefix: string, ext: string): Promise<string> {
+  await ensureDir(outDir);
+  const fileName = `${prefix}-${Date.now()}.${ext}`;
+  const fullPath = path.resolve(outDir, fileName);
+  await fs.writeFile(fullPath, Buffer.from(base64, 'base64'));
+  return fullPath;
+}
+
+export async function writeBufferFile(buf: Buffer, outDir: string, prefix: string, ext: string): Promise<string> {
+  await ensureDir(outDir);
+  const fileName = `${prefix}-${Date.now()}.${ext}`;
+  const fullPath = path.resolve(outDir, fileName);
+  await fs.writeFile(fullPath, buf);
+  return fullPath;
+}
+
+export async function detectMimeTypeFromPath(filePath: string): Promise<string> {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith('.png')) return 'image/png';
+  if (lower.endsWith('.jpg') || lower.endsWith('.jpeg')) return 'image/jpeg';
+  if (lower.endsWith('.webp')) return 'image/webp';
+  if (lower.endsWith('.mp4')) return 'video/mp4';
+  throw new Error(`지원하지 않는 파일 확장자입니다: ${filePath}`);
+}

package/src/utils/options.ts

@@ -0,0 +1,35 @@
+export function parseOptionPairs(optionPairs: string[] = []): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const pair of optionPairs) {
+    const idx = pair.indexOf('=');
+    if (idx <= 0) {
+      throw new Error(`잘못된 --option 형식입니다: ${pair}. 예: quality=high`);
+    }
+    const key = pair.slice(0, idx).trim();
+    const raw = pair.slice(idx + 1).trim();
+    out[key] = inferValue(raw);
+  }
+  return out;
+}
+
+function inferValue(value: string): unknown {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  return value;
+}
+
+export function mergeOptions(base: Record<string, unknown>, jsonString?: string): Record<string, unknown> {
+  if (!jsonString) return base;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(jsonString);
+  } catch {
+    throw new Error('--options-json 파싱 실패: 유효한 JSON 문자열을 입력해 주세요.');
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('--options-json은 JSON object 여야 합니다.');
+  }
+  return { ...base, ...(parsed as Record<string, unknown>) };
+}

package/src/utils/parts.ts

@@ -0,0 +1,42 @@
+import { InputPart } from '../core/types.js';
+
+export function parseParts(rawParts: string[]): InputPart[] {
+  const parsed: InputPart[] = [];
+  for (const raw of rawParts) {
+    const idx = raw.indexOf(':');
+    if (idx <= 0) {
+      throw new Error(`잘못된 --part 형식입니다: ${raw}. 예: text:고양이, image:/tmp/cat.png`);
+    }
+    const type = raw.slice(0, idx).trim();
+    const value = raw.slice(idx + 1).trim();
+
+    if (!value) {
+      throw new Error(`빈 값은 허용되지 않습니다: ${raw}`);
+    }
+
+    if (type === 'text') {
+      parsed.push({ type: 'text', value });
+      continue;
+    }
+    if (type === 'image') {
+      parsed.push({ type: 'image', value });
+      continue;
+    }
+
+    throw new Error(`지원하지 않는 part 타입입니다: ${type}. text/image만 지원합니다.`);
+  }
+
+  if (parsed.length === 0) {
+    throw new Error('최소 1개의 --part가 필요합니다.');
+  }
+
+  return parsed;
+}
+
+export function joinTextParts(parts: InputPart[]): string {
+  return parts.filter((p) => p.type === 'text').map((p) => p.value).join('\n');
+}
+
+export function imageParts(parts: InputPart[]): string[] {
+  return parts.filter((p) => p.type === 'image').map((p) => p.value);
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}