@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.33

package/dist/modules/agent/index.d.mts

@@ -0,0 +1,64 @@
+import { B as BlokkliModule } from '../../shared/editor.Iax3GCvt.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+type AgentProvider = 'anthropic' | 'openai';
+type AgentModelDefinition = {
+    name: string;
+    label: string;
+    isDefault?: boolean;
+    pricing?: {
+        input: number;
+        cacheWrite: number;
+        cacheRead: number;
+        output: number;
+    };
+};
+type AgentModuleOptions = {
+    /**
+     * Allowed origins for the fetch endpoint.
+     * URLs that the agent is allowed to fetch content from.
+     */
+    allowedFetchOrigins?: string[];
+    /**
+     * AI provider to use.
+     * - 'anthropic': Uses Anthropic's Claude models (default)
+     * - 'openai': Uses OpenAI's GPT models (requires openai npm package)
+     *
+     * NOTE: The API key needs to be provided at runtime via runtime config:
+     *
+     * NUXT_BLOKKLI_AGENT_API_KEY=hunter2
+     */
+    provider: AgentProvider;
+    /**
+     * Available models for the AI provider.
+     *
+     * At least one model must be defined. The model marked with `isDefault: true`
+     * (or the first model if none is marked) is used for conversations.
+     */
+    models: AgentModelDefinition[];
+    /**
+     * Debug the system prompt.
+     *
+     * If true (and only during dev mode), the system prompt is adjusted to explicitly allow asking about internals (such as available MCP tools, the system prompt itself, etc.).
+     */
+    debugPrompt?: boolean;
+    /**
+     * Default prompt suggestions shown in the welcome screen.
+     *
+     * These are displayed as clickable buttons when the conversation is empty.
+     */
+    defaultPrompts?: string[];
+    /**
+     * The name of the agent as shown to the user.
+     */
+    agentName?: string;
+};
+
+declare const _default: (options: AgentModuleOptions) => BlokkliModule<AgentModuleOptions>;
+
+export { _default as default };

package/dist/modules/agent/index.mjs

