@promptbook/remote-server 0.112.0-64 → 0.112.0-66

package/esm/index.es.js

@@ -1,4 +1,4 @@
-import { join, basename, dirname, isAbsolute } from 'path';
+import { posix, join, basename, dirname, isAbsolute } from 'path';
 import { spawn } from 'child_process';
 import colors from 'colors';
 import _spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
@@ -40,7 +40,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-64';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-66';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -959,6 +959,29 @@ function saturate(amount) {
 }
 // TODO: Maybe implement by mix+hsl
 
+/**
+ * Relative directory name without the `./` prefix for Git ignore rules and glob patterns.
+ *
+ * @private internal utility for Promptbook-owned temp files
+ */
+const PROMPTBOOK_TEMP_DIRECTORY_NAME = '.promptbook';
+/**
+ * Builds one project-relative path inside the shared Promptbook working directory.
+ *
+ * @private internal utility for Promptbook-owned temp files
+ */
+function getPromptbookTempPath(...pathSegments) {
+    return `./${getPromptbookTempPosixPath(...pathSegments)}`;
+}
+/**
+ * Builds one POSIX path fragment inside the shared Promptbook working directory for globs and generated text files.
+ *
+ * @private internal utility for Promptbook-owned temp files
+ */
+function getPromptbookTempPosixPath(...pathSegments) {
+    return posix.join(PROMPTBOOK_TEMP_DIRECTORY_NAME, ...pathSegments);
+}
+
 /**
  * Returns the same value that is passed as argument.
  * No side effects.
@@ -1149,7 +1172,6 @@ const DEFAULT_MAX_PARALLEL_COUNT = 5; // <- TODO: [🤹‍♂️]
  */
 const DEFAULT_MAX_EXECUTION_ATTEMPTS = 7; // <- TODO: [🤹‍♂️]
 // <- TODO: [🕝] Make also `AGENTS_DIRNAME_ALTERNATIVES`
-// TODO: Just `.promptbook` in config, hardcode subfolders like `download-cache` or `execution-cache`
 /**
  * Where to store the temporary downloads
  *
@@ -1157,7 +1179,15 @@ const DEFAULT_MAX_EXECUTION_ATTEMPTS = 7; // <- TODO: [🤹‍♂️]
  *
  * @public exported from `@promptbook/core`
  */
-const DEFAULT_DOWNLOAD_CACHE_DIRNAME = './.promptbook/download-cache';
+const DEFAULT_DOWNLOAD_CACHE_DIRNAME = getPromptbookTempPath('download-cache');
+/**
+ * Where to store the cache of executions for promptbook CLI
+ *
+ * Note: When the folder does not exist, it is created recursively
+ *
+ * @public exported from `@promptbook/core`
+ */
+getPromptbookTempPath('execution-cache');
 /**
  * Where to store the scrape cache
  *
@@ -1165,7 +1195,7 @@ const DEFAULT_DOWNLOAD_CACHE_DIRNAME = './.promptbook/download-cache';
  *
  * @public exported from `@promptbook/core`
  */
