@promptbook/cli 0.103.0-8 → 0.103.0

package/apps/agents-server/src/app/agents/[agentName]/api/chat/route.ts

@@ -0,0 +1,174 @@
+import { $getTableName } from '@/src/database/$getTableName';
+import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { $provideOpenAiAssistantExecutionToolsForServer } from '@/src/tools/$provideOpenAiAssistantExecutionToolsForServer';
+import { Agent, computeAgentHash, PROMPTBOOK_ENGINE_VERSION } from '@promptbook-local/core';
+import { computeHash, serializeError } from '@promptbook-local/utils';
+import { assertsError } from '../../../../../../../../src/errors/assertsError';
+
+/**
+ * Allow long-running streams: set to platform maximum (seconds)
+ */
+export const maxDuration = 300;
+
+export async function OPTIONS(request: Request) {
+    return new Response(null, {
+        status: 200,
+        headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+        },
+    });
+}
+
+export async function POST(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    let { agentName } = await params;
+    agentName = decodeURIComponent(agentName);
+
+    const body = await request.json();
+    const { message = 'Tell me more about yourself.', thread } = body;
+    //      <- TODO: [🐱‍🚀] To configuration DEFAULT_INITIAL_HIDDEN_MESSAGE
+
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        // [▶️] const executionTools = await $provideExecutionToolsForServer();
+        const openAiAssistantExecutionTools = await $provideOpenAiAssistantExecutionToolsForServer();
+        const agentSource = await collection.getAgentSource(agentName);
+        const agent = new Agent({
+            isVerbose: true, // <- TODO: [🐱‍🚀] From environment variable
+            executionTools: {
+                // [▶️] ...executionTools,
+                llm: openAiAssistantExecutionTools, // Note: Providing the OpenAI Assistant LLM tools to the Agent to be able to create its own Assistants GPTs
+            },
+            agentSource,
+        });
+
+        const agentHash = computeAgentHash(agentSource);
+        const userAgent = request.headers.get('user-agent');
+        const ip =
+            request.headers.get('x-forwarded-for') ||
+            request.headers.get('x-real-ip') ||
+            request.headers.get('x-client-ip');
+
+        // Note: Capture language and platform information
+        const language = request.headers.get('accept-language');
+        // Simple platform extraction from userAgent parentheses content (e.g., Windows NT 10.0; Win64; x64)
+        const platform = userAgent ? userAgent.match(/\(([^)]+)\)/)?.[1] : undefined; // <- TODO: [🧠] Improve platform parsing
+
+        // Note: Identify the user message
+        const userMessageContent = {
+            role: 'USER',
+            content: message,
+        };
+
+        // Record the user message
+        const supabase = $provideSupabaseForServer();
+        await supabase.from(await $getTableName('ChatHistory')).insert({
+            createdAt: new Date().toISOString(),
+            messageHash: computeHash(userMessageContent),
+            previousMessageHash: null, // <- TODO: [🧠] How to handle previous message hash?
+            agentName,
+            agentHash,
+            message: userMessageContent,
+            promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
+            url: request.url,
+            ip,
+            userAgent,
+            language,
+            platform,
+            source: 'AGENT_PAGE_CHAT',
+            apiKey: null,
+        });
+
+        const encoder = new TextEncoder();
+        const readableStream = new ReadableStream({
+            start(controller) {
+                let previousContent = '';
+
+                agent.callChatModelStream!(
+                    {
+                        title: `Chat with agent ${
+                            agentName /* <- TODO: [🕛] There should be `agentFullname` not `agentName` */
+                        }`,
+                        parameters: {},
+                        modelRequirements: {
+                            modelVariant: 'CHAT',
+                        },
+                        content: message,
+                        thread,
+                    },
+                    (chunk) => {
+                        const fullContent = chunk.content;
+                        const deltaContent = fullContent.substring(previousContent.length);
+                        previousContent = fullContent;
+
+                        controller.enqueue(encoder.encode(deltaContent));
+                    },
+                )
+                    .then(async (response) => {
+                        // Note: Identify the agent message
+                        const agentMessageContent = {
+                            role: 'MODEL',
+                            content: response.content,
+                        };
+
+                        // Record the agent message
+                        await supabase.from(await $getTableName('ChatHistory')).insert({
+                            createdAt: new Date().toISOString(),
+                            messageHash: computeHash(agentMessageContent),
+                            previousMessageHash: computeHash(userMessageContent),
+                            agentName,
+                            agentHash,
+                            message: agentMessageContent,
+                            promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
+                            url: request.url,
+                            ip,
+                            userAgent,
+                            language,
+                            platform,
+                            source: 'AGENT_PAGE_CHAT',
+                            apiKey: null,
+                        });
+
+                        // Note: [🐱‍🚀] Save the learned data
+                        const newAgentSource = agent.agentSource.value;
+                        if (newAgentSource !== agentSource) {
+                            await collection.updateAgentSource(agentName, newAgentSource);
+                        }
+
+                        controller.close();
+                    })
+                    .catch((error) => {
+                        controller.error(error);
+                    });
+            },
+        });
+
+        return new Response(readableStream, {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/markdown',
+                'Access-Control-Allow-Origin': '*', // <- Note: Allow embedding on other websites
+            },
+        });
+    } catch (error) {
+        assertsError(error);
+
+        console.error(error);
+
+        return new Response(
+            JSON.stringify(
+                serializeError(error),
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 400, // <- TODO: [🐱‍🚀] Make `errorToHttpStatusCode`
+                headers: { 'Content-Type': 'application/json' },
+            },
+        );
+    }
+}

