@promptbook/cli 0.103.0-10 → 0.103.0-100

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');
+}

package/apps/agents-server/src/app/agents/[agentName]/api/openai/v1/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/v1/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/openrouter/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 }, 'OpenRouter API Chat Completion');
+}

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

@@ -0,0 +1,76 @@
+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';
+import { assertsError } from '../../../../../../../../src/errors/assertsError';
+import { keepUnused } from '../../../../../../../../src/utils/organization/keepUnused';
+
+export async function OPTIONS(request: Request) {
+    keepUnused(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 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 agentProfile = parseAgentSource(agentSource);
+        const agentHash = computeAgentHash(agentSource);
+        const isVoiceCallingEnabled = (await getMetadata('IS_VOICE_CALLING_ENABLED')) === 'true';
+
+        return new Response(
+            JSON.stringify(
+                {
+                    ...agentProfile,
+                    agentHash,
+                    parameters: [], // <- TODO: [😰] Implement parameters
+                    isVoiceCallingEnabled, // [✨✷] Add voice calling status
+                },
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    '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' },
+            },
+        );
+    }
+}
+
+/**
+ * TODO: [🍞] DRY - Make some common utility for API on one agent
+ */

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

@@ -0,0 +1,181 @@
+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,
+            source: 'AGENT_PAGE_CHAT',
+            apiKey: null,
+        });
+
+        // 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,
+            source: 'AGENT_PAGE_CHAT',
+            apiKey: null,
+        });
+
+        // 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/BookEditorWrapper.tsx

@@ -0,0 +1,139 @@
+'use client';
+
+import { BookEditor } from '@promptbook-local/components';
+import { string_book } from '@promptbook-local/types';
+import { useEffect, useRef, useState } from 'react';
+
+type BookEditorWrapperProps = {
+    agentName: string;
+    initialAgentSource: string_book;
+};
+
+// TODO: [🐱‍🚀] Rename to BookEditorSavingWrapper
+
+export function BookEditorWrapper({ agentName, initialAgentSource }: BookEditorWrapperProps) {
+    const [agentSource, setAgentSource] = useState<string_book>(initialAgentSource);
+    const [saveStatus, setSaveStatus] = useState<'idle' | 'saving' | 'saved' | 'error'>('idle');
+
+    // Debounce timer ref so we can clear previous pending save
+    const debounceTimerRef = useRef<number | null>(null);
+    // Configurable debounce delay (ms) - tweak if needed
+    const DEBOUNCE_DELAY = 1000;
+
+    const performSave = async (sourceToSave: string_book) => {
+        setSaveStatus('saving');
+        try {
+            const response = await fetch(`/agents/${encodeURIComponent(agentName)}/api/book`, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'text/plain' },
+                body: sourceToSave,
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to save: ${response.statusText}`);
+            }
+            setSaveStatus('saved');
+            setTimeout(() => setSaveStatus('idle'), 2000); // Reset status after 2 seconds
+        } catch (error) {
+            console.error('Error saving agent source:', error);
+            setSaveStatus('error');
+            setTimeout(() => setSaveStatus('idle'), 3000);
+        }
+    };
+
+    const scheduleSave = (nextSource: string_book) => {
+        // Clear existing pending save
+        if (debounceTimerRef.current) {
+            clearTimeout(debounceTimerRef.current);
+        }
+        // We stay 'idle' while typing; could add a 'pending' status in future if desired
+        // Schedule new save
+        debounceTimerRef.current = window.setTimeout(() => {
+            performSave(nextSource);
+        }, DEBOUNCE_DELAY);
+    };
+
+    const handleChange = (newSource: string_book) => {
+        setAgentSource(newSource);
+        scheduleSave(newSource);
+    };
+
+    // Cleanup on unmount to avoid lingering timeouts
+    useEffect(() => {
+        return () => {
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+    }, []);
+
+    return (
+        <div className="w-full h-full">
+            {saveStatus !== 'idle' && (
+                <div
+                    role="status"
+                    aria-live="polite"
+                    className={`fixed top-5 right-28 z-50 px-4 py-2 text-sm rounded shadow-md ${
+                        saveStatus === 'saving'
+                            ? 'bg-blue-100 text-blue-800'
+                            : saveStatus === 'saved'
+                            ? 'bg-green-100 text-green-800'
+                            : 'bg-red-100 text-red-800'
+                    }`}
+                >
+                    {saveStatus === 'saving' && '💾 Saving...'}
+                    {saveStatus === 'saved' && '✅ Saved'}
+                    {saveStatus === 'error' && '❌ Failed to save'}
+                </div>
+            )}
+
+            <BookEditor
+                className="w-full h-full"
+                isBorderRadiusDisabled
+                height={null}
+                value={agentSource}
+                onChange={handleChange}
+                onFileUpload={async (file) => {
+                    const formData = new FormData();
+                    formData.append('file', file);
+
+                    const response = await fetch('/api/upload', {
+                        method: 'POST',
+                        body: formData,
+                    });
+
+                    if (!response.ok) {
+                        throw new Error(`Failed to upload file: ${response.statusText}`);
+                    }
+
+                    const { fileUrl: longFileUrl } = await response.json();
+
+                    const LONG_URL = `${process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!}/${process.env
+                        .NEXT_PUBLIC_CDN_PATH_PREFIX!}/user/files/`;
+                    const SHORT_URL = `https://ptbk.io/k/`;
+                    // <- TODO: [🌍] Unite this logic in one place
+
+                    const shortFileUrl = longFileUrl.split(LONG_URL).join(SHORT_URL);
+
+                    console.log(`File uploaded:`, {
+                        LONG_URL,
+                        SHORT_URL,
+                        longFileUrl,
+                        shortFileUrl,
+                        file,
+                        formData,
+                        response,
+                    });
+
+                    return shortFileUrl;
+                }}
+            />
+        </div>
+    );
+}
+
+/**
+ * TODO: Prompt: Use `import { debounce } from '@promptbook-local/utils';` instead of custom debounce implementation
+ * TODO: [🚗] Transfer the saving logic to `<BookEditor/>` be aware of CRDT / yjs approach to be implementable in future
+ * TODO: [🐱‍🚀] Add error handling and retry logic
+ * TODO: [🐱‍🚀] Show save status indicator
+ */

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

@@ -0,0 +1,35 @@
+'use server';
+
+import { ForbiddenPage } from '@/src/components/ForbiddenPage/ForbiddenPage';
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+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());
+
+    if (!(await isUserAdmin())) {
+        /* <- TODO: [👹] Here should be user permissions */
+        return <ForbiddenPage />;
+    }
+
+    let { agentName } = await params;
+    agentName = decodeURIComponent(agentName);
+    const collection = await $provideAgentCollectionForServer();
+    const agentSource = await collection.getAgentSource(decodeURIComponent(agentName));
+
+    return (
+        <div className={`w-screen h-[calc(100vh-60px)]`}>
+            <BookEditorWrapper agentName={agentName} initialAgentSource={agentSource} />
+        </div>
+    );
+}
+
+/**
+ * TODO: [🚗] Components and pages here should be just tiny UI wrapper around proper agent logic and components
+ */