@@ -0,0 +1,407 @@
+import { resolveFiles, createResolver, addServerHandler } from '@nuxt/kit';
+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';
+
+function toImportName(prefix, fileName) {
+  const name = fileName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return `${prefix}${name}`;
+}
+class CollectedAgentFile extends CollectedFile {
+  constructor(filePath, fileContents, composable, importPrefix) {
+    super(filePath, fileContents);
+    this.composable = composable;
+    this.importPrefix = importPrefix;
+  }
+  item = null;
+  async handleChange() {
+    if (!this.fileContents.includes(this.composable)) {
+      this.item = null;
+      return true;
+    }
+    const ext = path.extname(this.filePath);
+    const fileName = path.basename(this.filePath, ext);
+    const baseName = fileName === "index" ? path.basename(path.dirname(this.filePath)) : fileName;
+    const importName = toImportName(this.importPrefix, baseName);
+    this.item = {
+      filePath: this.filePath,
+      importName
+    };
+    return true;
+  }
+  getItem() {
+    return this.item;
+  }
+  isValid() {
+    return this.item !== null;
+  }
+}
+class AgentCollector extends Collector {
+  needsFileContents = true;
+  options;
+  constructor(helper, options) {
+    super(helper);
+    this.options = options;
+  }
+  async init() {
+    for (const dir of this.options.dirs) {
+      try {
+        await fs.promises.access(dir);
+      } catch {
+        continue;
+      }
+      const files = (await resolveFiles(dir, ["**/*.ts", "**/*.js"], {
+        followSymbolicLinks: false
+      })).filter((f) => !f.endsWith(".d.ts"));
+      for (const filePath of files) {
+        await this.addFile(filePath);
+      }
+    }
+  }
+  runHooks() {
+    return Promise.resolve();
+  }
+  async applies(filePath) {
+    const isInDir = this.options.dirs.some((dir) => filePath.startsWith(dir));
+    if (filePath.endsWith(".d.ts")) {
+      return false;
+    }
+    const hasValidExtension = filePath.endsWith(".ts") || filePath.endsWith(".js");
+    return isInDir && hasValidExtension;
+  }
+  createCollectedFile(filePath, fileContents) {
+    return new CollectedAgentFile(
+      filePath,
+      fileContents,
+      this.options.composable,
+      this.options.importPrefix
+    );
+  }
+  getDependencyTypes() {
+    return [this.options.dependency];
+  }
+  /**
+   * Get all collected items that are valid (contain the composable).
+   */
+  getItems() {
+    return [...this.files.values()].filter((v) => v.isValid()).map((v) => v.getItem());
+  }
+}
+
+function createClientTemplate(toolCollector, promptCollector, defaultPrompts, models, agentName) {
+  return defineCodeTemplate(
+    "agent-client",
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.ts$/, "");
+      const tools = toolCollector.getItems();
+      const prompts = promptCollector.getItems();
+      const imports = [];
+      const exports$1 = [];
+      for (const tool of tools) {
+        imports.push(`import ${tool.importName} from '${rel(tool.filePath)}'`);
+      }
+      if (tools.length === 0) {
+        exports$1.push("export const mcpTools = []");
+      } else {
+        exports$1.push(
+          `export const mcpTools = [
+  ${tools.map((t) => t.importName).join(",\n  ")}
+]`
+        );
+      }
+      for (const prompt of prompts) {
+        imports.push(
+          `import ${prompt.importName} from '${rel(prompt.filePath)}'`
+        );
+      }
+      if (prompts.length === 0) {
+        exports$1.push("export const agentPrompts = []");
+      } else {
+        exports$1.push(
+          `export const agentPrompts = [
+  ${prompts.map((p) => p.importName).join(",\n  ")}
+]`
+        );
+      }
+      exports$1.push(
+        `export const defaultPrompts = ${JSON.stringify(defaultPrompts)}`
+      );
+      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"));
+      }
+      parts.push(exports$1.join("\n"));
+      return parts.join("\n\n") + "\n";
+    },
+    () => {
+      return `import type { McpToolItem, AgentPromptItem } from '#blokkli/agent/app/types'
+import type { AgentModelDefinition } from '#blokkli/agent/shared/types'
+
+export const mcpTools: McpToolItem[]
+export const agentPrompts: AgentPromptItem[]
+export const defaultPrompts: string[]
+export const agentName: string
+export const models: AgentModelDefinition[]
+`;
+    }
+  );
+}
+
+function createServerTemplate(options) {
+  const {
+    moduleOptions,
+    providersPath,
+    sharedTypesPath,
+    skillsCollector,
+    skillsTypesPath,
+    systemPromptCollector,
+    systemPromptTypesPath
+  } = options;
+  const { allowedFetchOrigins, provider, models } = moduleOptions;
+  return defineCodeTemplate(
+    "agent-server",
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.ts$/, "");
+      const imports = [];
+      if (provider === "openai") {
+        imports.push(
+          `import { createOpenAIProvider } from '${rel(providersPath)}/openai'`
+        );
+      } else {
+        imports.push(
+          `import { createAnthropicProvider } from '${rel(providersPath)}/anthropic'`
+        );
+      }
+      const providerCreate = provider === "openai" ? "createOpenAIProvider()" : "createAnthropicProvider()";
+      const skills = skillsCollector.getItems();
+      for (const skill of skills) {
+        imports.push(`import ${skill.importName} from '${rel(skill.filePath)}'`);
+      }
+      const skillsExport = skills.length === 0 ? `export const skills = []` : `export const skills = [
+  ${skills.map((s) => s.importName).join(",\n  ")}
+]`;
+      const systemPrompts = systemPromptCollector.getItems();
+      for (const sp of systemPrompts) {
+        imports.push(`import ${sp.importName} from '${rel(sp.filePath)}'`);
+      }
+      const systemPromptsExport = systemPrompts.length === 0 ? `export const systemPrompts = []` : `export const systemPrompts = [
+  ${systemPrompts.map((sp) => sp.importName).join(",\n  ")}
+]`;
+      const originsJson = JSON.stringify(allowedFetchOrigins, null, 2);
+      return `${imports.join("\n")}
+
+export const allowedFetchOrigins = ${originsJson}
+
+export const provider = ${providerCreate}
+
+export const models = ${JSON.stringify(models)}
+export const debugPrompt = ${!!moduleOptions.debugPrompt}
+
+${skillsExport}
+
+${systemPromptsExport}
+`;
+    },
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.ts$/, "");
+      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)}'
+
+export const allowedFetchOrigins: string[]
+export const provider: AIProvider
+export const models: AgentModelDefinition[]
+export const debugPrompt: boolean
+export const skills: SkillDefinition[]
+export const systemPrompts: SystemPromptDefinition[]
+`;
+    },
+    {
+      context: "server",
+      write: true
+    }
+  );
+}
+
+const AGENT_ROUTE = "/api/blokkli/agent";
+const FETCH_ROUTE = "/api/blokkli/agent/fetch";
+const index = defineBlokkliModule({
+  alterOptions: (options) => {
+    options.featureImports ||= [];
+    const moduleResolver = createResolver(
+      fileURLToPath(new URL("./", import.meta.url))
+    );
+    const featurePath = moduleResolver.resolve(
+      "./runtime/app/features/agent/index.vue"
+    );
+    options.featureImports.push(featurePath);
+  },
+  async setup(ctx, options) {
+    if (!options.models?.length) {
+      throw new Error(
+        'Missing bl\xF6kkli agent option "models". At least one model must be defined.'
+      );
+    }
+    if (!options.provider) {
+      throw new Error('Missing bl\xF6kkli agent option "provider".');
+    }
+    if (!ctx.helper.nuxt.options.nitro?.experimental?.websocket) {
+      ctx.helper.logger.error(`Nitro experimental WebSocket support is not enabled.
+
+export default defineNuxtConfig({
+  nitro: {
+    experimental: {
+      websocket: true
+    }
+  }
+})
+`);
+      throw new Error("Experimental WebSocket support of Nitro is not enabled.");
+    }
+    const nuxt = ctx.helper.nuxt;
+    const moduleResolver = createResolver(
+      fileURLToPath(new URL("./", import.meta.url))
+    );
+    ctx.helper.nuxt.options.runtimeConfig.blokkli ||= {};
+    ctx.helper.nuxt.options.runtimeConfig.blokkli.agent ||= {};
+    ctx.helper.nuxt.options.runtimeConfig.blokkli.agent.apiKey ||= "";
+    ctx.helper.nuxt.options.runtimeConfig.blokkli.agent.authSecret ||= "";
+    ctx.helper.addAlias(
+      "#blokkli/agent/app",
+      moduleResolver.resolve("./runtime/app")
+    );
+    ctx.helper.addAlias(
+      "#blokkli/agent/shared",
+      moduleResolver.resolve("./runtime/shared")
+    );
+    ctx.helper.addAlias(
+      "#blokkli/agent/server",
+      moduleResolver.resolve("./runtime/server")
+    );
+    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]
+    });
+    await mcpTools.init();
+    ctx.context.addCollector(mcpTools);
+    const projectPromptsDir = path.resolve(
+      nuxt.options.rootDir,
+      "blokkli/prompts"
+    );
+    const promptsCollector = new AgentCollector(ctx.helper, {
+      composable: "defineBlokkliAgentPrompt",
+      importPrefix: "prompt",
+      dependency: "agent-prompts",
+      dirs: [projectPromptsDir]
+    });
+    await promptsCollector.init();
+    ctx.context.addCollector(promptsCollector);
+    ctx.context.addTemplate(
+      createClientTemplate(
+        mcpTools,
+        promptsCollector,
+        options.defaultPrompts || [],
+        options.models,
+        options.agentName ?? "Blocki"
+      )
+    );
+    const relativeToolsDir = path.relative(
+      nuxt.options.buildDir,
+      projectToolsDir
+    );
+    nuxt.options.typescript.tsConfig ||= {};
+    nuxt.options.typescript.tsConfig.include ||= [];
+    nuxt.options.typescript.tsConfig.include.push(relativeToolsDir);
+    const relativePromptsDir = path.relative(
+      nuxt.options.buildDir,
+      projectPromptsDir
+    );
+    nuxt.options.typescript.tsConfig.include.push(relativePromptsDir);
+    const moduleSkillsDir = moduleResolver.resolve(
+      "./runtime/server/default-skills"
+    );
+    const projectSkillsDir = path.resolve(
+      nuxt.options.rootDir,
+      "blokkli/skills"
+    );
+    const skillsCollector = new AgentCollector(ctx.helper, {
+      composable: "defineBlokkliAgentSkill",
+      importPrefix: "skill",
+      dependency: "agent-server",
+      dirs: [moduleSkillsDir, projectSkillsDir]
+    });
+    await skillsCollector.init();
+    ctx.context.addCollector(skillsCollector);
+    const moduleSystemPromptsDir = moduleResolver.resolve(
+      "./runtime/server/default-system-prompts"
+    );
+    const projectSystemPromptsDir = path.resolve(
+      nuxt.options.rootDir,
+      "blokkli/system-prompts"
+    );
+    const systemPromptCollector = new AgentCollector(ctx.helper, {
+      composable: "defineBlokkliAgentSystemPrompt",
+      importPrefix: "systemPrompt",
+      dependency: "agent-server",
+      dirs: [moduleSystemPromptsDir, projectSystemPromptsDir]
+    });
+    await systemPromptCollector.init();
+    ctx.context.addCollector(systemPromptCollector);
+    ctx.context.addTemplate(
+      createServerTemplate({
+        moduleOptions: options,
+        providersPath: moduleResolver.resolve("./runtime/server/providers"),
+        sharedTypesPath: moduleResolver.resolve("./runtime/shared/types"),
+        skillsCollector,
+        skillsTypesPath: moduleResolver.resolve(
+          "./runtime/server/skills/types"
+        ),
+        systemPromptCollector,
+        systemPromptTypesPath: moduleResolver.resolve(
+          "./runtime/server/system-prompts/types"
+        )
+      })
+    );
+    addServerHandler({
+      route: AGENT_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/agent"),
+      lazy: true
+    });
+    addServerHandler({
+      route: FETCH_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/fetch")
+    });
+    const relativeSkillsDir = path.relative(
+      nuxt.options.buildDir,
+      projectSkillsDir
+    );
+    const relativeSystemPromptsDir = path.relative(
+      nuxt.options.buildDir,
+      projectSystemPromptsDir
+    );
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.typescript ||= {};
+      nitroConfig.typescript.tsConfig ||= {};
+      nitroConfig.typescript.tsConfig.include ||= [];
+      nitroConfig.typescript.tsConfig.include.push(relativeSkillsDir);
+      nitroConfig.typescript.tsConfig.include.push(relativeSystemPromptsDir);
+    });
+    nuxt.hook("nitro:init", (nitro) => {
+      nitro.hooks.hook("types:extend", (types) => {
+        Reflect.deleteProperty(types.routes, AGENT_ROUTE);
+        Reflect.deleteProperty(types.routes, FETCH_ROUTE);
+      });
+    });
+  }
+});
+
+export { index as default };

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

@@ -0,0 +1,55 @@
+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 { AgentConversationSummary } from '#blokkli/agent/app/features/agent/types';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
+export type PendingMutationState = {
+    action: MutationAction;
+    resolve: (approved: boolean) => void;
+};
+export type PendingToolCall = {
+    toolName: string;
+    params: Record<string, unknown>;
+};
+export type AgentProviderOptions = {
+    app: BlokkliApp;
+    adapter: FullBlokkliAdapter<any>;
+    itemEntityType: string;
+};
+export type AgentProvider = {
+    isConnected: Readonly<Ref<boolean>>;
+    isReady: Readonly<Ref<boolean>>;
+    hasBeenReady: Readonly<Ref<boolean>>;
+    connect: () => void;
+    disconnect: () => void;
+    conversation: Ref<ConversationItem[]>;
+    activeItem: Ref<ActiveItem | null>;
+    isProcessing: Ref<boolean>;
+    isThinking: Ref<boolean>;
+    autoApprove: Ref<boolean>;
+    pendingMutation: Ref<PendingMutationState | null>;
+    pendingToolCall: Ref<PendingToolCall | null>;
+    plan: Ref<ClientPlanState | null>;
+    approvePlan: () => void;
+    rejectPlan: () => void;
+    usageTurns: Ref<UsageTurn[]>;
+    sendPrompt: (text: string, displayPrompt?: string, selectedUuids?: string[], attachments?: Attachment[]) => void;
+    retry: () => void;
+    approve: () => void;
+    reject: () => void;
+    setAutoApprove: (value: boolean) => void;
+    cancel: () => void;
+    newConversation: () => void;
+    getTranscript: () => void;
+    onToolComponentDone: (result: unknown) => void;
+    transcriptContent: Ref<string>;
+    showTranscript: Ref<boolean>;
+    conversationList: Ref<AgentConversationSummary[]>;
+    showConversationList: Ref<boolean>;
+    activeConversationId: Readonly<Ref<string | null>>;
+    switchConversation: (id: string) => void;
+    deleteConversation: (id: string) => void;
+    refreshConversationList: () => Promise<void>;
+};
+export default function (app: BlokkliApp, adapter: FullBlokkliAdapter<any>, agentName: string): AgentProvider;