@blokkli/editor 2.0.0-alpha.55 → 2.0.0-alpha.57

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@blokkli/editor",
   "configKey": "blokkli",
-  "version": "2.0.0-alpha.55",
+  "version": "2.0.0-alpha.57",
   "compatibility": {
     "nuxt": ">=3.15.0"
   },

package/dist/module.mjs

@@ -19,7 +19,7 @@ import 'typescript';
 import 'oxc-walker';
 
 const name = "@blokkli/editor";
-const version = "2.0.0-alpha.55";
+const version = "2.0.0-alpha.57";
 
 function validateOption(optionKey, option, icons) {
   const errors = [];

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

@@ -1,4 +1,6 @@
 export { defineBlokkliAgentTool } from './defineBlokkliAgentTool.js';
 export { defineBlokkliAgentPrompt } from './defineBlokkliAgentPrompt.js';
-export type { AgentProvider, AgentProviderOptions, PendingMutationState, PendingToolCall, } from './agentProvider.js';
+export { useAgent } from './useAgent.js';
+export type { PendingMutationState, PendingToolCall, } from '../providers/toolsProvider.js';
+export type { AgentApp } from '../types/index.js';
 export type { AgentConversationData, AgentConversationSummary, } from '../features/agent/types.js';

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

@@ -1,2 +1,3 @@
 export { defineBlokkliAgentTool } from "./defineBlokkliAgentTool.js";
 export { defineBlokkliAgentPrompt } from "./defineBlokkliAgentPrompt.js";
+export { useAgent } from "./useAgent.js";

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

@@ -0,0 +1,6 @@
+import type { AgentApp } from '#blokkli/agent/app/types';
+/**
+ * Access the agent app from any component below the agent Container.
+ * Mirrors `useBlokkli()` for the editor.
+ */
+export declare function useAgent(): AgentApp;

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

@@ -0,0 +1,11 @@
+import { inject } from "#imports";
+import { INJECT_AGENT_APP } from "#blokkli/agent/app/helpers/injections";
+export function useAgent() {
+  const app = inject(INJECT_AGENT_APP);
+  if (!app) {
+    throw new Error(
+      "useAgent() called outside the agent Container \u2014 make sure the agent feature is mounted."
+    );
+  }
+  return app;
+}

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

@@ -2,57 +2,57 @@
   <AgentPanel
     :is-shown
     :agent-name
-    :conversation
-    :active-item
-    :is-thinking
-    :is-processing
-    :is-connected
-    :has-been-ready
-    :pending-tool-call
-    :pending-mutation
-    :auto-approve
-    :conversation-list
-    :show-conversation-list
-    :plan
-    :tool-details
-    :usage-turns="usageTurns"
-    :page-context="pageContext"
+    :conversation="conversation.items.value"
+    :active-item="conversation.activeItem.value"
+    :is-thinking="agent.isThinking.value"
+    :is-processing="agent.isProcessing.value"
+    :is-connected="socket.isConnected.value"
+    :has-been-ready="agent.hasBeenReady.value"
+    :pending-tool-call="tools.pendingToolCall.value"
+    :pending-mutation="tools.pendingMutation.value"
+    :auto-approve="tools.autoApprove.value"
+    :conversation-list="conversation.conversationList.value"
+    :show-conversation-list="conversation.showConversationList.value"
+    :plan="plan.plan.value"
+    :tool-details="conversation.toolDetails"
+    :usage-turns="conversation.usageTurns.value"
+    :page-context="tools.pageContext.value"
     :supports-feedback="!!adapter.submitConversationFeedback"
-    :feedback-item-ids="feedbackItemIds"
-    @connect="connect"
-    @send-prompt="sendPrompt"
-    @retry="retry"
-    @cancel="cancel"
-    @approve="approve"
-    @reject="reject"
-    @set-auto-approve="setAutoApprove"
-    @new-conversation="newConversation"
-    @get-transcript="getTranscript"
-    @tool-component-done="onToolComponentDone"
-    @switch-conversation="switchConversation"
-    @delete-conversation="deleteConversation"
+    :feedback-item-ids="conversation.feedbackItemIds.value"
+    @connect="agent.connect"
+    @send-prompt="agent.sendPrompt"
+    @retry="agent.retry"
+    @cancel="agent.cancel"
+    @approve="tools.approve"
+    @reject="tools.reject"
+    @set-auto-approve="tools.setAutoApprove"
+    @new-conversation="agent.newConversation"
+    @get-transcript="agent.getTranscript"
+    @tool-component-done="tools.onComponentDone"
+    @switch-conversation="agent.switchConversation"
+    @delete-conversation="agent.deleteConversation"
     @submit-feedback="onSubmitFeedback"
     @feedback-done="onFeedbackDone"
     @show-conversations="onShowConversations"
     @hide-conversations="onHideConversations"
-    @approve-plan="approvePlan"
-    @reject-plan="rejectPlan"
+    @approve-plan="plan.approve"
+    @reject-plan="plan.reject"
   />
 
   <Teleport :to="ui.mainLayoutElement.value">
     <BlokkliTransition name="slide-up">
       <DialogModal
-        v-if="showTranscript"
+        v-if="conversation.showTranscript.value"
         id="agent-transcript"
         title="Agent Transcript"
         :width="900"
         hide-buttons
         full-screen
-        @cancel="showTranscript = false"
+        @cancel="conversation.showTranscript.value = false"
       >
         <AgentTranscript
-          v-if="transcriptContent"
-          :transcript="transcriptContent"
+          v-if="conversation.transcriptContent.value"
+          :transcript="conversation.transcriptContent.value"
         />
       </DialogModal>
     </BlokkliTransition>
@@ -64,10 +64,16 @@ import {
   useBlokkli,
   onBeforeUnmount,
   watch,
+  provide,
   defineAsyncComponent
 } from "#imports";
 import { DialogModal, BlokkliTransition } from "#blokkli/editor/components";
-import agentProvider from "#blokkli/agent/app/composables/agentProvider";
+import socketProvider from "#blokkli/agent/app/providers/socketProvider";
+import conversationProvider from "#blokkli/agent/app/providers/conversationProvider";
+import planProvider from "#blokkli/agent/app/providers/planProvider";
+import toolsProvider from "#blokkli/agent/app/providers/toolsProvider";
+import agentProvider from "#blokkli/agent/app/providers/agentProvider";
+import { INJECT_AGENT_APP } from "#blokkli/agent/app/helpers/injections";
 import AgentPanel from "./Panel/index.vue";
 const AgentTranscript = defineAsyncComponent(
   () => import("./Transcript/index.vue")
@@ -79,54 +85,43 @@ const props = defineProps({
   pendingPromptRequest: { type: [Object, null], required: true }
 });
 const emit = defineEmits(["consumed"]);
-const app = useBlokkli();
-const { ui } = app;
-const {
-  connect,
-  disconnect,
+const blokkli = useBlokkli();
+const { ui } = blokkli;
+const socket = socketProvider();
+const conversation = conversationProvider({ adapter: props.adapter });
+const plan = planProvider({ socket, conversation });
+const tools = toolsProvider({
+  app: blokkli,
+  adapter: props.adapter,
+  socket,
+  conversation
+});
+const agent = agentProvider({
+  app: blokkli,
+  adapter: props.adapter,
+  agentName: props.agentName,
+  socket,
   conversation,
-  activeItem,
-  isProcessing,
-  isThinking,
-  isConnected,
-  hasBeenReady,
-  autoApprove,
-  pendingMutation,
-  pendingToolCall,
   plan,
-  approvePlan,
-  rejectPlan,
-  usageTurns,
-  sendPrompt,
-  runToolForPrompt,
-  retry,
-  approve,
-  reject,
-  setAutoApprove,
-  cancel,
-  newConversation,
-  getTranscript,
-  onToolComponentDone,
-  transcriptContent,
-  showTranscript,
-  toolDetails,
-  conversationList,
-  showConversationList,
-  switchConversation,
-  deleteConversation,
-  refreshConversationList,
-  activeConversationId,
-  feedbackItemIds,
-  pageContext
-} = agentProvider(app, props.adapter, props.agentName);
+  tools
+});
+const adapter = props.adapter;
+const agentApp = {
+  socket,
+  conversation,
+  plan,
+  tools,
+  ...agent
+};
+provide(INJECT_AGENT_APP, agentApp);
 async function onSubmitFeedback(rating, comment) {
-  if (!props.adapter.submitConversationFeedback) return;
-  const conversationId = activeConversationId.value;
+  if (!adapter.submitConversationFeedback) return;
+  const conversationId = conversation.activeConversationId.value;
   if (!conversationId) return;
-  const lastItem = conversation.value[conversation.value.length - 1];
+  const lastItem = conversation.items.value[conversation.items.value.length - 1];
   if (!lastItem) return;
   try {
-    await props.adapter.submitConversationFeedback({
+    await adapter.submitConversationFeedback({
       conversationId,
       rating,
       lastItemId: lastItem.id,
@@ -137,17 +132,17 @@ async function onSubmitFeedback(rating, comment) {
   }
 }
 function onFeedbackDone() {
-  const lastItem = conversation.value[conversation.value.length - 1];
+  const lastItem = conversation.items.value[conversation.items.value.length - 1];
   if (lastItem) {
-    feedbackItemIds.value.add(lastItem.id);
+    conversation.feedbackItemIds.value.add(lastItem.id);
   }
 }
 async function onShowConversations() {
-  await refreshConversationList();
-  showConversationList.value = true;
+  await agent.refreshConversationList();
+  conversation.showConversationList.value = true;
 }
 function onHideConversations() {
-  showConversationList.value = false;
+  conversation.showConversationList.value = false;
 }
 watch(
   () => props.pendingPromptRequest,
@@ -155,22 +150,22 @@ watch(
     if (!request) return;
     emit("consumed");
     const { prompt, selectedUuids } = request;
-    const promptText = prompt.getPrompt(app);
-    const userPromptText = prompt.getUserPrompt?.(app);
+    const promptText = prompt.getPrompt(blokkli);
+    const userPromptText = prompt.getUserPrompt?.(blokkli);
     let preSeededResults = void 0;
     let autoExecuteTools = void 0;
     if (prompt.preExecute) {
       const preResult = await prompt.preExecute({
-        app,
+        app: blokkli,
         selectedUuids,
-        runTool: runToolForPrompt
+        runTool: tools.runForPrompt
       });
       if (preResult) {
         preSeededResults = preResult.preSeededResults;
         autoExecuteTools = preResult.autoExecuteTools;
       }
     }
-    sendPrompt(
+    agent.sendPrompt(
       promptText,
       userPromptText,
       selectedUuids,
@@ -184,7 +179,7 @@ watch(
   { immediate: true }
 );
 onBeforeUnmount(() => {
-  disconnect();
+  agent.disconnect();
 });
 </script>
 

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/index.d.ts

@@ -1,7 +1,21 @@
-import type { McpToolDefinition, McpToolContext, McpToolCategory, MutationAction, QueryResult, ToolError } from '#blokkli/agent/app/types';
+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.
  */

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

@@ -1,3 +1,19 @@
+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]));
 }

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/providers/agentProvider.d.ts

@@ -0,0 +1,33 @@
+import { type Ref } from '#imports';
+import type { Attachment, PreSeededToolResult, AutoExecuteTool } from '#blokkli/agent/app/types';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
+import type { SocketProvider } from './socketProvider.js';
+import type { ConversationProvider } from './conversationProvider.js';
+import type { PlanProvider } from './planProvider.js';
+import type { ToolsProvider } from './toolsProvider.js';
+export type AgentOrchestrator = {
+    isReady: Ref<boolean>;
+    hasBeenReady: Ref<boolean>;
+    isProcessing: Ref<boolean>;
+    isThinking: Ref<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+    sendPrompt: (prompt: string, displayPrompt?: string, selectedUuids?: string[], attachments?: Attachment[], autoLoadTools?: string[], autoLoadSkills?: string[], preSeededResults?: PreSeededToolResult[], autoExecuteTools?: AutoExecuteTool[]) => void;
+    retry: () => void;
+    cancel: () => void;
+    newConversation: () => void;
+    getTranscript: () => void;
+    switchConversation: (id: string) => Promise<void>;
+    deleteConversation: (id: string) => Promise<void>;
+    refreshConversationList: () => Promise<void>;
+};
+export default function agentProvider({ app, adapter, agentName, socket, conversation, plan, tools, }: {
+    app: BlokkliApp;
+    adapter: FullBlokkliAdapter<any>;
+    agentName: string;
+    socket: SocketProvider;
+    conversation: ConversationProvider;
+    plan: PlanProvider;
+    tools: ToolsProvider;
+}): AgentOrchestrator;