@promptbook/cli 0.103.0-48 → 0.103.0-50

package/apps/agents-server/src/utils/cdn/utils/nameToSubfolderPath.ts

@@ -5,5 +5,5 @@ export function nameToSubfolderPath(name: string_name): Array<string> {
 }
 
 /**
- * TODO: !!! Use `nameToSubfolderPath` from src
+ * TODO: [🐱‍🚀] Use `nameToSubfolderPath` from src
  */

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/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/apps/agents-server/src/utils/isIpAllowed.ts

@@ -0,0 +1,101 @@
+import { isIPv4, isIPv6 } from 'net';
+
+/**
+ * Checks if the IP address is allowed based on the allowed IPs list
+ *
+ * @param clientIp - The IP address of the client
+ * @param allowedIps - Comma separated list of allowed IPs or CIDR ranges
+ * @returns true if the IP is allowed, false otherwise
+ */
+export function isIpAllowed(clientIp: string, allowedIps: string | null | undefined): boolean {
+    if (!allowedIps || allowedIps.trim() === '') {
+        return true;
+    }
+
+    const allowedList = allowedIps.split(',').map((ip) => ip.trim());
+
+    for (const allowed of allowedList) {
+        if (allowed === '') {
+            continue;
+        }
+
+        if (allowed.includes('/')) {
+            // CIDR
+            if (isIpInCidr(clientIp, allowed)) {
+                return true;
+            }
+        } else {
+            // Single IP
+            if (clientIp === allowed) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+function isIpInCidr(ip: string, cidr: string): boolean {
+    try {
+        const [range, bitsStr] = cidr.split('/');
+        const bits = parseInt(bitsStr, 10);
+
+        if (isIPv4(ip) && isIPv4(range)) {
+            return isIPv4InCidr(ip, range, bits);
+        } else if (isIPv6(ip) && isIPv6(range)) {
+            return isIPv6InCidr(ip, range, bits);
+        } else if (isIPv6(ip) && isIPv4(range)) {
+            // Check if IPv6 is IPv4-mapped
+            if (ip.startsWith('::ffff:')) {
+                return isIPv4InCidr(ip.substring(7), range, bits);
+            }
+        }
+    } catch (error) {
+        console.error(`Error checking CIDR ${cidr} for IP ${ip}:`, error);
+    }
+    return false;
+}
+
+function ipToLong(ip: string): number {
+    return (
+        ip.split('.').reduce((acc, octet) => {
+            return (acc << 8) + parseInt(octet, 10);
+        }, 0) >>> 0
+    );
+}
+
+function isIPv4InCidr(ip: string, range: string, bits: number): boolean {
+    const mask = ~((1 << (32 - bits)) - 1);
+    const ipLong = ipToLong(ip);
+    const rangeLong = ipToLong(range);
+
+    return (ipLong & mask) === (rangeLong & mask);
+}
+
+function parseIPv6(ip: string): bigint {
+    // Expand ::
+    let fullIp = ip;
+    if (ip.includes('::')) {
+        const parts = ip.split('::');
+        const left = parts[0].split(':').filter(Boolean);
+        const right = parts[1].split(':').filter(Boolean);
+        const missing = 8 - (left.length + right.length);
+        const zeros = Array(missing).fill('0');
+        fullIp = [...left, ...zeros, ...right].join(':');
+    }
+
+    const parts = fullIp.split(':');
+    let value = BigInt(0);
+    for (const part of parts) {
+        value = (value << BigInt(16)) + BigInt(parseInt(part || '0', 16));
+    }
+    return value;
+}
+
+function isIPv6InCidr(ip: string, range: string, bits: number): boolean {
+    const ipBigInt = parseIPv6(ip);
+    const rangeBigInt = parseIPv6(range);
+    const mask = (BigInt(1) << BigInt(128)) - BigInt(1) ^ ((BigInt(1) << BigInt(128 - bits)) - BigInt(1));
+
+    return (ipBigInt & mask) === (rangeBigInt & mask);
+}

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

@@ -0,0 +1,31 @@
+import { cookies } from 'next/headers';
+import { getSession } from './session';
+
+/**
+ * Checks if the current user is an admin
+ * 
+ * Note: If `process.env.ADMIN_PASSWORD` is not set, everyone is admin
+ * 
+ * @returns true if the user is admin
+ */
+export async function isUserAdmin(): Promise<boolean> {
+    if (!process.env.ADMIN_PASSWORD) {
+        return true;
+    }
+
+    // Check legacy admin token
+    const cookieStore = await cookies();
+    const adminToken = cookieStore.get('adminToken');
+
+    if (adminToken?.value === process.env.ADMIN_PASSWORD) {
+        return true;
+    }
+
+    // Check session
+    const session = await getSession();
+    if (session?.isAdmin) {
+        return true;
+    }
+
+    return false;
+}

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

@@ -0,0 +1,50 @@
+import { createHmac } from 'crypto';
+import { cookies } from 'next/headers';
+
+const SESSION_COOKIE_NAME = 'sessionToken';
+const SECRET_KEY = process.env.ADMIN_PASSWORD || 'default-secret-key-change-me';
+
+type SessionUser = {
+    username: string;
+    isAdmin: boolean;
+};
+
+export async function setSession(user: SessionUser) {
+    const payload = JSON.stringify(user);
+    const signature = createHmac('sha256', SECRET_KEY).update(payload).digest('hex');
+    const token = `${Buffer.from(payload).toString('base64')}.${signature}`;
+    
+    (await cookies()).set(SESSION_COOKIE_NAME, token, {
+        httpOnly: true,
+        secure: process.env.NODE_ENV === 'production',
+        path: '/',
+        maxAge: 60 * 60 * 24 * 7, // 1 week
+    });
+}
+
+export async function clearSession() {
+    (await cookies()).delete(SESSION_COOKIE_NAME);
+    // Also clear legacy adminToken
+    (await cookies()).delete('adminToken');
+}
+
+export async function getSession(): Promise<SessionUser | null> {
+    const cookieStore = await cookies();
+    const token = cookieStore.get(SESSION_COOKIE_NAME)?.value;
+
+    if (!token) return null;
+
+    const [payloadBase64, signature] = token.split('.');
+    if (!payloadBase64 || !signature) return null;
+
+    const payload = Buffer.from(payloadBase64, 'base64').toString('utf-8');
+    const expectedSignature = createHmac('sha256', SECRET_KEY).update(payload).digest('hex');
+
+    if (signature !== expectedSignature) return null;
+
+    try {
+        return JSON.parse(payload) as SessionUser;
+    } catch {
+        return null;
+    }
+}

package/apps/agents-server/tailwind.config.ts

@@ -15,6 +15,8 @@ const config: Config = {
             colors: {
                 background: 'var(--background)',
                 foreground: 'var(--foreground)',
+                'promptbook-blue': '#7aebff',
+                'promptbook-blue-dark': '#30a8bd',
             },
         },
     },

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-48';
+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
@@ -86,6 +86,7 @@ const REMOTE_SERVER_URLS = [
     */
 ];
 /**
+ * TODO: [🐱‍🚀] Auto-federated server from url in here
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
@@ -432,6 +433,9 @@ class Color {
         if (hex.length === 3) {
             return Color.fromHex3(hex);
         }
+        if (hex.length === 4) {
+            return Color.fromHex4(hex);
+        }
         if (hex.length === 6) {
             return Color.fromHex6(hex);
         }
@@ -452,6 +456,19 @@ class Color {
         const b = parseInt(hex.substr(2, 1), 16) * 16;
         return take(new Color(r, g, b));
     }
+    /**
+     * Creates a new Color instance from color in hex format with 4 digits (with alpha channel)
+     *
+     * @param color in hex for example `09df`
+     * @returns Color object
+     */
+    static fromHex4(hex) {
+        const r = parseInt(hex.substr(0, 1), 16) * 16;
+        const g = parseInt(hex.substr(1, 1), 16) * 16;
+        const b = parseInt(hex.substr(2, 1), 16) * 16;
+        const a = parseInt(hex.substr(3, 1), 16) * 16;
+        return take(new Color(r, g, b, a));
+    }
     /**
      * Creates a new Color instance from color in hex format with 6 color digits (without alpha channel)
      *
@@ -642,7 +659,8 @@ class Color {
      * @returns true if the value is a valid hex color string (e.g., `#009edd`, `#fff`, etc.)
      */
     static isHexColorString(value) {
-        return typeof value === 'string' && /^#(?:[0-9a-fA-F]{3}){1,2}$/.test(value);
+        return (typeof value === 'string' &&
+            /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(value));
     }
     /**
      * Creates new Color object
@@ -983,6 +1001,7 @@ const PROMPTBOOK_COLOR = Color.fromHex('#79EAFD');
 ({
     TITLE: Color.fromHex('#244EA8'),
     LINE: Color.fromHex('#eeeeee'),
+    SEPARATOR: Color.fromHex('#cccccc'),
     COMMITMENT: Color.fromHex('#DA0F78'),
     PARAMETER: Color.fromHex('#8e44ad'),
 });
@@ -2385,7 +2404,7 @@ function deepClone(objectValue) {
     TODO: [🧠] Is there a better implementation?
     > const propertyNames = Object.getOwnPropertyNames(objectValue);
     > for (const propertyName of propertyNames) {
-    >     const value = (objectValue as really_any)[propertyName];
+    >     const value = (objectValue as chococake)[propertyName];
     >     if (value && typeof value === 'object') {
     >         deepClone(value);
     >     }
@@ -3204,7 +3223,7 @@ class DatabaseError extends Error {
     }
 }
 /**
- * TODO: !!!! Explain that NotFoundError (!!! and other specific errors) has priority over DatabaseError in some contexts
+ * TODO: [🐱‍🚀] Explain that NotFoundError ([🐱‍🚀] and other specific errors) has priority over DatabaseError in some contexts
  */
 
 /**
@@ -12972,6 +12991,18 @@ function renderPromptbookMermaid(pipelineJson, options) {
  * TODO: [🕌] When more than 2 functionalities, split into separate functions
  */
 
+/**
+ * Computes SHA-256 hash of the given object
+ *
+ * @public exported from `@promptbook/utils`
+ */
+function computeHash(value) {
+    return SHA256(hexEncoder.parse(spaceTrim(valueToString(value)))).toString( /* hex */);
+}
+/**
+ * TODO: [🥬][🥬] Use this ACRY
+ */
+
 /**
  * Makes first letter of a string lowercase
  *
@@ -15083,7 +15114,7 @@ function $initializeRunCommand(program) {
  */
 
 /**
- * !!!!!
+ * [🐱‍🚀]
  * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
  *
  * You can simply use `RemoteExecutionTools` on client-side javascript and connect to your remote server.
@@ -15091,11 +15122,11 @@ function $initializeRunCommand(program) {
  *
  * @see https://github.com/webgptorg/promptbook#remote-server
  * @public exported from `@promptbook/remote-server`
- * <- TODO: !!!! Change to `@promptbook/agent-server`
+ * <- TODO: [🐱‍🚀] Change to `@promptbook/agent-server`
  */
 async function startAgentServer(options) {
     const { port = 4440 } = options;
-    // TODO: !!!! [🌕]
+    // TODO: [🐱‍🚀] [🌕]
     const agentsServerRoot = join(__dirname, '../apps/agents-server');
     console.trace(`!!! Starting agents server on port ${port}...`);
     console.log(`!!! cwd`, process.cwd());
@@ -15131,7 +15162,7 @@ function $initializeStartAgentsServerCommand(program) {
     startServerCommand.alias('start');
     startServerCommand.action(handleActionErrors(async (path, cliOptions) => {
         const { port: portRaw, reload: isCacheReloaded, verbose: isVerbose } = cliOptions;
-        // TODO: !!!! [🌕] DRY
+        // TODO: [🐱‍🚀] [🌕] DRY
         const port = parseInt(portRaw, 10);
         if (isNaN(port) || port <= 0 || port > 65535) {
             console.error(colors.red(`Invalid port number: ${portRaw}`));
@@ -15173,11 +15204,11 @@ function $initializeStartAgentsServerCommand(program) {
         TODO_USE(tools);
         TODO_USE(collection);
         */
-        // TODO: !!!! Use
-        // TODO: !!!! Pass collection and tools to the server starter
-        // TODO: !!!! The Next app should be build during the package build step not here
+        // TODO: [🐱‍🚀] Use
+        // TODO: [🐱‍🚀] Pass collection and tools to the server starter
+        // TODO: [🐱‍🚀] The Next app should be build during the package build step not here
         /*
-        // TODO: !!!! Run this conditionally only in production mode in dev mode use `next dev`
+        // TODO: [🐱‍🚀] Run this conditionally only in production mode in dev mode use `next dev`
         await $execCommand({
             cwd: './apps/agents-server',
             command: `next build`,
@@ -20390,11 +20421,12 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
  *
  * This is useful for calling OpenAI API with a single assistant, for more wide usage use `OpenAiExecutionTools`.
  *
- * !!! Note: [🦖] There are several different things in Promptbook:
+ * Note: [🦖] There are several different things in Promptbook:
  * - `Agent` - which represents an AI Agent with its source, memories, actions, etc. Agent is a higher-level abstraction which is internally using:
  * - `LlmExecutionTools` - which wraps one or more LLM models and provides an interface to execute them
  * - `AgentLlmExecutionTools` - which is a specific implementation of `LlmExecutionTools` that wraps another LlmExecutionTools and applies agent-specific system prompts and requirements
  * - `OpenAiAssistantExecutionTools` - which is a specific implementation of `LlmExecutionTools` for OpenAI models with assistant capabilities, recommended for usage in `Agent` or `AgentLlmExecutionTools`
+ * - `RemoteAgent` - which is an `Agent` that connects to a Promptbook Agents Server
  *
  * @public exported from `@promptbook/openai`
  */
@@ -20429,6 +20461,12 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
      * Calls OpenAI API to use a chat model.
      */
     async callChatModel(prompt) {
+        return this.callChatModelStream(prompt, () => { });
+    }
+    /**
+     * Calls OpenAI API to use a chat model with streaming.
+     */
+    async callChatModelStream(prompt, onProgress) {
         var _a, _b, _c;
         if (this.options.isVerbose) {
             console.info('💬 OpenAI callChatModel call', { prompt });
@@ -20496,21 +20534,24 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
                 console.info('connect', stream.currentEvent);
             }
         });
-        /*
-        stream.on('messageDelta', (messageDelta) => {
-            if (
-                this.options.isVerbose &&
-                messageDelta &&
-                messageDelta.content &&
-                messageDelta.content[0] &&
-                messageDelta.content[0].type === 'text'
-            ) {
-                console.info('messageDelta', messageDelta.content[0].text?.value);
+        stream.on('textDelta', (textDelta, snapshot) => {
+            if (this.options.isVerbose && textDelta.value) {
+                console.info('textDelta', textDelta.value);
             }
-
-            // <- TODO: [🐚] Make streaming and running tasks working
+            const chunk = {
+                content: textDelta.value || '',
+                modelName: 'assistant',
+                timing: {
+                    start,
+                    complete: $getCurrentDate(),
+                },
+                usage: UNCERTAIN_USAGE,
+                rawPromptContent,
+                rawRequest,
+                rawResponse: snapshot,
+            };
+            onProgress(chunk);
         });
-        */
         stream.on('messageCreated', (message) => {
             if (this.options.isVerbose) {
                 console.info('messageCreated', message);
@@ -20546,7 +20587,7 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         }
         return exportJson({
             name: 'promptResult',
-            message: `Result of \`OpenAiAssistantExecutionTools.callChatModel\``,
+            message: `Result of \`OpenAiAssistantExecutionTools.callChatModelStream\``,
             order: [],
             value: {
                 content: resultContent,
@@ -20685,9 +20726,9 @@ class OpenAiAssistantExecutionTools extends OpenAiExecutionTools {
         }
         const assistant = await client.beta.assistants.create(assistantConfig);
         console.log(`✅ Assistant created: ${assistant.id}`);
-        // TODO: !!!! Try listing existing assistants
-        // TODO: !!!! Try marking existing assistants by DISCRIMINANT
-        // TODO: !!!! Allow to update and reconnect to existing assistants
+        // TODO: [🐱‍🚀] Try listing existing assistants
+        // TODO: [🐱‍🚀] Try marking existing assistants by DISCRIMINANT
+        // TODO: [🐱‍🚀] Allow to update and reconnect to existing assistants
         return new OpenAiAssistantExecutionTools({
             ...this.options,
             isCreatingNewAssistantsAllowed: false,
@@ -23009,6 +23050,60 @@ class MemoryCommitmentDefinition extends BaseCommitmentDefinition {
  * Note: [💞] Ignore a discrepancy between file name and entity name
  */
 
+/**
+ * INITIAL MESSAGE commitment definition
+ *
+ * The INITIAL MESSAGE commitment defines the first message that the user sees when opening the chat.
+ * It is used to greet the user and set the tone of the conversation.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * INITIAL MESSAGE Hello! I am ready to help you with your tasks.
+ * ```
+ *
+ * @private [🪔] Maybe export the commitments through some package
+ */
+class InitialMessageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('INITIAL MESSAGE');
+    }
+    /**
+     * Short one-line description of INITIAL MESSAGE.
+     */
+    get description() {
+        return 'Defines the **initial message** shown to the user when the chat starts.';
+    }
+    /**
+     * Markdown documentation for INITIAL MESSAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # ${this.type}
+
+            Defines the first message that the user sees when opening the chat. This message is purely for display purposes in the UI and does not inherently become part of the LLM's system prompt context (unless also included via other means).
+
+            ## Key aspects
+
+            - Used to greet the user.
+            - Sets the tone of the conversation.
+            - Displayed immediately when the chat interface loads.
+
+            ## Examples
+
+            \`\`\`book
+            Support Agent
+
+            PERSONA You are a helpful support agent.
+            INITIAL MESSAGE Hi there! How can I assist you today?
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        return requirements;
+    }
+}
+
 /**
  * MESSAGE commitment definition
  *
@@ -24170,6 +24265,7 @@ const COMMITMENT_REGISTRY = [
     new NoteCommitmentDefinition('NONCE'),
     new GoalCommitmentDefinition('GOAL'),
     new GoalCommitmentDefinition('GOALS'),
+    new InitialMessageCommitmentDefinition(),
     new MessageCommitmentDefinition('MESSAGE'),
     new MessageCommitmentDefinition('MESSAGES'),
     new ScenarioCommitmentDefinition('SCENARIO'),
@@ -24548,7 +24644,7 @@ function generatePlaceholderAgentProfileImageUrl(agentName) {
  * @public exported from `@promptbook/core`
  */
 function computeAgentHash(agentSource) {
-    return SHA256(hexEncoder.parse(agentSource /* <- TODO: !!!!! spaceTrim */)).toString( /* hex */);
+    return computeHash(agentSource);
 }
 
 /**
@@ -24597,13 +24693,31 @@ function parseAgentSource(agentSource) {
         }
         personaDescription += commitment.content;
     }
+    let initialMessage = null;
+    for (const commitment of parseResult.commitments) {
+        if (commitment.type !== 'INITIAL MESSAGE') {
+            continue;
+        }
+        // Note: Initial message override logic - later overrides earlier
+        //       Or should it append? Usually initial message is just one block.
+        //       Let's stick to "later overrides earlier" for simplicity, or just take the last one.
+        initialMessage = commitment.content;
+    }
     const meta = {};
+    const links = [];
     for (const commitment of parseResult.commitments) {
+        if (commitment.type === 'META LINK') {
+            links.push(spaceTrim(commitment.content));
+            continue;
+        }
         if (commitment.type !== 'META') {
             continue;
         }
         // Parse META commitments - format is "META TYPE content"
         const metaTypeRaw = commitment.content.split(' ')[0] || 'NONE';
+        if (metaTypeRaw === 'LINK') {
+            links.push(spaceTrim(commitment.content.substring(metaTypeRaw.length)));
+        }
         const metaType = normalizeTo_camelCase(metaTypeRaw);
         meta[metaType] = spaceTrim(commitment.content.substring(metaTypeRaw.length));
     }
@@ -24619,7 +24733,9 @@ function parseAgentSource(agentSource) {
         agentName: normalizeAgentName(parseResult.agentName || createDefaultAgentName(agentSource)),
         agentHash,
         personaDescription,
+        initialMessage,
         meta,
+        links,
         parameters,
     };
 }