@revenexx/editor 0.1.0

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

@@ -0,0 +1,228 @@
+<template>
+  <PluginSidebar
+    id="agent"
+    :title="agentName"
+    :tooltip-title
+    :tour-text="
+  $t('aiAgentTourText', 'Chat with an AI assistant to edit page content.')
+"
+    icon="stars"
+    weight="-900"
+    render-always
+    beta
+    region="right-bottom"
+    @toggle="closeAgentPopup"
+  >
+    <template #icon>
+      <Icon name="stars" class="bk-is-animated" />
+    </template>
+    <template #default="{ isShown, shouldRender }">
+      <AgentContainer
+        v-if="shouldRender"
+        :is-shown
+        :adapter
+        :pending-prompt-request="pendingPromptRequest"
+        @consumed="pendingPromptRequest = null"
+      />
+    </template>
+  </PluginSidebar>
+
+  <Teleport :to="ui.mainLayoutElement.value">
+    <Popup
+      id="agent"
+      ref="popup"
+      :title="$t('aiAgentPopupTitle', 'AI-Assistant')"
+      :cta="$t('aiAgentIntroPopupCta', 'Get started')"
+      theme="primary"
+      position="bottom-right"
+      @submit="openAgent"
+    >
+      <Icon name="stars" class="bk-is-animated" />
+      <p v-html="popupText" />
+    </Popup>
+  </Teleport>
+
+  <Teleport v-if="canManageConversations" :to="ui.mainLayoutElement.value">
+    <BlokkliTransition name="slide-up">
+      <ConversationsAdminDialog
+        v-if="showConversationsAdmin"
+        @cancel="closeConversationsAdmin"
+      />
+    </BlokkliTransition>
+  </Teleport>
+</template>
+
+<script setup>
+import {
+  useBlokkli,
+  defineBlokkliFeature,
+  computed,
+  shallowRef,
+  useTemplateRef,
+  defineAsyncComponent
+} from "#imports";
+import { PluginSidebar } from "#blokkli/editor/plugins";
+import { Icon, Popup, BlokkliTransition } from "#blokkli/editor/components";
+import { agentPrompts, agentName } from "#blokkli-build/agent-prompts";
+import {
+  defineItemDropdownAction,
+  defineMenuButton
+} from "#blokkli/editor/composables";
+const AgentContainer = defineAsyncComponent(() => import("./Container.vue"));
+const ConversationsAdminDialog = defineAsyncComponent(
+  () => import("./ConversationsAdmin/index.vue")
+);
+const { adapter } = defineBlokkliFeature({
+  id: "agent",
+  icon: "stars",
+  label: "AI Agent",
+  description: "Chat with an AI assistant to edit page content.",
+  requiredPermissions: ["use_agent"],
+  requiredAdapterMethods: [
+    "updateFieldValue",
+    "addNewBlock",
+    "deleteBlocks",
+    "moveMultipleBlocks"
+  ]
+});
+const app = useBlokkli();
+const { $t, ui, permissions } = app;
+const canManageConversations = permissions.hasPermission(
+  "manage_agent_conversations"
+);
+const showConversationsAdmin = computed(
+  () => ui.currentDialog.value?.id === "agentConversations"
+);
+function closeConversationsAdmin() {
+  ui.closeDialog("agentConversations");
+}
+defineMenuButton(() => {
+  if (!canManageConversations) return void 0;
+  if (!adapter.agentConversations?.queryConversations) return void 0;
+  return {
+    id: "agentConversations",
+    title: $t("agentConversations", "Agent conversations"),
+    description: $t(
+      "agentConversationsMenuDescription",
+      "Browse and manage all agent conversations."
+    ),
+    icon: "bk_mdi_forum",
+    secondary: true,
+    callback: () => ui.openDialog({ id: "agentConversations", alignment: "center" })
+  };
+});
+const popup = useTemplateRef("popup");
+const pendingPromptRequest = shallowRef(null);
+function closeAgentPopup() {
+  if (popup.value) {
+    popup.value.closePopup();
+  }
+}
+function openAgent() {
+  app.eventBus.emit("sidebar:open", "agent");
+}
+const popupText = computed(() => {
+  return $t(
+    "aiAgentIntroPopup",
+    "Need help editing? @name is your AI assistant \u2014 it can add, move, and update blocks and much more. Give it a try!"
+  ).replace("@name", `<em>${agentName}</em>`);
+});
+const tooltipTitle = computed(() => {
+  return $t("agentSidebarTooltipLabel", "@name (AI-Assistant)").replace(
+    "@name",
+    agentName
+  );
+});
+defineItemDropdownAction(() => {
+  return agentPrompts.flatMap((promptFactory) => {
+    const promptsResult = "__factory" in promptFactory ? promptFactory.resolve(app) : promptFactory;
+    const prompts = Array.isArray(promptsResult) ? promptsResult : [promptsResult];
+    return prompts.map((prompt) => {
+      return {
+        id: "agent:prompt:" + prompt.id,
+        label: prompt.getLabel(app),
+        icon: "stars",
+        group: "agent",
+        variant: "agent",
+        weight: -900,
+        callback: () => {
+          app.eventBus.emit("sidebar:open", "agent");
+          pendingPromptRequest.value = {
+            prompt,
+            selectedBlocks: app.selection.items.value.map((item) => ({
+              uuid: item.uuid,
+              bundle: item.bundle,
+              label: app.types.getBlockLabel(item.bundle)
+            }))
+          };
+        }
+      };
+    });
+  });
+});
+</script>
+
+<script>
+export default {
+  name: "Agent"
+};
+</script>
+
+<style>/*! tailwindcss v4.2.4 | MIT License | https://tailwindcss.com */
+@keyframes bk-sparkle {
+  0%,
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 0.7;
+    transform: scale(0.6);
+  }
+}
+.bk #bk-sidebar-button-agent {
+  color: white;
+}
+:is(.bk #bk-sidebar-button-agent) svg {
+  width: 30px;
+  height: 30px;
+  --bk-tw-translate-x: -7%;
+  translate: var(--bk-tw-translate-x) var(--bk-tw-translate-y);
+}
+:is(.bk .bk-icon-stars.bk-is-animated) svg path {
+  animation: bk-sparkle 3s ease-in-out infinite;
+}
+:is(:is(.bk .bk-icon-stars.bk-is-animated) svg path):nth-child(1) {
+  transform-origin: 19px 19px;
+  animation-delay: 0.6s;
+}
+:is(:is(.bk .bk-icon-stars.bk-is-animated) svg path):nth-child(2) {
+  transform-origin: 9px 12px;
+  animation-delay: 0s;
+}
+:is(:is(.bk .bk-icon-stars.bk-is-animated) svg path):nth-child(3) {
+  transform-origin: 19px 5px;
+  animation-delay: 1.2s;
+}
+:is(.bk-popup.bk-is-agent .bk-popup-content-text) .bk-icon {
+  float: right;
+  margin-left: 2px;
+}
+:is(:is(.bk-popup.bk-is-agent .bk-popup-content-text) .bk-icon) svg {
+  width: 60px;
+  height: 60px;
+  fill: rgb(var(--bk-theme-accent-600) / 1);
+}
+:is(.bk-popup.bk-is-agent .bk-popup-content-text) p {
+  -webkit-hyphens: auto;
+  hyphens: auto;
+}
+:is(:is(.bk-popup.bk-is-agent .bk-popup-content-text) p) em {
+  --bk-tw-font-weight: var(--font-weight-bold, 700);
+  font-weight: var(--font-weight-bold, 700);
+  -webkit-hyphens: none;
+  hyphens: none;
+  color: rgb(var(--bk-theme-accent-600) / 1);
+  font-style: normal;
+}
+</style>

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

