@promptbook/cli 0.112.0-125 → 0.112.0-127

package/apps/agents-server/src/components/NewAgentDialog/ManGoNewAgentWizard/state/OnboardingProvider.tsx

@@ -0,0 +1,121 @@
+'use client';
+
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { NotAllowed } from '../../../../../../../src/errors/NotAllowed';
+
+import type { OnboardingState } from '../types';
+
+/** sessionStorage key for the wizard session — exported so callers (e.g. the dashboard's
+ * "Nový onboarding") can clear a stale draft before starting fresh. */
+export const ONBOARDING_STORAGE_KEY = 'onboarding:v1';
+const STORAGE_KEY = ONBOARDING_STORAGE_KEY;
+
+const INITIAL_STATE: OnboardingState = {
+    agentName: '',
+    agentBrief: '',
+    bookSource: '',
+    knowledge: [],
+    testMessages: [],
+    savedAgentId: null,
+    savedAgentTargetPath: null,
+};
+
+type OnboardingPatch = Partial<OnboardingState> | ((previous: OnboardingState) => Partial<OnboardingState>);
+
+type OnboardingContextValue = {
+    readonly state: OnboardingState;
+    /** True once the initial `sessionStorage` hydration has run (client-only). */
+    readonly isHydrated: boolean;
+    /**
+     * Shallow-merges a patch into the state and writes it through to `sessionStorage`.
+     * Accepts a function form for updates that depend on the latest state (e.g. mutating
+     * the knowledge list from several concurrent uploads).
+     */
+    readonly update: (patch: OnboardingPatch) => void;
+    /** Clears the session (state + storage). */
+    readonly reset: () => void;
+};
+
+const OnboardingContext = createContext<OnboardingContextValue | null>(null);
+
+function readPersistedState(): OnboardingState | null {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+
+    try {
+        const raw = window.sessionStorage.getItem(STORAGE_KEY);
+        return raw ? { ...INITIAL_STATE, ...(JSON.parse(raw) as Partial<OnboardingState>) } : null;
+    } catch {
+        return null;
+    }
+}
+
+function writePersistedState(state: OnboardingState): void {
+    if (typeof window === 'undefined') {
+        return;
+    }
+
+    try {
+        window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+    } catch {
+        // Ignore storage failures (private mode, quota) — state still lives in memory.
+    }
+}
+
+/**
+ * Holds the whole wizard state for one onboarding session.
+ *
+ * Mounted by the `/onboarding` layout route so the state survives navigation between
+ * steps. Hydration from `sessionStorage` happens after the first client render to avoid
+ * an SSR/CSR mismatch; subsequent writes are write-through.
+ */
+export function OnboardingProvider({ children }: { readonly children: React.ReactNode }) {
+    const [state, setState] = useState<OnboardingState>(INITIAL_STATE);
+    const [isHydrated, setIsHydrated] = useState(false);
+
+    useEffect(() => {
+        const persisted = readPersistedState();
+        if (persisted) {
+            setState(persisted);
+        }
+        setIsHydrated(true);
+    }, []);
+
+    const update = useCallback((patch: OnboardingPatch) => {
+        setState((previous) => {
+            const resolved = typeof patch === 'function' ? patch(previous) : patch;
+            const next = { ...previous, ...resolved };
+            writePersistedState(next);
+            return next;
+        });
+    }, []);
+
+    const reset = useCallback(() => {
+        setState(INITIAL_STATE);
+        if (typeof window !== 'undefined') {
+            try {
+                window.sessionStorage.removeItem(STORAGE_KEY);
+            } catch {
+                // Ignore.
+            }
+        }
+    }, []);
+
+    const value = useMemo<OnboardingContextValue>(
+        () => ({ state, isHydrated, update, reset }),
+        [state, isHydrated, update, reset],
+    );
+
+    return <OnboardingContext.Provider value={value}>{children}</OnboardingContext.Provider>;
+}
+
+export function useOnboarding(): OnboardingContextValue {
+    const context = useContext(OnboardingContext);
+
+    if (!context) {
+        throw new NotAllowed('useOnboarding must be used within an <OnboardingProvider>.');
+    }
+
+    return context;
+}

package/apps/agents-server/src/components/NewAgentDialog/ManGoNewAgentWizard/types.ts

