@promptbook/cli 0.103.0-49 → 0.103.0-50

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

@@ -1,6 +1,11 @@
-import { redirect } from 'next/navigation';
+import { notFound, redirect } from 'next/navigation';
 
 export default async function RedirectPage({ params }: { params: Promise<{ agentName: string; rest: string[] }> }) {
     const { agentName, rest } = await params;
+
+    if (agentName === 'agents' || agentName === 'api' || agentName.startsWith('.')) {
+        notFound();
+    }
+
     redirect(`/agents/${agentName}/${rest.join('/')}`);
 }

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

@@ -11,6 +11,17 @@ 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 }> }) {
     let { agentName } = await params;
     agentName = decodeURIComponent(agentName);
@@ -110,6 +121,12 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
                             platform,
                         });
 
+                        // Note: [🐱‍🚀] Save the learned data
+                        const newAgentSource = agent.agentSource.value;
+                        if (newAgentSource !== agentSource) {
+                            await collection.updateAgentSource(agentName, newAgentSource);
+                        }
+
                         controller.close();
                     })
                     .catch((error) => {
@@ -120,7 +137,10 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
 
         return new Response(readableStream, {
             status: 200,
-            headers: { 'Content-Type': 'text/markdown' },
+            headers: {
+                'Content-Type': 'text/markdown',
+                'Access-Control-Allow-Origin': '*', // <- Note: Allow embedding on other websites
+            },
         });
     } catch (error) {
         assertsError(error);

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

@@ -1,9 +1,21 @@
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
-import { parseAgentSource } from '@promptbook-local/core';
+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;
@@ -13,10 +25,15 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
         const collection = await $provideAgentCollectionForServer();
         const agentSource = await collection.getAgentSource(agentName);
         const agentProfile = parseAgentSource(agentSource);
+        const agentHash = computeAgentHash(agentSource);
 
         return new Response(
             JSON.stringify(
-                agentProfile,
+                {
+                    ...agentProfile,
+                    agentHash,
+                    parameters: [], // <- TODO: [😰] Implement parameters
+                },
                 // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
                 null,
                 4,
@@ -24,7 +41,10 @@ export async function GET(request: Request, { params }: { params: Promise<{ agen
             ),
             {
                 status: 200,
-                headers: { 'Content-Type': 'application/json' },
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*', // <- Note: Allow embedding on other websites
+                },
             },
         );
     } catch (error) {

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

@@ -4,7 +4,7 @@ import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentColle
 // import { BookEditor } from '@promptbook-local/components';
 import { $provideServer } from '@/src/tools/$provideServer';
 import { parseAgentSource } from '@promptbook-local/core';
-import { Columns2Icon, Edit2Icon } from 'lucide-react';
+import { Columns2Icon, MessagesSquareIcon, NotebookPenIcon } from 'lucide-react';
 import { headers } from 'next/headers';
 import { notFound } from 'next/navigation';
 import { Color } from '../../../../../../src/utils/color/Color';
@@ -114,6 +114,14 @@ export default async function AgentPage({ params }: { params: Promise<{ agentNam
 
                 <div className="flex flex-col gap-2 mt-auto">
                     <div className="flex gap-2">
+                        <a
+                            href={`/agents/${encodeURIComponent(agentName)}/chat`}
+                            // <- TODO: [🧠] Can I append path like this on current browser URL in href?
+                            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"
+                        >
+                            <MessagesSquareIcon className="ml-2 w-4 h-4 mr-2" />
+                            Chat
+                        </a>
                         <a
                             href={`/agents/${encodeURIComponent(agentName)}/book+chat`}
                             // <- TODO: [🧠] Can I append path like this on current browser URL in href?
@@ -127,7 +135,7 @@ export default async function AgentPage({ params }: { params: Promise<{ agentNam
                             // <- TODO: [🧠] Can I append path like this on current browser URL in href?
                             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"
                         >
-                            <Edit2Icon className="ml-2 w-4 h-4 mr-2" />
+                            <NotebookPenIcon className="ml-2 w-4 h-4 mr-2" />
                             Edit
                         </a>
                     </div>

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

@@ -0,0 +1,34 @@
+import { NextResponse } from 'next/server';
+import { getMetadata } from '../../../database/getMetadata';
+import { $provideAgentCollectionForServer } from '../../../tools/$provideAgentCollectionForServer';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        const agents = await collection.listAgents();
+        const serverUrl = (await getMetadata('SERVER_URL')) || '';
+        const federatedServersString = (await getMetadata('FEDERATED_SERVERS')) || '';
+        const federatedServers = federatedServersString
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s !== '');
+
+        const agentsWithUrl = agents.map((agent) => ({
+            ...agent,
+            url: `${serverUrl}/${agent.agentName}`,
+        }));
+
+        return NextResponse.json({
+            agents: agentsWithUrl,
+            federatedServers,
+        });
+    } catch (error) {
+        console.error('Error fetching agents:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch agents' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/page.tsx

@@ -10,10 +10,12 @@ import { $sideEffect } from '../../../../src/utils/organization/$sideEffect';
 import { AuthControls } from '../components/Auth/AuthControls';
 import { UsersList } from '../components/UsersList/UsersList';
 import VercelDeploymentCard from '../components/VercelDeploymentCard/VercelDeploymentCard';
+import { getMetadata } from '../database/getMetadata';
 import { getLongRunningTask } from '../deamons/longRunningTask';
 import { $provideAgentCollectionForServer } from '../tools/$provideAgentCollectionForServer';
 import { $provideExecutionToolsForServer } from '../tools/$provideExecutionToolsForServer';
 import { $provideServer } from '../tools/$provideServer';
+import { getFederatedAgents } from '../utils/getFederatedAgents';
 import { getCurrentUser } from '../utils/getCurrentUser';
 import { isUserAdmin } from '../utils/isUserAdmin';
 import { AddAgentButton } from './AddAgentButton';
@@ -37,6 +39,14 @@ export default async function HomePage() {
     const collection = await $provideAgentCollectionForServer();
     const agents = await collection.listAgents();
 
+    const federatedServersString = (await getMetadata('FEDERATED_SERVERS')) || '';
+    const federatedServers = federatedServersString
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s !== '');
+
+    const externalAgents = await getFederatedAgents(federatedServers);
+
     const longRunningTask = getLongRunningTask();
 
     const executionTools = await $provideExecutionToolsForServer();
@@ -73,6 +83,29 @@ export default async function HomePage() {
                     </div>
                 </>
 
+                {externalAgents.length > 0 && (
+                    <>
+                        <h2 className="text-3xl text-gray-900 mt-16 mb-4">External Agents ({externalAgents.length})</h2>
+                        <div className="grid gap-6 md:grid-cols-2 lg:grid-cols-3">
+                            {externalAgents.map((agent) => (
+                                <Link key={agent.url} href={agent.url}>
+                                    <AvatarProfile
+                                        {...{ agent }}
+                                        style={
+                                            !agent.meta.color
+                                                ? {}
+                                                : {
+                                                      backgroundColor: `${agent.meta.color}22`, // <- TODO: Use Color object here
+                                                  }
+                                        }
+                                        className="block p-6 bg-white rounded-lg shadow-md hover:shadow-xl transition-shadow duration-300 border border-gray-200 hover:border-blue-400"
+                                    />
+                                </Link>
+                            ))}
+                        </div>
+                    </>
+                )}
+
                 {isAdmin && <UsersList />}
 
                 {isAdmin && (

package/apps/agents-server/src/database/metadataDefaults.ts

@@ -29,4 +29,9 @@ export const metadataDefaults = [
         value: '',
         note: 'Comma separated list of allowed IPs or CIDR ranges. If set, only clients from these IPs are allowed to access the server.',
     },
+    {
+        key: 'FEDERATED_SERVERS',
+        value: '',
+        note: 'Comma separated list of federated servers URLs. The server will look to all federated servers and list their agents.',
+    },
 ] as const;

package/apps/agents-server/src/middleware.ts

@@ -72,10 +72,48 @@ export async function middleware(req: NextRequest) {
         }
     }
 
-    const allowedIps = allowedIpsMetadata !== null && allowedIpsMetadata !== undefined ? allowedIpsMetadata : allowedIpsEnv;
+    const allowedIps =
+        allowedIpsMetadata !== null && allowedIpsMetadata !== undefined ? allowedIpsMetadata : allowedIpsEnv;
 
     if (isIpAllowed(ip, allowedIps)) {
-        // 3. Custom Domain Routing
+        // Handle OPTIONS (preflight) requests before any redirects
+        // to avoid CORS issues ("Redirect is not allowed for a preflight request")
+        if (req.method === 'OPTIONS') {
+            return new NextResponse(null, {
+                status: 200,
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type',
+                },
+            });
+        }
+
+        // 3. Redirect /:agentName/* to /agents/:agentName/*
+        //    This enables accessing agents from the root path
+        const pathParts = req.nextUrl.pathname.split('/');
+        const potentialAgentName = pathParts[1];
+
+        if (
+            potentialAgentName &&
+            !['agents', 'api', '_next', 'favicon.ico'].includes(potentialAgentName) &&
+            !potentialAgentName.startsWith('.') &&
+            // Note: Other static files are excluded by the matcher configuration below
+            true
+        ) {
+            const url = req.nextUrl.clone();
+            url.pathname = `/agents${req.nextUrl.pathname}`;
+            const response = NextResponse.redirect(url);
+
+            // Enable CORS for the redirect
+            response.headers.set('Access-Control-Allow-Origin', '*');
+            response.headers.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            response.headers.set('Access-Control-Allow-Headers', 'Content-Type');
+
+            return response;
+        }
+
+        // 4. Custom Domain Routing
         //    If the host is not one of the configured SERVERS, try to find an agent with a matching META LINK
 
         if (host && SERVERS && !SERVERS.some((server) => server === host)) {
@@ -94,7 +132,7 @@ export async function middleware(req: NextRequest) {
                 // We check all configured servers because the custom domain could point to any of them
                 // (or if they share the database, we need to check the relevant tables)
                 const serversToCheck = SERVERS;
-                
+
                 // TODO: [🧠] If there are many servers, this loop might be slow. Optimize if needed.
                 for (const serverHost of serversToCheck) {
                     let serverName = serverHost;
@@ -105,11 +143,11 @@ export async function middleware(req: NextRequest) {
                     // Search for agent with matching META LINK
                     // agentProfile->links is an array of strings
                     // We check if it contains the host, or https://host, or http://host
-                    
+
                     const searchLinks = [host, `https://${host}`, `http://${host}`];
-                    
+
                     // Construct OR filter: agentProfile.cs.{"links":["link1"]},agentProfile.cs.{"links":["link2"]},...
-                    const orFilter = searchLinks.map(link => `agentProfile.cs.{"links":["${link}"]}`).join(',');
+                    const orFilter = searchLinks.map((link) => `agentProfile.cs.{"links":["${link}"]}`).join(',');
 
                     try {
                         const { data } = await supabase
@@ -123,7 +161,7 @@ export async function middleware(req: NextRequest) {
                             // Found the agent!
                             const url = req.nextUrl.clone();
                             url.pathname = `/${data.agentName}`;
-                            
+
                             // Pass the server context to the app via header
                             const requestHeaders = new Headers(req.headers);
                             requestHeaders.set('x-promptbook-server', serverHost);
@@ -135,8 +173,8 @@ export async function middleware(req: NextRequest) {
                             });
                         }
                     } catch (error) {
-                         // Ignore error (e.g. table not found, or agent not found) and continue to next server
-                         // console.error(`Error checking server ${serverHost} for custom domain ${host}:`, error);
+                        // Ignore error (e.g. table not found, or agent not found) and continue to next server
+                        // console.error(`Error checking server ${serverHost} for custom domain ${host}:`, error);
                     }
                 }
             }

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

@@ -0,0 +1,66 @@
+import { AgentCollection } from '@promptbook-local/types';
+
+type Agent = Awaited<ReturnType<AgentCollection['listAgents']>>[number];
+
+type AgentWithUrl = Agent & {
+    url: string;
+};
+
+type AgentsApiResponse = {
+    agents: AgentWithUrl[];
+    federatedServers: string[];
+};
+
+/**
+ * Fetches agents from federated servers recursively
+ */
+export async function getFederatedAgents(initialServers: string[]): Promise<AgentWithUrl[]> {
+    const visited = new Set<string>();
+    const queue = [...initialServers];
+    const externalAgentsMap = 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)) {
+                for (const agent of data.agents) {
+                    if (agent.url && !externalAgentsMap.has(agent.url)) {
+                        externalAgentsMap.set(agent.url, agent);
+                    }
+                }
+            }
+
+            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(externalAgentsMap.values());
+}

package/esm/index.es.js

@@ -47,7 +47,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.103.0-49';
+const PROMPTBOOK_ENGINE_VERSION = '0.103.0-50';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name

package/esm/typings/src/_packages/components.index.d.ts

@@ -51,6 +51,7 @@ import { ResetIcon } from '../book-components/icons/ResetIcon';
 import { SaveIcon } from '../book-components/icons/SaveIcon';
 import { SendIcon } from '../book-components/icons/SendIcon';
 import { TemplateIcon } from '../book-components/icons/TemplateIcon';
+import { PromptbookAgent } from '../book-components/PromptbookAgent/PromptbookAgent';
 import { BrandedQrCode } from '../book-components/Qr/BrandedQrCode';
 import { GenericQrCode } from '../book-components/Qr/GenericQrCode';
 import { PromptbookQrCode } from '../book-components/Qr/PromptbookQrCode';
@@ -109,6 +110,7 @@ export { ResetIcon };
 export { SaveIcon };
 export { SendIcon };
 export { TemplateIcon };
+export { PromptbookAgent };
 export { BrandedQrCode };
 export { GenericQrCode };
 export { PromptbookQrCode };

package/esm/typings/src/book-components/PromptbookAgent/PromptbookAgent.d.ts

@@ -0,0 +1,20 @@
+import './PromptbookAgent.css';
+type PromptbookAgentProps = {
+    /**
+     * URL of the agent to connect to
+     *
+     * @example "http://s6.ptbk.io/benjamin-white"
+     */
+    agentUrl: string;
+};
+/**
+ * Renders a floating agent button that opens a chat window with the remote agent.
+ *
+ * @public exported from `@promptbook/components`
+ */
+export declare function PromptbookAgent(props: PromptbookAgentProps): import("react/jsx-runtime").JSX.Element;
+export {};
+/**
+ * TODO: !!! Load the full branding
+ * TODO: !!! <promptbook-agent> element
+ */

package/esm/typings/src/llm-providers/agent/Agent.d.ts

@@ -2,6 +2,8 @@ import { BehaviorSubject } from 'rxjs';
 import type { AgentBasicInformation, BookParameter } from '../../book-2.0/agent-source/AgentBasicInformation';
 import type { string_book } from '../../book-2.0/agent-source/string_book';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+import type { ChatPromptResult } from '../../execution/PromptResult';
+import type { Prompt } from '../../types/Prompt';
 import type { string_agent_hash, string_agent_name, string_agent_url, string_url_image } from '../../types/typeAliases';
 import { AgentLlmExecutionTools } from './AgentLlmExecutionTools';
 import type { AgentOptions } from './AgentOptions';
@@ -55,6 +57,12 @@ export declare class Agent extends AgentLlmExecutionTools implements LlmExecutio
     get parameters(): BookParameter[];
     readonly agentSource: BehaviorSubject<string_book>;
     constructor(options: AgentOptions);
+    /**
+     * Calls the chat model with agent-specific system prompt and requirements with streaming
+     *
+     * Note: This method also implements the learning mechanism
+     */
+    callChatModelStream(prompt: Prompt, onProgress: (chunk: ChatPromptResult) => void): Promise<ChatPromptResult>;
 }
 /**
  * TODO: [🧠][😰]Agent is not working with the parameters, should it be?

package/esm/typings/src/llm-providers/agent/AgentLlmExecutionTools.d.ts

@@ -1,4 +1,5 @@
 import type { Promisable } from 'type-fest';
+import type { string_book } from '../../book-2.0/agent-source/string_book';
 import type { ChatParticipant } from '../../book-components/Chat/types/ChatParticipant';
 import type { AvailableModel } from '../../execution/AvailableModel';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
@@ -40,6 +41,12 @@ export declare class AgentLlmExecutionTools implements LlmExecutionTools {
      * @param agentSource The agent source string that defines the agent's behavior
      */
     constructor(options: CreateAgentLlmExecutionToolsOptions);
+    /**
+     * Updates the agent source and clears the cache
+     *
+     * @param agentSource The new agent source string
+     */
+    protected updateAgentSource(agentSource: string_book): void;
     /**
      * Get cached or parse agent information
      */

package/esm/typings/src/llm-providers/agent/RemoteAgent.d.ts

@@ -1,5 +1,6 @@
 import type { ChatPromptResult } from '../../execution/PromptResult';
 import type { Prompt } from '../../types/Prompt';
+import type { string_agent_hash, string_agent_name } from '../../types/typeAliases';
 import { Agent } from './Agent';
 import type { RemoteAgentOptions } from './RemoteAgentOptions';
 /**
@@ -20,7 +21,11 @@ export declare class RemoteAgent extends Agent {
      * The source of the agent
      */
     private agentUrl;
+    private _remoteAgentName;
+    private _remoteAgentHash;
     private constructor();
+    get agentName(): string_agent_name;
+    get agentHash(): string_agent_hash;
     /**
      * Calls the agent on agents remote server
      */

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.103.0-48`).
+ * It follows semantic versioning (e.g., `0.103.0-49`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.103.0-49",
+    "version": "0.103.0-50",
     "description": "Promptbook: Turn your company's scattered knowledge into AI ready books",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -56,7 +56,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.103.0-49';
+    const PROMPTBOOK_ENGINE_VERSION = '0.103.0-50';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name