@@ -0,0 +1,3 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/modules/agent/runtime/app/features/agent/types.d.ts

@@ -0,0 +1,147 @@
+import type { AgentPromptDefinition } from '#blokkli/agent/app/types';
+import type { BlokkliUser } from '#blokkli/editor/types/user';
+import type { AdapterSearchArguments } from '#blokkli/editor/adapter';
+import type { PluginConfigInput } from '#blokkli/editor/types/pluginConfig';
+import type { SelectedBlock } from '#blokkli/agent/shared/types';
+/**
+ * A pending request from the outer feature's item-dropdown action that the
+ * inner container consumes on mount (or on change if already mounted).
+ */
+export type PendingPromptRequest = {
+    prompt: AgentPromptDefinition;
+    selectedBlocks: SelectedBlock[];
+};
+export type AgentConversationHostInfo = {
+    entityType: string;
+    entityUuid: string;
+    label?: string | null;
+    editUrl?: string | null;
+};
+export type AgentConversationItem = {
+    uuid: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    host: AgentConversationHostInfo | null;
+    /** The conversation's creator, or `null` when their account has been deleted. */
+    author: BlokkliUser | null;
+};
+export type AgentConversationItemSummary = Omit<AgentConversationItem, 'host' | 'author'>;
+export type AgentConversationData = AgentConversationItem & {
+    clientState: string;
+    serverState: string;
+    hash: string;
+    feedbackItemIds?: string[];
+    feedback?: AgentConversationFeedbackItem[];
+};
+export type AgentConversationUpsert = Pick<AgentConversationData, 'uuid' | 'title' | 'clientState' | 'serverState' | 'hash'>;
+export type AgentConversationFeedbackRating = 'bad' | 'fine' | 'good';
+export type AgentConversationFeedback = {
+    conversationId: string;
+    rating: AgentConversationFeedbackRating;
+    lastItemId: string;
+    comment?: string;
+};
+export type AgentConversationFeedbackItem = {
+    id: string;
+    createdAt: string;
+    rating: AgentConversationFeedbackRating;
+    comment: string | null;
+    itemId: string;
+    /** Who left the feedback, or `null` when their account has been deleted. */
+    author: BlokkliUser | null;
+    conversationUuid: string;
+};
+export type AgentConversationQueryResult = {
+    filters: PluginConfigInput[];
+    items: AgentConversationItem[];
+    total: number;
+    perPage: number;
+};
+export type AgentConversationFeedbackQueryResult = {
+    filters: PluginConfigInput[];
+    items: AgentConversationFeedbackItem[];
+    total: number;
+    perPage: number;
+};
+declare module '#blokkli/editor/types/permissions' {
+    interface UserPermissionMap {
+        use_agent: 'Use the AI agent.';
+        manage_agent_conversations: 'Browse and delete agent conversations across all entities and users.';
+    }
+}
+declare module '#blokkli/editor/adapter' {
+    interface BlokkliAdapter<T> {
+        /**
+         * Rearrange blocks within a field by specifying the desired order.
+         *
+         * All provided UUIDs must belong to the same field. The blocks
+         * are reordered to match the given UUID array order.
+         */
+        rearrangeBlocks?: (e: {
+            host: import('#blokkli/editor/types/field').BlokkliItemHost;
+            uuids: string[];
+        }) => Promise<MutationResponseLike<T>>;
+        /**
+         * Get an authentication token for the agent WebSocket connection.
+         *
+         * The token is included in the WebSocket init message and validated
+         * server-side using HMAC. The adapter should obtain the token from
+         * an authenticated CMS endpoint.
+         */
+        getAgentAuthToken?: () => Promise<string | null>;
+        /**
+         * Manage persisted agent conversations.
+         *
+         * Each conversation is stored as a structured record with separate
+         * fields for client state, server state, and the HMAC hash.
+         * Timestamps (createdAt, updatedAt) are managed by the backend.
+         */
+        agentConversations?: {
+            upsert: (data: AgentConversationUpsert) => Promise<boolean>;
+            /**
+             * Load a conversation by its globally unique UUID. The backend
+             * authorizes based on conversation ownership or the
+             * `manage_agent_conversations` permission.
+             */
+            load: (uuid: string) => Promise<AgentConversationData | null>;
+            /**
+             * Load the most recently updated conversation for the current host
+             * entity (the entity the editor is open on).
+             */
+            loadLatest: () => Promise<AgentConversationData | null>;
+            /**
+             * List conversations for the current host entity.
+             */
+            list: () => Promise<AgentConversationItemSummary[]>;
+            delete: (uuid: string) => Promise<boolean>;
+            /**
+             * Submit user feedback for a conversation item. Feedback is stored
+             * separately from conversation data and should survive conversation
+             * deletion. The `lastItemId` references the item visible when the
+             * user submitted the rating.
+             */
+            submitFeedback?: (feedback: AgentConversationFeedback) => Promise<boolean>;
+            /**
+             * Query conversations across all host entities and users, with
+             * pagination. Ordered newest first. The shape mirrors
+             * `mediaLibraryGetResults` so the same paginated-list pattern can
+             * be reused on the consumer side.
+             *
+             * Backends must enforce the `manage_agent_conversations` permission
+             * server-side. The frontend gates the UI but never trusts it.
+             */
+            queryConversations?: (e: AdapterSearchArguments) => Promise<AgentConversationQueryResult>;
+            /**
+             * Query feedback ratings across all conversations and users, with
+             * pagination. Ordered newest first. Each entry is joined with its
+             * parent conversation so the consumer can render without a second
+             * roundtrip per row. The shape mirrors `mediaLibraryGetResults`.
+             *
+             * Backends must enforce the `manage_agent_conversations` permission
+             * server-side.
+             */
+            queryFeedback?: (e: AdapterSearchArguments) => Promise<AgentConversationFeedbackQueryResult>;
+        };
+    }
+}

