@promptbook/cli 0.103.0-54 → 0.103.0-56

package/apps/agents-server/src/app/agents/[agentName]/agentLinks.tsx

@@ -0,0 +1,80 @@
+import {
+    BookOpenIcon,
+    CodeIcon,
+    GlobeIcon,
+    HistoryIcon,
+    LinkIcon,
+    MessageSquareIcon,
+    NotebookPenIcon,
+} from 'lucide-react';
+import type { ComponentType } from 'react';
+
+type AgentLink = {
+    title: string;
+    href: string;
+    icon: ComponentType<{ className?: string }>;
+    description?: string;
+    target?: '_blank' | '_self';
+    rel?: string;
+};
+
+export const getAgentLinks = (agentName: string): AgentLink[] => {
+    const encodedName = encodeURIComponent(agentName);
+    return [
+        {
+            title: 'Chat with Agent',
+            href: `/agents/${encodedName}`,
+            icon: MessageSquareIcon,
+            description: 'Direct interface to converse with the agent.',
+        },
+        {
+            title: 'Edit Book',
+            href: `/agents/${encodedName}/book`,
+            icon: NotebookPenIcon,
+            description: "Edit the agent's knowledge book.",
+        },
+        {
+            title: 'Integration',
+            href: `/agents/${encodedName}/integration`,
+            icon: CodeIcon,
+            description: 'Learn how to integrate this agent into your applications.',
+        },
+        {
+            title: 'History & Feedback',
+            href: `/agents/${encodedName}/history`,
+            icon: HistoryIcon,
+            description: 'View past conversations and provide feedback.',
+        },
+        {
+            title: 'All Links',
+            href: `/agents/${encodedName}/links`,
+            icon: LinkIcon,
+            description: 'Signpost & Links',
+        },
+        {
+            title: 'Website Integration',
+            href: `/agents/${encodedName}/website-integration`,
+            icon: GlobeIcon,
+            description: 'Embed the agent chat widget directly into your React application.',
+        },
+    ];
+};
+
+export const getAgentExternalLinks = (): AgentLink[] => [
+    {
+        title: 'Promptbook Studio',
+        href: 'https://promptbook.studio',
+        icon: BookOpenIcon,
+        description: 'Create and manage your own agents',
+        target: '_blank',
+        rel: 'noopener noreferrer',
+    },
+    {
+        title: 'GitHub Repository',
+        href: 'https://github.com/webgptorg/promptbook',
+        icon: CodeIcon,
+        description: 'Star us and contribute to the project',
+        target: '_blank',
+        rel: 'noopener noreferrer',
+    },
+];

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

@@ -1,4 +1,5 @@
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { resolveInheritedAgentSource } from '@/src/utils/resolveInheritedAgentSource';
 import { padBook, validateBook } from '@promptbook-local/core';
 import { serializeError } from '@promptbook-local/utils';
 import spaceTrim from 'spacetrim';
