openbot 0.1.28 → 0.2.0

package/dist/registry/ts-agent-loader.js

@@ -0,0 +1,82 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { ensurePluginReady } from "./plugin-loader.js";
+/**
+ * Discover and load TS-defined agents from a directory.
+ *
+ * Scans each subdirectory for a package.json and an index file.
+ *
+ * @param agentsDir Absolute path to the agents directory (e.g. ~/.openbot/agents)
+ * @param defaultModel Language model to use for agent LLMs
+ * @param options Optional API keys for creating specific models
+ * @returns Array of discovered agent entries ready for registration
+ */
+export async function discoverTsAgents(agentsDir, defaultModel, options) {
+    const agents = [];
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+                continue;
+            const agentDir = path.join(agentsDir, entry.name);
+            // We only consider it a TS agent if it doesn't have an agent.yaml
+            // (This avoids double-loading if someone has both for some reason)
+            const yamlPath = path.join(agentDir, "agent.yaml");
+            const hasYaml = await fs.access(yamlPath).then(() => true).catch(() => false);
+            if (hasYaml)
+                continue;
+            // Check for package.json to see if it's a package
+            const pkgPath = path.join(agentDir, "package.json");
+            const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
+            if (!hasPackageJson)
+                continue;
+            try {
+                // 1. Ensure dependencies and build are ready
+                await ensurePluginReady(agentDir);
+                // 2. Find index file
+                let indexPath;
+                const possibleIndices = ["dist/index.js", "index.js", "index.ts"];
+                for (const file of possibleIndices) {
+                    try {
+                        const fullPath = path.join(agentDir, file);
+                        await fs.access(fullPath);
+                        indexPath = fullPath;
+                        break;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!indexPath)
+                    continue;
+                // 3. Import and instantiate
+                const moduleUrl = pathToFileURL(indexPath).href;
+                const module = await import(moduleUrl);
+                // Support 'agent', 'plugin', 'default', or 'entry'
+                const definition = module.agent || module.plugin || module.default || module.entry;
+                if (definition && typeof definition.factory === "function") {
+                    const name = definition.name || entry.name;
+                    const description = definition.description || "TS Agent";
+                    agents.push({
+                        name,
+                        description,
+                        plugin: definition.factory({ ...options, model: defaultModel }),
+                        capabilities: definition.capabilities,
+                        subscribe: definition.subscribe,
+                    });
+                    console.log(`[agents] Loaded TS agent: ${name} — ${description}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[agents] Failed to load TS agent package "${entry.name}":`, err);
+            }
+        }
+    }
+    catch {
+        // Agents directory doesn't exist
+    }
+    return agents;
+}

package/dist/registry/yaml-agent-loader.js

@@ -136,8 +136,10 @@ export async function discoverYamlAgents(agentsDir, pluginRegistry, defaultModel
                 console.log(`[agents] Loaded: ${config.name} — ${config.description}${config.model ? ` (model: ${config.model})` : ""}`);
             }
             catch (err) {
-                // Invalid or missing agent.yaml — silently skip
-                console.warn(`[agents] Error loading "${entry.name}/agent.yaml":`, err);
+                // Invalid or missing agent.yaml — silently skip if missing, warn if invalid
+                if (err.code !== 'ENOENT') {
+                    console.warn(`[agents] Error loading "${entry.name}/agent.yaml":`, err);
+                }
             }
         }
     }

package/dist/server.js

@@ -3,55 +3,295 @@ import express from "express";
 import cors from "cors";
 import { generateId } from "melony";
 import { createOpenBot } from "./open-bot.js";