package/dist/modules/agent/runtime/app/helpers/buildPageContext.d.ts

@@ -0,0 +1,7 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { PageContext } from '#blokkli/agent/shared/types';
+/**
+ * Build the PageContext sent to the agent server on init. Pure builder over
+ * the BlokkliApp providers — no closures, no refs.
+ */
+export declare function buildPageContext(app: BlokkliApp, contentSearchTabs?: PageContext['contentSearchTabs']): Promise<PageContext>;

package/dist/modules/agent/runtime/app/helpers/buildPageContext.js

@@ -0,0 +1,81 @@
+import { itemEntityType } from "#blokkli-build/config";
+export async function buildPageContext(app, contentSearchTabs) {
+  const { types, definitions, context, state, ui, $t, analyze } = app;
+  const bundles = [];
+  for (const bundle of types.generallyAvailableBundles) {
+    const contentFields = [
+      ...types.editableFieldConfig.forEntityTypeAndBundle(itemEntityType, bundle.id).filter((f) => f.type !== "table").map((f) => ({
+        name: f.name,
+        label: f.label,
+        type: f.type === "frame" || f.type === "markup" ? "markup" : "plain"
+      })),
+      ...types.droppableFieldConfig.forEntityTypeAndBundle(itemEntityType, bundle.id).map((f) => ({
+        name: f.name,
+        label: f.label,
+        type: f.type,
+        allowed: f.allowed
+      }))
+    ];
+    const paragraphFields = types.fieldConfig.forEntityTypeAndBundle(itemEntityType, bundle.id).map((f) => ({
+      name: f.name,
+      label: f.label,
+      allowedBundles: f.allowedBundles,
+      cardinality: f.cardinality
+    }));
+    bundles.push({
+      id: bundle.id,
+      label: bundle.label,
+      description: bundle.description,
+      contentFields,
+      paragraphFields
+    });
+  }
+  const fragments = definitions.fragmentDefinitions.value.map((f) => ({
+    name: f.name,
+    label: f.label,
+    description: f.description
+  }));
+  const entityContentFields = [
+    ...types.editableFieldConfig.forEntityTypeAndBundle(
+      context.value.entityType,
+      context.value.entityBundle
+    ).filter((f) => f.type !== "table").map((f) => ({
+      name: f.name,
+      label: f.label,
+      type: f.type === "frame" || f.type === "markup" ? "markup" : "plain"
+    })),
+    ...types.droppableFieldConfig.forEntityTypeAndBundle(
+      context.value.entityType,
+      context.value.entityBundle
+    ).map((f) => ({
+      name: f.name,
+      label: f.label,
+      type: f.type,
+      allowed: f.allowed
+    }))
+  ];
+  await analyze.ensureInitialized();
+  const analyzersList = 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, $t) : a.label,
+    description: typeof a.description === "function" ? a.description(context.value.language, $t) : a.description
+  }));
+  return {
+    title: state.entity.value.label || "",
+    entityType: context.value.entityType,
+    entityUuid: context.value.entityUuid,
+    entityBundle: context.value.entityBundle,
+    bundleLabel: state.entity.value.bundleLabel || "",
+    itemEntityType,
+    bundles,
+    interfaceLanguage: ui.interfaceLanguage.value,
+    entityLanguage: context.value.language,
+    isPublished: state.entity.value.status ?? null,
+    editMode: state.editMode.value,
+    fragments,
+    entityContentFields,
+    ...contentSearchTabs?.length ? { contentSearchTabs } : {},
+    ...analyzersList.length ? { analyzers: analyzersList } : {}
+  };
+}

