@lovelybunch/api 1.0.76-alpha.9 → 1.0.77-alpha.0

package/dist/routes/api/v1/jobs/[id]/route.d.ts

@@ -9,12 +9,6 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
 }, 404, "json">) | (Response & import("hono").TypedResponse<{
     success: true;
     data: {
-        id: string;
-        name: string;
-        description?: string;
-        prompt: string;
-        model: string;
-        status: ScheduledJobStatus;
         schedule: {
             type: "cron";
             expression: string;
@@ -27,29 +21,32 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             timezone?: string;
             anchorHour?: number;
         };
+        status: ScheduledJobStatus;
+        id: string;
+        name: string;
         metadata: {
             createdAt: string;
             updatedAt: string;
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        description?: string;
+        model: string;
+        prompt: string;
+        mcpServers?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
         runs: {
-            id: string;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
             status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            error?: string;
+            id: string;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
-            error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -73,12 +70,6 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
 }, 400, "json">) | (Response & import("hono").TypedResponse<{
     success: true;
     data: {
-        id: string;
-        name: string;
-        description?: string;
-        prompt: string;
-        model: string;
-        status: ScheduledJobStatus;
         schedule: {
             type: "cron";
             expression: string;
@@ -91,29 +82,32 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             timezone?: string;
             anchorHour?: number;
         };
+        status: ScheduledJobStatus;
+        id: string;
+        name: string;
         metadata: {
             createdAt: string;
             updatedAt: string;
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        description?: string;
+        model: string;
+        prompt: string;
+        mcpServers?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
         runs: {
-            id: string;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
             status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            error?: string;
+            id: string;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
-            error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

package/dist/routes/api/v1/jobs/[id]/route.js

@@ -1,6 +1,6 @@
 import { JobStore } from '../../../../../lib/jobs/job-store.js';
 import { getGlobalJobScheduler } from '../../../../../lib/jobs/global-job-scheduler.js';
-import { normalizeSchedule, normalizeStatus, } from '../route.js';
+import { normalizeSchedule, normalizeStatus, withLightweightRuns, } from '../route.js';
 const store = new JobStore();
 const scheduler = getGlobalJobScheduler();
 function normalizeScheduleUpdate(current, incoming) {
@@ -32,7 +32,7 @@ export async function GET(c) {
                 }
             }, 404);
         }
-        return c.json({ success: true, data: job });
+        return c.json({ success: true, data: withLightweightRuns(job) });
     }
     catch (error) {
         console.error('Failed to fetch job:', error);
@@ -101,7 +101,7 @@ export async function PATCH(c) {
         const reloaded = await store.getJob(updated.id);
         return c.json({
             success: true,
-            data: reloaded ?? updated
+            data: withLightweightRuns(reloaded ?? updated)
         });
     }
     catch (error) {

package/dist/routes/api/v1/jobs/[id]/run/route.d.ts

@@ -12,8 +12,8 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
         run: {
             id: string;
             jobId: string;
-            trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            trigger: import("node_modules/@lovelybunch/types/src/index.js").ScheduledJobTrigger;
+            status: import("node_modules/@lovelybunch/types/src/index.js").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
             outputPath?: string;

package/dist/routes/api/v1/jobs/[id]/runs/[runId]/route.d.ts

@@ -10,8 +10,8 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
     data: {
         id: string;
         jobId: string;
-        trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-        status: import("@lovelybunch/types").ScheduledJobRunStatus;
+        trigger: import("node_modules/@lovelybunch/types/src/index.js").ScheduledJobTrigger;
+        status: import("node_modules/@lovelybunch/types/src/index.js").ScheduledJobRunStatus;
         startedAt: string;
         finishedAt?: string;
         outputPath?: string;

package/dist/routes/api/v1/jobs/route.d.ts

@@ -1,16 +1,16 @@
 import { Context } from 'hono';
-import { DayOfWeek, ScheduledJobSchedule, ScheduledJobStatus } from '@lovelybunch/types';
+import { DayOfWeek, ScheduledJobRun, ScheduledJobRunMeta, ScheduledJobSchedule, ScheduledJobStatus } from '@lovelybunch/types';
 export declare function normalizeSchedule(schedule?: Partial<ScheduledJobSchedule>): ScheduledJobSchedule;
 export declare function normalizeStatus(status?: ScheduledJobStatus): ScheduledJobStatus;
+export declare function toRunMeta(run: ScheduledJobRun): ScheduledJobRunMeta;
+export declare function withLightweightRuns<T extends {
+    runs: ScheduledJobRun[];
+}>(job: T): Omit<T, 'runs'> & {
+    runs: ScheduledJobRunMeta[];
+};
 export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
     success: true;
     data: {
-        id: string;
-        name: string;
-        description?: string;
-        prompt: string;
-        model: string;
-        status: ScheduledJobStatus;
         schedule: {
             type: "cron";
             expression: string;
@@ -23,29 +23,32 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             timezone?: string;
             anchorHour?: number;
         };
+        status: ScheduledJobStatus;
+        id: string;
+        name: string;
         metadata: {
             createdAt: string;
             updatedAt: string;
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        description?: string;
+        model: string;
+        prompt: string;
+        mcpServers?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
         runs: {
-            id: string;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
             status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            error?: string;
+            id: string;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
-            error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     }[];
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -63,12 +66,6 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
 }, 400, "json">) | (Response & import("hono").TypedResponse<{
     success: true;
     data: {
-        id: string;
-        name: string;
-        description?: string;
-        prompt: string;
-        model: string;
-        status: ScheduledJobStatus;
         schedule: {
             type: "cron";
             expression: string;
@@ -81,29 +78,32 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
             timezone?: string;
             anchorHour?: number;
         };
+        status: ScheduledJobStatus;
+        id: string;
+        name: string;
         metadata: {
             createdAt: string;
             updatedAt: string;
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        description?: string;
+        model: string;
+        prompt: string;
+        mcpServers?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
         runs: {
-            id: string;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
             status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            error?: string;
+            id: string;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
-            error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, 201, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

package/dist/routes/api/v1/jobs/route.js

@@ -58,12 +58,27 @@ export function normalizeSchedule(schedule) {
 export function normalizeStatus(status) {
     return status === 'active' ? 'active' : 'paused';
 }
+export function toRunMeta(run) {
+    return {
+        id: run.id,
+        jobId: run.jobId,
+        trigger: run.trigger,
+        status: run.status,
+        startedAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        error: run.error,
+    };
+}
+export function withLightweightRuns(job) {
+    const { runs, ...rest } = job;
+    return { ...rest, runs: runs.map(toRunMeta) };
+}
 export async function GET(c) {
     try {
         const jobs = await store.listJobs();
         return c.json({
             success: true,
-            data: jobs
+            data: jobs.map(withLightweightRuns)
         });
     }
     catch (error) {
@@ -131,7 +146,7 @@ export async function POST(c) {
         const created = await store.getJob(job.id);
         return c.json({
             success: true,
-            data: created ?? job
+            data: withLightweightRuns(created ?? job)
         }, 201);
     }
     catch (error) {

package/dist/routes/api/v1/jobs/status/route.d.ts

@@ -7,7 +7,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         runningCount: number;
         jobs: {
             id: string;
-            status: import("@lovelybunch/types").ScheduledJobStatus;
+            status: import("node_modules/@lovelybunch/types/src/index.js").ScheduledJobStatus;
             nextRunAt?: string;
             lastRunAt?: string;
             timerActive: boolean;

package/dist/routes/api/v1/mail/route.d.ts

@@ -116,7 +116,7 @@ export declare function setMailStatusHandler(c: Context): Promise<(Response & im
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: any;
-}, 500 | 404, "json">)>;
+}, 404 | 500, "json">)>;
 /**
  * POST /api/v1/mail/:id/reply
  * Reply to an email
@@ -154,7 +154,7 @@ export declare function replyMailHandler(c: Context): Promise<(Response & import
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: any;
-}, 500 | 404, "json">)>;
+}, 404 | 500, "json">)>;
 /**
  * POST /api/v1/mail/send
  * Send an email (coming soon)
@@ -217,7 +217,7 @@ export declare function setMailActionHandler(c: Context): Promise<(Response & im
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: any;
-}, 500 | 404, "json">)>;
+}, 404 | 500, "json">)>;
 /**
  * GET /api/v1/mail/:id/processing
  * Get processing status and log tail for an email

package/dist/routes/api/v1/mcp/index.js

@@ -3,10 +3,36 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { ZodError } from 'zod';
 import { listTasks, getTask, createTask, updateTask, deleteTask, getContext, updateContext, appendContext, replaceContextSection, listKnowledge, getKnowledge, createKnowledge, updateKnowledge, listEvents, } from '@lovelybunch/core';
-import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, roleContextTool, agentsContextTool, teamContextTool, memoryContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
+import { homedir } from 'os';
+import { readFileSync, existsSync } from 'fs';
 const app = new Hono();
 const storage = new FileStorageAdapter();
+const COCONUT_HOST = 'https://app.coconut.dev';
+function getCallbackToken() {
+    try {
+        const platform = process.platform;
+        let configDir;
+        if (platform === 'win32') {
+            configDir = path.join(process.env.APPDATA || homedir(), 'coconuts');
+        }
+        else if (platform === 'darwin') {
+            configDir = path.join(homedir(), 'Library', 'Application Support', 'coconuts');
+        }
+        else {
+            configDir = path.join(process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config'), 'coconuts');
+        }
+        const configFile = path.join(configDir, 'config.json');
+        if (!existsSync(configFile))
+            return null;
+        const config = JSON.parse(readFileSync(configFile, 'utf-8'));
+        return config.apiKeys?.callbackToken || null;
+    }
+    catch {
+        return null;
+    }
+}
 function resolveGaitPath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
@@ -78,15 +104,18 @@ app.get('/', async (c) => {
         }
         const names = Object.keys(externalServers);
         // Add built-in tools (include full JSON schema for parameters)
-        // Note: tasks now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
+        // Note: tasks now supports full CRUD, knowledge/context tools are read+write, events is read-only
         const builtInTools = {
             tasks: tasksFullTool,
             knowledge_documents: knowledgeTool,
             activity_events: eventsTool,
-            project_context: projectContextTool,
-            architecture_context: architectureContextTool,
             role_context: roleContextTool,
-            resources: resourcesTool
+            agents_context: agentsContextTool,
+            team_context: teamContextTool,
+            memory_context: memoryContextTool,
+            resources: resourcesTool,
+            list_connectors: listConnectorsTool,
+            connector_request: connectorRequestTool
         };
         return c.json({
             success: true,
@@ -106,16 +135,19 @@ app.get('/', async (c) => {
  */
 app.get('/schema', async (c) => {
     try {
-        // Note: tasks now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
+        // Note: tasks now supports full CRUD, knowledge/context tools are read+write, events is read-only
         const schema = {
             tools: {
                 tasks: tasksFullTool,
                 knowledge_documents: knowledgeTool,
                 activity_events: eventsTool,
-                project_context: projectContextTool,
-                architecture_context: architectureContextTool,
                 role_context: roleContextTool,
-                resources: resourcesTool
+                agents_context: agentsContextTool,
+                team_context: teamContextTool,
+                memory_context: memoryContextTool,
+                resources: resourcesTool,
+                list_connectors: listConnectorsTool,
+                connector_request: connectorRequestTool
             }
         };
         return c.json(schema);
@@ -144,18 +176,27 @@ app.post('/execute', async (c) => {
         if (tool === 'activity_events') {
             return await executeEventsTool(c, args);
         }
-        if (tool === 'project_context') {
-            return await executeProjectContextTool(c, args);
-        }
-        if (tool === 'architecture_context') {
-            return await executeArchitectureContextTool(c, args);
-        }
         if (tool === 'role_context') {
             return await executeRoleContextTool(c, args);
         }
+        if (tool === 'agents_context') {
+            return await executeAgentsContextTool(c, args);
+        }
+        if (tool === 'team_context') {
+            return await executeTeamContextTool(c, args);
+        }
+        if (tool === 'memory_context') {
+            return await executeMemoryContextTool(c, args);
+        }
         if (tool === 'resources') {
             return await executeResourcesTool(c, args);
         }
+        if (tool === 'list_connectors') {
+            return await executeListConnectorsTool(c);
+        }
+        if (tool === 'connector_request') {
+            return await executeConnectorRequestTool(c, args);
+        }
         return c.json({ success: false, error: 'Unknown tool' }, 400);
     }
     catch (error) {
@@ -446,15 +487,18 @@ async function executeContextTool(c, contextType, args) {
     }
 }
 // Wrapper functions for each context type (maintain API compatibility)
-async function executeProjectContextTool(c, args) {
-    return executeContextTool(c, 'project', args);
-}
-async function executeArchitectureContextTool(c, args) {
-    return executeContextTool(c, 'architecture', args);
-}
 async function executeRoleContextTool(c, args) {
     return executeContextTool(c, 'role', args);
 }
+async function executeAgentsContextTool(c, args) {
+    return executeContextTool(c, 'agents', args);
+}
+async function executeTeamContextTool(c, args) {
+    return executeContextTool(c, 'team', args);
+}
+async function executeMemoryContextTool(c, args) {
+    return executeContextTool(c, 'memory', args);
+}
 // Resources tool executor — proxies to the resource API endpoints on the same server
 async function executeResourcesTool(c, args) {
     const { operation, query, type_filter, resource_id, prompt, model, aspect_ratio, text, voice, duration, resolution, url, tags, description } = args;
@@ -525,6 +569,135 @@ async function executeResourcesTool(c, args) {
         return c.json({ success: false, error: error.message || 'Resources tool execution failed' }, 500);
     }
 }
+async function executeListConnectorsTool(c) {
+    const token = getCallbackToken();
+    if (!token) {
+        return c.json({
+            success: false,
+            error: 'Callback token not configured. Set it via PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        }, 400);
+    }
+    try {
+        const res = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+            headers: { 'X-Callback-Token': token }
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return c.json({
+                success: false,
+                error: `Control plane returned ${res.status}: ${body || res.statusText}`
+            }, res.status >= 500 ? 502 : 400);
+        }
+        const data = await res.json();
+        const accounts = Array.isArray(data) ? data : (data.accounts ?? data.data ?? []);
+        return c.json({
+            success: true,
+            data: accounts,
+            count: accounts.length,
+            message: `Found ${accounts.length} connected service${accounts.length === 1 ? '' : 's'}`
+        });
+    }
+    catch (error) {
+        console.error('Error listing connectors:', error);
+        return c.json({ success: false, error: error.message || 'Failed to list connectors' }, 500);
+    }
+}
+async function executeConnectorRequestTool(c, args) {
+    const { app: appSlug, method, path: apiPath, body, headers: extraHeaders } = args;
+    if (!appSlug || !method || !apiPath) {
+        return c.json({ success: false, error: 'app, method, and path are required' }, 400);
+    }
+    const token = getCallbackToken();
+    if (!token) {
+        return c.json({
+            success: false,
+            error: 'Callback token not configured. Set it via PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        }, 400);
+    }
+    try {
+        const accounts = await fetchConnectorAccounts(token);
+        const account = accounts.find((a) => a.appSlug === appSlug || a.appName?.toLowerCase() === appSlug.toLowerCase());
+        if (!account) {
+            return c.json({
+                success: false,
+                error: `No connected account found for "${appSlug}"`,
+                available: accounts.map((a) => a.appSlug || a.appName)
+            }, 404);
+        }
+        const url = resolveConnectorUrl(appSlug, apiPath);
+        if (!url) {
+            return c.json({
+                success: false,
+                error: `Unknown app "${appSlug}" and path is not a full URL. Use a full URL (https://...) or a known app slug.`
+            }, 400);
+        }
+        let parsedBody = undefined;
+        if (body) {
+            try {
+                parsedBody = typeof body === 'string' ? JSON.parse(body) : body;
+            }
+            catch {
+                return c.json({ success: false, error: 'Invalid JSON in body parameter' }, 400);
+            }
+        }
+        let parsedHeaders = {};
+        if (extraHeaders) {
+            try {
+                parsedHeaders = typeof extraHeaders === 'string' ? JSON.parse(extraHeaders) : extraHeaders;
+            }
+            catch {
+                return c.json({ success: false, error: 'Invalid JSON in headers parameter' }, 400);
+            }
+        }
+        const proxyPayload = {
+            accountId: account.accountId,
+            url,
+            method: method.toUpperCase()
+        };
+        if (parsedBody !== undefined)
+            proxyPayload.body = parsedBody;
+        if (Object.keys(parsedHeaders).length > 0)
+            proxyPayload.headers = parsedHeaders;
+        const proxyRes = await fetch(`${COCONUT_HOST}/api/connectors/proxy`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Callback-Token': token
+            },
+            body: JSON.stringify(proxyPayload)
+        });
+        if (!proxyRes.ok) {
+            const errBody = await proxyRes.text().catch(() => '');
+            return c.json({
+                success: false,
+                error: `Proxy request failed (${proxyRes.status}): ${errBody || proxyRes.statusText}`
+            }, proxyRes.status >= 500 ? 502 : 400);
+        }
+        const responseData = await proxyRes.json().catch(async () => {
+            return await proxyRes.text().catch(() => null);
+        });
+        return c.json({
+            success: true,
+            data: responseData,
+            message: `${method.toUpperCase()} ${apiPath} via ${appSlug}`
+        });
+    }
+    catch (error) {
+        console.error('Error executing connector request:', error);
+        return c.json({ success: false, error: error.message || 'Connector request failed' }, 500);
+    }
+}
+async function fetchConnectorAccounts(token) {
+    const res = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+        headers: { 'X-Callback-Token': token }
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Failed to fetch accounts (${res.status}): ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return Array.isArray(data) ? data : (data.accounts ?? data.data ?? []);
+}
 /**
  * GET /api/v1/mcp/raw-config
  * Returns the raw MCP configuration for editing in settings UI

package/dist/routes/api/v1/resources/generate/route.js

@@ -70,6 +70,7 @@ const THUMBNAILS_DIR = path.join(RESOURCES_DIR, 'thumbnails');
 // Model ID mapping from frontend values to Replicate model identifiers
 const MODEL_ID_MAP = {
     'nano-banana-pro': 'google/nano-banana-pro',
+    'nano-banana-2': 'google/nano-banana-2',
     'flux-2-dev': 'black-forest-labs/flux-2-dev',
     'flux-2-pro': 'black-forest-labs/flux-2-pro',
     'gpt-image-1.5': 'openai/gpt-image-1.5',
@@ -135,7 +136,7 @@ export async function POST(c) {
             }, 400);
         }
         const body = await c.req.json();
-        const { prompt, model = 'nano-banana-pro', dimensions, resolution, output_format = 'png', output_quality, quality, go_fast, safety_tolerance, background, image_input, 
+        const { prompt, model = 'nano-banana-2', dimensions, resolution, output_format = 'png', output_quality, quality, go_fast, safety_tolerance, background, image_input, 
         // Legacy
         inspiration } = body;
         if (!prompt) {
@@ -215,7 +216,7 @@ export async function POST(c) {
             }
         }
         // Map model selector value to Replicate model ID
-        const replicateModelId = MODEL_ID_MAP[model] || MODEL_ID_MAP['nano-banana-pro'];
+        const replicateModelId = MODEL_ID_MAP[model] || MODEL_ID_MAP['nano-banana-2'];
         // Build model-specific input payload
         const input = {
             prompt: fullPrompt,
@@ -233,7 +234,13 @@ export async function POST(c) {
         }
         // Model-specific parameters
         if (model === 'nano-banana-pro' || model === 'Nano Banana Pro') {
-            // Nano Banana Pro specific settings
+            input.resolution = resolution || '2K';
+            input.safety_filter_level = 'block_only_high';
+            if (imageInputArray.length > 0) {
+                input.image_input = imageInputArray;
+            }
+        }
+        else if (model === 'nano-banana-2') {
             input.resolution = resolution || '2K';
             input.safety_filter_level = 'block_only_high';
             if (imageInputArray.length > 0) {