@@ -0,0 +1,52 @@
+/**
+ * Domain types for the onboarding wizard (Phase 1).
+ *
+ * These are the module's own types — anything coming from the outside (API responses,
+ * server functions) is mapped onto these in `services/` so the UI never depends on
+ * external shapes directly.
+ */
+
+export type KnowledgeItemStatus = 'uploading' | 'ready' | 'error';
+
+export type KnowledgeFileItem = {
+    readonly kind: 'file';
+    readonly id: string;
+    readonly name: string;
+    readonly size: number;
+    readonly publicUrl: string;
+    readonly objectKey: string;
+    readonly status: KnowledgeItemStatus;
+};
+
+export type KnowledgeUrlItem = {
+    readonly kind: 'url';
+    readonly id: string;
+    readonly url: string;
+    readonly status: KnowledgeItemStatus;
+};
+
+export type KnowledgeItem = KnowledgeFileItem | KnowledgeUrlItem;
+
+export type ChatRole = 'user' | 'agent';
+
+export type ChatMessage = {
+    readonly id: string;
+    readonly role: ChatRole;
+    readonly content: string;
+};
+
+/**
+ * The full in-memory state of one onboarding session. Persisted to `sessionStorage`
+ * so a refresh does not throw away work-in-progress. No server-side persistence in v1.
+ */
+export type OnboardingState = {
+    readonly agentName: string;
+    readonly agentBrief: string;
+    readonly bookSource: string;
+    readonly knowledge: readonly KnowledgeItem[];
+    readonly testMessages: readonly ChatMessage[];
+    /** Permanent id of the created agent once this session reached "Hotovo" (so we save it exactly once). */
+    readonly savedAgentId: string | null;
+    /** Route opened by the final CTA after the agent is created. */
+    readonly savedAgentTargetPath: string | null;
+};

package/apps/agents-server/src/components/NewAgentDialog/createNewAgentWizardSource.ts

