@promptbook/cli 0.103.0-52 → 0.103.0-54

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

@@ -0,0 +1,63 @@
+'use client';
+
+import { useState } from 'react';
+import { $clearAgentChatHistory } from '../../../utils/chatHistoryAdmin';
+
+type ClearAgentChatHistoryButtonProps = {
+    /**
+     * Agent name for which the chat history should be cleared.
+     */
+    agentName: string;
+
+    /**
+     * Optional callback invoked after successful clearing.
+     */
+    onCleared?: () => void;
+};
+
+/**
+ * Admin-only button to clear chat history for a specific agent.
+ *
+ * This is intentionally small and self-contained so it can be reused
+ * from different admin-oriented surfaces without duplicating logic.
+ */
+export function ClearAgentChatHistoryButton({ agentName, onCleared }: ClearAgentChatHistoryButtonProps) {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const handleClick = async () => {
+        if (!agentName) return;
+
+        const confirmed = window.confirm(
+            `Are you sure you want to permanently delete all chat history for agent "${agentName}"?`,
+        );
+        if (!confirmed) return;
+
+        try {
+            setLoading(true);
+            setError(null);
+            await $clearAgentChatHistory(agentName);
+            if (onCleared) {
+                onCleared();
+            }
+        } catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to clear chat history');
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    return (
+        <div className="flex flex-col gap-2">
+            <button
+                type="button"
+                onClick={handleClick}
+                disabled={loading}
+                className="inline-flex items-center justify-center whitespace-nowrap rounded-md border border-red-300 bg-white px-3 py-1.5 text-xs font-semibold text-red-700 shadow-sm hover:bg-red-50 disabled:cursor-not-allowed disabled:opacity-60"
+            >
+                {loading ? 'Clearing history…' : 'Clear chat history'}
+            </button>
+            {error && <div className="text-xs text-red-600">{error}</div>}
+        </div>
+    );
+}

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

@@ -0,0 +1,41 @@
+'use client';
+
+import { CopyIcon } from 'lucide-react';
+import { useRouter } from 'next/navigation';
+
+type CloneAgentButtonProps = {
+    agentName: string;
+};
+
+export function CloneAgentButton({ agentName }: CloneAgentButtonProps) {
+    const router = useRouter();
+
+    const handleClone = async () => {
+        if (!window.confirm(`Clone agent "${agentName}"?`)) return;
+        
+        try {
+            const response = await fetch(`/api/agents/${encodeURIComponent(agentName)}/clone`, { method: 'POST' });
+            
+            if (!response.ok) {
+                throw new Error('Failed to clone agent');
+            }
+
+            const newAgent = await response.json();
+            router.push(`/${newAgent.agentName}`);
+            router.refresh();
+        } catch (error) {
+            alert('Failed to clone agent');
+            console.error(error);
+        }
+    };
+
+    return (
+        <button
+            onClick={handleClone}
+            className="flex-1 inline-flex items-center justify-center whitespace-nowrap bg-white hover:bg-gray-100 text-gray-800 px-4 py-2 rounded shadow font-semibold transition border border-gray-200"
+        >
+            <CopyIcon className="ml-2 w-4 h-4 mr-2" />
+            Clone
+        </button>
+    );
+}

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

@@ -0,0 +1,74 @@
+'use client';
+
+import { TODO_any } from '@promptbook-local/types';
+import { ShoppingBagIcon } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+
+type BeforeInstallPromptEvent = Event & {
+    prompt: () => Promise<void>;
+    userChoice: Promise<{ outcome: 'accepted' | 'dismissed'; platform: string }>;
+};
+
+export function InstallPwaButton() {
+    const [installPromptEvent, setInstallPromptEvent] = useState<BeforeInstallPromptEvent | null>(null);
+    const [isInstalled, setIsInstalled] = useState(false);
+    const [hasPrompted, setHasPrompted] = useState(false);
+
+    useEffect(() => {
+        function handleBeforeInstallPrompt(e: Event) {
+            // Some browsers (Chrome) fire this event when PWA is installable
+            e.preventDefault();
+            setInstallPromptEvent(e as BeforeInstallPromptEvent);
+        }
+
+        function updateInstalledStatus() {
+            const mediaMatch = window.matchMedia('(display-mode: standalone)');
+            const standalone = mediaMatch.matches || (window.navigator as TODO_any).standalone === true;
+            setIsInstalled(standalone);
+        }
+
+        window.addEventListener('beforeinstallprompt', handleBeforeInstallPrompt);
+        updateInstalledStatus();
+        window.matchMedia('(display-mode: standalone)').addEventListener('change', updateInstalledStatus);
+
+        return () => {
+            window.removeEventListener('beforeinstallprompt', handleBeforeInstallPrompt);
+            window.matchMedia('(display-mode: standalone)').removeEventListener('change', updateInstalledStatus);
+        };
+    }, []);
+
+    const onInstall = useCallback(async () => {
+        if (!installPromptEvent) return;
+        try {
+            installPromptEvent.prompt();
+            setHasPrompted(true);
+            const choice = await installPromptEvent.userChoice.catch(() => null);
+            if (choice?.outcome === 'accepted') {
+                setIsInstalled(true);
+            }
+        } finally {
+            // Clear stored event so button hides if dismissed
+            setInstallPromptEvent(null);
+        }
+    }, [installPromptEvent]);
+
+    if (isInstalled || (!installPromptEvent && hasPrompted)) return null;
+
+    return (
+        <button
+            type="button"
+            onClick={onInstall}
+            className="flex-1 inline-flex items-center justify-center whitespace-nowrap bg-white hover:bg-gray-100 text-gray-800 px-4 py-2 rounded shadow font-semibold transition border border-gray-200"
+            style={{
+                opacity: installPromptEvent ? 1 : 0.5,
+                cursor: installPromptEvent ? 'pointer' : 'wait',
+            }}
+            aria-label="Install App"
+            disabled={!installPromptEvent}
+        >
+            {/* Simple icon substitute: download arrow */}
+            <ShoppingBagIcon className="ml-2 w-4 h-4 mr-2" />
+            Install
+        </button>
+    );
+}

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

@@ -0,0 +1,24 @@
+'use client';
+
+import { useEffect } from 'react';
+
+type ServiceWorkerRegisterProps = {
+    scope: string;
+};
+
+export function ServiceWorkerRegister({ scope }: ServiceWorkerRegisterProps) {
+    useEffect(() => {
+        if ('serviceWorker' in navigator) {
+            navigator.serviceWorker
+                .register('/sw.js', { scope })
+                .then((registration) => {
+                    console.log('Service Worker registered with scope:', registration.scope);
+                })
+                .catch((error) => {
+                    console.error('Service Worker registration failed:', error);
+                });
+        }
+    }, [scope]);
+
+    return null;
+}

package/apps/agents-server/src/app/agents/[agentName]/_utils.ts

@@ -0,0 +1,19 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { parseAgentSource } from '@promptbook-local/core';
+
+export const AGENT_ACTIONS = ['Emails', 'Web chat', 'Read documents', 'Browser', 'WhatsApp', '<Coding/>'];
+
+export async function getAgentName(params: Promise<{ agentName: string }>) {
+    const { agentName } = await params;
+    return decodeURIComponent(agentName);
+}
+
+export async function getAgentProfile(agentName: string) {
+    const collection = await $provideAgentCollectionForServer();
+    const agentSource = await collection.getAgentSource(agentName);
+    return parseAgentSource(agentSource);
+}
+
+/**
+ * TODO: Split to multiple files
+ */

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

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+    request: NextRequest,
+    { params }: { params: Promise<{ agentName: string }> }
+) {
+    try {
+        const { agentName } = await params;
+        // agentName is likely the federated server URL (e.g., "https://s6.ptbk.io")
+        // It comes decoded from the URL params if it was encoded in the request path
+        
+        let serverUrl = agentName;
+
+        // If the serverUrl doesn't look like a URL, it might be just a hostname or something else
+        // But the requirement says we look for /agents/[federated-server]/api/agents
+        // The client will likely pass the full URL or hostname.
+        // We'll assume if it doesn't start with http, we might need to prepend it, or it's invalid.
+        // However, the current federated servers list contains full URLs.
+        
+        // If it was somehow double encoded or something, we might need to handle it, but standard Next.js behavior is single decode.
+        
+        if (!serverUrl.startsWith('http')) {
+             // Maybe it is just a hostname?
+             // Let's try to assume https if missing
+             if (serverUrl.includes('.')) {
+                 serverUrl = `https://${serverUrl}`;
+             } else {
+                 return NextResponse.json(
+                    { error: 'Invalid federated server URL' },
+                    { status: 400 }
+                );
+             }
+        }
+
+        // Normalize URL (remove trailing slash)
+        serverUrl = serverUrl.replace(/\/$/, '');
+
+        const response = await fetch(`${serverUrl}/api/agents`, {
+            // Forward relevant headers if necessary, or just basic fetch
+            headers: {
+                'Content-Type': 'application/json',
+                // Add any other needed headers
+            },
+            next: { revalidate: 600 }, // Cache for 10 minutes
+        });
+
+        if (!response.ok) {
+            console.warn(`Proxy failed to fetch agents from ${serverUrl}: ${response.status} ${response.statusText}`);
+            return NextResponse.json(
+                { error: `Failed to fetch from ${serverUrl}` },
+                { status: response.status }
+            );
+        }
+
+        const data = await response.json();
+        return NextResponse.json(data);
+
+    } catch (error) {
+        console.error('Proxy error fetching federated agents:', error);
+        return NextResponse.json(
+            { error: 'Internal Server Error' },
+            { status: 500 }
+        );
+    }
+}

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