package/dist/modules/agent/runtime/app/helpers/historySignature.d.ts

@@ -0,0 +1,14 @@
+import type { MutationItem } from '#blokkli/editor/types/state';
+/**
+ * A snapshot identifier for the mutation at a given history index. Used to
+ * detect whether a previously snapshotted rollback target is still reachable —
+ * the index alone is not enough because manual undo + new edits can replace
+ * mutations in place while keeping the array length similar.
+ */
+export declare function computeHistorySignature(mutations: MutationItem[], index: number): string;
+/**
+ * Returns true when `index` still exists in `mutations` AND the mutation at
+ * that position still matches the recorded `signature`. Used to decide
+ * whether to show retry/edit on a user message.
+ */
+export declare function isHistorySnapshotReachable(mutations: MutationItem[], index: number | undefined, signature: string | undefined): boolean;

package/dist/modules/agent/runtime/app/helpers/historySignature.js

@@ -0,0 +1,13 @@
+export function computeHistorySignature(mutations, index) {
+  if (index < 0) return "pristine";
+  const m = mutations[index];
+  if (!m) return "unknown";
+  return `${m.timestamp ?? ""}|${m.pluginId ?? ""}|${m.plugin?.label ?? ""}`;
+}
+export function isHistorySnapshotReachable(mutations, index, signature) {
+  if (index === void 0 || signature === void 0) return false;
+  if (index < -1) return false;
+  if (index === -1) return signature === "pristine";
+  if (index >= mutations.length) return false;
+  return computeHistorySignature(mutations, index) === signature;
+}

