sonamu 0.7.12 → 0.7.13

package/dist/vector/embedding.js

@@ -1,6 +1,4 @@
-import { createOpenAI } from "@ai-sdk/openai";
 import { embedMany } from "ai";
-import { VoyageAIClient } from "voyageai";
 import { Sonamu } from "../api/sonamu.js";
 import { DEFAULT_VECTOR_CONFIG } from "./config.js";
 /**
@@ -34,7 +32,8 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
     }
     /**
    * Voyage AI 클라이언트 초기화
-   */ getVoyageClient() {
+   */ async getVoyageClient() {
+        const { VoyageAIClient } = await import("voyageai");
         const apiKey = Sonamu.secrets?.voyage_api_key ?? process.env.VOYAGE_API_KEY;
         if (!apiKey) {
             throw new Error("VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.");
@@ -45,7 +44,8 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
     }
     /**
    * OpenAI provider 생성
-   */ getOpenAIProvider() {
+   */ async getOpenAIProvider() {
+        const { createOpenAI } = await import("@ai-sdk/openai");
         const apiKey = Sonamu.secrets?.openai_api_key ?? process.env.OPENAI_API_KEY;
         if (!apiKey) {
             throw new Error("OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.");
@@ -85,7 +85,7 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
     /**
    * Voyage AI 임베딩
    */ async embedVoyage(texts, inputType) {
-        const client = this.getVoyageClient();
+        const client = await this.getVoyageClient();
         const voyageConfig = this.config.voyage;
         const response = await client.embed({
             input: texts,
@@ -104,7 +104,7 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
     /**
    * OpenAI 임베딩
    */ async embedOpenAI(texts) {
-        const openai = this.getOpenAIProvider();
+        const openai = await this.getOpenAIProvider();
         const openaiConfig = this.config.openai;
         const model = openai.embeddingModel(openaiConfig.model);
         const { embeddings, usage } = await embedMany({
@@ -125,4 +125,4 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
 }
 export const Embedding = new EmbeddingClass();
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/embedding.ts"],"sourcesContent":["import { createOpenAI, type OpenAIProvider } from \"@ai-sdk/openai\";\nimport { type EmbeddingModel, embedMany } from \"ai\";\nimport { VoyageAIClient } from \"voyageai\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { DEFAULT_VECTOR_CONFIG } from \"./config\";\nimport type {\n  EmbeddingProvider,\n  EmbeddingResult,\n  ProgressCallback,\n  VectorConfig,\n  VectorInputType,\n} from \"./types\";\n\n/**\n * 임베딩 클라이언트\n * Voyage AI와 OpenAI 임베딩을 SDK 방식으로 통합 지원\n */\nexport class EmbeddingClass {\n  private config: VectorConfig;\n\n  constructor(config: Partial<VectorConfig> = {}) {\n    this.config = {\n      voyage: { ...DEFAULT_VECTOR_CONFIG.voyage, ...config.voyage },\n      openai: { ...DEFAULT_VECTOR_CONFIG.openai, ...config.openai },\n      chunking: { ...DEFAULT_VECTOR_CONFIG.chunking, ...config.chunking },\n      search: { ...DEFAULT_VECTOR_CONFIG.search, ...config.search },\n      pgvector: { ...DEFAULT_VECTOR_CONFIG.pgvector, ...config.pgvector },\n    };\n  }\n\n  /**\n   * Voyage AI 클라이언트 초기화\n   */\n  private getVoyageClient(): VoyageAIClient {\n    const apiKey = Sonamu.secrets?.voyage_api_key ?? process.env.VOYAGE_API_KEY;\n    if (!apiKey) {\n      throw new Error(\"VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\");\n    }\n    return new VoyageAIClient({ apiKey });\n  }\n\n  /**\n   * OpenAI provider 생성\n   */\n  private getOpenAIProvider(): OpenAIProvider {\n    const apiKey = Sonamu.secrets?.openai_api_key ?? process.env.OPENAI_API_KEY;\n    if (!apiKey) {\n      throw new Error(\"OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\");\n    }\n    return createOpenAI({ apiKey });\n  }\n\n  /**\n   * 텍스트 임베딩 생성\n   * @param texts - 임베딩할 텍스트 배열 (batchSize이상 시 자동 분할)\n   * @param provider - 'voyage' | 'openai'\n   * @param inputType - 'document' | 'query' (Voyage AI만 해당)\n   * @param onProgress - 진행률 콜백\n   */\n  async embed(\n    texts: string[],\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\",\n    onProgress?: ProgressCallback,\n  ): Promise<EmbeddingResult[]> {\n    const maxBatchSize =\n      provider === \"voyage\" ? this.config.voyage.batchSize : this.config.openai.batchSize;\n\n    // batchSize이하면 바로 호출\n    if (texts.length <= maxBatchSize) {\n      return provider === \"voyage\"\n        ? await this.embedVoyage(texts, inputType)\n        : await this.embedOpenAI(texts);\n    }\n\n    // batchSize이상이면 자동으로 나눠서 처리\n    const batches = Array.from({ length: Math.ceil(texts.length / maxBatchSize) }, (_, i) =>\n      texts.slice(i * maxBatchSize, (i + 1) * maxBatchSize),\n    );\n\n    const results = await Promise.all(\n      batches.map((batch) =>\n        provider === \"voyage\" ? this.embedVoyage(batch, inputType) : this.embedOpenAI(batch),\n      ),\n    );\n\n    onProgress?.(texts.length, texts.length);\n    return results.flat();\n  }\n\n  /**\n   * 단일 텍스트 임베딩 (편의 메서드)\n   */\n  async embedOne(\n    text: string,\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\",\n  ): Promise<EmbeddingResult> {\n    const results = await this.embed([text], provider, inputType);\n    return results[0];\n  }\n\n  /**\n   * Voyage AI 임베딩\n   */\n  private async embedVoyage(\n    texts: string[],\n    inputType: VectorInputType,\n  ): Promise<EmbeddingResult[]> {\n    const client = this.getVoyageClient();\n    const voyageConfig = this.config.voyage;\n\n    const response = await client.embed({\n      input: texts,\n      model: voyageConfig.model,\n      inputType: inputType,\n    });\n    if (!response.data) {\n      throw new Error(\"Voyage API: 응답 데이터가 없습니다.\");\n    }\n\n    return response.data.map((item) => ({\n      embedding: item.embedding ?? [],\n      model: voyageConfig.model,\n      tokenCount: response.usage?.totalTokens ?? 0,\n    }));\n  }\n\n  /**\n   * OpenAI 임베딩\n   */\n  private async embedOpenAI(texts: string[]): Promise<EmbeddingResult[]> {\n    const openai = this.getOpenAIProvider();\n    const openaiConfig = this.config.openai;\n    const model = openai.embeddingModel(openaiConfig.model);\n\n    const { embeddings, usage } = await embedMany({\n      model: model as EmbeddingModel,\n      values: texts,\n    });\n\n    return embeddings.map((embedding) => ({\n      embedding,\n      model: openaiConfig.model,\n      tokenCount: usage?.tokens ?? 0,\n    }));\n  }\n\n  /**\n   * 임베딩 provider의 차원 수 반환\n   */\n  getDimensions(provider: EmbeddingProvider): number {\n    return provider === \"voyage\" ? this.config.voyage.dimensions : this.config.openai.dimensions;\n  }\n}\nexport const Embedding = new EmbeddingClass();\n"],"names":["createOpenAI","embedMany","VoyageAIClient","Sonamu","DEFAULT_VECTOR_CONFIG","EmbeddingClass","config","voyage","openai","chunking","search","pgvector","getVoyageClient","apiKey","secrets","voyage_api_key","process","env","VOYAGE_API_KEY","Error","getOpenAIProvider","openai_api_key","OPENAI_API_KEY","embed","texts","provider","inputType","onProgress","maxBatchSize","batchSize","length","embedVoyage","embedOpenAI","batches","Array","from","Math","ceil","_","i","slice","results","Promise","all","map","batch","flat","embedOne","text","client","voyageConfig","response","input","model","data","item","embedding","tokenCount","usage","totalTokens","openaiConfig","embeddingModel","embeddings","values","tokens","getDimensions","dimensions","Embedding"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/embedding.ts"],"sourcesContent":["import type { OpenAIProvider } from \"@ai-sdk/openai\";\nimport { type EmbeddingModel, embedMany } from \"ai\";\nimport type { VoyageAIClient } from \"voyageai\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { DEFAULT_VECTOR_CONFIG } from \"./config\";\nimport type {\n  EmbeddingProvider,\n  EmbeddingResult,\n  ProgressCallback,\n  VectorConfig,\n  VectorInputType,\n} from \"./types\";\n\n/**\n * 임베딩 클라이언트\n * Voyage AI와 OpenAI 임베딩을 SDK 방식으로 통합 지원\n */\nexport class EmbeddingClass {\n  private config: VectorConfig;\n\n  constructor(config: Partial<VectorConfig> = {}) {\n    this.config = {\n      voyage: { ...DEFAULT_VECTOR_CONFIG.voyage, ...config.voyage },\n      openai: { ...DEFAULT_VECTOR_CONFIG.openai, ...config.openai },\n      chunking: { ...DEFAULT_VECTOR_CONFIG.chunking, ...config.chunking },\n      search: { ...DEFAULT_VECTOR_CONFIG.search, ...config.search },\n      pgvector: { ...DEFAULT_VECTOR_CONFIG.pgvector, ...config.pgvector },\n    };\n  }\n\n  /**\n   * Voyage AI 클라이언트 초기화\n   */\n  private async getVoyageClient(): Promise<VoyageAIClient> {\n    const { VoyageAIClient } = await import(\"voyageai\");\n    const apiKey = Sonamu.secrets?.voyage_api_key ?? process.env.VOYAGE_API_KEY;\n    if (!apiKey) {\n      throw new Error(\"VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\");\n    }\n    return new VoyageAIClient({ apiKey });\n  }\n\n  /**\n   * OpenAI provider 생성\n   */\n  private async getOpenAIProvider(): Promise<OpenAIProvider> {\n    const { createOpenAI } = await import(\"@ai-sdk/openai\");\n    const apiKey = Sonamu.secrets?.openai_api_key ?? process.env.OPENAI_API_KEY;\n    if (!apiKey) {\n      throw new Error(\"OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\");\n    }\n    return createOpenAI({ apiKey });\n  }\n\n  /**\n   * 텍스트 임베딩 생성\n   * @param texts - 임베딩할 텍스트 배열 (batchSize이상 시 자동 분할)\n   * @param provider - 'voyage' | 'openai'\n   * @param inputType - 'document' | 'query' (Voyage AI만 해당)\n   * @param onProgress - 진행률 콜백\n   */\n  async embed(\n    texts: string[],\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\",\n    onProgress?: ProgressCallback,\n  ): Promise<EmbeddingResult[]> {\n    const maxBatchSize =\n      provider === \"voyage\" ? this.config.voyage.batchSize : this.config.openai.batchSize;\n\n    // batchSize이하면 바로 호출\n    if (texts.length <= maxBatchSize) {\n      return provider === \"voyage\"\n        ? await this.embedVoyage(texts, inputType)\n        : await this.embedOpenAI(texts);\n    }\n\n    // batchSize이상이면 자동으로 나눠서 처리\n    const batches = Array.from({ length: Math.ceil(texts.length / maxBatchSize) }, (_, i) =>\n      texts.slice(i * maxBatchSize, (i + 1) * maxBatchSize),\n    );\n\n    const results = await Promise.all(\n      batches.map((batch) =>\n        provider === \"voyage\" ? this.embedVoyage(batch, inputType) : this.embedOpenAI(batch),\n      ),\n    );\n\n    onProgress?.(texts.length, texts.length);\n    return results.flat();\n  }\n\n  /**\n   * 단일 텍스트 임베딩 (편의 메서드)\n   */\n  async embedOne(\n    text: string,\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\",\n  ): Promise<EmbeddingResult> {\n    const results = await this.embed([text], provider, inputType);\n    return results[0];\n  }\n\n  /**\n   * Voyage AI 임베딩\n   */\n  private async embedVoyage(\n    texts: string[],\n    inputType: VectorInputType,\n  ): Promise<EmbeddingResult[]> {\n    const client = await this.getVoyageClient();\n    const voyageConfig = this.config.voyage;\n\n    const response = await client.embed({\n      input: texts,\n      model: voyageConfig.model,\n      inputType: inputType,\n    });\n    if (!response.data) {\n      throw new Error(\"Voyage API: 응답 데이터가 없습니다.\");\n    }\n\n    return response.data.map((item) => ({\n      embedding: item.embedding ?? [],\n      model: voyageConfig.model,\n      tokenCount: response.usage?.totalTokens ?? 0,\n    }));\n  }\n\n  /**\n   * OpenAI 임베딩\n   */\n  private async embedOpenAI(texts: string[]): Promise<EmbeddingResult[]> {\n    const openai = await this.getOpenAIProvider();\n    const openaiConfig = this.config.openai;\n    const model = openai.embeddingModel(openaiConfig.model);\n\n    const { embeddings, usage } = await embedMany({\n      model: model as EmbeddingModel,\n      values: texts,\n    });\n\n    return embeddings.map((embedding) => ({\n      embedding,\n      model: openaiConfig.model,\n      tokenCount: usage?.tokens ?? 0,\n    }));\n  }\n\n  /**\n   * 임베딩 provider의 차원 수 반환\n   */\n  getDimensions(provider: EmbeddingProvider): number {\n    return provider === \"voyage\" ? this.config.voyage.dimensions : this.config.openai.dimensions;\n  }\n}\nexport const Embedding = new EmbeddingClass();\n"],"names":["embedMany","Sonamu","DEFAULT_VECTOR_CONFIG","EmbeddingClass","config","voyage","openai","chunking","search","pgvector","getVoyageClient","VoyageAIClient","apiKey","secrets","voyage_api_key","process","env","VOYAGE_API_KEY","Error","getOpenAIProvider","createOpenAI","openai_api_key","OPENAI_API_KEY","embed","texts","provider","inputType","onProgress","maxBatchSize","batchSize","length","embedVoyage","embedOpenAI","batches","Array","from","Math","ceil","_","i","slice","results","Promise","all","map","batch","flat","embedOne","text","client","voyageConfig","response","input","model","data","item","embedding","tokenCount","usage","totalTokens","openaiConfig","embeddingModel","embeddings","values","tokens","getDimensions","dimensions","Embedding"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.7.12",
+  "version": "0.7.13",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -68,6 +68,7 @@
     "knex": "^3.1.0",
     "mime-types": "^3.0.1",
     "minimatch": "^10.0.3",
+    "node-cron": "^4.2.1",
     "node-sql-parser": "^5.2.0",
     "pg": "^8.16.3",
     "prompts": "^2.4.2",
@@ -76,10 +77,9 @@
     "tsicli": "^1.0.5",
     "vitest": "^4.0.10",
     "zod": "^4.1.12",
-    "node-cron": "^4.2.1",
     "@sonamu-kit/hmr-hook": "^0.4.1",
-    "@sonamu-kit/ts-loader": "^2.1.3",
     "@sonamu-kit/tasks": "^0.0.1",
+    "@sonamu-kit/ts-loader": "^2.1.3",
     "@sonamu-kit/hmr-runner": "^0.1.1"
   },
   "devDependencies": {
@@ -104,8 +104,8 @@
     "ai": "6.0.0-beta.138",
     "fastify": "^4.23.2",
     "knex": "^3.1.0",
-    "typescript": "^5.9.3",
     "pgvector": "^0.2.1",
+    "typescript": "^5.9.3",
     "voyageai": "^0.0.8"
   },
   "peerDependenciesMeta": {
@@ -130,7 +130,9 @@
   },
   "scripts": {
     "dev": "nodemon exec",
-    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "build": "run-s 'build:sonamu' 'build:ui-web'",
+    "build:sonamu": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "build:ui-web": "cd ui-web && pnpm install && pnpm build",
     "test:type": "vitest --typecheck test-d.ts"
   }
 }

package/src/api/config.ts

@@ -30,9 +30,6 @@ export type SonamuConfig = {
   sync: {
     targets: string[]; // "web", "app" 등
   };
-  ui?: {
-    port: number;
-  };
 
   database: {
     // 데이터베이스

package/src/api/sonamu.ts

@@ -231,8 +231,6 @@ class SonamuClass {
       await this.syncer.sync();
 
       await this.startWatcher();
-
-      this.syncer.syncUI();
     }
 
     this.isInitialized = true;
@@ -346,10 +344,19 @@ class SonamuClass {
       },
     );
 
+    // Sonamu UI API
+    const { sonamuUIApiPlugin } = await import("../ui/api");
+    server.register(sonamuUIApiPlugin);
+
     // API 라우팅 (로컬HMR 상태와 구분)
     const { isLocal } = await import("../utils/controller");
     if (isLocal()) {
       server.all("*", async (request, reply) => {
+        // Sonamu UI
+        if (request.url.startsWith("/sonamu-ui")) {
+          return;
+        }
+
         const found = this.syncer.apis.find(
           (api) =>
             this.config.api.route.prefix + api.path === request.url.split("?")[0] &&
@@ -358,8 +365,14 @@ class SonamuClass {
         if (found) {
           return this.getApiHandler(found, config)(request, reply);
         }
-        const { NotFoundException } = await import("../exceptions/so-exceptions");
-        throw new NotFoundException("존재하지 않는 API 접근입니다.");
+
+        if (request.url.startsWith("/api/")) {
+          const { NotFoundException } = await import("../exceptions/so-exceptions");
+          throw new NotFoundException(`존재하지 않는 API 접근입니다. ${request.url}`);
+        }
+
+        // 일반 파일 접근시 별도의 에러 출력하지 않음
+        return;
       });
     } else {
       for (const api of this.syncer.apis) {

package/src/bin/cli.ts

@@ -22,7 +22,7 @@ import { BUILD_DIR, SWC_BUILD_COMMAND, TSC_TYPE_CHECK_COMMAND } from "./build-co
 let migrator: Migrator;
 
 async function bootstrap() {
-  const notToInit = ["dev", "build", "start", "ui"].includes(process.argv[2] ?? "");
+  const notToInit = ["dev", "build", "start"].includes(process.argv[2] ?? "");
   if (!notToInit) {
     await Sonamu.init(false, false);
   }
@@ -58,7 +58,6 @@ async function bootstrap() {
         ["scaffold", "model_test", "#entityId"],
         ["scaffold", "view_list", "#entityId"],
         ["scaffold", "view_form", "#entityId"],
-        ["ui"],
         ["sync"],
         ["dev"],
         ["build"],
@@ -74,7 +73,6 @@ async function bootstrap() {
         stub_entity,
         scaffold_model,
         scaffold_model_test,
-        ui,
         // scaffold_view_list,
         // scaffold_view_form,
         sync,
@@ -452,67 +450,3 @@ async function scaffold_model_test(entityId: string) {
     entityId,
   });
 }
-
-async function ui() {
-  try {
-    const apiRootPath = findApiRootPath();
-
-    // 사용자 프로젝트의 패키지들 중에서 @sonamu-kit/ui를 찾습니다.
-    // 이를 위해서 createRequire를 사용하여 프로젝트 경로 기준으로 resolve합니다.
-    const projectRequire = createRequire(path.join(apiRootPath, "package.json"));
-    const uiPackagePath = projectRequire.resolve("@sonamu-kit/ui"); // 없으면 여기서 터져요(MODULE_NOT_FOUND)
-    const uiNodePath = path.join(path.dirname(uiPackagePath), "run-ui.js");
-
-    if (!(await exists(uiNodePath))) {
-      console.log(
-        chalk.red(`UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`),
-      );
-      return;
-    }
-
-    // UI를 별도 프로세스로 실행 (hmr-hook 활성화)
-    const uiProcess = spawn(
-      process.execPath,
-      [
-        "--import",
-        "sonamu/ts-loader-register",
-        "--import",
-        "sonamu/hmr-hook-register",
-        "--enable-source-maps",
-        "--no-warnings",
-        uiNodePath,
-      ],
-      {
-        stdio: "inherit",
-        env: {
-          ...process.env,
-          HOT: "yes",
-          API_ROOT_PATH: apiRootPath, // UI는 얘만 알면 돼요! 나머지는 얘가 떠서 알아서 할 것임 ㅎ
-        },
-      },
-    );
-
-    // 종료 처리
-    const cleanup = () => {
-      console.log(chalk.yellow("\n\n👋 Shutting down UI server..."));
-      uiProcess.kill("SIGTERM");
-      process.exit(0);
-    };
-
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-
-    uiProcess.on("exit", (code) => {
-      if (code !== 0) {
-        console.error(chalk.red(`❌ UI server exited with code ${code}`));
-        process.exit(code || 1);
-      }
-    });
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("isn't declared")) {
-      console.log(`You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`);
-      return;
-    }
-    throw e;
-  }
-}

package/src/syncer/api-parser.ts

@@ -98,7 +98,8 @@ export async function readApisFromFile(filePath: AbsolutePath): Promise<Extended
     // const p = path.join(tmpdir(), "sonamu-syncer-error.json");
     // writeFileSync(p, JSON.stringify(registeredApis, null, 2));
     // execSync(`open ${p}`);
-    throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+    // throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+    return [];
   }
 
   // 등록된 API에 현재 메소드 타입 정보 확장

package/src/syncer/syncer.ts

@@ -1,6 +1,7 @@
 import { hot } from "@sonamu-kit/hmr-hook";
 import assert from "assert";
 import chalk from "chalk";
+import { EventEmitter } from "events";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import inflection from "inflection";
 import { minimatch } from "minimatch";
@@ -45,6 +46,7 @@ export class Syncer {
   models: LoadedModels = {};
   workflows: Map<string, WorkflowMetadata[]> = new Map();
   isSyncing: boolean = false;
+  eventEmitter: EventEmitter = new EventEmitter();
 
   /**
    * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
@@ -100,17 +102,24 @@ export class Syncer {
         console.log(chalk.bold(`🔄 Invalidated:`));
 
         for (const invalidatedPath of invalidatedPaths) {
-          // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.
-          // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.
-          // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.
-          const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
-          if (removedApis.length > 0) {
-            console.log(
-              chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),
-              chalk.gray(`(with ${removedApis.length} APIs)`),
+          try {
+            // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.
+            // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.
+            // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.
+            const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
+            if (removedApis.length > 0) {
+              console.log(
+                chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),
+                chalk.gray(`(with ${removedApis.length} APIs)`),
+              );
+            } else {
+              console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
+            }
+          } catch (e) {
+            console.error(e);
+            console.error(
+              chalk.red(`Failed to remove invalidated registered APIs for ${invalidatedPath}`),
             );
-          } else {
-            console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
           }
         }
       }
@@ -132,7 +141,7 @@ export class Syncer {
     await this.autoloadApis();
     await this.autoloadWorkflows();
 
-    this.syncUI();
+    this.eventEmitter.emit("onHMRCompleted");
   }
 
   removeInvalidatedRegisteredApis(
@@ -551,16 +560,6 @@ export class Syncer {
     );
   }
 
-  syncUI() {
-    const uiPort = Sonamu.config.ui?.port ?? 57000;
-
-    if (!isTest()) {
-      fetch(`http://127.0.0.1:${uiPort}/api/reload`, {
-        method: "GET",
-      }).catch((e) => console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`)));
-    }
-  }
-
   /**
    * 하위호환용 프록시 메소드입니다.
    */

package/src/ui/ai-api.ts

@@ -0,0 +1,60 @@
+// import { convertToModelMessages, type UIMessage } from "ai";
+// import type { FastifyInstance } from "fastify";
+// import { BadRequestException, type FixtureRecord } from "sonamu";
+// import { aiClient } from "./ai-client";
+
+// export async function setAiApi(server: FastifyInstance) {
+//   await aiClient.init();
+
+//   server.post("/api/ai/fixture/chat", async (request, reply) => {
+//     const { messages, fixtureRecords } = request.body as {
+//       messages: UIMessage[];
+//       fixtureRecords?: FixtureRecord[];
+//     };
+
+//     if (!fixtureRecords || fixtureRecords.length === 0) {
+//       throw new BadRequestException("픽스쳐 레코드가 없습니다. 픽스쳐 조회 후 시도하세요.");
+//     }
+
+//     const result = aiClient.handleFixture(convertToModelMessages(messages), fixtureRecords);
+//     const response = result.toUIMessageStreamResponse();
+
+//     reply.raw.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+
+//     if (response.body) {
+//       const reader = response.body.getReader();
+//       while (true) {
+//         const { done, value } = await reader.read();
+//         if (done) break;
+//         reply.raw.write(value);
+//       }
+//     }
+
+//     reply.raw.end();
+//     return reply;
+//   });
+
+//   // Entity/Enum 생성용 AI Chat Stream
+//   server.post("/api/ai/entity/chat", async (request, reply) => {
+//     const { messages } = request.body as {
+//       messages: UIMessage[];
+//     };
+
+//     const result = aiClient.handleEntity(convertToModelMessages(messages));
+//     const response = result.toUIMessageStreamResponse();
+
+//     reply.raw.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+
+//     if (response.body) {
+//       const reader = response.body.getReader();
+//       while (true) {
+//         const { done, value } = await reader.read();
+//         if (done) break;
+//         reply.raw.write(value);
+//       }
+//     }
+
+//     reply.raw.end();
+//     return reply;
+//   });
+// }