@@ -0,0 +1,176 @@
+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';
+
+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 },
+        );
+    }
+}

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

@@ -1,3 +1,4 @@
+import { getMetadata } from '@/src/database/getMetadata';
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
 import { computeAgentHash, parseAgentSource } from '@promptbook-local/core';
 import { serializeError } from '@promptbook-local/utils';
@@ -26,6 +27,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
         const agentSource = await collection.getAgentSource(agentName);
         const agentProfile = parseAgentSource(agentSource);
         const agentHash = computeAgentHash(agentSource);
+        const isVoiceCallingEnabled = (await getMetadata('IS_VOICE_CALLING_ENABLED')) === 'true';
 
         return new Response(
             JSON.stringify(
@@ -33,6 +35,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
                     ...agentProfile,
                     agentHash,
                     parameters: [], // <- TODO: [😰] Implement parameters
+                    isVoiceCallingEnabled, // [✨✷] Add voice calling status
                 },
                 // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
                 null,

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

@@ -0,0 +1,177 @@
+import { $getTableName } from '@/src/database/$getTableName';
+import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
+import { getMetadata } from '@/src/database/getMetadata';
+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';
+
+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 }> }) {
+    // Check if voice calling is enabled
+    const isVoiceCallingEnabled = (await getMetadata('IS_VOICE_CALLING_ENABLED')) === 'true';
+    if (!isVoiceCallingEnabled) {
+        return new Response(JSON.stringify({ error: 'Voice calling is disabled on this server' }), {
+            status: 403,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+
+    let { agentName } = await params;
+    agentName = decodeURIComponent(agentName);
+
+    // Note: Parse FormData for audio file
+    const formData = await request.formData();
+    const audioFile = formData.get('audio') as File | null;
+    const threadString = formData.get('thread') as string | null;
+    const thread = threadString ? JSON.parse(threadString) : undefined;
+    const messageContext = formData.get('message') as string | null; // Optional text context or previous message?
+
+    if (!audioFile) {
+        return new Response(JSON.stringify({ error: 'No audio file provided' }), {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        const openAiAssistantExecutionTools = await $provideOpenAiAssistantExecutionToolsForServer();
+        const agentSource = await collection.getAgentSource(agentName);
+        const agent = new Agent({
+            isVerbose: true,
+            executionTools: {
+                llm: openAiAssistantExecutionTools,
+            },
+            agentSource,
+        });
+
+        // 1. Transcribe Audio (STT)
+        const client = await openAiAssistantExecutionTools.getClient();
+        const transcription = await client.audio.transcriptions.create({
+            file: audioFile,
+            model: 'whisper-1',
+        });
+        const message = transcription.text;
+
+        // --- Common Chat Logic Start (TODO: Extract) ---
+
+        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');
+        const language = request.headers.get('accept-language');
+        const platform = userAgent ? userAgent.match(/\(([^)]+)\)/)?.[1] : undefined;
+
+        // Identify and Record User Message
+        const userMessageContent = {
+            role: 'USER',
+            content: message,
+            isVoiceCall: true, // Mark as voice call
+        };
+        const supabase = $provideSupabaseForServer();
+        await supabase.from(await $getTableName('ChatHistory')).insert({
+            createdAt: new Date().toISOString(),
+            messageHash: computeHash(userMessageContent),
+            previousMessageHash: null,
+            agentName,
+            agentHash,
+            message: userMessageContent,
+            promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
+            url: request.url,
+            ip,
+            userAgent,
+            language,
+            platform,
+        });
+
+        // Call Agent
+        const response = await agent.callChatModel({
+            title: `Voice Chat with agent ${agentName}`,
+            parameters: {},
+            modelRequirements: {
+                modelVariant: 'CHAT',
+            },
+            content: message,
+            thread,
+        });
+
+        const agentMessageContent = {
+            role: 'MODEL',
+            content: response.content,
+            isVoiceCall: true,
+        };
+
+        // Record 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,
+        });
+
+        // Learning
+        const newAgentSource = agent.agentSource.value;
+        if (newAgentSource !== agentSource) {
+            await collection.updateAgentSource(agentName, newAgentSource);
+        }
+
+        // --- Common Chat Logic End ---
+
+        // 2. Synthesize Audio (TTS)
+        const mp3 = await client.audio.speech.create({
+            model: 'tts-1',
+            voice: 'alloy',
+            input: response.content,
+        });
+
+        const buffer = Buffer.from(await mp3.arrayBuffer());
+        const base64Audio = buffer.toString('base64');
+
+        return new Response(
+            JSON.stringify({
+                userMessage: message,
+                agentMessage: response.content,
+                audio: base64Audio,
+                audioFormat: 'mp3',
+            }),
+            {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+            },
+        );
+    } catch (error) {
+        assertsError(error);
+        console.error(error);
+        return new Response(JSON.stringify(serializeError(error), null, 4), {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}

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

@@ -5,8 +5,11 @@ import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentColle
 import { isUserAdmin } from '@/src/utils/isUserAdmin';
 import { headers } from 'next/headers';
 import { $sideEffect } from '../../../../../../../src/utils/organization/$sideEffect';
+import { generateAgentMetadata } from '../generateAgentMetadata';
 import { BookEditorWrapper } from './BookEditorWrapper';
 
+export const generateMetadata = generateAgentMetadata;
+
 export default async function AgentBookPage({ params }: { params: Promise<{ agentName: string }> }) {
     $sideEffect(headers());