-const DEFAULT_SCRAPE_CACHE_DIRNAME = './.promptbook/scrape-cache';
+const DEFAULT_SCRAPE_CACHE_DIRNAME = getPromptbookTempPath('scrape-cache');
 // <- TODO: [🧜‍♂️]
 /**
  * Default settings for parsing and generating CSV files in Promptbook.
@@ -12679,18 +12709,6 @@ function parseDataUrlKnowledgeSource(source) {
 }
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
-/**
- * Name of the tool used by agents to search configured `KNOWLEDGE` sources.
- *
- * @public exported from `@promptbook/core`
- */
-const KNOWLEDGE_SEARCH_TOOL_NAME = 'knowledge_search';
-/**
- * Title of the system-message section generated for `KNOWLEDGE` commitments.
- *
- * @private constant of `KnowledgeCommitmentDefinition`
- */
-const KNOWLEDGE_SEARCH_SYSTEM_SECTION_TITLE = 'Knowledge Search';
 /**
  * KNOWLEDGE commitment definition
  *
@@ -12812,17 +12830,9 @@ class KnowledgeCommitmentDefinition extends BaseCommitmentDefinition {
             knowledgeInfoEntries.push(`Knowledge Source Inline: ${inlineSource.filename} (derived from inline content and processed for retrieval during chat)`);
         }
         if (knowledgeInfoEntries.length === 0) {
-            return addKnowledgeSearchToolAndSystemSection(nextRequirements);
+            return nextRequirements;
         }
-        return addKnowledgeSearchToolAndSystemSection(nextRequirements);
-    }
-    /**
-     * Gets human-readable titles for tool functions provided by this commitment.
-     */
-    getToolTitles() {
-        return {
-            [KNOWLEDGE_SEARCH_TOOL_NAME]: 'Knowledge search',
-        };
+        return this.appendToSystemMessage(nextRequirements, knowledgeInfoEntries.join('\n'), '\n\n');
     }
 }
 /**
@@ -12836,128 +12846,6 @@ function hasMeaningfulNonUrlText(content, urls) {
     const significantText = contentWithoutUrls.replace(/[\s.,!?;:'"`()[\]{}<>/-]+/g, '');
     return significantText.length > 0;
 }
-/**
- * Adds the shared `knowledge_search` tool definition and the consolidated system-message section.
- *
- * @param requirements - Requirements after one `KNOWLEDGE` commitment was applied.
- * @returns Requirements with the knowledge search instructions and tool definition.
- *
- * @private internal utility of `KnowledgeCommitmentDefinition`
- */
-function addKnowledgeSearchToolAndSystemSection(requirements) {
-    const nextRequirements = addKnowledgeSearchTool(requirements);
-    const section = createKnowledgeSearchSystemSection(nextRequirements);
-    const sectionHeader = `## ${KNOWLEDGE_SEARCH_SYSTEM_SECTION_TITLE}`;
-    if (nextRequirements.systemMessage.includes(sectionHeader)) {
-        return {
-            ...nextRequirements,
-            systemMessage: nextRequirements.systemMessage.replace(new RegExp(`## ${KNOWLEDGE_SEARCH_SYSTEM_SECTION_TITLE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?(?=\\n\\n##|$)`), section),
-        };
-    }
-    return {
-        ...nextRequirements,
-        systemMessage: nextRequirements.systemMessage.trim()
-            ? `${nextRequirements.systemMessage}\n\n${section}`
-            : section,
-    };
-}
-/**
- * Adds the `knowledge_search` model tool when it is not already present.
- *
- * @param requirements - Current model requirements.
- * @returns Requirements with the tool definition available to the model.
- *
- * @private internal utility of `KnowledgeCommitmentDefinition`
- */
-function addKnowledgeSearchTool(requirements) {
-    const existingTools = requirements.tools || [];
-    if (existingTools.some((tool) => tool.name === KNOWLEDGE_SEARCH_TOOL_NAME)) {
-        return requirements;
-    }
-    return {
-        ...requirements,
-        tools: [
-            ...existingTools,
-            {
-                name: KNOWLEDGE_SEARCH_TOOL_NAME,
-                description: spaceTrim$1(`
-                    Search the agent's configured knowledge sources and return relevant excerpts with citation ids.
-                    Use this before answering questions that may depend on the agent's KNOWLEDGE commitments.
-                `),
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        query: {
-                            type: 'string',
-                            description: 'The natural-language search query for the knowledge base.',
-                        },
-                        limit: {
-                            type: 'integer',
-                            description: 'Maximum number of matching source excerpts to return.',
-                        },
-                    },
-                    required: ['query'],
-                },
-            },
-        ],
-    };
-}
-/**
- * Creates the model-facing system-message section for knowledge search.
- *
- * @param requirements - Current model requirements.
- * @returns Markdown system-message section.
- *
- * @private internal utility of `KnowledgeCommitmentDefinition`
- */
-function createKnowledgeSearchSystemSection(requirements) {
-    const sourceEntries = createKnowledgeSourceSystemEntries(requirements);
-    const sourceList = sourceEntries.length > 0 ? sourceEntries.map((entry) => `-   ${entry}`).join('\n') : '-   None';
-    return spaceTrim$1(`
-        ## ${KNOWLEDGE_SEARCH_SYSTEM_SECTION_TITLE}
-
-        -   Use \`${KNOWLEDGE_SEARCH_TOOL_NAME}\` to search the configured knowledge sources before answering questions that depend on this agent's knowledge base.
-        -   Base source-backed factual answers on the returned excerpts.
-        -   When you use a returned excerpt, include its citation marker in the answer body, for example \`[0:0]\`.
-        -   If the search returns no relevant information, say that the knowledge base did not contain the answer instead of inventing it.
-
-        Configured knowledge sources:
-        ${sourceList}
-    `);
-}
-/**
- * Builds a stable list of configured knowledge sources for system-message diagnostics.
- *
- * @param requirements - Current model requirements.
- * @returns Human-readable source entries.
- *
- * @private internal utility of `KnowledgeCommitmentDefinition`
- */
-function createKnowledgeSourceSystemEntries(requirements) {
-    var _a;
-    const entries = [];
-    const seenEntries = new Set();
-    for (const source of requirements.knowledgeSources || []) {
-        const entry = `Source URL: ${source} (processed for retrieval during chat)`;
-        if (seenEntries.has(entry)) {
-            continue;
-        }
-        seenEntries.add(entry);
-        entries.push(entry);
-    }
-    const inlineSources = (((_a = requirements._metadata) === null || _a === void 0 ? void 0 : _a.inlineKnowledgeSources) || [])
-        .map((source) => source.filename)
-        .filter(Boolean);
-    for (const filename of inlineSources) {
-        const entry = `Knowledge Source Inline: ${filename} (Inline source: processed for retrieval during chat)`;
-        if (seenEntries.has(entry)) {
-            continue;
-        }
-        seenEntries.add(entry);
-        entries.push(entry);
-    }
-    return entries;
-}
 
 /**
  * LANGUAGE commitment definition
@@ -15609,6 +15497,177 @@ function drawFractalCore(context, size, palette, timeMs, corePhase) {
     context.restore();
 }
 
+/* eslint-disable no-magic-numbers */
+/**
+ * Builds the seeded six-face texture pack used by the Minecraft-style head cuboid.
+ *
+ * @param random Seeded random generator.
+ * @param palette Derived avatar palette.
+ * @param hasHeadband Whether the generated avatar should include a colored headband.
+ * @returns Head cuboid textures.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function createMinecraftHeadTextures(random, palette, hasHeadband) {
+    const faceTexture = createMinecraftFaceTexture(random, palette, hasHeadband);
+    const hairColor = random() < 0.5 ? palette.primary : palette.secondary;
+    const skinColor = palette.highlight;
+    const headbandColor = hasHeadband ? palette.accent : hairColor;
+    const sideTexture = createFilledTexture(skinColor);
+    const backTexture = createFilledTexture(skinColor);
+    const topTexture = createFilledTexture(hairColor);
+    const bottomTexture = createFilledTexture(`${palette.shadow}cc`);
+    fillTextureRect(sideTexture, 0, 0, 8, 3, hairColor);
+    fillTextureRect(backTexture, 0, 0, 8, 5, hairColor);
+    fillTextureRect(backTexture, 1, 5, 6, 1, hairColor);
+    if (hasHeadband) {
+        fillTextureRect(sideTexture, 0, 2, 8, 1, headbandColor);
+        fillTextureRect(backTexture, 0, 2, 8, 1, headbandColor);
+        fillTextureRect(topTexture, 0, 4, 8, 1, headbandColor);
+    }
+    sideTexture[4][4] = `${palette.shadow}99`;
+    sideTexture[5][4] = `${palette.shadow}cc`;
+    backTexture[6][2] = `${palette.shadow}99`;
+    backTexture[6][5] = `${palette.shadow}99`;
+    return {
+        front: faceTexture,
+        back: backTexture,
+        left: sideTexture,
+        right: mirrorMinecraftTexture(sideTexture),
+        top: topTexture,
+        bottom: bottomTexture,
+    };
+}
+/**
+ * Builds the seeded six-face texture pack used by the Minecraft-style torso cuboid.
+ *
+ * @param random Seeded random generator.
+ * @param palette Derived avatar palette.
+ * @returns Torso cuboid textures.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function createMinecraftTorsoTextures(random, palette) {
+    const frontTexture = createMinecraftShirtTexture(random, palette);
+    const sideTexture = createFilledTexture(palette.primary);
+    const backTexture = createFilledTexture(palette.primary);
+    const topTexture = createFilledTexture(`${palette.highlight}dd`);
+    const bottomTexture = createFilledTexture(`${palette.shadow}dd`);
+    const stripeColor = random() < 0.5 ? palette.secondary : palette.highlight;
+    fillTextureRect(sideTexture, 0, 0, 8, 2, palette.shadow);
+    fillTextureRect(backTexture, 0, 0, 8, 2, palette.shadow);
+    fillTextureRect(backTexture, 3, 2, 2, 6, stripeColor);
+    fillTextureRect(sideTexture, 4, 2, 1, 6, stripeColor);
+    fillTextureRect(topTexture, 0, 0, 8, 2, palette.shadow);
+    fillTextureRect(topTexture, 2, 2, 4, 4, stripeColor);
+    return {
+        front: frontTexture,
+        back: backTexture,
+        left: sideTexture,
+        right: mirrorMinecraftTexture(sideTexture),
+        top: topTexture,
+        bottom: bottomTexture,
+    };
+}
+/**
+ * Mirrors one Minecraft texture horizontally.
+ *
+ * @param texture Source texture.
+ * @returns Mirrored texture copy.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function mirrorMinecraftTexture(texture) {
+    return texture.map((row) => [...row].reverse());
+}
+/**
+ * Creates the front-face pixel texture for the cube head.
+ *
+ * @param random Seeded random generator.
+ * @param palette Derived avatar palette.
+ * @param hasHeadband Whether the avatar should render a headband row.
+ * @returns 8x8 pixel texture.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function createMinecraftFaceTexture(random, palette, hasHeadband) {
+    const texture = createFilledTexture(palette.highlight);
+    const hairlineColor = random() < 0.5 ? palette.primary : palette.secondary;
+    const cheekColor = random() < 0.5 ? `${palette.accent}bb` : `${palette.secondary}bb`;
+    fillTextureRect(texture, 0, 0, 8, 2, hairlineColor);
+    texture[2][0] = hairlineColor;
+    texture[2][7] = hairlineColor;
+    texture[3][0] = hairlineColor;
+    texture[3][7] = hairlineColor;
+    if (hasHeadband) {
+        fillTextureRect(texture, 0, 2, 8, 1, palette.accent);
+    }
+    texture[3][2] = palette.ink;
+    texture[3][5] = palette.ink;
+    texture[4][2] = '#ffffff';
+    texture[4][5] = '#ffffff';
+    texture[5][1] = cheekColor;
+    texture[5][6] = cheekColor;
+    texture[5][3] = palette.shadow;
+    texture[5][4] = palette.shadow;
+    texture[6][3] = palette.shadow;
+    texture[6][4] = palette.shadow;
+    return texture;
+}
+/**
+ * Creates the front-face pixel texture for the torso.
+ *
+ * @param random Seeded random generator.
+ * @param palette Derived avatar palette.
+ * @returns 8x8 torso texture.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function createMinecraftShirtTexture(random, palette) {
+    const texture = createFilledTexture(palette.primary);
+    const stripeColor = random() < 0.5 ? palette.secondary : palette.highlight;
+    fillTextureRect(texture, 0, 0, 8, 2, palette.shadow);
+    for (let rowIndex = 2; rowIndex < 8; rowIndex++) {
+        texture[rowIndex][3] = stripeColor;
+        texture[rowIndex][4] = stripeColor;
+    }
+    texture[4][1] = palette.accent;
+    texture[4][6] = palette.accent;
+    texture[5][2] = palette.highlight;
+    texture[5][5] = palette.highlight;
+    return texture;
+}
+/**
+ * Creates one solid-color 8x8 Minecraft texture.
+ *
+ * @param color Fill color.
+ * @returns Filled 8x8 texture.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function createFilledTexture(color) {
+    return Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => color));
+}
+/**
+ * Fills one rectangular area inside a mutable Minecraft texture.
+ *
+ * @param texture Mutable target texture.
+ * @param x Left texture coordinate.
+ * @param y Top texture coordinate.
+ * @param width Rectangle width.
+ * @param height Rectangle height.
+ * @param color Fill color.
+ *
+ * @private helper of the Minecraft avatar visuals
+ */
+function fillTextureRect(texture, x, y, width, height, color) {
+    for (let rowIndex = y; rowIndex < y + height; rowIndex++) {
+        for (let columnIndex = x; columnIndex < x + width; columnIndex++) {
+            texture[rowIndex][columnIndex] = color;
+        }
+    }
+}
+
 /* eslint-disable no-magic-numbers */
 /**
  * Minecraft-style 3D avatar visual.
@@ -15633,8 +15692,8 @@ const minecraftAvatarVisual = {
         const bodyX = size * 0.33;
         const bodyY = headY + headSize * 0.96;
         const hasHeadband = random() < 0.5;
-        const faceTexture = createMinecraftFaceTexture(createRandom('minecraft-face'), palette, hasHeadband);
-        const shirtTexture = createMinecraftShirtTexture(createRandom('minecraft-shirt'), palette);
+        const headTextures = createMinecraftHeadTextures(createRandom('minecraft-face'), palette, hasHeadband);
+        const torsoTextures = createMinecraftTorsoTextures(createRandom('minecraft-shirt'), palette);
         drawAvatarFrame(context, size, palette);
         const spotlight = context.createRadialGradient(size * 0.5, size * 0.18, size * 0.05, size * 0.5, size * 0.18, size * 0.5);
         spotlight.addColorStop(0, `${palette.highlight}66`);
@@ -15654,7 +15713,7 @@ const minecraftAvatarVisual = {
             width: bodyWidth,
             height: bodyHeight,
             depth: bodyDepth,
-            frontTexture: shirtTexture,
+            frontTexture: torsoTextures.front,
             topColor: `${palette.highlight}cc`,
             sideColor: `${palette.secondary}dd`,
             outlineColor: `${palette.shadow}aa`,
@@ -15665,7 +15724,7 @@ const minecraftAvatarVisual = {
             width: headSize,
             height: headSize,
             depth,
-            frontTexture: faceTexture,
+            frontTexture: headTextures.front,
             topColor: `${palette.highlight}ee`,
             sideColor: `${palette.secondary}ee`,
             outlineColor: `${palette.shadow}cc`,
@@ -15730,72 +15789,505 @@ function drawVoxelCuboid(context, cuboid) {
     context.closePath();
     context.stroke();
 }
+
+/* eslint-disable no-magic-numbers */
 /**
- * Creates the front-face pixel texture for the cube head.
+ * Fixed scene camera distance used for the proper-3D projection.
  *
- * @param random Seeded random generator.
+ * @private helper of `minecraft2AvatarVisual`
+ */
+const CAMERA_DISTANCE_RATIO = 1.4;
+/**
+ * Shared light direction used to shade projected cuboid faces.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+const LIGHT_DIRECTION = normalizeVector3({
+    x: 0.4,
+    y: -0.65,
+    z: 0.92,
+});
+/**
+ * Minecraft 3D 2 avatar visual.
+ *
+ * @private built-in avatar visual
+ */
+const minecraft2AvatarVisual = {
+    id: 'minecraft2',
+    title: 'Minecraft 3D 2',
+    description: 'Proper 3D Minecraft-style portrait with textured cuboids and pointer-driven head turns.',
+    isAnimated: true,
+    supportsPointerTracking: true,
+    render({ context, size, palette, createRandom, timeMs, interaction }) {
+        const spotlightY = size * 0.22;
+        const headRandom = createRandom('minecraft2-head');
+        const hasHeadband = headRandom() < 0.5;
+        const headTextures = createMinecraftHeadTextures(createRandom('minecraft2-head-textures'), palette, hasHeadband);
+        const torsoTextures = createMinecraftTorsoTextures(createRandom('minecraft2-body-textures'), palette);
+        const bob = Math.sin(timeMs / 880) * size * 0.014;
+        const bodyYaw = -0.24 + Math.sin(timeMs / 2300) * 0.06 + interaction.bodyOffsetX * 0.16;
+        const bodyPitch = -0.12 + Math.cos(timeMs / 2800) * 0.02 - interaction.bodyOffsetY * 0.06;
+        const headYaw = -0.18 + Math.sin(timeMs / 1900 + 0.6) * 0.05 + interaction.gazeX * 0.62;
+        const headPitch = -0.12 + Math.cos(timeMs / 2400 + 1.1) * 0.03 - interaction.gazeY * 0.38;
+        const sceneCenterX = size * 0.5;
+        const sceneCenterY = size * 0.57;
+        const bodyWidth = size * 0.225;
+        const bodyHeight = size * 0.245;
+        const bodyDepth = size * 0.145;
+        const headSize = size * 0.24;
+        const headLift = size * 0.205;
+        const headForwardShift = interaction.intensity * size * 0.018;
+        const sceneCuboids = [
+            {
+                center: {
+                    x: interaction.bodyOffsetX * size * 0.026,
+                    y: size * 0.05 + interaction.bodyOffsetY * size * 0.018 + bob,
+                    z: 0,
+                },
+                width: bodyWidth,
+                height: bodyHeight,
+                depth: bodyDepth,
+                rotationX: bodyPitch,
+                rotationY: bodyYaw,
+                textures: torsoTextures,
+                outlineColor: `${palette.shadow}cc`,
+            },
+            {
+                center: {
+                    x: interaction.bodyOffsetX * size * 0.018 + interaction.gazeX * size * 0.016,
+                    y: -headLift + bob * 1.15,
+                    z: headForwardShift,
+                },
+                width: headSize,
+                height: headSize,
+                depth: headSize,
+                rotationX: headPitch,
+                rotationY: headYaw,
+                textures: headTextures,
+                outlineColor: `${palette.shadow}dd`,
+            },
+        ];
+        const visibleFaces = sceneCuboids
+            .flatMap((cuboid) => resolveVisibleCuboidFaces(cuboid, size, sceneCenterX, sceneCenterY))
+            .sort((firstFace, secondFace) => firstFace.averageDepth - secondFace.averageDepth);
+        drawAvatarFrame(context, size, palette);
+        drawMinecraftBackdrop(context, size, palette, sceneCenterX, spotlightY, interaction, timeMs);
+        drawMinecraftShadow(context, size, palette, interaction, timeMs);
+        for (const visibleFace of visibleFaces) {
+            drawTexturedProjectedFace(context, visibleFace);
+        }
+    },
+};
+/**
+ * Draws the shared background atmosphere behind the Minecraft 3D 2 portrait.
+ *
+ * @param context Canvas 2D context.
+ * @param size Canvas size in CSS pixels.
  * @param palette Derived avatar palette.
- * @param hasHeadband Whether the avatar should render a headband row.
- * @returns 8x8 pixel texture.
+ * @param sceneCenterX Horizontal scene center.
+ * @param spotlightY Vertical spotlight anchor.
+ * @param interaction Smoothed pointer-aware interaction state.
+ * @param timeMs Current animation time in milliseconds.
  *
- * @private helper of `minecraftAvatarVisual`
+ * @private helper of `minecraft2AvatarVisual`
  */
