@blokkli/editor 2.0.0-alpha.35 → 2.0.0-alpha.37

package/dist/modules/agent/index.mjs

@@ -3,7 +3,12 @@ import { fileURLToPath } from 'node:url';
 import * as path from 'node:path';
 import { d as defineBlokkliModule } from '../../shared/editor.CGf7C_0M.mjs';
 import * as fs from 'node:fs';
-import { C as Collector, a as CollectedFile, d as defineCodeTemplate } from '../../shared/editor.DMFfaLVE.mjs';
+import { C as Collector, a as CollectedFile } from '../../shared/editor.BFIzNSQM.mjs';
+import { d as defineCodeTemplate } from '../../shared/editor.6D5vApr0.mjs';
+import MagicString from 'magic-string';
+import { parse } from 'acorn';
+import { walk } from 'estree-walker-ts';
+import { transformSync } from 'esbuild';
 
 function toImportName(prefix, fileName) {
   const name = fileName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
@@ -90,7 +95,7 @@ class AgentCollector extends Collector {
   }
 }
 
-function createClientTemplate(toolCollector, promptCollector, defaultPrompts, models, agentName) {
+function createClientTemplate(toolCollector, promptCollector, options) {
   return defineCodeTemplate(
     "agent-client",
     (ctx) => {
@@ -126,10 +131,15 @@ function createClientTemplate(toolCollector, promptCollector, defaultPrompts, mo
         );
       }
       exports$1.push(
-        `export const defaultPrompts = ${JSON.stringify(defaultPrompts)}`
+        `export const defaultPrompts = ${JSON.stringify(options.defaultPrompts ?? [])}`
+      );
+      exports$1.push(`export const models = ${JSON.stringify(options.models)}`);
+      exports$1.push(
+        `export const agentName = ${JSON.stringify(options.agentName ?? "Superbl\xF6kkli")}`
+      );
+      exports$1.push(
+        `export const hasWebFetch = ${JSON.stringify(!!options.allowedFetchOrigins)}`
       );
-      exports$1.push(`export const models = ${JSON.stringify(models)}`);
-      exports$1.push(`export const agentName = ${JSON.stringify(agentName)}`);
       const parts = [];
       if (imports.length > 0) {
         parts.push(imports.join("\n"));
@@ -138,14 +148,15 @@ function createClientTemplate(toolCollector, promptCollector, defaultPrompts, mo
       return parts.join("\n\n") + "\n";
     },
     () => {
-      return `import type { McpToolItem, AgentPromptItem } from '#blokkli/agent/app/types'
+      return `import type { McpToolDefinition, AgentPromptItem } from '#blokkli/agent/app/types'
 import type { AgentModelDefinition } from '#blokkli/agent/shared/types'
 
-export const mcpTools: McpToolItem[]
+export const mcpTools: McpToolDefinition[]
 export const agentPrompts: AgentPromptItem[]
 export const defaultPrompts: string[]
 export const agentName: string
 export const models: AgentModelDefinition[]
+export const hasWebFetch: boolean
 `;
     }
   );
@@ -159,7 +170,8 @@ function createServerTemplate(options) {
     skillsCollector,
     skillsTypesPath,
     systemPromptCollector,
-    systemPromptTypesPath
+    systemPromptTypesPath,
+    mcpToolsCollector
   } = options;
   const { allowedFetchOrigins, provider, models } = moduleOptions;
   return defineCodeTemplate(
@@ -191,6 +203,15 @@ function createServerTemplate(options) {
       const systemPromptsExport = systemPrompts.length === 0 ? `export const systemPrompts = []` : `export const systemPrompts = [
   ${systemPrompts.map((sp) => sp.importName).join(",\n  ")}
 ]`;
+      const tools = mcpToolsCollector.getItems();
+      for (const tool of tools) {
+        imports.push(
+          `import ${tool.importName} from '${rel(tool.filePath)}?blokkliAgentTool'`
+        );
+      }
+      const toolDefinitionsExport = tools.length === 0 ? `export const toolDefinitions = []` : `export const toolDefinitions = [
+  ${tools.map((t) => t.importName).join(",\n  ")},
+].filter(v => v !== null)`;
       const originsJson = JSON.stringify(allowedFetchOrigins, null, 2);
       return `${imports.join("\n")}
 
@@ -204,6 +225,8 @@ export const debugPrompt = ${!!moduleOptions.debugPrompt}
 ${skillsExport}
 
 ${systemPromptsExport}
+
+${toolDefinitionsExport}
 `;
     },
     (ctx) => {
@@ -211,7 +234,7 @@ ${systemPromptsExport}
       return `import type { AIProvider } from '${rel(providersPath)}/types'
 import type { SkillDefinition } from '${rel(skillsTypesPath)}'
 import type { SystemPromptDefinition } from '${rel(systemPromptTypesPath)}'
-import type { AgentModelDefinition } from '${rel(sharedTypesPath)}'
+import type { AgentModelDefinition, ServerToolMetadata } from '${rel(sharedTypesPath)}'
 
 export const allowedFetchOrigins: string[]
 export const provider: AIProvider
@@ -219,6 +242,7 @@ export const models: AgentModelDefinition[]
 export const debugPrompt: boolean
 export const skills: SkillDefinition[]
 export const systemPrompts: SystemPromptDefinition[]
+export const toolDefinitions: ServerToolMetadata[]
 `;
     },
     {
@@ -228,6 +252,206 @@ export const systemPrompts: SystemPromptDefinition[]
   );
 }
 
+const QUERY = "?blokkliAgentTool";
+const PROPERTIES_TO_REMOVE = /* @__PURE__ */ new Set([
+  "execute",
+  "resultSchema",
+  "component",
+  "label",
+  "prunedSummary",
+  "mockParams",
+  "mockParamsVariants",
+  "requiresApproval",
+  "icon"
+]);
+const SERVER_SAFE_IMPORTS = /* @__PURE__ */ new Set([
+  "zod",
+  "../schemas",
+  "#blokkli/agent/app/tools/schemas",
+  "../chart_schemas",
+  "#blokkli-build/charts-config"
+]);
+function isServerSafeImport(source) {
+  return SERVER_SAFE_IMPORTS.has(source);
+}
+function agentToolStripPlugin() {
+  return {
+    name: "blokkli:agent-tool-strip",
+    resolveId(source, importer) {
+      if (!source.includes(QUERY)) return null;
+      const cleanPath = source.replace(QUERY, "");
+      let resolved;
+      if (importer && (cleanPath.startsWith(".") || cleanPath.startsWith("/"))) {
+        const importerDir = path.dirname(importer);
+        resolved = path.resolve(importerDir, cleanPath);
+      } else {
+        resolved = cleanPath;
+      }
+      if (!fs.existsSync(resolved) && fs.existsSync(resolved + ".ts")) {
+        resolved = resolved + ".ts";
+      }
+      return resolved + QUERY;
+    },
+    load(id) {
+      if (!id.includes(QUERY)) return null;
+      const filePath = id.replace(QUERY, "");
+      let rawSource;
+      try {
+        rawSource = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        this.error(`Cannot read agent tool file: ${filePath}`);
+      }
+      const { code: jsSource } = transformSync(rawSource, {
+        loader: "ts",
+        format: "esm",
+        target: "esnext"
+      });
+      return transformToolSource(jsSource, filePath);
+    }
+  };
+}
+function findToolExport(ast) {
+  let result = null;
+  walk(ast, {
+    enter(node) {
+      if (result) return;
+      let callExpr = null;
+      if (node.type === "ExportDefaultDeclaration") {
+        const decl = node.declaration;
+        if (decl?.type === "CallExpression" && decl.callee?.type === "Identifier" && decl.callee.name === "defineBlokkliAgentTool") {
+          callExpr = decl;
+        }
+      }
+      if (node.type === "VariableDeclarator") {
+        const init = node.init;
+        if (init?.type === "CallExpression" && init.callee?.type === "Identifier" && init.callee.name === "defineBlokkliAgentTool") {
+          callExpr = init;
+        }
+      }
+      if (!callExpr) return;
+      const arg = callExpr.arguments[0];
+      if (arg?.type !== "ObjectExpression") return;
+      const toolObject = arg;
+      result = { toolObject, call: callExpr };
+    },
+    leave() {
+    }
+  });
+  return result;
+}
+const REQUIRED_PROPERTIES = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "category",
+  "paramsSchema"
+]);
+function validateTransformedOutput(output, filePath) {
+  let ast;
+  try {
+    ast = parse(output, {
+      sourceType: "module",
+      ecmaVersion: "latest"
+    });
+  } catch (e) {
+    return `Transformed output is not valid JavaScript${filePath ? ` (${filePath})` : ""}: ${e}`;
+  }
+  let exportedObject = null;
+  walk(ast, {
+    enter(node) {
+      if (exportedObject) return;
+      if (node.type === "ExportDefaultDeclaration") {
+        const decl = node.declaration;
+        if (decl?.type === "ObjectExpression") {
+          exportedObject = decl;
+        }
+      }
+      if (node.type === "VariableDeclarator") {
+        const id = node.id;
+        const init = node.init;
+        if (id?.type === "Identifier" && id.name === "stdin_default" && init?.type === "ObjectExpression") {
+          exportedObject = init;
+        }
+      }
+    },
+    leave() {
+    }
+  });
+  if (!exportedObject) {
+    return `No default-exported object found in transformed output${filePath ? ` (${filePath})` : ""}`;
+  }
+  const foundProps = /* @__PURE__ */ new Set();
+  for (const prop of exportedObject.properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key;
+    if (key.type === "Identifier") {
+      foundProps.add(key.name);
+    } else if (key.type === "Literal" && typeof key.value === "string") {
+      foundProps.add(key.value);
+    }
+  }
+  const missing = [...REQUIRED_PROPERTIES].filter((p) => !foundProps.has(p));
+  if (missing.length > 0) {
+    return `Transformed tool output is missing required properties: ${missing.join(", ")}${filePath ? ` (${filePath})` : ""}`;
+  }
+  return null;
+}
+function transformToolSource(source, filePath) {
+  const ast = parse(source, {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  });
+  const exportInfo = findToolExport(ast);
+  if (!exportInfo) {
+    return source;
+  }
+  const s = new MagicString(source);
+  const { toolObject, call } = exportInfo;
+  walk(ast, {
+    enter(node) {
+      if (node.type !== "ImportDeclaration") return;
+      const importDecl = node;
+      const importSource = importDecl.source.value;
+      if (!isServerSafeImport(importSource)) {
+        let removeEnd = importDecl.end;
+        if (source[removeEnd] === "\n") {
+          removeEnd++;
+        }
+        s.remove(importDecl.start, removeEnd);
+      }
+    },
+    leave() {
+    }
+  });
+  for (const prop of toolObject.properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key;
+    let name = null;
+    if (key.type === "Identifier") {
+      name = key.name;
+    } else if (key.type === "Literal" && typeof key.value === "string") {
+      name = key.value;
+    }
+    if (name && PROPERTIES_TO_REMOVE.has(name)) {
+      const propNode = prop;
+      let removeEnd = propNode.end;
+      const afterProp = source.substring(removeEnd);
+      const commaMatch = afterProp.match(/^\s*,/);
+      if (commaMatch) {
+        removeEnd += commaMatch[0].length;
+      }
+      s.remove(propNode.start, removeEnd);
+    }
+  }
+  s.overwrite(call.start, toolObject.start, "");
+  s.overwrite(toolObject.end, call.end, "");
+  const result = s.toString();
+  const error = validateTransformedOutput(result, filePath);
+  if (error) {
+    throw new Error(error);
+  }
+  return result;
+}
+
 const AGENT_ROUTE = "/api/blokkli/agent";
 const FETCH_ROUTE = "/api/blokkli/agent/fetch";
 const index = defineBlokkliModule({
@@ -283,15 +507,19 @@ export default defineNuxtConfig({
       "#blokkli/agent/server",
       moduleResolver.resolve("./runtime/server")
     );
+    const moduleBlokkliDirs = ctx.helper.options.blokkliDirs || [];
     const moduleToolsDir = moduleResolver.resolve("./runtime/app/tools");
     const projectToolsDir = path.resolve(nuxt.options.rootDir, "blokkli/tools");
     const mcpTools = new AgentCollector(ctx.helper, {
       composable: "defineBlokkliAgentTool",
       importPrefix: "tool",
       dependency: "agent-mcp-tools",
-      dirs: [moduleToolsDir, projectToolsDir]
+      dirs: [
+        moduleToolsDir,
+        projectToolsDir,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "tools"))
+      ]
     });
-    await mcpTools.init();
     ctx.context.addCollector(mcpTools);
     const projectPromptsDir = path.resolve(
       nuxt.options.rootDir,
@@ -301,18 +529,14 @@ export default defineNuxtConfig({
       composable: "defineBlokkliAgentPrompt",
       importPrefix: "prompt",
       dependency: "agent-prompts",
-      dirs: [projectPromptsDir]
+      dirs: [
+        projectPromptsDir,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "prompts"))
+      ]
     });
-    await promptsCollector.init();
     ctx.context.addCollector(promptsCollector);
     ctx.context.addTemplate(
-      createClientTemplate(
-        mcpTools,
-        promptsCollector,
-        options.defaultPrompts || [],
-        options.models,
-        options.agentName ?? "Blocki"
-      )
+      createClientTemplate(mcpTools, promptsCollector, options)
     );
     const relativeToolsDir = path.relative(
       nuxt.options.buildDir,
@@ -326,6 +550,11 @@ export default defineNuxtConfig({
       projectPromptsDir
     );
     nuxt.options.typescript.tsConfig.include.push(relativePromptsDir);
+    for (const dir of moduleBlokkliDirs) {
+      const toolsDir = path.join(dir, "tools");
+      const relDir = path.relative(nuxt.options.buildDir, toolsDir);
+      nuxt.options.typescript.tsConfig.include.push(relDir);
+    }
     const moduleSkillsDir = moduleResolver.resolve(
       "./runtime/server/default-skills"
     );
@@ -337,9 +566,12 @@ export default defineNuxtConfig({
       composable: "defineBlokkliAgentSkill",
       importPrefix: "skill",
       dependency: "agent-server",
-      dirs: [moduleSkillsDir, projectSkillsDir]
+      dirs: [
+        moduleSkillsDir,
+        projectSkillsDir,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "skills"))
+      ]
     });
-    await skillsCollector.init();
     ctx.context.addCollector(skillsCollector);
     const moduleSystemPromptsDir = moduleResolver.resolve(
       "./runtime/server/default-system-prompts"
@@ -352,9 +584,12 @@ export default defineNuxtConfig({
       composable: "defineBlokkliAgentSystemPrompt",
       importPrefix: "systemPrompt",
       dependency: "agent-server",
-      dirs: [moduleSystemPromptsDir, projectSystemPromptsDir]
+      dirs: [
+        moduleSystemPromptsDir,
+        projectSystemPromptsDir,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "system-prompts"))
+      ]
     });
-    await systemPromptCollector.init();
     ctx.context.addCollector(systemPromptCollector);
     ctx.context.addTemplate(
       createServerTemplate({
@@ -368,7 +603,8 @@ export default defineNuxtConfig({
         systemPromptCollector,
         systemPromptTypesPath: moduleResolver.resolve(
           "./runtime/server/system-prompts/types"
-        )
+        ),
+        mcpToolsCollector: mcpTools
       })
     );
     addServerHandler({
@@ -394,6 +630,18 @@ export default defineNuxtConfig({
       nitroConfig.typescript.tsConfig.include ||= [];
       nitroConfig.typescript.tsConfig.include.push(relativeSkillsDir);
       nitroConfig.typescript.tsConfig.include.push(relativeSystemPromptsDir);
+      nitroConfig.rollupConfig ||= {};
+      nitroConfig.rollupConfig.plugins ||= [];
+      nitroConfig.rollupConfig.plugins.push(
+        agentToolStripPlugin()
+      );
+      nitroConfig.alias ||= {};
+      nitroConfig.alias["#blokkli/agent/app/tools/schemas"] = moduleResolver.resolve("./runtime/app/tools/schemas");
+      for (const [key, value] of Object.entries(nuxt.options.alias)) {
+        if (key.startsWith("#blokkli/") && !nitroConfig.alias[key]) {
+          nitroConfig.alias[key] = value;
+        }
+      }
     });
     nuxt.hook("nitro:init", (nitro) => {
       nitro.hooks.hook("types:extend", (types) => {

package/dist/modules/agent/runtime/app/composables/agentProvider.d.ts

@@ -1,6 +1,6 @@
 import { type Ref } from '#imports';
 import { type Attachment, type ConversationItem, type ActiveItem, type MutationAction } from '#blokkli/agent/app/types';
-import type { ClientPlanState, UsageTurn } from '#blokkli/agent/shared/types';
+import type { ClientPlanState, UsageTurn, Transcript } from '#blokkli/agent/shared/types';
 import type { AgentConversationSummary } from '#blokkli/agent/app/features/agent/types';
 import type { BlokkliApp } from '#blokkli/editor/types/app';
 import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
@@ -43,7 +43,7 @@ export type AgentProvider = {
     newConversation: () => void;
     getTranscript: () => void;
     onToolComponentDone: (result: unknown) => void;
-    transcriptContent: Ref<string>;
+    transcriptContent: Ref<Transcript | null>;
     showTranscript: Ref<boolean>;
     conversationList: Ref<AgentConversationSummary[]>;
     showConversationList: Ref<boolean>;

package/dist/modules/agent/runtime/app/composables/agentProvider.js

@@ -6,7 +6,7 @@ import {
   createToolMap,
   executeTool,
   getToolCategory,
-  getToolsForServer,
+  getToolInfoForServer,
   getToolDefinition,
   isMutationAction,
   isQueryResult,
@@ -38,7 +38,7 @@ export default function(app, adapter, agentName) {
   const pendingToolCall = ref(null);
   let pendingToolCallResolve = null;
   const plan = ref(null);
-  const transcriptContent = ref("");
+  const transcriptContent = ref(null);
   const showTranscript = ref(false);
   const activeConversationId = ref(null);
   const conversationList = ref([]);
@@ -251,6 +251,19 @@ export default function(app, adapter, agentName) {
     const ctx = createToolContext();
     const resolved = await resolveTools(mcpTools, ctx);
     toolMap = createToolMap(resolved);
+    const toolNames = getToolInfoForServer(
+      resolved,
+      state.editMode.value,
+      adapter
+    );
+    let contentSearchTabs;
+    if (adapter.getContentSearchTabs) {
+      try {
+        contentSearchTabs = await adapter.getContentSearchTabs();
+      } catch (e) {
+        console.warn("[blokkli agent] Failed to fetch content search tabs:", e);
+      }
+    }
     if (adapter.getAgentAuthToken) {
       try {
         const authToken = await adapter.getAgentAuthToken();
@@ -264,26 +277,21 @@ export default function(app, adapter, agentName) {
           disconnect();
           return;
         }
+        const pageContext = await buildPageContext(contentSearchTabs);
+        pendingInit = { toolNames, pageContext };
         send({ type: "authenticate", authToken });
-        pendingInit = {
-          tools: getToolsForServer(resolved, state.editMode.value, adapter),
-          pageContext: buildPageContext()
-        };
         return;
       } catch (e) {
         console.error("Failed to obtain agent auth token:", e);
       }
     }
-    sendInit(
-      getToolsForServer(resolved, state.editMode.value, adapter),
-      buildPageContext()
-    );
+    sendInit(toolNames, await buildPageContext(contentSearchTabs));
   }
-  async function sendInit(tools, pageContext) {
-    send({ type: "init", tools, pageContext });
+  async function sendInit(toolNames, pageContext) {
+    send({ type: "init", toolNames, pageContext });
     isReady.value = true;
     hasBeenReady.value = true;
-    if (adapter.agentConversations) {
+    if (adapter.agentConversations && !pendingPrompt) {
       try {
         const latest = await adapter.agentConversations.loadLatest();
         if (latest) {
@@ -305,7 +313,7 @@ export default function(app, adapter, agentName) {
       sendPrompt(prompt, displayPrompt, selectedUuids, attachments);
     }
   }
-  function buildPageContext() {
+  async function buildPageContext(contentSearchTabs) {
     const { types, definitions } = app;
     const bundles = [];
     for (const bundle of types.generallyAvailableBundles) {
@@ -360,6 +368,13 @@ export default function(app, adapter, agentName) {
         allowed: f.allowed
       }))
     ];
+    await app.analyze.ensureInitialized();
+    const analyzersList = app.analyze.analyzers.value.filter((a) => !a.requireRawPage).map((a) => ({
+      id: a.id,
+      type: a.type,
+      label: typeof a.label === "function" ? a.label(context.value.language) : a.label,
+      description: typeof a.description === "function" ? a.description(context.value.language) : a.description
+    }));
     const pageContext = {
       title: state.entity.value.label || "",
       entityType: context.value.entityType,
@@ -373,7 +388,9 @@ export default function(app, adapter, agentName) {
       isPublished: state.entity.value.status ?? null,
       editMode: state.editMode.value,
       fragments,
-      entityContentFields
+      entityContentFields,
+      ...contentSearchTabs?.length ? { contentSearchTabs } : {},
+      ...analyzersList.length ? { analyzers: analyzersList } : {}
     };
     return pageContext;
   }
@@ -412,7 +429,7 @@ export default function(app, adapter, agentName) {
     switch (data.type) {
       case "authenticated":
         if (pendingInit) {
-          sendInit(pendingInit.tools, pendingInit.pageContext);
+          sendInit(pendingInit.toolNames, pendingInit.pageContext);
           pendingInit = null;
         }
         break;
@@ -492,7 +509,7 @@ export default function(app, adapter, agentName) {
         }
         break;
       case "transcript":
-        transcriptContent.value = data.content;
+        transcriptContent.value = data.transcript;
         showTranscript.value = true;
         break;
       case "conversation_state":

package/dist/modules/agent/runtime/app/composables/defineBlokkliAgentTool.d.ts

@@ -1,4 +1,4 @@
-import type { McpToolDefinition, McpToolCategory, McpToolFactoryInput, McpToolFactory } from '#blokkli/agent/app/types';
+import type { McpToolDefinition, McpToolCategory } from '#blokkli/agent/app/types';
 import type { AdapterMethods } from '#blokkli/editor/adapter';
 import type { z } from 'zod';
 import type { Component } from 'vue';
@@ -7,7 +7,7 @@ import type { Component } from 'vue';
  *
  * Tools are defined once and compiled into two bundles:
  * - Client bundle: Full definition with execute function (for Vue component)
- * - Server bundle: Tools are sent dynamically via WebSocket on init
+ * - Server bundle: Static metadata extracted at build time
  *
  * The Zod schemas provide:
  * - Type-safe parameter and result definitions with TypeScript inference
@@ -43,23 +43,5 @@ import type { Component } from 'vue';
  *   },
  * })
  * ```
- *
- * @example Factory pattern for dynamic tools:
- * ```typescript
- * export default defineBlokkliAgentTool({
- *   resolve: async (ctx) => {
- *     if (!ctx.adapter.getContentSearchTabs) return []
- *     const tabs = await ctx.adapter.getContentSearchTabs()
- *     return Object.entries(tabs).map(([id, label]) =>
- *       defineBlokkliAgentTool({
- *         name: `search_${id}`,
- *         requiredAdapterMethods: ['getContentSearchResults'],
- *         // ... each tool has full type safety
- *       })
- *     )
- *   },
- * })
- * ```
  */
 export declare function defineBlokkliAgentTool<TParamsSchema extends z.ZodType, TResultSchema extends z.ZodType, const TMethods extends readonly AdapterMethods[] = readonly [], TComponent extends Component | undefined = undefined, TCategory extends McpToolCategory = McpToolCategory>(options: McpToolDefinition<TParamsSchema, TResultSchema, TMethods, TComponent, TCategory>): McpToolDefinition<TParamsSchema, TResultSchema, TMethods, TComponent, TCategory>;
-export declare function defineBlokkliAgentTool(options: McpToolFactoryInput): McpToolFactory;

package/dist/modules/agent/runtime/app/composables/defineBlokkliAgentTool.js

@@ -1,6 +1,3 @@
 export function defineBlokkliAgentTool(options) {
-  if ("resolve" in options) {
-    return { ...options, __factory: true };
-  }
   return options;
 }

package/dist/modules/agent/runtime/app/features/agent/Panel/Conversation/Item/Assistant/index.vue

@@ -16,13 +16,13 @@ const props = defineProps({
 });
 const { state } = useBlokkli();
 const contentEl = ref();
-marked.setOptions({ gfm: true, breaks: true });
 function renderContent(content) {
   const container = contentEl.value;
   if (!container) return;
   const ownerName = state.owner.value?.name || "";
   container.innerHTML = marked.parse(
-    content.replaceAll(PLACEHOLDER_USER_NAME, ownerName)
+    content.replaceAll(PLACEHOLDER_USER_NAME, ownerName),
+    { gfm: true, breaks: true }
   );
 }
 watch(

package/dist/modules/agent/runtime/app/features/agent/Panel/Conversation/Item/User/index.vue

@@ -22,8 +22,7 @@ const props = defineProps({
   content: { type: String, required: true },
   attachments: { type: Array, required: false }
 });
-marked.setOptions({ gfm: true, breaks: true });
 const html = computed(() => {
-  return props.content ? marked.parse(props.content) : "";
+  return props.content ? marked.parse(props.content, { gfm: true, breaks: true }) : "";
 });
 </script>

package/dist/modules/agent/runtime/app/features/agent/Panel/DebugGallery/index.vue

@@ -47,7 +47,6 @@ import { computed } from "#imports";
 import Conversation from "../Conversation/index.vue";
 import PendingMutation from "../PendingMutation/index.vue";
 import { mcpTools } from "#blokkli-build/agent-client";
-import { isToolDefinition } from "#blokkli/agent/app/helpers";
 const mockContext = {
   app: null,
   itemEntityType: "paragraph",
@@ -153,7 +152,7 @@ const mockMutations = [
   }
 ];
 const toolsWithMockParams = computed(
-  () => mcpTools.filter(isToolDefinition).filter(
+  () => mcpTools.filter(
     (tool) => !!tool.component && !!tool.mockParams
   )
 );

package/dist/modules/agent/runtime/app/features/agent/Panel/Input/Actions/index.d.vue.ts

@@ -4,6 +4,7 @@ type __VLS_Props = {
     isConnected: boolean;
     canSubmit: boolean;
     hasText: boolean;
+    hasConversation: boolean;
     usageTurns: UsageTurn[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {