@blokkli/editor 2.0.0-alpha.4 → 2.0.0-alpha.40

package/dist/modules/agent/index.mjs

@@ -0,0 +1,768 @@
+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, e as extractStringProperty } from '../../shared/editor.9vf8ZnOp.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, buildSync } from 'esbuild';
+import 'typescript';
+import 'oxc-walker';
+
+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);
+    const name = extractStringProperty(
+      this.fileContents,
+      [this.composable],
+      "name"
+    );
+    this.item = {
+      filePath: this.filePath,
+      importName,
+      name
+    };
+    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());
+  }
+  /**
+   * Get the extracted `name` values from all valid items.
+   */
+  getNames() {
+    return this.getItems().filter((item) => item.name !== void 0).map((item) => item.name);
+  }
+}
+
+function createClientTemplate(toolCollector, promptCollector, skillsCollector, options) {
+  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(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 toolNames = ${JSON.stringify(toolCollector.getNames())}`
+      );
+      exports$1.push(
+        `export const skillNames = ${JSON.stringify(skillsCollector.getNames())}`
+      );
+      const parts = [];
+      if (imports.length > 0) {
+        parts.push(imports.join("\n"));
+      }
+      parts.push(exports$1.join("\n"));
+      return parts.join("\n\n") + "\n";
+    },
+    (ctx) => {
+      const tools = toolCollector.getItems();
+      const skillNamesList = skillsCollector.getNames();
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.ts$/, "");
+      const agentSkillNameType = skillNamesList.length > 0 ? skillNamesList.map((n) => `'${n}'`).join(" | ") : "string";
+      const toolsWithNames = tools.filter((t) => t.name !== void 0);
+      let toolMapBlock;
+      let agentToolNameType;
+      if (toolsWithNames.length > 0) {
+        const entries = toolsWithNames.map((t) => {
+          const importPath = rel(t.filePath);
+          return `  '${t.name}': {
+    params: _ToolParams<typeof import('${importPath}')['default']>
+    result: _ToolResult<typeof import('${importPath}')['default']>
+  }`;
+        }).join("\n");
+        toolMapBlock = `export interface AgentToolMap {
+${entries}
+}`;
+        agentToolNameType = "keyof AgentToolMap";
+      } else {
+        toolMapBlock = `export type AgentToolMap = Record<string, { params: Record<string, unknown>; result: unknown }>`;
+        agentToolNameType = "string";
+      }
+      return `import type { z } from 'zod'
+import type { McpToolDefinition, AgentPromptItem } from '#blokkli/agent/app/types'
+import type { AgentModelDefinition } from '#blokkli/agent/shared/types'
+
+type _ToolParams<T> = T extends { paramsSchema: infer P extends z.ZodType } ? z.infer<P> : never
+type _ToolResult<T> = T extends { resultSchema: infer R extends z.ZodType } ? z.infer<R> : never
+
+${toolMapBlock}
+
+export type AgentToolName = ${agentToolNameType}
+export type AgentSkillName = ${agentSkillNameType}
+
+export const mcpTools: McpToolDefinition[]
+export const agentPrompts: AgentPromptItem[]
+export const defaultPrompts: string[]
+export const agentName: string
+export const models: AgentModelDefinition[]
+export const hasWebFetch: boolean
+export const toolNames: readonly AgentToolName[]
+export const skillNames: readonly AgentSkillName[]
+`;
+    }
+  );
+}
+
+function createServerTemplate(options) {
+  const {
+    moduleOptions,
+    providersPath,
+    sharedTypesPath,
+    skillsCollector,
+    skillsTypesPath,
+    systemPromptCollector,
+    systemPromptTypesPath,
+    mcpToolsCollector
+  } = 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 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")}
+
+export const allowedFetchOrigins = ${originsJson}
+
+export const provider = ${providerCreate}
+
+export const models = ${JSON.stringify(models)}
+export const debugPrompt = ${!!moduleOptions.debugPrompt}
+
+${skillsExport}
+
+${systemPromptsExport}
+
+${toolDefinitionsExport}
+`;
+    },
+    (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, ServerToolMetadata } 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[]
+export const toolDefinitions: ServerToolMetadata[]
+`;
+    },
+    {
+      context: "server",
+      write: true
+    }
+  );
+}
+
+const QUERY = "?blokkliAgentTool";
+const PROPERTIES_TO_KEEP = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "category",
+  "paramsSchema",
+  "modes",
+  "lazy",
+  "volatile",
+  "requiredAdapterMethods",
+  "requiredFeatures",
+  "resolve"
+]);
+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 {
+        return 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 treeShake(code) {
+  const result = buildSync({
+    stdin: { contents: code, loader: "js", resolveDir: "/tmp" },
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "esnext",
+    treeShaking: true,
+    external: ["*"]
+  });
+  return result.outputFiles[0].text;
+}
+function removeDeadImports(code) {
+  const ast = parse(code, {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  });
+  const importRanges = [];
+  walk(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const n = node;
+        importRanges.push({ start: n.start, end: n.end });
+      }
+    },
+    leave() {
+    }
+  });
+  const usedIds = /* @__PURE__ */ new Set();
+  walk(ast, {
+    enter(node) {
+      if (node.type === "Identifier") {
+        const n = node;
+        const inImport = importRanges.some(
+          (r) => n.start >= r.start && n.start < r.end
+        );
+        if (!inImport) {
+          usedIds.add(n.name);
+        }
+      }
+    },
+    leave() {
+    }
+  });
+  const s = new MagicString(code);
+  walk(ast, {
+    enter(node) {
+      if (node.type !== "ImportDeclaration") return;
+      const importDecl = node;
+      const hasUsedBinding = (importDecl.specifiers || []).some(
+        (spec) => usedIds.has(spec.local.name)
+      );
+      if (!hasUsedBinding) {
+        let removeEnd = importDecl.end;
+        if (code[removeEnd] === "\n") {
+          removeEnd++;
+        }
+        s.remove(importDecl.start, removeEnd);
+      }
+    },
+    leave() {
+    }
+  });
+  return s.toString();
+}
+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;
+  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_KEEP.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 = removeDeadImports(treeShake(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 STREAM_ROUTE = "/api/blokkli/agent/stream";
+const ROUTE_ROUTE = "/api/blokkli/agent/route";
+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 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,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "tools"))
+      ]
+    });
+    ctx.context.addCollector(mcpTools);
+    const modulePromptsDir = moduleResolver.resolve("./runtime/app/prompts");
+    const projectPromptsDir = path.resolve(
+      nuxt.options.rootDir,
+      "blokkli/prompts"
+    );
+    const promptsCollector = new AgentCollector(ctx.helper, {
+      composable: "defineBlokkliAgentPrompt",
+      importPrefix: "prompt",
+      dependency: "agent-prompts",
+      dirs: [
+        modulePromptsDir,
+        projectPromptsDir,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "prompts"))
+      ]
+    });
+    ctx.context.addCollector(promptsCollector);
+    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);
+    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"
+    );
+    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,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "skills"))
+      ]
+    });
+    ctx.context.addCollector(skillsCollector);
+    ctx.context.addTemplate(
+      createClientTemplate(
+        mcpTools,
+        promptsCollector,
+        skillsCollector,
+        options
+      )
+    );
+    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,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "system-prompts"))
+      ]
+    });
+    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"
+        ),
+        mcpToolsCollector: mcpTools
+      })
+    );
+    addServerHandler({
+      route: AGENT_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/agent"),
+      lazy: true
+    });
+    addServerHandler({
+      route: FETCH_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/fetch")
+    });
+    addServerHandler({
+      route: STREAM_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/stream")
+    });
+    addServerHandler({
+      route: ROUTE_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/route")
+    });
+    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);
+      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) => {
+        Reflect.deleteProperty(types.routes, AGENT_ROUTE);
+        Reflect.deleteProperty(types.routes, FETCH_ROUTE);
+        Reflect.deleteProperty(types.routes, STREAM_ROUTE);
+        Reflect.deleteProperty(types.routes, ROUTE_ROUTE);
+      });
+    });
+  }
+});
+
+export { index as default };