package/dist/modules/agent/runtime/app/helpers/id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate a short, unique-enough id for client-side conversation items and
+ * tool calls. Not cryptographic — use `generateUUID` for anything persisted as
+ * a stable identity.
+ */
+export declare function generateId(): string;

package/dist/modules/agent/runtime/app/helpers/id.js

@@ -0,0 +1,3 @@
+export function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}

package/dist/modules/agent/runtime/app/helpers/index.d.ts

@@ -0,0 +1,56 @@
+import type { McpToolDefinition, McpToolContext, McpToolCategory, MutationAction, QueryResult, ToolError, ToolMeta } from '#blokkli/agent/app/types';
+import type { BlokkliAdapter } from '#blokkli/editor/adapter';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { EditMode } from '#blokkli/editor/types/state';
+/**
+ * Narrow an `unknown` to a plain record. One cast at the boundary so call
+ * sites can read `obj.foo` without scattering casts everywhere.
+ */
+export declare function asRecord(value: unknown): Record<string, unknown> | null;
+/**
+ * Pull component side-channel meta (`_details`, `_usage`, `_skipLlmResponse`)
+ * off an emitted tool result so the LLM-facing payload can be sent without
+ * them.
+ */
+export declare function splitMeta(raw: unknown): {
+    payload: unknown;
+    meta: ToolMeta;
+};
+/**
+ * Create a map of tool name to tool definition for quick lookup.
+ */
+export declare function createToolMap(tools: McpToolDefinition[]): Record<string, McpToolDefinition>;
+/**
+ * Get tool names for the server.
+ *
+ * Applies three filters in order:
+ * 1. `tool.modes` must include the current edit mode.
+ * 2. `tool.requiredAdapterMethods` (if any) must all exist on the adapter.
+ * 3. `tool.isAvailable(app)` (if defined) must return (or resolve to) true.
+ */
+export declare function getToolInfoForServer(tools: McpToolDefinition[], editMode: EditMode, app: BlokkliApp, adapter?: BlokkliAdapter<unknown>): Promise<string[]>;
+/**
+ * Execute a tool by name with the given context and parameters.
+ * Validates parameters with Zod before executing.
+ */
+export declare function executeTool(toolMap: Record<string, McpToolDefinition>, name: string, context: McpToolContext, params: Record<string, unknown>): Promise<unknown>;
+/**
+ * Get the category of a tool by name.
+ */
+export declare function getToolCategory(toolMap: Record<string, McpToolDefinition>, name: string): McpToolCategory;
+/**
+ * Get the tool definition by name.
+ */
+export declare function getToolDefinition(toolMap: Record<string, McpToolDefinition>, name: string): McpToolDefinition;
+/**
+ * Check if a result is a MutationAction.
+ */
+export declare function isMutationAction(result: unknown): result is MutationAction;
+/**
+ * Check if a result is a QueryResult.
+ */
+export declare function isQueryResult(result: unknown): result is QueryResult;
+/**
+ * Check if a result is a ToolError.
+ */
+export declare function isToolError(result: unknown): result is ToolError;