-function createMinecraftFaceTexture(random, palette, hasHeadband) {
-    const texture = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => palette.highlight));
-    const hairlineColor = random() < 0.5 ? palette.primary : palette.secondary;
-    const cheekColor = random() < 0.5 ? `${palette.accent}bb` : `${palette.secondary}bb`;
-    for (let rowIndex = 0; rowIndex < 2; rowIndex++) {
-        for (let columnIndex = 0; columnIndex < 8; columnIndex++) {
-            texture[rowIndex][columnIndex] = hairlineColor;
+function drawMinecraftBackdrop(context, size, palette, sceneCenterX, spotlightY, interaction, timeMs) {
+    const spotlightGradient = context.createRadialGradient(sceneCenterX + interaction.gazeX * size * 0.08, spotlightY + interaction.gazeY * size * 0.05, size * 0.03, sceneCenterX, spotlightY, size * 0.52);
+    spotlightGradient.addColorStop(0, `${palette.highlight}66`);
+    spotlightGradient.addColorStop(0.42, `${palette.accent}1d`);
+    spotlightGradient.addColorStop(1, `${palette.highlight}00`);
+    context.fillStyle = spotlightGradient;
+    context.fillRect(0, 0, size, size);
+    const rimGradient = context.createLinearGradient(0, size * 0.14, 0, size * 0.92);
+    rimGradient.addColorStop(0, `${palette.highlight}12`);
+    rimGradient.addColorStop(0.55, `${palette.secondary}0a`);
+    rimGradient.addColorStop(1, `${palette.shadow}00`);
+    context.fillStyle = rimGradient;
+    context.fillRect(0, 0, size, size);
+    context.save();
+    context.globalAlpha = 0.08 + interaction.intensity * 0.04;
+    context.fillStyle = palette.highlight;
+    context.beginPath();
+    context.arc(size * 0.72 + Math.sin(timeMs / 1600) * size * 0.03, size * 0.2 + Math.cos(timeMs / 1400) * size * 0.018, size * 0.025, 0, Math.PI * 2);
+    context.fill();
+    context.restore();
+}
+/**
+ * Draws the soft floor shadow used to anchor the cuboids in the frame.
+ *
+ * @param context Canvas 2D context.
+ * @param size Canvas size in CSS pixels.
+ * @param palette Derived avatar palette.
+ * @param interaction Smoothed pointer-aware interaction state.
+ * @param timeMs Current animation time in milliseconds.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function drawMinecraftShadow(context, size, palette, interaction, timeMs) {
+    context.save();
+    context.fillStyle = `${palette.shadow}66`;
+    context.filter = `blur(${size * 0.02}px)`;
+    context.beginPath();
+    context.ellipse(size * 0.5 + interaction.gazeX * size * 0.03, size * 0.85 + Math.sin(timeMs / 880) * size * 0.01, size * (0.16 + interaction.intensity * 0.015), size * 0.055, 0, 0, Math.PI * 2);
+    context.fill();
+    context.restore();
+}
+/**
+ * Resolves all visible projected faces for one scene cuboid.
+ *
+ * @param cuboid Scene cuboid definition.
+ * @param size Canvas size in CSS pixels.
+ * @param sceneCenterX Horizontal scene center.
+ * @param sceneCenterY Vertical scene center.
+ * @returns Visible faces sorted later by depth.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function resolveVisibleCuboidFaces(cuboid, size, sceneCenterX, sceneCenterY) {
+    const halfWidth = cuboid.width / 2;
+    const halfHeight = cuboid.height / 2;
+    const halfDepth = cuboid.depth / 2;
+    const faceDefinitions = [
+        {
+            texture: cuboid.textures.front,
+            corners: [
+                { x: -halfWidth, y: -halfHeight, z: halfDepth },
+                { x: halfWidth, y: -halfHeight, z: halfDepth },
+                { x: halfWidth, y: halfHeight, z: halfDepth },
+                { x: -halfWidth, y: halfHeight, z: halfDepth },
+            ],
+        },
+        {
+            texture: cuboid.textures.back,
+            corners: [
+                { x: halfWidth, y: -halfHeight, z: -halfDepth },
+                { x: -halfWidth, y: -halfHeight, z: -halfDepth },
+                { x: -halfWidth, y: halfHeight, z: -halfDepth },
+                { x: halfWidth, y: halfHeight, z: -halfDepth },
+            ],
+        },
+        {
+            texture: cuboid.textures.right,
+            corners: [
+                { x: halfWidth, y: -halfHeight, z: halfDepth },
+                { x: halfWidth, y: -halfHeight, z: -halfDepth },
+                { x: halfWidth, y: halfHeight, z: -halfDepth },
+                { x: halfWidth, y: halfHeight, z: halfDepth },
+            ],
+        },
+        {
+            texture: cuboid.textures.left,
+            corners: [
+                { x: -halfWidth, y: -halfHeight, z: -halfDepth },
+                { x: -halfWidth, y: -halfHeight, z: halfDepth },
+                { x: -halfWidth, y: halfHeight, z: halfDepth },
+                { x: -halfWidth, y: halfHeight, z: -halfDepth },
+            ],
+        },
+        {
+            texture: cuboid.textures.top,
+            corners: [
+                { x: -halfWidth, y: -halfHeight, z: -halfDepth },
+                { x: halfWidth, y: -halfHeight, z: -halfDepth },
+                { x: halfWidth, y: -halfHeight, z: halfDepth },
+                { x: -halfWidth, y: -halfHeight, z: halfDepth },
+            ],
+        },
+        {
+            texture: cuboid.textures.bottom,
+            corners: [
+                { x: -halfWidth, y: halfHeight, z: halfDepth },
+                { x: halfWidth, y: halfHeight, z: halfDepth },
+                { x: halfWidth, y: halfHeight, z: -halfDepth },
+                { x: -halfWidth, y: halfHeight, z: -halfDepth },
+            ],
+        },
+    ];
+    const visibleFaces = faceDefinitions
+        .map((faceDefinition) => {
+        const transformedCorners = faceDefinition.corners.map((corner) => transformScenePoint(corner, cuboid.center, cuboid.rotationX, cuboid.rotationY));
+        const faceNormal = normalizeVector3(crossProduct3D(subtractPoint3D(transformedCorners[1], transformedCorners[0]), subtractPoint3D(transformedCorners[2], transformedCorners[0])));
+        if (faceNormal.z <= 0.02) {
+            return null;
         }
+        const projectedCorners = transformedCorners.map((corner) => projectScenePoint(corner, size, sceneCenterX, sceneCenterY));
+        return {
+            corners: projectedCorners,
+            texture: faceDefinition.texture,
+            averageDepth: transformedCorners.reduce((depthSum, corner) => depthSum + corner.z, 0) / transformedCorners.length,
+            lightIntensity: clampNumber$1(dotProduct3D(faceNormal, LIGHT_DIRECTION), -1, 1),
+            outlineColor: cuboid.outlineColor,
+        };
+    });
+    return visibleFaces.filter((visibleFace) => visibleFace !== null);
+}
+/**
+ * Draws one projected textured face by tessellating its texture cells into quads.
+ *
+ * @param context Canvas 2D context.
+ * @param face Visible projected face.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function drawTexturedProjectedFace(context, face) {
+    var _a;
+    const rows = face.texture.length;
+    const columns = ((_a = face.texture[0]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    if (rows === 0 || columns === 0) {
+        return;
     }
-    texture[2][0] = hairlineColor;
-    texture[2][7] = hairlineColor;
-    texture[3][0] = hairlineColor;
-    texture[3][7] = hairlineColor;
-    if (hasHeadband) {
-        for (let columnIndex = 0; columnIndex < 8; columnIndex++) {
-            texture[2][columnIndex] = palette.accent;
+    for (let rowIndex = 0; rowIndex < rows; rowIndex++) {
+        for (let columnIndex = 0; columnIndex < columns; columnIndex++) {
+            const startX = columnIndex / columns;
+            const endX = (columnIndex + 1) / columns;
+            const startY = rowIndex / rows;
+            const endY = (rowIndex + 1) / rows;
+            drawProjectedQuad(context, [
+                interpolateProjectedQuad(face.corners, startX, startY),
+                interpolateProjectedQuad(face.corners, endX, startY),
+                interpolateProjectedQuad(face.corners, endX, endY),
+                interpolateProjectedQuad(face.corners, startX, endY),
+            ], face.texture[rowIndex][columnIndex]);
         }
     }
-    texture[3][2] = palette.ink;
-    texture[3][5] = palette.ink;
-    texture[4][2] = '#ffffff';
-    texture[4][5] = '#ffffff';
-    texture[5][1] = cheekColor;
-    texture[5][6] = cheekColor;
-    texture[5][3] = palette.shadow;
-    texture[5][4] = palette.shadow;
-    texture[6][3] = palette.shadow;
-    texture[6][4] = palette.shadow;
-    return texture;
+    if (face.lightIntensity > 0) {
+        drawProjectedQuad(context, face.corners, `rgba(255, 255, 255, ${0.15 * face.lightIntensity})`);
+    }
+    else if (face.lightIntensity < 0) {
+        drawProjectedQuad(context, face.corners, `rgba(0, 0, 0, ${0.22 * Math.abs(face.lightIntensity)})`);
+    }
+    context.save();
+    context.beginPath();
+    context.moveTo(face.corners[0].x, face.corners[0].y);
+    for (let cornerIndex = 1; cornerIndex < face.corners.length; cornerIndex++) {
+        context.lineTo(face.corners[cornerIndex].x, face.corners[cornerIndex].y);
+    }
+    context.closePath();
+    context.strokeStyle = face.outlineColor;
+    context.lineWidth = Math.max(1.1, getProjectedQuadPerimeter(face.corners) * 0.0045);
+    context.lineJoin = 'round';
+    context.stroke();
+    context.restore();
 }
 /**
- * Creates the front-face pixel texture for the torso.
+ * Draws one filled projected quad.
  *
- * @param random Seeded random generator.
- * @param palette Derived avatar palette.
- * @returns 8x8 torso texture.
+ * @param context Canvas 2D context.
+ * @param corners Quad corners in clockwise order.
+ * @param fillStyle CSS fill style.
  *
- * @private helper of `minecraftAvatarVisual`
+ * @private helper of `minecraft2AvatarVisual`
  */
-function createMinecraftShirtTexture(random, palette) {
-    const texture = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => palette.primary));
-    const stripeColor = random() < 0.5 ? palette.secondary : palette.highlight;
-    for (let rowIndex = 0; rowIndex < 2; rowIndex++) {
-        for (let columnIndex = 0; columnIndex < 8; columnIndex++) {
-            texture[rowIndex][columnIndex] = palette.shadow;
-        }
+function drawProjectedQuad(context, corners, fillStyle) {
+    context.beginPath();
+    context.moveTo(corners[0].x, corners[0].y);
+    context.lineTo(corners[1].x, corners[1].y);
+    context.lineTo(corners[2].x, corners[2].y);
+    context.lineTo(corners[3].x, corners[3].y);
+    context.closePath();
+    context.fillStyle = fillStyle;
+    context.fill();
+}
+/**
+ * Interpolates one point inside a projected quad across both quad axes.
+ *
+ * @param corners Quad corners in clockwise order.
+ * @param horizontalRatio Horizontal ratio in the range `[0, 1]`.
+ * @param verticalRatio Vertical ratio in the range `[0, 1]`.
+ * @returns Interpolated projected point.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function interpolateProjectedQuad(corners, horizontalRatio, verticalRatio) {
+    const topPoint = interpolateProjectedPoint(corners[0], corners[1], horizontalRatio);
+    const bottomPoint = interpolateProjectedPoint(corners[3], corners[2], horizontalRatio);
+    return interpolateProjectedPoint(topPoint, bottomPoint, verticalRatio);
+}
+/**
+ * Interpolates between two projected points.
+ *
+ * @param startPoint Start point.
+ * @param endPoint End point.
+ * @param ratio Interpolation ratio in the range `[0, 1]`.
+ * @returns Interpolated projected point.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function interpolateProjectedPoint(startPoint, endPoint, ratio) {
+    return {
+        x: startPoint.x + (endPoint.x - startPoint.x) * ratio,
+        y: startPoint.y + (endPoint.y - startPoint.y) * ratio,
+        z: startPoint.z + (endPoint.z - startPoint.z) * ratio,
+    };
+}
+/**
+ * Projects one rotated scene point into canvas coordinates.
+ *
+ * @param point Scene point.
+ * @param size Canvas size in CSS pixels.
+ * @param sceneCenterX Horizontal scene center.
+ * @param sceneCenterY Vertical scene center.
+ * @returns Projected point.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function projectScenePoint(point, size, sceneCenterX, sceneCenterY) {
+    const cameraDistance = size * CAMERA_DISTANCE_RATIO;
+    const perspectiveScale = cameraDistance / Math.max(cameraDistance - point.z, cameraDistance * 0.35);
+    return {
+        x: sceneCenterX + point.x * perspectiveScale,
+        y: sceneCenterY + point.y * perspectiveScale,
+        z: point.z,
+    };
+}
+/**
+ * Applies the local cuboid rotations and translation to one scene point.
+ *
+ * @param localPoint Point in cuboid-local space.
+ * @param center Cuboid center in scene space.
+ * @param rotationX Cuboid pitch in radians.
+ * @param rotationY Cuboid yaw in radians.
+ * @returns Transformed scene-space point.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function transformScenePoint(localPoint, center, rotationX, rotationY) {
+    const yawedPoint = rotatePointAroundY(localPoint, rotationY);
+    const pitchedPoint = rotatePointAroundX(yawedPoint, rotationX);
+    return {
+        x: center.x + pitchedPoint.x,
+        y: center.y + pitchedPoint.y,
+        z: center.z + pitchedPoint.z,
+    };
+}
+/**
+ * Rotates one point around the local Y axis.
+ *
+ * @param point Source point.
+ * @param angle Rotation angle in radians.
+ * @returns Rotated point.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function rotatePointAroundY(point, angle) {
+    const cosine = Math.cos(angle);
+    const sine = Math.sin(angle);
+    return {
+        x: point.x * cosine + point.z * sine,
+        y: point.y,
+        z: -point.x * sine + point.z * cosine,
+    };
+}
+/**
+ * Rotates one point around the local X axis.
+ *
+ * @param point Source point.
+ * @param angle Rotation angle in radians.
+ * @returns Rotated point.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function rotatePointAroundX(point, angle) {
+    const cosine = Math.cos(angle);
+    const sine = Math.sin(angle);
+    return {
+        x: point.x,
+        y: point.y * cosine - point.z * sine,
+        z: point.y * sine + point.z * cosine,
+    };
+}
+/**
+ * Subtracts one 3D point from another.
+ *
+ * @param leftPoint Left point.
+ * @param rightPoint Right point.
+ * @returns Difference vector.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function subtractPoint3D(leftPoint, rightPoint) {
+    return {
+        x: leftPoint.x - rightPoint.x,
+        y: leftPoint.y - rightPoint.y,
+        z: leftPoint.z - rightPoint.z,
+    };
+}
+/**
+ * Computes the 3D cross product of two vectors.
+ *
+ * @param leftVector Left vector.
+ * @param rightVector Right vector.
+ * @returns Cross product.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function crossProduct3D(leftVector, rightVector) {
+    return {
+        x: leftVector.y * rightVector.z - leftVector.z * rightVector.y,
+        y: leftVector.z * rightVector.x - leftVector.x * rightVector.z,
+        z: leftVector.x * rightVector.y - leftVector.y * rightVector.x,
+    };
+}
+/**
+ * Computes the 3D dot product of two vectors.
+ *
+ * @param leftVector Left vector.
+ * @param rightVector Right vector.
+ * @returns Dot product.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function dotProduct3D(leftVector, rightVector) {
+    return leftVector.x * rightVector.x + leftVector.y * rightVector.y + leftVector.z * rightVector.z;
+}
+/**
+ * Normalizes one 3D vector while keeping zero vectors stable.
+ *
+ * @param vector Source vector.
+ * @returns Normalized vector.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function normalizeVector3(vector) {
+    const length = Math.hypot(vector.x, vector.y, vector.z);
+    if (length === 0) {
+        return vector;
     }
-    for (let rowIndex = 2; rowIndex < 8; rowIndex++) {
-        texture[rowIndex][3] = stripeColor;
-        texture[rowIndex][4] = stripeColor;
+    return {
+        x: vector.x / length,
+        y: vector.y / length,
+        z: vector.z / length,
+    };
+}
+/**
+ * Clamps one number into the provided range.
+ *
+ * @param value Input value.
+ * @param minimumValue Inclusive lower bound.
+ * @param maximumValue Inclusive upper bound.
+ * @returns Clamped value.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function clampNumber$1(value, minimumValue, maximumValue) {
+    return Math.min(maximumValue, Math.max(minimumValue, value));
+}
+/**
+ * Measures the perimeter of one projected quad.
+ *
+ * @param corners Quad corners.
+ * @returns Perimeter length.
+ *
+ * @private helper of `minecraft2AvatarVisual`
+ */
+function getProjectedQuadPerimeter(corners) {
+    let perimeter = 0;
+    for (let cornerIndex = 0; cornerIndex < corners.length; cornerIndex++) {
+        const currentCorner = corners[cornerIndex];
+        const nextCorner = corners[(cornerIndex + 1) % corners.length];
+        perimeter += Math.hypot(nextCorner.x - currentCorner.x, nextCorner.y - currentCorner.y);
     }
-    texture[4][1] = palette.accent;
-    texture[4][6] = palette.accent;
-    texture[5][2] = palette.highlight;
-    texture[5][5] = palette.highlight;
-    return texture;
+    return perimeter;
 }
 
 /* eslint-disable no-magic-numbers */
@@ -17400,6 +17892,7 @@ const AVATAR_VISUALS = [
     octopus3AvatarVisual,
     asciiOctopusAvatarVisual,
     minecraftAvatarVisual,
+    minecraft2AvatarVisual,
     fractalAvatarVisual,
     orbAvatarVisual,
 ];
@@ -18702,7 +19195,11 @@ class PersonaCommitmentDefinition extends BaseCommitmentDefinition {
         // Create new system message with persona at the beginning
         // Format: "You are {agentName}\n{personaContent}"
         // The # PERSONA comment will be removed later by removeCommentsFromSystemMessage
-        const personaSection = `# PERSONA\nYou are ${agentName}\n${mergedPersonaContent}`; // <- TODO: Use spaceTrim
+        const personaSection = spaceTrim$1((block) => `
+                # PERSONA
+                You are ${agentName}
+                ${block(mergedPersonaContent)}
+            `);
         const newSystemMessage = cleanedMessage ? `${personaSection}\n\n${cleanedMessage}` : personaSection;
         return {
             ...requirements,
@@ -19604,7 +20101,10 @@ function buildTeamSystemMessageBody(teamEntries) {
  */
 function buildTeamToolDescription(entry) {
     const detailLines = collectTeamEntryDetails(entry).map(({ label, content }) => `${label}: ${content}`);
-    return [`Consult teammate ${entry.teammate.label}`, ...detailLines].join('\n');
+    return spaceTrim$1((block) => `
+            Consult teammate ${entry.teammate.label}
+            ${block(detailLines.join('\n'))}
+        `);
 }
 /**
  * Collects structured teammate details that should stay visible to the model.
@@ -25101,7 +25601,10 @@ function createListedTimeoutsAssistantMessage(options) {
     if (hiddenCount > 0) {
         summaryRows.push(`...and ${hiddenCount} more.`);
     }
-    return [`Found ${options.total} ${options.total === 1 ? 'timeout' : 'timeouts'}:`, ...summaryRows].join('\n');
+    return spaceTrim$1((block) => `
+            Found ${options.total} ${options.total === 1 ? 'timeout' : 'timeouts'}:
+            ${block(summaryRows.join('\n'))}
+        `);
 }
 /**
  * Formats one timeout row for assistant-visible timeout listings.
@@ -28070,8 +28573,10 @@ async function renderMarkdownServerIndex(runtime) {
             **Application mode:** ${serverInfo.isApplicationModeAllowed ? 'enabled' : 'disabled'}
             ${block(!runtime.configuration.isApplicationModeAllowed || runtime.configuration.collection === null
         ? ''
-        : '**Pipelines in collection:**\n' +
-            serverInfo.pipelines.map((pipelineUrl) => `- ${pipelineUrl}`).join('\n'))}
+        : spaceTrim$1((nestedBlock) => `
+                              **Pipelines in collection:**
+                              ${nestedBlock(serverInfo.pipelines.map((pipelineUrl) => `- ${pipelineUrl}`).join('\n'))}
+                          `))}
             **Running executions:** ${serverInfo.runningExecutions}
 
             ---
@@ -31065,11 +31570,11 @@ function formatChatAttachmentContext(attachments) {
     if (attachments.length === 0) {
         return '';
     }
-    return [
-        CHAT_ATTACHMENTS_HEADING,
-        ...attachments.map((attachment) => formatChatAttachmentLine(attachment)),
-        CHAT_ATTACHMENTS_INSTRUCTION,
-    ].join('\n');
+    return spaceTrim$1((block) => `
+            ${CHAT_ATTACHMENTS_HEADING}
+            ${block(attachments.map((attachment) => formatChatAttachmentLine(attachment)).join('\n'))}
+            ${CHAT_ATTACHMENTS_INSTRUCTION}
+        `);
 }
 
 /**
@@ -31310,24 +31815,24 @@ function formatResolvedChatAttachmentContent(contentResolution) {
             : ''}`
         : null;
     const warningsLine = contentResolution.warnings.length > 0 ? `Warnings: ${contentResolution.warnings.join(' | ')}` : null;
-    if (!contentResolution.content) {
+    const metadataLines = [decodingLine, warningsLine].filter((line) => Boolean(line)).join('\n');
+    const resolvedContent = contentResolution.content;
+    if (!resolvedContent) {
         const reason = contentResolution.reason || 'content unavailable';
-        return [`- ${attachmentLabel}: ${reason}. URL: ${contentResolution.attachment.url}`, decodingLine, warningsLine]
-            .filter(Boolean)
-            .join('\n');
+        return spaceTrim$1((block) => `
+                - ${attachmentLabel}: ${reason}. URL: ${contentResolution.attachment.url}
+                ${block(metadataLines)}
+            `);
     }
     const truncatedLabel = contentResolution.isTruncated ? ' [truncated]' : '';
-    return [
-        `File: ${attachmentLabel}${truncatedLabel}`,
-        `URL: ${contentResolution.attachment.url}`,
-        decodingLine,
-        warningsLine,
-        '```text',
-        contentResolution.content,
-        '```',
-    ]
-        .filter(Boolean)
-        .join('\n');
+    return spaceTrim$1((block) => `
+            File: ${attachmentLabel}${truncatedLabel}
+            URL: ${contentResolution.attachment.url}
+            ${block(metadataLines)}
+            \`\`\`text
+            ${block(resolvedContent)}
+            \`\`\`
+        `);
 }
 /**
  * Formats inline attachment-content context section for the model.
@@ -31341,11 +31846,14 @@ function formatChatAttachmentContentContext(resolvedContents) {
     if (resolvedContents.length === 0) {
         return '';
     }
-    return [
-        CHAT_ATTACHMENT_CONTENT_HEADING,
-        CHAT_ATTACHMENT_CONTENT_INSTRUCTION,
-        ...resolvedContents.map((resolvedContent) => formatResolvedChatAttachmentContent(resolvedContent)),
-    ].join('\n\n');
+    return spaceTrim$1((block) => `
+            ${CHAT_ATTACHMENT_CONTENT_HEADING}
+            ${CHAT_ATTACHMENT_CONTENT_INSTRUCTION}
+
+            ${block(resolvedContents
+        .map((resolvedContent) => formatResolvedChatAttachmentContent(resolvedContent))
+        .join('\n\n'))}
+        `);
 }
 
 /**
@@ -32490,9 +32998,11 @@ class OpenAiCompatibleUnsupportedParameterRetrier {
      * Creates the retry-history error message shared by all OpenAI-compatible model variants.
      */
     createAttemptHistoryError(finalErrorMessage) {
-        return new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
-            formatUnsupportedParameterAttemptHistory(this.attemptStack) +
-            `\nFinal error: ${finalErrorMessage}`);
+        return new PipelineExecutionError(spaceTrim$1((block) => `
+                    All attempts failed. Attempt history:
+                    ${block(formatUnsupportedParameterAttemptHistory(this.attemptStack))}
+                    Final error: ${finalErrorMessage}
+                `));
     }
 }
 
@@ -35086,7 +35596,7 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
             });
         }
         let vectorStoreId = cachedVectorStoreId;