-import { loadConfig } from "./config.js";
-import { loadSession, saveSession, logEvent, loadEvents } from "./session.js";
+import { loadConfig, saveConfig, isConfigured, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
+import { loadSession, saveSession, logEvent, loadEvents, listSessions } from "./session.js";
+import { listYamlAgents } from "./registry/index.js";
+import { exec } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { fetchProviderModels, getModelCatalog } from "./model-catalog.js";
+import { DEFAULT_MODEL_BY_PROVIDER, DEFAULT_MODEL_ID } from "./model-defaults.js";
 export async function startServer(options = {}) {
     const config = loadConfig();
     const PORT = Number(options.port ?? config.port ?? process.env.PORT ?? 4001);
     const app = express();
-    // Initialize the agent instance once at startup
-    const openBotAgent = await createOpenBot({
+    const orchestrator = await createOpenBot({
         openaiApiKey: options.openaiApiKey,
         anthropicApiKey: options.anthropicApiKey,
     });
     app.use(cors());
-    app.use(express.json());
-    app.get("/", async (req, res) => {
+    app.use(express.json({ limit: "20mb" }));
+    const getUploadsDir = () => {
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        return path.join(resolvedBaseDir, "uploads");
+    };
+    const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+    const allowedMimeTypes = new Set([
+        "image/png",
+        "image/jpeg",
+        "image/webp",
+        "image/gif",
+        "image/svg+xml",
+    ]);
+    const extensionByMimeType = {
+        "image/png": ".png",
+        "image/jpeg": ".jpg",
+        "image/webp": ".webp",
+        "image/gif": ".gif",
+        "image/svg+xml": ".svg",
+    };
+    // Return available models to the client.
+    // It prefers fresh provider APIs and falls back to bundled defaults.
+    app.get("/api/models", async (_req, res) => {
+        try {
+            const models = await getModelCatalog();
+            res.json(models);
+        }
+        catch (err) {
+            console.error("Failed to load models:", err);
+            res.json([]);
+        }
+    });
+    app.post("/api/models/preview", async (req, res) => {
+        const { provider, apiKey } = req.body;
+        if (provider !== "openai" && provider !== "anthropic") {
+            return res.status(400).json({ error: "Invalid provider" });
+        }
+        if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
+            return res.status(400).json({ error: "API key is required" });
+        }
+        try {
+            const models = await fetchProviderModels(provider, apiKey.trim());
+            res.json(models);
+        }
+        catch (err) {
+            console.error("Failed to preview models:", err);
+            res.status(502).json({ error: "Failed to fetch models from provider" });
+        }
+    });
+    app.get("/", async (_req, res) => {
         res.json({
-            message: "Melony Express demo server",
-            chatEndpoint: "/api/chat",
-            stream: "Server-Sent Events (SSE)",
+            message: "OpenBot API server",
+            version: "2.0",
+            endpoints: {
+                chat: "POST /api/chat",
+                config: "GET|POST /api/config",
+                sessions: "GET /api/sessions",
+                agents: "GET /api/agents",
+                prompts: "GET /api/prompts",
+            },
         });
     });
-    // View endpoint (GET version of chat, returns JSON instead of SSE)
-    app.get("/api/view", async (req, res) => {
-        const { type = "init", data: dataStr } = req.query;
-        // Parse the structured data
-        const eventData = dataStr ? JSON.parse(dataStr) : {};
-        const { sessionId = "default", history = false } = eventData;
-        const state = (await loadSession(sessionId)) ?? {};
-        state.sessionId = sessionId;
-        const response = await openBotAgent.jsonResponse({
-            type: type,
-            data: eventData,
-        }, {
-            state,
-            runId: generateId(),
-        });
-        const result = await response.json();
-        const uiEvents = result.events.filter((event) => event.type === "ui");
-        const layout = uiEvents.find((e) => e.meta?.type === "layout")?.data;
-        const sidebar = uiEvents.find((e) => e.meta?.type === "sidebar")?.data;
-        const content = uiEvents.find((e) => e.meta?.type === "content")?.data;
-        const initialEvents = history ? await loadEvents(sessionId) : undefined;
+    // ─── REST API ───────────────────────────────────────────────────
+    app.get("/api/prompts", async (_req, res) => {
+        res.json([
+            { label: "Who are you?", icon: "user" },
+            { label: "Who am I?", icon: "help-circle" },
+            { label: "How can you help me?", icon: "sparkles" },
+            { label: "What is the weather in Tokyo?", icon: "sun" },
+        ]);
+    });
+    app.post("/api/uploads/image", async (req, res) => {
+        const { name, mimeType, dataBase64 } = req.body;
+        if (!mimeType || !allowedMimeTypes.has(mimeType)) {
+            return res.status(400).json({ error: "Unsupported image mime type" });
+        }
+        if (!dataBase64 || typeof dataBase64 !== "string") {
+            return res.status(400).json({ error: "Image payload is required" });
+        }
+        const bytes = Buffer.from(dataBase64, "base64");
+        if (!bytes.length) {
+            return res.status(400).json({ error: "Invalid image payload" });
+        }
+        if (bytes.length > MAX_IMAGE_BYTES) {
+            return res.status(413).json({ error: "Image too large (max 8MB)" });
+        }
+        try {
+            const ext = extensionByMimeType[mimeType] ?? ".bin";
+            const now = new Date();
+            const y = now.getFullYear().toString();
+            const m = String(now.getMonth() + 1).padStart(2, "0");
+            const datePath = path.join(y, m);
+            const fileName = `${Date.now()}-${randomUUID()}${ext}`;
+            const id = path.posix.join(y, m, fileName);
+            const uploadsDir = getUploadsDir();
+            const datedDir = path.join(uploadsDir, datePath);
+            await fs.mkdir(datedDir, { recursive: true });
+            await fs.writeFile(path.join(datedDir, fileName), bytes);
+            const origin = `${req.protocol}://${req.get("host")}`;
+            const encodedId = id.split("/").map(encodeURIComponent).join("/");
+            res.json({
+                id,
+                name: typeof name === "string" && name.trim() ? name.trim() : `image${ext}`,
+                mimeType,
+                size: bytes.length,
+                url: `${origin}/api/uploads/${encodedId}`,
+            });
+        }
+        catch (error) {
+            console.error("Image upload failed:", error);
+            res.status(500).json({ error: "Failed to store image" });
+        }
+    });
+    app.get("/api/uploads/*", async (req, res) => {
+        const rawPath = req.params[0];
+        if (!rawPath || rawPath.includes("\\")) {
+            return res.status(400).send("Invalid upload id");
+        }
+        const normalized = path.posix.normalize(rawPath);
+        if (normalized.startsWith("../") || normalized === "..") {
+            return res.status(400).send("Invalid upload id");
+        }
+        const uploadsDir = getUploadsDir();
+        const filePath = path.join(uploadsDir, normalized);
+        try {
+            await fs.access(filePath);
+            res.sendFile(filePath);
+        }
+        catch {
+            res.status(404).send("Upload not found");
+        }
+    });
+    app.get("/api/config", async (_req, res) => {
+        const cfg = loadConfig();
         res.json({
-            ui: layout,
-            sidebar,
-            content,
-            initialEvents,
+            configured: isConfigured(),
+            model: cfg.model || DEFAULT_MODEL_ID,
+            defaultModelId: DEFAULT_MODEL_ID,
+            defaultModels: DEFAULT_MODEL_BY_PROVIDER,
+            hasOpenAIKey: !!cfg.openaiApiKey,
+            hasAnthropicKey: !!cfg.anthropicApiKey,
         });
     });
-    // Chat endpoint
+    app.post("/api/config", async (req, res) => {
+        const { openai_api_key, anthropic_api_key, model } = req.body;
+        const updates = {};
+        if (model)
+            updates.model = model.trim();
+        if (openai_api_key && openai_api_key !== "••••••••••••••••")
+            updates.openaiApiKey = openai_api_key.trim();
+        if (anthropic_api_key && anthropic_api_key !== "••••••••••••••••")
+            updates.anthropicApiKey = anthropic_api_key.trim();
+        if (Object.keys(updates).length > 0) {
+            saveConfig(updates);
+        }
+        res.json({ success: true });
+    });
+    app.get("/api/sessions", async (_req, res) => {
+        const sessions = await listSessions();
+        res.json(sessions);
+    });
+    app.get("/api/sessions/:id/events", async (req, res) => {
+        const events = await loadEvents(req.params.id);
+        res.json(events);
+    });
+    app.get("/api/agents", async (_req, res) => {
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const agentsDir = path.join(resolvedBaseDir, "agents");
+        try {
+            const agents = await listYamlAgents(agentsDir);
+            res.json(agents);
+        }
+        catch {
+            res.json([]);
+        }
+    });
+    app.get("/api/agents/:name/yaml", async (req, res) => {
+        const { name } = req.params;
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const yamlPath = path.join(resolvedBaseDir, "agents", name, "agent.yaml");
+        try {
+            const content = await fs.readFile(yamlPath, "utf-8");
+            res.send(content);
+        }
+        catch {
+            res.status(404).send("Agent not found or has no agent.yaml");
+        }
+    });
+    app.put("/api/agents/:name/yaml", async (req, res) => {
+        const { name } = req.params;
+        const { yaml } = req.body;
+        if (!yaml || typeof yaml !== "string") {
+            return res.status(400).json({ error: "YAML content is required" });
+        }
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const agentDir = path.join(resolvedBaseDir, "agents", name);
+        const yamlPath = path.join(agentDir, "agent.yaml");
+        try {
+            await fs.mkdir(agentDir, { recursive: true });
+            await fs.writeFile(yamlPath, yaml, "utf-8");
+            // Optionally, hot-reload openBotAgent if needed here.
+            // But OpenBot runtime loads agents at startup or dynamically per request?
+            // createOpenBot builds the Melony App. Since createOpenBot is called at startup:
+            // openBotAgent = await createOpenBot(...) happens once.
+            // Restarting server is required unless we hot-reload. We can just leave it as is 
+            // and instruct the user to restart, or implement a simple hot reload. Let's stick to simple file write first.
+            res.json({ success: true });
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).json({ error: "Failed to write agent.yaml" });
+        }
+    });
+    app.post("/api/actions/open-folder", async (req, res) => {
+        const { folder } = req.body;
+        if (folder) {
+            const command = os.platform() === "win32"
+                ? `explorer "${folder}"`
+                : os.platform() === "darwin"
+                    ? `open "${folder}"`
+                    : `xdg-open "${folder}"`;
+            exec(command, (error) => {
+                if (error)
+                    console.error(`Failed to open folder: ${error.message}`);
+            });
+        }
+        res.json({ success: true });
+    });
+    app.get("/api/agents/:name/avatar", async (req, res) => {
+        const { name } = req.params;
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const extensions = [".png", ".jpg", ".jpeg", ".svg", ".webp", ".gif"];
+        const fileNames = ["avatar", "icon", "image", "logo"];
+        const searchDirs = [
+            path.join(resolvedBaseDir, "agents", name, "assets"),
+            path.join(process.cwd(), "server", "src", "agents", name, "assets"),
+            path.join(process.cwd(), "server", "src", "assets", "agents", name),
+            path.join(process.cwd(), "server", "src", "agents", "assets"),
+            path.join(process.cwd(), "server", "src", "assets")
+        ];
+        for (const dir of searchDirs) {
+            for (const fileName of fileNames) {
+                for (const ext of extensions) {
+                    const baseName = (dir.endsWith("assets") && !dir.includes(name)) ? name : fileName;
+                    const p = path.join(dir, `${baseName}${ext}`);
+                    try {
+                        await fs.access(p);
+                        return res.sendFile(p);
+                    }
+                    catch {
+                        // continue
+                    }
+                    if (baseName === name)
+                        break;
+                }
+            }
+        }
+        res.status(404).send("Avatar not found");
+    });
+    // ─── Chat SSE endpoint ──────────────────────────────────────────
     app.post("/api/chat", async (req, res) => {
         const body = req.body;
         if (!body.event || typeof body.event.type !== "string") {
@@ -65,12 +305,15 @@ export async function startServer(options = {}) {
             Connection: "keep-alive",
         });
         res.flushHeaders?.();
-        const runtime = openBotAgent.build();
         const sessionId = body.sessionId ?? "default";
         const runId = body.runId ?? `run_${generateId()}`;
         const state = (await loadSession(sessionId)) ?? {};
         state.sessionId = sessionId;
-        const iterator = runtime.run(body.event, {
+        if (!state.cwd)
+            state.cwd = process.cwd();
+        if (!state.workspaceRoot)
+            state.workspaceRoot = process.cwd();
+        const iterator = orchestrator.run(body.event, {
             runId,
             state,
         });
@@ -80,14 +323,11 @@ export async function startServer(options = {}) {
         res.on("close", stopStreaming);
         try {
             for await (const chunk of iterator) {
-                if (res.writableEnded) {
+                if (res.writableEnded)
                     break;
-                }
-                // Log each event to the persistent file
                 await logEvent(sessionId, runId, chunk);
                 res.write(`data: ${JSON.stringify(chunk)}\n\n`);
             }
-            // After the run finishes, save the final state back to disk
             await saveSession(sessionId, state);
         }
         catch (error) {
@@ -109,6 +349,7 @@ export async function startServer(options = {}) {
     app.listen(PORT, () => {
         console.log(`OpenBot server listening at http://localhost:${PORT}`);
         console.log(`  - Chat endpoint: POST /api/chat`);
+        console.log(`  - REST endpoints: /api/config, /api/sessions, /api/agents`);
         if (options.openaiApiKey)
             console.log("  - Using OpenAI API Key from CLI");
         if (options.anthropicApiKey)

package/dist/ui/widgets/action-list.js

@@ -0,0 +1,9 @@
+import { ui } from '@melony/ui-kit/server';
+export const actionList = (title, actions) => ui.box({ border: true, radius: 'md', padding: 'md' }, [
+    ui.col({ gap: 'md' }, [
+        ui.heading(title, { level: 4 }),
+        ui.row({ gap: 'sm', wrap: 'wrap' }, actions.map(a => ui.button({ variant: a.variant || 'outline', onClickAction: a.action }, [
+            ui.text(a.label, { size: 'sm' })
+        ])))
+    ])
+]);

package/dist/ui/widgets/approval-card.js

@@ -0,0 +1,15 @@
+import { ui } from '@melony/ui-kit/server';
+export const approvalCard = (title, description, approveAction, denyAction) => ui.box({ border: true, radius: 'md', padding: 'md' }, [
+    ui.col({ gap: 'sm' }, [
+        ui.heading(title, { level: 4 }),
+        ui.text(description, { size: 'sm', color: 'muted' }),
+        ui.row({ gap: 'sm', justify: 'end' }, [
+            ui.button({ variant: 'outline', onClickAction: denyAction }, [
+                ui.text('Deny', { size: 'xs' })
+            ]),
+            ui.button({ variant: 'primary', onClickAction: approveAction }, [
+                ui.text('Approve', { size: 'xs' })
+            ])
+        ])
+    ])
+]);

package/dist/ui/widgets/code-snippet.js

@@ -0,0 +1,2 @@
+import { ui } from '@melony/ui-kit/server';
+export const codeSnippet = (code, language = 'text') => ui.markdown(`\`\`\`${language}\n${code}\n\`\`\``);

package/dist/ui/widgets/data-block.js

@@ -0,0 +1,5 @@
+import { ui } from "@melony/ui-kit";
+export const dataBlockWidget = (data) => ui.col({ gap: 'xs' }, Object.entries(data).filter(([_, v]) => v !== undefined && v !== null).map(([key, value]) => ui.row({ gap: 'sm', align: 'start' }, [
+    ui.text(`${key}:`, { weight: 'semibold', size: 'xs', color: 'muted' }),
+    ui.text(String(value), { size: 'xs' }),
+])));

package/dist/ui/widgets/data-table.js

@@ -0,0 +1,8 @@
+import { ui } from '@melony/ui-kit/server';
+export const dataTable = (headers, rows) => {
+    const headerRow = `| ${headers.join(' | ')} |`;
+    const separator = `| ${headers.map(() => '---').join(' | ')} |`;
+    const dataRows = rows.map(row => `| ${row.join(' | ')} |`).join('\n');
+    const markdownTable = `${headerRow}\n${separator}\n${dataRows}`;
+    return ui.markdown(markdownTable);
+};

package/dist/ui/widgets/empty-state.js

@@ -0,0 +1,7 @@
+import { ui } from '@melony/ui-kit/server';
+export const emptyState = (message, iconName) => ui.box({ padding: 'lg', border: true, radius: 'md' }, [
+    ui.col({ align: 'center', justify: 'center', gap: 'sm' }, [
+        iconName ? ui.icon(iconName) : ui.text('∅', { size: 'lg', color: 'muted' }),
+        ui.text(message, { size: 'sm', color: 'muted' })
+    ])
+]);

package/dist/ui/widgets/index.js

@@ -0,0 +1,19 @@
+import { keyValue } from './key-value.js';
+import { dataTable } from './data-table.js';
+import { codeSnippet } from './code-snippet.js';
+import { statusWidget as status } from './status.js';
+import { progressStep } from './progress-step.js';
+import { approvalCard } from './approval-card.js';
+import { actionList } from './action-list.js';
+import { emptyState } from './empty-state.js';
+export const widgets = {
+    keyValue,
+    dataTable,
+    codeSnippet,
+    status,
+    progressStep,
+    approvalCard,
+    actionList,
+    emptyState,
+};
+export default widgets;

package/dist/ui/widgets/key-value.js

@@ -0,0 +1,12 @@
+import { ui } from '@melony/ui-kit/server';
+export const keyValue = (title, data) => ui.box({ border: true, radius: 'md', padding: 'md' }, [
+    ui.col({ gap: 'md' }, [
+        ui.heading(title, { level: 4 }),
+        ui.col({ gap: 'xs' }, Object.entries(data)
+            .filter(([_, v]) => v !== undefined && v !== null)
+            .map(([key, value]) => ui.row({ gap: 'sm', align: 'start' }, [
+            ui.text(`${key}:`, { weight: 'bold', size: 'sm', color: 'muted' }),
+            ui.text(String(value), { size: 'sm' })
+        ])))
+    ])
+]);

package/dist/ui/widgets/progress-step.js

@@ -0,0 +1,5 @@
+import { ui } from '@melony/ui-kit/server';
+export const progressStep = (currentStep, totalSteps, label) => ui.row({ gap: 'md', align: 'center', padding: 'sm' }, [
+    ui.text(`Step ${currentStep} of ${totalSteps}`, { weight: 'bold', size: 'sm' }),
+    ui.text(label, { size: 'sm', color: 'muted' })
+]);

package/dist/ui/widgets/resource-card.js

@@ -0,0 +1,10 @@
+import { ui } from '@melony/ui-kit';
+export const resourceCardWidget = (title, subtitle, children = []) => ui.box({
+    border: true,
+    radius: 'lg',
+    padding: 'md',
+}, [
+    ui.heading(title, { level: 4 }),
+    ui.text(subtitle ?? '', { size: 'sm', color: 'mutedForeground' }),
+    ...children,
+]);

package/dist/ui/widgets/status.js

@@ -0,0 +1,5 @@
+import { ui } from '@melony/ui-kit';
+export const statusWidget = (message, severity = 'info') => ui.text(message, {
+    color: severity === 'error' ? 'danger' : severity === 'success' ? 'success' : 'muted',
+    size: 'xs',
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.1.28",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "bin": {
@@ -9,7 +9,7 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.33",
     "@ai-sdk/openai": "^3.0.13",
-    "@melony/ui-kit": "^0.1.5",
+    "@melony/ui-kit": "^0.1.30",
     "@types/cors": "^2.8.19",
     "ai": "^6.0.42",
     "commander": "^14.0.2",