@@ -13,8 +14,9 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
     try {
         const collection = await $provideAgentCollectionForServer();
         const agentSource = await collection.getAgentSource(agentName);
+        const effectiveAgentSource = await resolveInheritedAgentSource(agentSource, collection);
 
-        return new Response(agentSource, {
+        return new Response(effectiveAgentSource, {
             status: 200,
             headers: { 'Content-Type': 'text/plain' /* <- TODO: [🎳] Mime type of book */ },
         });

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

@@ -77,11 +77,15 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
             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 ${
@@ -95,7 +99,11 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
                         thread,
                     },
                     (chunk) => {
-                        controller.enqueue(encoder.encode(chunk.content));
+                        const fullContent = chunk.content;
+                        const deltaContent = fullContent.substring(previousContent.length);
+                        previousContent = fullContent;
+
+                        controller.enqueue(encoder.encode(deltaContent));
                     },
                 )
                     .then(async (response) => {
@@ -119,6 +127,8 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
                             userAgent,
                             language,
                             platform,
+                            source: 'AGENT_PAGE_CHAT',
+                            apiKey: null,
                         });
 
                         // Note: [🐱‍🚀] Save the learned data

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/route.ts

@@ -1,4 +1,5 @@
 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';
@@ -12,7 +13,8 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
     try {
         const collection = await $provideAgentCollectionForServer();
         const agentSource = await collection.getAgentSource(agentName);
-        const modelRequirements = await createAgentModelRequirements(agentSource);
+        const effectiveAgentSource = await resolveInheritedAgentSource(agentSource, collection);
+        const modelRequirements = await createAgentModelRequirements(effectiveAgentSource);
 
         return new Response(
             JSON.stringify(

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

@@ -1,4 +1,5 @@
 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';
@@ -12,7 +13,8 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
     try {
         const collection = await $provideAgentCollectionForServer();
         const agentSource = await collection.getAgentSource(agentName);
-        const modelRequirements = await createAgentModelRequirements(agentSource);
+        const effectiveAgentSource = await resolveInheritedAgentSource(agentSource, collection);
+        const modelRequirements = await createAgentModelRequirements(effectiveAgentSource);
         const { systemMessage } = modelRequirements;
 
         return new Response(systemMessage, {

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

@@ -1,176 +1,10 @@
-import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
-import { $provideExecutionToolsForServer } from '@/src/tools/$provideExecutionToolsForServer';
-import { Agent } from '@promptbook-local/core';
-import { ChatMessage, ChatPromptResult, Prompt, TODO_any } from '@promptbook-local/types';
-import { NextRequest, NextResponse } from 'next/server';
+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;
-    
-    // Note: Authentication is handled by middleware
-    // If we are here, the request is either authenticated or public access is allowed (but middleware blocks it if not)
-
-    try {
-        const body = await request.json();
-        const { messages, stream, model } = body;
-
-        if (!messages || !Array.isArray(messages) || messages.length === 0) {
-            return NextResponse.json(
-                { error: { message: 'Messages array is required and cannot be empty.', type: 'invalid_request_error' } },
-                { status: 400 },
-            );
-        }
-
-        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 },
-            );
-        }
-
-        const executionTools = await $provideExecutionToolsForServer();
-        const agent = new Agent({
-            agentSource,
-            executionTools,
-            isVerbose: true, // or false
-        });
-
-        // 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}`, // Placeholder ID
-            from: msg.role === 'assistant' ? 'agent' : 'user', // Mapping standard OpenAI roles
-            content: msg.content,
-            isComplete: true,
-            date: new Date(), // We don't have the real date, using current
-        }));
-
-        const prompt: Prompt = {
-            title: 'OpenAI API Chat Completion',
-            content: lastMessage.content,
-            modelRequirements: {
-                modelVariant: 'CHAT',
-                // We could pass 'model' from body if we wanted to enforce it, but Agent usually has its own config
-            },
-            parameters: {},
-            thread,
-        } as Prompt; 
-        // Note: Casting as Prompt because the type definition might require properties we don't strictly use or that are optional but TS complains
-
-        if (stream) {
-            const encoder = new TextEncoder();
-            const readableStream = new ReadableStream({
-                async start(controller) {
-                    const runId = `chatcmpl-${Math.random().toString(36).substring(2, 15)}`;
-                    const created = Math.floor(Date.now() / 1000);
-
-                    let previousContent = '';
-
-                    try {
-                        await agent.callChatModelStream(prompt, (chunk: ChatPromptResult) => {
-                            const fullContent = chunk.content;
-                            const deltaContent = fullContent.substring(previousContent.length);
-                            previousContent = fullContent;
-
-                            if (deltaContent) {
-                                const chunkData = {
-                                    id: runId,
-                                    object: 'chat.completion.chunk',
-                                    created,
-                                    model: model || 'promptbook-agent',
-                                    choices: [
-                                        {
-                                            index: 0,
-                                            delta: {
-                                                content: deltaContent,
-                                            },
-                                            finish_reason: null,
-                                        },
-                                    ],
-                                };
-                                controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunkData)}\n\n`));
-                            }
-                        });
-
-                        const doneChunkData = {
-                            id: runId,
-                            object: 'chat.completion.chunk',
-                            created,
-                            model: model || 'promptbook-agent',
-                            choices: [
-                                {
-                                    index: 0,
-                                    delta: {},
-                                    finish_reason: 'stop',
-                                },
-                            ],
-                        };
-                        controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunkData)}\n\n`));
-                        controller.enqueue(encoder.encode('[DONE]'));
-                    } catch (error) {
-                        console.error('Error during streaming:', error);
-                        // OpenAI stream doesn't usually send error JSON in stream, just closes or sends error text?
-                        // But we should try to close gracefully or error.
-                        controller.error(error);
-                    }
-                    controller.close();
-                },
-            });
-
-            return new Response(readableStream, {
-                headers: {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    Connection: 'keep-alive',
-                },
-            });
-        } else {
-             const result = await agent.callChatModel(prompt);
-             
-             return NextResponse.json({
-                id: `chatcmpl-${Math.random().toString(36).substring(2, 15)}`,
-                object: 'chat.completion',
-                created: Math.floor(Date.now() / 1000),
-                model: model || 'promptbook-agent',
-                choices: [
-                    {
-                        index: 0,
-                        message: {
-                            role: 'assistant',
-                            content: result.content,
-                        },
-                        finish_reason: 'stop',
-                    },
-                ],
-                usage: {
-                    prompt_tokens: result.usage?.input?.tokensCount?.value || 0,
-                    completion_tokens: result.usage?.output?.tokensCount?.value || 0,
-                    total_tokens: (result.usage?.input?.tokensCount?.value || 0) + (result.usage?.output?.tokensCount?.value || 0),
-                },
-             });
-        }
-
-    } catch (error) {
-        console.error('Error in OpenAI API handler:', error);
-        return NextResponse.json(
-            { error: { message: (error as Error).message || 'Internal Server Error', type: 'server_error' } },
-            { status: 500 },
-        );
-    }
+    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');
+}