-        if (this.isNativeKnowledgeSearchEnabled && !vectorStoreId && knowledgeSources && knowledgeSources.length > 0) {
+        if (!vectorStoreId && knowledgeSources && knowledgeSources.length > 0) {
             const vectorStoreResult = await this.createVectorStoreWithKnowledgeSources({
                 client: await this.getClient(),
                 name,
@@ -35095,19 +35605,13 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
             });
             vectorStoreId = vectorStoreResult.vectorStoreId;
         }
-        else if (this.isNativeKnowledgeSearchEnabled && vectorStoreId && this.options.isVerbose) {
+        else if (vectorStoreId && this.options.isVerbose) {
             console.info('[🤰]', 'Using cached vector store for AgentKit agent', {
                 name,
                 vectorStoreId,
             });
         }
-        if (!this.isNativeKnowledgeSearchEnabled) {
-            vectorStoreId = undefined;
-        }
-        const agentKitTools = this.buildAgentKitTools({
-            tools,
-            vectorStoreId,
-        });
+        const agentKitTools = this.buildAgentKitTools({ tools, vectorStoreId });
         const openAiAgentKitAgent = new Agent$1({
             name,
             model: this.agentKitModelName,
@@ -35126,7 +35630,7 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
                 name,
                 model: this.agentKitModelName,
                 toolCount: agentKitTools.length,
-                hasVectorStore: this.isNativeKnowledgeSearchEnabled && Boolean(vectorStoreId),
+                hasVectorStore: Boolean(vectorStoreId),
             });
         }
         return preparedAgent;
@@ -35625,12 +36129,6 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
     get agentKitOptions() {
         return this.options;
     }
-    /**
-     * Returns true when hosted OpenAI vector-store search should back `knowledgeSources`.
-     */
-    get isNativeKnowledgeSearchEnabled() {
-        return this.agentKitOptions.isNativeKnowledgeSearchEnabled !== false;
-    }
     /**
      * Discriminant for type guards.
      */