package/dist/modules/agent/runtime/app/helpers/index.js

@@ -0,0 +1,68 @@
+import { coerceStringifiedParams } from "#blokkli/agent/shared/toolParams";
+export function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+export function splitMeta(raw) {
+  const obj = asRecord(raw);
+  if (!obj) return { payload: raw, meta: {} };
+  const meta = {};
+  if (obj._details !== void 0) meta.details = obj._details;
+  if (obj._usage) meta.usage = obj._usage;
+  if (obj._skipLlmResponse === true) meta.skipLlmResponse = true;
+  if (Object.keys(meta).length === 0) {
+    return { payload: raw, meta };
+  }
+  const { _details: _, _usage: __, _skipLlmResponse: ___, ...payload } = obj;
+  return { payload, meta };
+}
+export function createToolMap(tools) {
+  return Object.fromEntries(tools.map((t) => [t.name, t]));
+}
+export async function getToolInfoForServer(tools, editMode, app, adapter) {
+  const staticFiltered = tools.filter((tool) => {
+    if (!tool.modes.includes(editMode)) return false;
+    if (!tool.requiredAdapterMethods) return true;
+    if (!adapter) return true;
+    return tool.requiredAdapterMethods.every(
+      (method) => typeof adapter[method] === "function"
+    );
+  });
+  const availability = await Promise.all(
+    staticFiltered.map(
+      (tool) => tool.isAvailable ? Promise.resolve(tool.isAvailable(app)) : true
+    )
+  );
+  return staticFiltered.filter((_, index) => availability[index]).map((t) => t.name);
+}
+export async function executeTool(toolMap, name, context, params) {
+  const tool = toolMap[name];
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  const coerced = coerceStringifiedParams(params);
+  const validatedParams = tool.paramsSchema.parse(coerced);
+  return tool.execute(context, validatedParams);
+}
+export function getToolCategory(toolMap, name) {
+  const tool = toolMap[name];
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool.category;
+}
+export function getToolDefinition(toolMap, name) {
+  const tool = toolMap[name];
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool;
+}
+export function isMutationAction(result) {
+  return typeof result === "object" && result !== null && "type" in result && "label" in result && "apply" in result && typeof result.apply === "function";
+}
+export function isQueryResult(result) {
+  return typeof result === "object" && result !== null && "label" in result && "result" in result && !("apply" in result);
+}
+export function isToolError(result) {
+  return typeof result === "object" && result !== null && "error" in result && typeof result.error === "string";
+}

package/dist/modules/agent/runtime/app/helpers/injections.d.ts

@@ -0,0 +1,3 @@
+import type { InjectionKey } from '#imports';
+import type { AgentApp } from '#blokkli/agent/app/types';
+export declare const INJECT_AGENT_APP: InjectionKey<AgentApp>;

package/dist/modules/agent/runtime/app/helpers/injections.js

@@ -0,0 +1,3 @@
+export const INJECT_AGENT_APP = Symbol(
+  "blokkli_agent_app"
+);

package/dist/modules/agent/runtime/app/helpers/linkifyBlockUuids.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Replace bare block UUIDs in markdown text with clickable chips. Known UUIDs
+ * become `<a class="bk-agent-block-ref" href="#uuid">label</a>`; UUIDs whose
+ * block is no longer on the page become a non-clickable
+ * `<span class="bk-agent-block-ref-deleted">[<deletedLabel>]</span>`.
+ *
+ * UUIDs inside fenced or inline code regions and UUIDs already used as a link
+ * target (preceded by `#`) are left alone, so existing `[text](#uuid)` links
+ * from older conversations pass through unchanged.
+ */
+export declare function linkifyBlockUuids(content: string, resolve: (uuid: string) => string | null, deletedLabel: string): string;