@promptbook/cli 0.103.0-1 → 0.103.0-100

package/apps/agents-server/src/utils/chatHistoryAdmin.ts

@@ -0,0 +1,96 @@
+import type { AgentsServerDatabase } from '../database/schema';
+
+export type ChatHistoryRow = AgentsServerDatabase['public']['Tables']['ChatHistory']['Row'];
+export type ChatHistorySortField = 'createdAt' | 'agentName' | 'id';
+export type ChatHistorySortOrder = 'asc' | 'desc';
+
+export type ChatHistoryListResponse = {
+    items: ChatHistoryRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+    sortBy: ChatHistorySortField;
+    sortOrder: ChatHistorySortOrder;
+};
+
+export type ChatHistoryListParams = {
+    page?: number;
+    pageSize?: number;
+    agentName?: string;
+    search?: string;
+    sortBy?: ChatHistorySortField;
+    sortOrder?: ChatHistorySortOrder;
+};
+
+/**
+ * Build query string for chat history listing.
+ */
+function buildQuery(params: ChatHistoryListParams): string {
+    const searchParams = new URLSearchParams();
+
+    if (params.page && params.page > 0) searchParams.set('page', String(params.page));
+    if (params.pageSize && params.pageSize > 0) searchParams.set('pageSize', String(params.pageSize));
+    if (params.agentName) searchParams.set('agentName', params.agentName);
+    if (params.search) searchParams.set('search', params.search);
+    if (params.sortBy) searchParams.set('sortBy', params.sortBy);
+    if (params.sortOrder) searchParams.set('sortOrder', params.sortOrder);
+
+    const qs = searchParams.toString();
+    return qs ? `?${qs}` : '';
+}
+
+/**
+ * Fetch chat history from the admin API.
+ *
+ * This is shared between the admin page and other admin UIs (e.g. per-agent tools)
+ * to keep the API surface DRY.
+ */
+export async function $fetchChatHistory(params: ChatHistoryListParams = {}): Promise<ChatHistoryListResponse> {
+    const qs = buildQuery(params);
+    const response = await fetch(`/api/chat-history${qs}`, {
+        method: 'GET',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to load chat history');
+    }
+
+    return (await response.json()) as ChatHistoryListResponse;
+}
+
+/**
+ * Clear chat history for a specific agent.
+ */
+export async function $clearAgentChatHistory(agentName: string): Promise<void> {
+    if (!agentName) {
+        throw new Error('agentName is required to clear chat history');
+    }
+
+    const response = await fetch(`/api/chat-history?agentName=${encodeURIComponent(agentName)}`, {
+        method: 'DELETE',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to clear chat history');
+    }
+}
+
+/**
+ * Delete a single chat history row by ID.
+ */
+export async function $deleteChatHistoryRow(id: number): Promise<void> {
+    if (!id || id <= 0) {
+        throw new Error('Valid id is required to delete chat history row');
+    }
+
+    const response = await fetch(`/api/chat-history/${encodeURIComponent(String(id))}`, {
+        method: 'DELETE',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to delete chat history row');
+    }
+}

package/apps/agents-server/src/utils/convertToCsv.ts

@@ -0,0 +1,31 @@
+/**
+ * Converts an array of objects to a CSV string
+ */
+export function convertToCsv(data: Array<Record<string, unknown>>): string {
+    if (data.length === 0) {
+        return '';
+    }
+
+    const headers = Object.keys(data[0]);
+    const csvRows = [headers.join(',')];
+
+    for (const row of data) {
+        const values = headers.map((header) => {
+            let value = row[header];
+
+            if (value === null || value === undefined) {
+                value = '';
+            } else if (typeof value === 'object') {
+                value = JSON.stringify(value);
+            } else {
+                value = String(value);
+            }
+
+            const escaped = (value as string).replace(/"/g, '""');
+            return `"${escaped}"`;
+        });
+        csvRows.push(values.join(','));
+    }
+
+    return csvRows.join('\n');
+}

package/apps/agents-server/src/utils/getCurrentUser.ts

@@ -0,0 +1,32 @@
+import { cookies } from 'next/headers';
+import { getSession } from './session';
+
+export type UserInfo = {
+    username: string;
+    isAdmin: boolean;
+};
+
+export async function getCurrentUser(): Promise<UserInfo | null> {
+    // Check session
+    const session = await getSession();
+    if (session) {
+        return {
+            username: session.username,
+            isAdmin: session.isAdmin
+        };
+    }
+
+    // Check legacy admin token
+    if (process.env.ADMIN_PASSWORD) {
+        const cookieStore = await cookies();
+        const adminToken = cookieStore.get('adminToken');
+        if (adminToken?.value === process.env.ADMIN_PASSWORD) {
+            return {
+                username: 'admin',
+                isAdmin: true
+            };
+        }
+    }
+
+    return null;
+}

package/apps/agents-server/src/utils/getEffectiveFederatedServers.ts

@@ -0,0 +1,22 @@
+import type { string_promptbook_server_url } from '../../../../src/types/typeAliases';
+import { AUTO_FEDERATED_AGENT_SERVER_URLS } from '../../../../servers';
+
+/**
+ * Computes the effective list of federated servers for the current Agents Server.
+ *
+ * - Combines servers listed in the FEDERATED_SERVERS metadata (comma-separated)
+ *   with a set of auto-federated servers defined in the root servers.ts config.
+ * - Ensures uniqueness and trims whitespace.
+ */
+export function getEffectiveFederatedServers(federatedServersString: string): Array<string_promptbook_server_url> {
+    const manualFederatedServers = federatedServersString
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s): s is string_promptbook_server_url => s !== '');
+
+    const merged = Array.from(
+        new Set<string_promptbook_server_url>([...manualFederatedServers, ...AUTO_FEDERATED_AGENT_SERVER_URLS]),
+    );
+
+    return merged;
+}

package/apps/agents-server/src/utils/getFederatedAgents.ts

@@ -0,0 +1,89 @@
+import { AgentCollection } from '@promptbook-local/types';
+
+type Agent = Awaited<ReturnType<AgentCollection['listAgents']>>[number];
+
+type AgentWithUrl = Agent & {
+    url: string;
+};
+
+type AgentsApiResponse = {
+    agents: AgentWithUrl[];
+    federatedServers: string[];
+};
+
+export type AgentsByServer = {
+    serverUrl: string;
+    agents: AgentWithUrl[];
+};
+
+/**
+ * Fetches agents from federated servers recursively
+ */
+export async function getFederatedAgents(initialServers: string[]): Promise<AgentsByServer[]> {
+    const visited = new Set<string>();
+    const queue = [...initialServers];
+    const agentsByServer = new Map<string, AgentWithUrl[]>();
+    const MAX_SERVERS = 20;
+
+    while (queue.length > 0 && visited.size < MAX_SERVERS) {
+        const serverUrl = queue.shift();
+        if (!serverUrl) continue;
+
+        const normalizedUrl = serverUrl.trim().replace(/\/$/, '');
+        if (visited.has(normalizedUrl)) continue;
+        visited.add(normalizedUrl);
+
+        try {
+            // TODO: [🧠] Should we use some shorter timeout?
+            const response = await fetch(`${normalizedUrl}/api/agents`, {
+                next: { revalidate: 600 }, // Cache for 10 minutes
+            });
+
+            if (!response.ok) {
+                console.warn(`Failed to fetch agents from ${normalizedUrl}: ${response.status} ${response.statusText}`);
+                continue;
+            }
+
+            const data: AgentsApiResponse = await response.json();
+
+            if (data.agents && Array.isArray(data.agents)) {
+                const serverAgents: AgentWithUrl[] = [];
+                const existingAgentUrls = new Set<string>();
+
+                // Collect all existing agent URLs across all servers
+                for (const agents of agentsByServer.values()) {
+                    for (const agent of agents) {
+                        existingAgentUrls.add(agent.url);
+                    }
+                }
+
+                for (const agent of data.agents) {
+                    if (agent.url && !existingAgentUrls.has(agent.url)) {
+                        serverAgents.push(agent);
+                        existingAgentUrls.add(agent.url);
+                    }
+                }
+
+                if (serverAgents.length > 0) {
+                    agentsByServer.set(normalizedUrl, serverAgents);
+                }
+            }
+
+            if (data.federatedServers && Array.isArray(data.federatedServers)) {
+                for (const server of data.federatedServers) {
+                    const normalizedServer = server.trim().replace(/\/$/, '');
+                    if (!visited.has(normalizedServer) && normalizedServer !== '') {
+                        queue.push(normalizedServer);
+                    }
+                }
+            }
+        } catch (error) {
+            console.error(`Error fetching agents from ${normalizedUrl}:`, error);
+        }
+    }
+
+    return Array.from(agentsByServer.entries()).map(([serverUrl, agents]) => ({
+        serverUrl,
+        agents,
+    }));
+}

package/apps/agents-server/src/utils/getFederatedServersFromMetadata.ts

@@ -0,0 +1,10 @@
+import { getMetadata } from '../database/getMetadata';
+import { getEffectiveFederatedServers } from './getEffectiveFederatedServers';
+
+/**
+ * Reads FEDERATED_SERVERS metadata and returns a normalized list of server URLs.
+ */
+export async function getFederatedServersFromMetadata(): Promise<string[]> {
+    const federatedServersString = (await getMetadata('FEDERATED_SERVERS')) || '';
+    return getEffectiveFederatedServers(federatedServersString);
+}

package/apps/agents-server/src/utils/getVisibleCommitmentDefinitions.ts

@@ -0,0 +1,12 @@
+import { getGroupedCommitmentDefinitions } from '../../../../src/commitments';
+import { NotYetImplementedCommitmentDefinition } from '../../../../src/commitments/_base/NotYetImplementedCommitmentDefinition';
+
+/**
+ * Gets visible commitment definitions for documentation
+ * Excluding those that are not yet implemented
+ */
+export function getVisibleCommitmentDefinitions() {
+    return getGroupedCommitmentDefinitions().filter(
+        (group) => !(group.primary instanceof NotYetImplementedCommitmentDefinition),
+    );
+}

package/apps/agents-server/src/utils/handleChatCompletion.ts

@@ -0,0 +1,355 @@
+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 { ChatMessage, ChatPromptResult, Prompt, string_book, TODO_any } from '@promptbook-local/types';
+import { computeHash } from '@promptbook-local/utils';
+import { NextRequest, NextResponse } from 'next/server';
+import { validateApiKey } from './validateApiKey';
+
+export async function handleChatCompletion(
+    request: NextRequest,
+    params: { agentName?: string },
+    title: string = 'API Chat Completion',
+) {
+    const { agentName: agentNameFromParams } = 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 },
+        );
+    }
+    const apiKey = apiKeyValidation.token || null;
+
+    try {
+        const body = await request.json();
+        const { messages, stream, model } = body;
+
+        const agentName = agentNameFromParams || model;
+
+        if (!agentName) {
+            return NextResponse.json(
+                {
+                    error: {
+                        message: 'Agent name is required. Please provide it in the URL or as the "model" parameter.',
+                        type: 'invalid_request_error',
+                    },
+                },
+                { status: 400 },
+            );
+        }
+
+        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: string_book;
+        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 },
+            );
+        }
+
+        // Note: Handle system messages as CONTEXT
+        const systemMessages = messages.filter((msg: TODO_any) => msg.role === 'system');
+        if (systemMessages.length > 0) {
+            const contextString = systemMessages.map((msg: TODO_any) => `CONTEXT ${msg.content}`).join('\n');
+            agentSource = `${agentSource}\n\n${contextString}` as string_book;
+        }
+
+        const threadMessages = messages.filter((msg: TODO_any) => msg.role !== 'system');
+
+        if (threadMessages.length === 0) {
+            return NextResponse.json(
+                {
+                    error: {
+                        message: 'Messages array must contain at least one non-system message.',
+                        type: 'invalid_request_error',
+                    },
+                },
+                { status: 400 },
+            );
+        }
+
+        const openAiAssistantExecutionTools = await $provideOpenAiAssistantExecutionToolsForServer();
+        const agent = new Agent({
+            agentSource,
+            executionTools: {
+                llm: openAiAssistantExecutionTools, // Note: Use the same OpenAI Assistant LLM tools as the chat route
+            },
+            isVerbose: true, // or false
+        });
+
+        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
+
+        // Prepare thread and content
+        const lastMessage = threadMessages[threadMessages.length - 1];
+        const previousMessages = threadMessages.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
+        }));
+
+        // Note: Identify the user message
+        const userMessageContent = {
+            role: 'USER',
+            content: lastMessage.content,
+        };
+
+        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: 'OPENAI_API_COMPATIBILITY',
+            apiKey,
+        });
+
+        const prompt: Prompt = {
+            title,
+            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);
+
+                    // Note: Send the initial chunk with role
+                    const initialChunkData = {
+                        id: runId,
+                        object: 'chat.completion.chunk',
+                        created,
+                        model: model || 'promptbook-agent',
+                        choices: [
+                            {
+                                index: 0,
+                                delta: {
+                                    role: 'assistant',
+                                    content: '',
+                                },
+                                finish_reason: null,
+                            },
+                        ],
+                    };
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(initialChunkData)}\n\n`));
+
+                    let previousContent = '';
+
+                    try {
+                        const result = 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`));
+                            }
+                        });
+
+                        // Note: Identify the agent message
+                        const agentMessageContent = {
+                            role: 'MODEL',
+                            content: result.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: 'OPENAI_API_COMPATIBILITY',
+                            apiKey,
+                        });
+
+                        // Note: [🐱‍🚀] Save the learned data
+                        const newAgentSource = agent.agentSource.value;
+                        if (newAgentSource !== agentSource) {
+                            await collection.updateAgentSource(agentName, newAgentSource);
+                        }
+
+                        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);
+
+            // Note: Identify the agent message
+            const agentMessageContent = {
+                role: 'MODEL',
+                content: result.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: 'OPENAI_API_COMPATIBILITY',
+                apiKey,
+            });
+
+            // Note: [🐱‍🚀] Save the learned data
+            const newAgentSource = agent.agentSource.value;
+            if (newAgentSource !== agentSource) {
+                await collection.updateAgentSource(agentName, newAgentSource);
+            }
+
+            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 ${title} handler:`, error);
+        return NextResponse.json(
+            { error: { message: (error as Error).message || 'Internal Server Error', type: 'server_error' } },
+            { status: 500 },
+        );
+    }
+}
+
+/**
+ * TODO: [🈹] Maybe move chat thread handling here
+ */