package/apps/agents-server/src/app/agents/[agentName]/api/feedback/route.ts

@@ -0,0 +1,54 @@
+import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
+import { NextRequest, NextResponse } from 'next/server';
+import { PROMPTBOOK_ENGINE_VERSION } from '../../../../../../../../src/version';
+import { $getTableName } from '../../../../../database/$getTableName';
+
+type FeedbackRequest = {
+    agentHash: string;
+    rating?: string;
+    textRating?: string;
+    chatThread?: string;
+    userNote?: string;
+    expectedAnswer?: string;
+};
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ agentName: string }> }) {
+    try {
+        const { agentName } = await params;
+        const body = (await request.json()) as FeedbackRequest;
+        const { agentHash, rating, textRating, chatThread, userNote, expectedAnswer } = body;
+
+        if (!agentHash) {
+            return NextResponse.json({ message: 'Missing agentHash' }, { status: 400 });
+        }
+
+        const supabase = $provideSupabaseForServer();
+
+        const { error } = await supabase.from(await $getTableName('ChatFeedback')).insert({
+            createdAt: new Date().toISOString(),
+            agentName,
+            agentHash,
+            rating,
+            textRating,
+            chatThread,
+            userNote,
+            expectedAnswer,
+            promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
+            // Telemetry fields can be populated here if available in headers
+            // For now we leave them null or let Supabase handle default if any (though schema has them nullable)
+            url: request.headers.get('referer') || undefined,
+            userAgent: request.headers.get('user-agent') || undefined,
+            ip: request.headers.get('x-forwarded-for') || undefined,
+        });
+
+        if (error) {
+            console.error('Error inserting feedback:', error);
+            return NextResponse.json({ message: 'Failed to save feedback' }, { status: 500 });
+        }
+
+        return NextResponse.json({ message: 'Feedback saved' }, { status: 201 });
+    } catch (error) {
+        console.error('Unexpected error in feedback route:', error);
+        return NextResponse.json({ message: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/agents/[agentName]/api/mcp/route.ts

@@ -0,0 +1,203 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { $provideExecutionToolsForServer } from '@/src/tools/$provideExecutionToolsForServer';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { Agent } from '@promptbook-local/core';
+import { ChatMessage, ChatPromptResult, Prompt, TODO_any } from '@promptbook-local/types';
+import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+
+// Global map to store active transports
+// Note: This works in stateful environments or single-instance deployments.
+// In serverless with multiple instances, this will fail if POST lands on a different instance.
+// However, for standard deployments or sticky sessions, it works.
+const sessions = new Map<string, SSENextJsTransport>();
+
+class SSENextJsTransport implements Transport {
+    public onmessage?: (message: JSONRPCMessage) => void;
+    public onclose?: () => void;
+    public onError?: (error: Error) => void;
+    private controller: ReadableStreamDefaultController<TODO_any>;
+    private encoder = new TextEncoder();
+    public sessionId: string;
+
+    constructor(controller: ReadableStreamDefaultController<TODO_any>, sessionId: string) {
+        this.controller = controller;
+        this.sessionId = sessionId;
+    }
+
+    async start(): Promise<void> {
+        // No-op for SSE
+    }
+
+    async close(): Promise<void> {
+        this.onclose?.();
+        sessions.delete(this.sessionId);
+    }
+
+    async send(message: JSONRPCMessage): Promise<void> {
+        const event = `event: message\ndata: ${JSON.stringify(message)}\n\n`;
+        this.controller.enqueue(this.encoder.encode(event));
+    }
+
+    async handlePostMessage(message: JSONRPCMessage): Promise<void> {
+        this.onmessage?.(message);
+    }
+
+    sendEndpointEvent(endpoint: string) {
+        const event = `event: endpoint\ndata: ${endpoint}\n\n`;
+        this.controller.enqueue(this.encoder.encode(event));
+    }
+}
+
+export async function GET(
+    request: NextRequest,
+    { params }: { params: Promise<{ agentName: string }> },
+) {
+    const { agentName } = await params;
+
+    // Check if agent exists
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        await collection.getAgentSource(agentName);
+    } catch (error) {
+        return NextResponse.json({ error: 'Agent not found' }, { status: 404 });
+    }
+
+    const sessionId = crypto.randomUUID();
+
+    const stream = new ReadableStream({
+        start: async (controller) => {
+            const transport = new SSENextJsTransport(controller, sessionId);
+            sessions.set(sessionId, transport);
+
+            // Send endpoint event
+            // Construct the POST endpoint URL
+            // We assume the client can construct it or we send relative/absolute path
+            // The user wants: /agents/[agentName]/api/mcp
+            // We can send specific query param
+            const endpoint = `/agents/${agentName}/api/mcp?sessionId=${sessionId}`;
+            transport.sendEndpointEvent(endpoint);
+
+            // Initialize MCP Server
+            const server = new McpServer({
+                name: `Agent ${agentName}`,
+                version: '1.0.0',
+            });
+
+            // Register Chat Tool
+            server.tool(
+                'chat',
+                {
+                    messages: z.array(
+                        z.object({
+                            role: z.enum(['user', 'assistant', 'system']),
+                            content: z.string(),
+                        }),
+                    ),
+                    model: z.string().optional(),
+                },
+                async ({ messages, model }) => {
+                    try {
+                        const collection = await $provideAgentCollectionForServer();
+                        const agentSource = await collection.getAgentSource(agentName);
+
+                        const executionTools = await $provideExecutionToolsForServer();
+                        const agent = new Agent({
+                            agentSource,
+                            executionTools,
+                            isVerbose: true,
+                        });
+
+                        // Prepare thread and content
+                        const lastMessage = messages[messages.length - 1];
+                        const previousMessages = messages.slice(0, -1);
+
+                        const thread: ChatMessage[] = previousMessages.map((msg: TODO_any, index: number) => ({
+                            id: `msg-${index}`,
+                            from: msg.role === 'assistant' ? 'agent' : 'user', // Mapping standard roles
+                            content: msg.content,
+                            isComplete: true,
+                            date: new Date(),
+                        }));
+
+                        const prompt: Prompt = {
+                            title: 'MCP Chat Completion',
+                            content: lastMessage.content,
+                            modelRequirements: {
+                                modelVariant: 'CHAT',
+                            },
+                            parameters: {},
+                            thread,
+                        } as Prompt;
+
+                        const result = await agent.callChatModel(prompt);
+
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: result.content,
+                                },
+                            ],
+                        };
+                    } catch (error) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Error: ${(error as Error).message}`,
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                },
+            );
+
+            await server.connect(transport);
+
+            // Handle connection close
+            // In ReadableStream, verify if there is a way to detect close from client side in Next.js?
+            // Usually if client disconnects, the stream might be cancelled.
+            // But we don't have a direct hook here unless we return logic in 'cancel'.
+        },
+        cancel() {
+            sessions.delete(sessionId);
+        },
+    });
+
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+        },
+    });
+}
+
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ agentName: string }> },
+) {
+    const { searchParams } = new URL(request.url);
+    const sessionId = searchParams.get('sessionId');
+
+    if (!sessionId) {
+        return NextResponse.json({ error: 'Session ID required' }, { status: 400 });
+    }
+
+    const transport = sessions.get(sessionId);
+    if (!transport) {
+        return NextResponse.json({ error: 'Session not found' }, { status: 404 });
+    }
+
+    try {
+        const body = await request.json();
+        await transport.handlePostMessage(body);
+        return NextResponse.json({ success: true }); // Accepted
+    } catch (error) {
+        return NextResponse.json({ error: 'Invalid request' }, { status: 400 });
+    }
+}

package/apps/agents-server/src/app/agents/[agentName]/api/modelRequirements/TODO.txt

@@ -0,0 +1 @@
+TODO: [🎣][🧠] Maybe do API / Page for transpilers, Allow to export each agent

package/apps/agents-server/src/app/agents/[agentName]/api/modelRequirements/route.ts

@@ -0,0 +1,55 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { resolveInheritedAgentSource } from '@/src/utils/resolveInheritedAgentSource';
+import { createAgentModelRequirements } from '@promptbook-local/core';
+import { serializeError } from '@promptbook-local/utils';
+import { assertsError } from '../../../../../../../../src/errors/assertsError';
+import { keepUnused } from '../../../../../../../../src/utils/organization/keepUnused';
+
+export async function GET(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    keepUnused(request /* <- Note: We dont need `request` parameter */);
+    let { agentName } = await params;
+    agentName = decodeURIComponent(agentName);
+
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        const agentSource = await collection.getAgentSource(agentName);
+        const effectiveAgentSource = await resolveInheritedAgentSource(agentSource, collection);
+        const modelRequirements = await createAgentModelRequirements(effectiveAgentSource);
+
+        return new Response(
+            JSON.stringify(
+                modelRequirements,
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            },
+        );
+    } catch (error) {
+        assertsError(error);
+
+        console.error(error);
+
+        return new Response(
+            JSON.stringify(
+                serializeError(error),
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 400, // <- TODO: [🐱‍🚀] Make `errorToHttpStatusCode`
+                headers: { 'Content-Type': 'application/json' },
+            },
+        );
+    }
+}
+
+/**
+ * TODO: [🍞] DRY - Make some common utility for API on one agent
+ */

package/apps/agents-server/src/app/agents/[agentName]/api/modelRequirements/systemMessage/route.ts

@@ -0,0 +1,47 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { resolveInheritedAgentSource } from '@/src/utils/resolveInheritedAgentSource';
+import { createAgentModelRequirements } from '@promptbook-local/core';
+import { serializeError } from '@promptbook-local/utils';
+import { assertsError } from '../../../../../../../../../src/errors/assertsError';
+import { keepUnused } from '../../../../../../../../../src/utils/organization/keepUnused';
+
+export async function GET(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    keepUnused(request /* <- Note: We dont need `request` parameter */);
+    let { agentName } = await params;
+    agentName = decodeURIComponent(agentName);
+
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        const agentSource = await collection.getAgentSource(agentName);
+        const effectiveAgentSource = await resolveInheritedAgentSource(agentSource, collection);
+        const modelRequirements = await createAgentModelRequirements(effectiveAgentSource);
+        const { systemMessage } = modelRequirements;
+
+        return new Response(systemMessage, {
+            status: 200,
+            headers: { 'Content-Type': 'text/markdown' },
+        });
+    } catch (error) {
+        assertsError(error);
+
+        console.error(error);
+
+        return new Response(
+            JSON.stringify(
+                serializeError(error),
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 400, // <- TODO: [🐱‍🚀] Make `errorToHttpStatusCode`
+                headers: { 'Content-Type': 'application/json' },
+            },
+        );
+    }
+}
+
+/**
+ * TODO: [🍞] DRY - Make some common utility for API on one agent
+ */

package/apps/agents-server/src/app/agents/[agentName]/api/openai/chat/completions/route.ts

@@ -0,0 +1,10 @@
+import { handleChatCompletion } from '@/src/utils/handleChatCompletion';
+import { NextRequest } from 'next/server';
+
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ agentName: string }> },
+) {
+    const { agentName } = await params;
+    return handleChatCompletion(request, { agentName }, 'OpenAI API Chat Completion');
+}

package/apps/agents-server/src/app/agents/[agentName]/api/openai/models/route.ts

@@ -0,0 +1,93 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { validateApiKey } from '@/src/utils/validateApiKey';
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * GET /agents/[agentName]/api/openai/models
+ *
+ * Lists available models for the OpenAI-compatible API.
+ * This endpoint is required for OpenAI-compatible clients (like Jan, LM Studio, etc.)
+ * to discover available models.
+ */
+export async function GET(request: NextRequest, { params }: { params: Promise<{ agentName: string }> }) {
+    const { agentName } = await params;
+
+    // Validate API key explicitly (in addition to middleware)
+    const apiKeyValidation = await validateApiKey(request);
+    if (!apiKeyValidation.isValid) {
+        return NextResponse.json(
+            {
+                error: {
+                    message: apiKeyValidation.error || 'Invalid API key',
+                    type: 'authentication_error',
+                },
+            },
+            { status: 401 },
+        );
+    }
+
+    try {
+        const collection = await $provideAgentCollectionForServer();
+
+        let agentSource;
+        try {
+            agentSource = await collection.getAgentSource(agentName);
+        } catch (error) {
+            return NextResponse.json(
+                { error: { message: `Agent '${agentName}' not found.`, type: 'invalid_request_error' } },
+                { status: 404 },
+            );
+        }
+
+        if (!agentSource) {
+            return NextResponse.json(
+                { error: { message: `Agent '${agentName}' not found.`, type: 'invalid_request_error' } },
+                { status: 404 },
+            );
+        }
+
+        // Return the agent as a single model in OpenAI format
+        // The model ID is the agent name, which clients will use when making chat completion requests
+        const models = [
+            {
+                id: agentName,
+                object: 'model',
+                created: Math.floor(Date.now() / 1000),
+                owned_by: 'promptbook',
+                permission: [
+                    {
+                        id: `modelperm-${agentName}`,
+                        object: 'model_permission',
+                        created: Math.floor(Date.now() / 1000),
+                        allow_create_engine: false,
+                        allow_sampling: true,
+                        allow_logprobs: false,
+                        allow_search_indices: false,
+                        allow_view: true,
+                        allow_fine_tuning: false,
+                        organization: '*',
+                        group: null,
+                        is_blocking: false,
+                    },
+                ],
+                root: agentName,
+                parent: null,
+            },
+        ];
+
+        return NextResponse.json({
+            object: 'list',
+            data: models,
+        });
+    } catch (error) {
+        console.error('Error in models listing handler:', error);
+        return NextResponse.json(
+            { error: { message: (error as Error).message || 'Internal Server Error', type: 'server_error' } },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * TODO: [🧠] Consider listing all available agents as models when agentName is a wildcard or special value
+ */

package/apps/agents-server/src/app/agents/[agentName]/api/openai/v1/chat/completions/route.ts

@@ -0,0 +1,10 @@
+import { handleChatCompletion } from '@/src/utils/handleChatCompletion';
+import { NextRequest } from 'next/server';
+
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ agentName: string }> },
+) {
+    const { agentName } = await params;
+    return handleChatCompletion(request, { agentName }, 'OpenAI API Chat Completion');
+}