@@ -213,7 +213,7 @@ export function createNewAgentWizardSource(options: CreateNewAgentWizardSourceOp
         }))
         .filter((item) => item.label !== '' && item.source !== '');
     const noteLines = [
-        'NOTE This agent was created via the NEW_AGENT_WIZZARD flow',
+        'NOTE This agent was created via the NEW_AGENT_WIZARD flow',
         `- Goal: ${summarizedGoal || 'Guided default goal'}`,
         `- Personality: ${formatSummaryList(personaTraits, 'Default guided persona')}`,
         `- Learning: ${options.isOpenToLearning ? 'Open to learning' : 'Fixed after creation'}`,

package/apps/agents-server/src/components/NewAgentDialog/trackNewAgentCreationEvent.ts

@@ -21,7 +21,7 @@ export type TrackNewAgentCreationEventOptions = {
     /**
      * Concrete surface the user interacted with.
      */
-    readonly surface?: 'editor' | 'wizard';
+    readonly surface?: 'editor' | 'wizard' | 'mango-wizard';
     /**
      * Folder scope where the flow started.
      */

package/apps/agents-server/src/components/NewAgentDialog/useNewAgentDialog.tsx

@@ -3,6 +3,7 @@
 import type { string_book } from '@promptbook-local/types';
 import type { ReactElement } from 'react';
 import { useCallback, useState } from 'react';
+import { NotAllowed } from '../../../../../src/errors/NotAllowed';
 import { appendHeadlessParam, useIsHeadless } from '../_utils/headlessParam';
 import type { AgentVisibility } from '../../utils/agentVisibility';
 import { buildFreshAgentChatHref } from '../../utils/agentRouting/agentRouteHrefs';
@@ -18,6 +19,10 @@ import type {
     NewAgentWizardOpenEditorRequest,
 } from './NewAgentWizard';
 import { NewAgentWizard } from './NewAgentWizard';
+import {
+    ManGoNewAgentWizard,
+    type ManGoNewAgentWizardCreateRequest,
+} from './ManGoNewAgentWizard/ManGoNewAgentWizard';
 import { trackNewAgentCreationEvent } from './trackNewAgentCreationEvent';
 
 /**
@@ -105,6 +110,12 @@ type NewAgentDialogState =
           readonly defaultVisibility: AgentVisibility;
           readonly initialAgentName?: string;
           readonly targetFolderId: number | null | undefined;
+      }
+    | {
+          readonly surface: 'mango-wizard';
+          readonly mode: NewAgentWizardMode;
+          readonly defaultVisibility: AgentVisibility;
+          readonly targetFolderId: number | null | undefined;
       };
 
 /**
@@ -176,6 +187,21 @@ export function useNewAgentDialog(options: UseNewAgentDialogOptions): UseNewAgen
                     folderId: openOptions?.folderId,
                 });
 
+                if (settings.mode === 'MANGO_WIZARD') {
+                    setDialogState({
+                        surface: 'mango-wizard',
+                        mode: settings.mode,
+                        defaultVisibility: settings.defaultVisibility,
+                        targetFolderId: openOptions?.folderId,
+                    });
+                    trackNewAgentCreationEvent('new_agent_wizard_shown', {
+                        mode: settings.mode,
+                        surface: 'mango-wizard',
+                        folderId: openOptions?.folderId,
+                    });
+                    return;
+                }
+
                 if (settings.mode === 'WIZARD') {
                     let initialAgentName = '';
                     try {
@@ -268,6 +294,47 @@ export function useNewAgentDialog(options: UseNewAgentDialogOptions): UseNewAgen
         [dialogState, handleCreatedAgent, onCreateFailed],
     );
 
+    const handleCreateFromManGoWizard = useCallback(
+        async (request: ManGoNewAgentWizardCreateRequest) => {
+            if (!dialogState || dialogState.surface !== 'mango-wizard') {
+                throw new NotAllowed('The manGo wizard is not currently open.');
+            }
+
+            try {
+                const { agentName, permanentId } = await $createAgentFromBookAction(
+                    request.agentSource,
+                    dialogState.targetFolderId,
+                    request.visibility,
+                );
+                const createdAgent = createCreatedAgentPayload(agentName, permanentId);
+                trackNewAgentCreationEvent('new_agent_created', {
+                    mode: dialogState.mode,
+                    surface: 'mango-wizard',
+                    folderId: dialogState.targetFolderId,
+                    knowledgeCount: request.knowledgeCount,
+                });
+                await onCreated?.(createdAgent);
+
+                return {
+                    permanentId,
+                    targetPath: createdAgent.targetPath,
+                };
+            } catch (error) {
+                await onCreateFailed?.(error);
+                throw error;
+            }
+        },
+        [dialogState, onCreateFailed, onCreated],
+    );
+
+    const handleOpenCreatedManGoAgent = useCallback(
+        (targetPath: string) => {
+            setDialogState(null);
+            window.location.assign(appendHeadlessParam(targetPath, isHeadless));
+        },
+        [isHeadless],
+    );
+
     const handleOpenEditorFromWizard = useCallback((request: NewAgentWizardOpenEditorRequest) => {
         setDialogState((currentDialogState) => {
             if (!currentDialogState || currentDialogState.surface !== 'wizard') {
@@ -305,6 +372,15 @@ export function useNewAgentDialog(options: UseNewAgentDialogOptions): UseNewAgen
                     onCreate={handleCreateFromWizard}
                     onOpenEditor={handleOpenEditorFromWizard}
                 />
+            ) : dialogState?.surface === 'mango-wizard' ? (
+                <ManGoNewAgentWizard
+                    mode={dialogState.mode}
+                    defaultVisibility={dialogState.defaultVisibility}
+                    folderId={dialogState.targetFolderId}
+                    onClose={closeNewAgentDialog}
+                    onCreate={handleCreateFromManGoWizard}
+                    onOpenCreatedAgent={handleOpenCreatedManGoAgent}
+                />
             ) : null,
     };
 }

package/apps/agents-server/src/constants/newAgentWizard.ts

@@ -1,22 +1,27 @@
 /**
  * Metadata key that controls which "new agent" creation experience is shown.
  */
-export const NEW_AGENT_WIZZARD_METADATA_KEY = 'NEW_AGENT_WIZZARD' as const;
+export const NEW_AGENT_WIZARD_METADATA_KEY = 'NEW_AGENT_WIZARD' as const;
+
+/**
+ * Previous metadata key retained only for reading already persisted settings.
+ */
+export const LEGACY_NEW_AGENT_WIZARD_METADATA_KEY = ['NEW_AGENT_', 'WIZ', 'ZARD'].join('');
 
 /**
  * Supported new-agent creation experiences.
  */
-export const NEW_AGENT_WIZZARD_VALUES = ['BOILERPLATE', 'WIZARD'] as const;
+export const NEW_AGENT_WIZARD_VALUES = ['BOILERPLATE', 'WIZARD', 'MANGO_WIZARD'] as const;
 
 /**
  * Canonical union of supported new-agent creation experiences.
  */
-export type NewAgentWizardMode = (typeof NEW_AGENT_WIZZARD_VALUES)[number];
+export type NewAgentWizardMode = (typeof NEW_AGENT_WIZARD_VALUES)[number];
 
 /**
  * Shared select options for the new-agent experience metadata.
  */
-export const NEW_AGENT_WIZZARD_OPTIONS: ReadonlyArray<{
+export const NEW_AGENT_WIZARD_OPTIONS: ReadonlyArray<{
     readonly value: NewAgentWizardMode;
     readonly label: string;
 }> = [
@@ -28,12 +33,16 @@ export const NEW_AGENT_WIZZARD_OPTIONS: ReadonlyArray<{
         value: 'WIZARD',
         label: 'Wizard',
     },
+    {
+        value: 'MANGO_WIZARD',
+        label: 'manGo wizard',
+    },
 ] as const;
 
 /**
  * Default creation experience used when metadata is missing or invalid.
  */
-export const DEFAULT_NEW_AGENT_WIZZARD_MODE: NewAgentWizardMode = 'BOILERPLATE';
+export const DEFAULT_NEW_AGENT_WIZARD_MODE: NewAgentWizardMode = 'MANGO_WIZARD';
 
 /**
  * Returns whether the provided value is a supported new-agent creation experience.
@@ -42,7 +51,7 @@ export const DEFAULT_NEW_AGENT_WIZZARD_MODE: NewAgentWizardMode = 'BOILERPLATE';
  * @returns `true` when the value matches a supported mode.
  */
 export function isNewAgentWizardMode(value: unknown): value is NewAgentWizardMode {
-    return typeof value === 'string' && NEW_AGENT_WIZZARD_VALUES.includes(value as NewAgentWizardMode);
+    return typeof value === 'string' && NEW_AGENT_WIZARD_VALUES.includes(value as NewAgentWizardMode);
 }
 
 /**
@@ -54,12 +63,12 @@ export function isNewAgentWizardMode(value: unknown): value is NewAgentWizardMod
  */
 export function parseNewAgentWizardMode(
     value: unknown,
-    fallback: NewAgentWizardMode = DEFAULT_NEW_AGENT_WIZZARD_MODE,
+    fallback: NewAgentWizardMode = DEFAULT_NEW_AGENT_WIZARD_MODE,
 ): NewAgentWizardMode {
     if (typeof value !== 'string') {
         return fallback;
     }
 
-    const normalized = value.trim().toUpperCase();
+    const normalized = value.trim().toUpperCase().replace(/[\s-]+/g, '_');
     return isNewAgentWizardMode(normalized) ? normalized : fallback;
 }

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

@@ -10,6 +10,17 @@ import { cache } from 'react';
  */
 const metadataDefaultsMap = new Map<string, string>(metadataDefaults.map((metadata) => [metadata.key, metadata.value]));
 
+/**
+ * Precomputed map of legacy metadata keys keyed by canonical metadata key.
+ *
+ * @private Internal helper for metadata lookups in `apps/agents-server`.
+ */
+const metadataLegacyKeysMap = new Map<string, ReadonlyArray<string>>(
+    metadataDefaults
+        .filter((metadata) => metadata.legacyKeys && metadata.legacyKeys.length > 0)
+        .map((metadata): [string, ReadonlyArray<string>] => [metadata.key, metadata.legacyKeys ?? []]),
+);
+
 /**
  * Process-level cache lifetime for metadata reads.
  *
@@ -146,8 +157,33 @@ export async function getMetadataMap(keys: readonly string[]): Promise<Record<st
 
     const metadataRecord: Record<string, string | null> = {};
     for (const key of uniqueKeys) {
-        metadataRecord[key] = loadedMap.get(key) ?? metadataDefaultsMap.get(key) ?? null;
+        metadataRecord[key] = resolveMetadataValue(key, loadedMap);
     }
 
     return metadataRecord;
 }
+
+/**
+ * Resolves one metadata value from canonical rows, legacy rows, or default definitions.
+ *
+ * @param key - Canonical metadata key requested by the caller.
+ * @param loadedMap - Persisted metadata values keyed by database row key.
+ * @returns Stored, legacy, default, or `null` metadata value.
+ *
+ * @private Internal helper for metadata lookups in `apps/agents-server`.
+ */
+function resolveMetadataValue(key: string, loadedMap: ReadonlyMap<string, string | null>): string | null {
+    const storedValue = loadedMap.get(key);
+    if (storedValue !== undefined && storedValue !== null) {
+        return storedValue;
+    }
+
+    for (const legacyKey of metadataLegacyKeysMap.get(key) ?? []) {
+        const legacyValue = loadedMap.get(legacyKey);
+        if (legacyValue !== undefined && legacyValue !== null) {
+            return legacyValue;
+        }
+    }
+
+    return metadataDefaultsMap.get(key) ?? null;
+}

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

@@ -19,7 +19,12 @@ import {
 } from '../constants/defaultAgentAvatarVisual';
 import { DEFAULT_THEME_METADATA_KEY, DEFAULT_THEME_MODE, THEME_MODE_OPTIONS } from '../constants/themeMode';
 import { DEFAULT_NAME_POOL, NAME_POOL_METADATA_KEY, NAME_POOL_OPTIONS } from '../constants/namePool';
-import { NEW_AGENT_WIZZARD_METADATA_KEY, NEW_AGENT_WIZZARD_OPTIONS } from '../constants/newAgentWizard';
+import {
+    DEFAULT_NEW_AGENT_WIZARD_MODE,
+    LEGACY_NEW_AGENT_WIZARD_METADATA_KEY,
+    NEW_AGENT_WIZARD_METADATA_KEY,
+    NEW_AGENT_WIZARD_OPTIONS,
+} from '../constants/newAgentWizard';
 import {
     DEFAULT_SHIBBOLETH_DISPLAY_NAME_ATTRIBUTE_NAMES,
     DEFAULT_SHIBBOLETH_EMAIL_ATTRIBUTE_NAMES,
@@ -90,6 +95,11 @@ export type MetadataDefinition = {
      * Optional predefined values rendered as a select instead of a free-form input.
      */
     readonly options?: ReadonlyArray<MetadataDefinitionOption>;
+
+    /**
+     * Optional previous keys that should be read when the canonical key is absent.
+     */
+    readonly legacyKeys?: ReadonlyArray<string>;
 };
 
 /**
@@ -120,7 +130,7 @@ const analyticsMetadataDefaults = ANALYTICS_METADATA_KEYS.map((key) => {
 /**
  * Constant for metadata defaults.
  */
-export const metadataDefaults = [
+export const metadataDefaults: ReadonlyArray<MetadataDefinition> = [
     {
         key: 'SERVER_NAME',
         value: 'Promptbook Agents Server',
@@ -473,13 +483,14 @@ export const metadataDefaults = [
         options: AGENT_VISIBILITY_OPTIONS,
     },
     {
-        key: NEW_AGENT_WIZZARD_METADATA_KEY,
-        value: 'BOILERPLATE',
+        key: NEW_AGENT_WIZARD_METADATA_KEY,
+        value: DEFAULT_NEW_AGENT_WIZARD_MODE,
         note: `Controls the "new agent" flow. Allowed values: ${formatMetadataOptionValues(
-            NEW_AGENT_WIZZARD_OPTIONS,
+            NEW_AGENT_WIZARD_OPTIONS,
         )}.`,
         type: 'TEXT_SINGLE_LINE',
-        options: NEW_AGENT_WIZZARD_OPTIONS,
+        options: NEW_AGENT_WIZARD_OPTIONS,
+        legacyKeys: [LEGACY_NEW_AGENT_WIZARD_METADATA_KEY],
     },
     {
         key: 'MANAGEMENT_API_CORS_ORIGINS',
@@ -536,7 +547,7 @@ export const metadataDefaults = [
         type: 'TEXT_SINGLE_LINE',
     },
     ...analyticsMetadataDefaults,
-] as const satisfies ReadonlyArray<MetadataDefinition>;
+];
 
 /**
  * Lookup map for metadata definitions by key.

package/apps/agents-server/src/database/migrations/2026-06-2200-new-agent-wizard-metadata-key.sql

@@ -0,0 +1,27 @@
+UPDATE "prefix_Metadata"
+SET "key" = 'NEW_AGENT_WIZARD',
+    "note" = 'Controls the "new agent" flow. Allowed values: BOILERPLATE, WIZARD, MANGO_WIZARD.',
+    "updatedAt" = NOW()
+WHERE "key" = 'NEW_AGENT_' || 'WIZ' || 'ZARD'
+  AND NOT EXISTS (SELECT 1 FROM "prefix_Metadata" WHERE "key" = 'NEW_AGENT_WIZARD');
+
+DELETE FROM "prefix_Metadata"
+WHERE "key" = 'NEW_AGENT_' || 'WIZ' || 'ZARD';
+
+INSERT INTO "prefix_Metadata" ("key", "value", "note", "createdAt", "updatedAt")
+SELECT 'NEW_AGENT_WIZARD',
+       'MANGO_WIZARD',
+       'Controls the "new agent" flow. Allowed values: BOILERPLATE, WIZARD, MANGO_WIZARD.',
+       NOW(),
+       NOW()
+WHERE NOT EXISTS (SELECT 1 FROM "prefix_Metadata" WHERE "key" = 'NEW_AGENT_WIZARD');
+
+UPDATE "prefix_Metadata"
+SET "value" = CASE
+                  WHEN REPLACE(REPLACE(UPPER(TRIM(COALESCE("value", ''))), ' ', '_'), '-', '_') IN ('BOILERPLATE', 'WIZARD', 'MANGO_WIZARD')
+                      THEN REPLACE(REPLACE(UPPER(TRIM("value")), ' ', '_'), '-', '_')
+                  ELSE 'MANGO_WIZARD'
+              END,
+    "note" = 'Controls the "new agent" flow. Allowed values: BOILERPLATE, WIZARD, MANGO_WIZARD.',
+    "updatedAt" = NOW()
+WHERE "key" = 'NEW_AGENT_WIZARD';

package/apps/agents-server/src/database/migrations/2026-06-2201-new-agent-wizard-mango-default.sql

@@ -0,0 +1,11 @@
+UPDATE "prefix_Metadata"
+SET "value" = CASE
+                  WHEN REPLACE(REPLACE(UPPER(TRIM(COALESCE("value", ''))), ' ', '_'), '-', '_') = 'BOILERPLATE'
+                      THEN 'MANGO_WIZARD'
+                  WHEN REPLACE(REPLACE(UPPER(TRIM(COALESCE("value", ''))), ' ', '_'), '-', '_') IN ('WIZARD', 'MANGO_WIZARD')
+                      THEN REPLACE(REPLACE(UPPER(TRIM("value")), ' ', '_'), '-', '_')
+                  ELSE 'MANGO_WIZARD'
+              END,
+    "note" = 'Controls the "new agent" flow. Allowed values: BOILERPLATE, WIZARD, MANGO_WIZARD.',
+    "updatedAt" = NOW()
+WHERE "key" = 'NEW_AGENT_WIZARD';

package/apps/agents-server/src/generated/reservedPaths.ts

@@ -25,6 +25,8 @@ export const RESERVED_PATHS: readonly string[] = [
     "manifest.webmanifest",
     "openapi.json",
     "pixel-agents-assets",
+    "promptbook-logo-blue.png",
+    "promptbook-logo-white.png",
     "recycle-bin",
     "restricted",
     "robots.txt",

package/apps/agents-server/src/languages/translations/english.yaml

@@ -384,7 +384,7 @@ footer.logosAndBranding: Logos & Branding
 footer.connectSectionTitle: Connect
 footer.linksSectionTitle: Links
 footer.allRightsReserved: All rights reserved.
-footer.madeInCzechRepublic: Made with ❤️ in the Czech Republic
+footer.madeInCzechRepublic: Made with ❤️ in Europe
 footer.engineVersion: Promptbook engine version
 forbidden.title: 403 Forbidden
 forbidden.message: You do not have permission to access this page.

package/apps/agents-server/src/tools/createChatAttachmentToolFunctions.ts

@@ -460,7 +460,13 @@ function truncateAttachmentToolContent(content: string, warnings: string[]): str
     }
 
     warnings.push(`Returned content was truncated to ${MAX_ATTACHED_FILE_OUTPUT_CHARACTERS} characters.`);
-    return `${content.slice(0, MAX_ATTACHED_FILE_OUTPUT_CHARACTERS)}\n\n[...truncated...]`;
+    return spaceTrim(
+        (block) => `
+            ${block(content.slice(0, MAX_ATTACHED_FILE_OUTPUT_CHARACTERS))}
+
+            [...truncated...]
+        `,
+    );
 }
 
 /**
@@ -583,9 +589,7 @@ function normalizeBoundedInteger(
     }
 
     if (parsed < min || parsed > max) {
-        throw new LimitReachedError(
-            `Tool argument \`${fieldName}\` must be between \`${min}\` and \`${max}\`.`,
-        );
+        throw new LimitReachedError(`Tool argument \`${fieldName}\` must be between \`${min}\` and \`${max}\`.`);
     }
 
     return parsed;