@circuitwall/jarela 0.14.0 → 1.0.0

package/lib/tools/extension-surfaces.ts

@@ -0,0 +1,153 @@
+// Meta-introspection: a hand-curated catalog of every place a third party
+// (or the agent itself, on behalf of the user) can extend or customize the
+// app. Read-only. The tool returns a structured map that points to the
+// registration entrypoint, the integration guide section, and an example
+// file for each surface — so the agent can answer "how do I add an X?"
+// or "what can be customized" without needing the docs in its context.
+//
+// SOURCE OF TRUTH: this file. When a new extension surface lands, add an
+// entry below — it's a single source for both the agent runtime and the
+// `docs/EXTENDING.md` table-of-contents anchor.
+
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { registerTools } from "./registry";
+
+interface ExtensionSurface {
+  id: string;
+  name: string;
+  summary: string;
+  registration_entrypoint: string;
+  doc_section: string;
+  example_path?: string;
+  introspection_tool?: string;
+  related_adrs: string[];
+}
+
+const SURFACES: readonly ExtensionSurface[] = [
+  {
+    id: "llm_provider_builtin",
+    name: "Built-in LLM provider",
+    summary:
+      "Add a new in-tree adapter (Anthropic, OpenAI, Gemini, … pattern). " +
+      "Implements the ModelProvider interface and is registered via the static " +
+      "BUILTINS map in lib/providers/index.ts.",
+    registration_entrypoint: "lib/providers/index.ts (BUILTINS map)",
+    doc_section: "docs/EXTENDING.md#adding-an-llm-provider-built-in",
+    example_path: "lib/providers/anthropic.ts",
+    introspection_tool: "list_providers",
+    related_adrs: ["ADR-0013"],
+  },
+  {
+    id: "llm_provider_external",
+    name: "External LLM provider plugin",
+    summary:
+      "Drop a `.cjs` plugin into ~/.jarela/providers/ that exports an object " +
+      "matching ModelProvider. Hot-loaded per call (no rebuild).",
+    registration_entrypoint: "~/.jarela/providers/<name>.cjs",
+    doc_section: "docs/EXTENDING.md#adding-an-llm-provider-external",
+    example_path: "lib/providers/template-external.cjs.example",
+    introspection_tool: "list_providers",
+    related_adrs: ["ADR-0013"],
+  },
+  {
+    id: "builtin_tool",
+    name: "Built-in tool",
+    summary:
+      "Add a tool callable by the agent. Implement with @langchain/core/tools, " +
+      "register with `registerTools(category, capability, [tool])`, and add a " +
+      "side-effect import in lib/tools/builtins.ts. Capability gating is " +
+      "read | write | execute.",
+    registration_entrypoint: "lib/tools/<name>.ts (registerTools call) + lib/tools/builtins.ts",
+    doc_section: "docs/EXTENDING.md#adding-a-built-in-tool",
+    example_path: "lib/tools/template.ts",
+    introspection_tool: "list_tools",
+    related_adrs: ["ADR-0038"],
+  },
+  {
+    id: "mcp_server",
+    name: "MCP server",
+    summary:
+      "Connect a Model Context Protocol server (stdio or http transport). " +
+      "Configured via the UI (mcp_servers DB table) or programmatically through " +
+      "lib/stores/mcp-servers.ts. Tools auto-merge into the same pool as " +
+      "built-ins. Online discovery via the MCP registry is also supported.",
+    registration_entrypoint: "lib/stores/mcp-servers.ts (upsertMcpServer)",
+    doc_section: "docs/EXTENDING.md#adding-an-mcp-server",
+    introspection_tool: "list_mcp_servers",
+    related_adrs: ["ADR-0014"],
+  },
+  {
+    id: "agent_harness",
+    name: "Agent harness",
+    summary:
+      "Compose system-prompt sections that shape an agent's behaviour " +
+      "(plan-first, self-config, capability-listing, etc.). Built-in presets " +
+      "live in lib/agents/harness/presets.ts; custom harnesses are stored in " +
+      "the memory_store under the `app-settings` namespace.",
+    registration_entrypoint: "lib/agents/harness/presets.ts (built-in) or memory_store (custom)",
+    doc_section: "docs/EXTENDING.md#adding-a-custom-harness",
+    related_adrs: ["ADR-0036"],
+  },
+  {
+    id: "integration_manifest",
+    name: "Integration manifest",
+    summary:
+      "Add a new agent-led setup recipe — prerequisites, ordered steps, " +
+      "troubleshooting hints. The agent narrates the recipe and proposes " +
+      "the corresponding config changes through propose_config_change.",
+    registration_entrypoint: "lib/integrations/registry.ts",
+    doc_section: "docs/EXTENDING.md#adding-an-integration-manifest",
+    introspection_tool: "list_integrations",
+    related_adrs: ["ADR-0010"],
+  },
+  {
+    id: "brand_overlay",
+    name: "Brand / app identity",
+    summary:
+      "Customize the app's name, description, and issue URL via environment " +
+      "variables. No code change required. Used by downstream packages that " +
+      "consume @circuitwall/jarela as an npm dep (e.g. brand overlays).",
+    registration_entrypoint: "NEXT_PUBLIC_APP_NAME, NEXT_PUBLIC_APP_DESCRIPTION, NEXT_PUBLIC_APP_ISSUE_URL",
+    doc_section: "docs/EXTENDING.md#branding-the-app",
+    related_adrs: ["ADR-0005"],
+  },
+];
+
+export const describeExtensionSurfacesTool = tool(
+  async () => {
+    return JSON.stringify({
+      surfaces: SURFACES,
+      count: SURFACES.length,
+      guide_path: "docs/EXTENDING.md",
+      contract_paths: [
+        "lib/providers/types.ts (ModelProvider interface)",
+        "lib/tools/types.ts (OpenAITool, ToolContext, InvokeMessage)",
+        "lib/tools/registry.ts (registerTools, ToolCategory, Capability)",
+        "lib/mcp/registry.ts (RegistryEntry, applyVariables)",
+      ],
+      notes: [
+        "Each surface's introspection_tool, when set, lets you enumerate what's " +
+          "currently registered. Call those when the user asks 'what's available' " +
+          "rather than describing the type from memory.",
+        "A surface can have either a static example_path (for external plugins) or " +
+          "no example (for surfaces wired entirely through the UI / DB). When in " +
+          "doubt, the doc_section under EXTENDING.md is the canonical walk-through.",
+      ],
+    });
+  },
+  {
+    name: "describe_extension_surfaces",
+    description:
+      "Return the curated catalog of every extension surface in this app — " +
+      "providers, tools, MCP servers, harnesses, integration manifests, brand " +
+      "overlay. Each entry has a registration entrypoint, an EXTENDING.md " +
+      "section anchor, and (when applicable) the introspection tool that lists " +
+      "what's currently registered. Read-only. Call this when the user asks " +
+      "'how do I add an X?' or 'what can be customized?' so you can guide " +
+      "them with the right files and docs.",
+    schema: z.object({}),
+  },
+);
+
+registerTools("Config", "read", [describeExtensionSurfacesTool]);

package/lib/tools/index.ts

@@ -47,13 +47,32 @@ export {
   type ToolGroup,
 } from "./registry";
 
-const ALL_BUILTINS: StructuredToolInterface[] = registeredTools();
-export const BUILTIN_TOOL_NAMES: ReadonlySet<string> = registeredNames();
+// Live accessors — DO NOT snapshot at module-load time. Some tool modules
+// import back from this file (for `getAllToolsAsync` etc.) and would create
+// a circular import cycle: their `registerTools(...)` call runs AFTER this
+// module finishes evaluating, so any captured snapshot here would miss them
+// and they'd silently disappear from the agent's tool pool. Live calls dodge
+// the problem — by the time anyone INVOKES `getAllTools()` / etc., every
+// builtin has registered.
+function allBuiltins(): StructuredToolInterface[] {
+  return registeredTools();
+}
+function builtinNames(): ReadonlySet<string> {
+  return registeredNames();
+}
+
+// Backwards-compatible export. Callers that import this Set get its current
+// contents at the moment they read it (a fresh Set each access). Internal
+// code prefers `builtinNames()` directly; this stays for external consumers
+// like the extensions API route.
+export function getBuiltinToolNames(): ReadonlySet<string> {
+  return builtinNames();
+}
 
 // Per-call recompute so files dropped in $JARELA_TOOLS_DIR are picked up
 // without restart. loadExternalTools cache-busts require() per file.
 function loadExternal() {
-  return loadExternalTools(BUILTIN_TOOL_NAMES);
+  return loadExternalTools(builtinNames());
 }
 
 export type ToolSource = "builtin" | "external" | "mcp";
@@ -63,7 +82,7 @@ export type ToolSource = "builtin" | "external" | "mcp";
 // neither a registered built-in nor an external (JARELA_TOOLS_DIR) tool —
 // matches today's behavior where MCP tools are everything else.
 export function getToolSource(name: string): ToolSource {
-  if (BUILTIN_TOOL_NAMES.has(name)) return "builtin";
+  if (builtinNames().has(name)) return "builtin";
   if (loadExternal().tools.some((t) => t.name === name)) return "external";
   return "mcp";
 }
@@ -120,7 +139,7 @@ function applyCategoryToggles(tools: StructuredToolInterface[]): StructuredToolI
 // and any code path that can't await.
 export function getAllTools(policy?: ToolPolicy): StructuredToolInterface[] {
   return applyPolicy(
-    [...applyCategoryToggles(ALL_BUILTINS), ...loadExternal().tools],
+    [...applyCategoryToggles(allBuiltins()), ...loadExternal().tools],
     policy,
   );
 }
@@ -137,7 +156,7 @@ export async function getAllToolsAsync(policy?: ToolPolicy): Promise<StructuredT
     console.error("[tools] MCP load failed, continuing with built-ins only:", err);
   }
   return applyPolicy(
-    [...applyCategoryToggles(ALL_BUILTINS), ...loadExternal().tools, ...mcpTools],
+    [...applyCategoryToggles(allBuiltins()), ...loadExternal().tools, ...mcpTools],
     policy,
   );
 }
@@ -161,7 +180,7 @@ export async function executeTool(
   args: Record<string, unknown>,
   context: ToolContext = {},
 ): Promise<unknown> {
-  let t = ALL_BUILTINS.find((x) => x.name === name);
+  let t = allBuiltins().find((x) => x.name === name);
   if (t) {
     const cat = registeredCategory(name);
     if (cat && disabledCategories().has(cat)) {
@@ -204,7 +223,7 @@ export function initTools(): InitToolsSummary {
   const toolsDir = getToolsDir();
   const result = loadExternal();
   const summary: InitToolsSummary = {
-    builtinCount: ALL_BUILTINS.length,
+    builtinCount: allBuiltins().length,
     externalCount: result.tools.length,
     errors: result.errors,
     toolsDir,

package/lib/tools/list-tools.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-list-tools-"));
+process.env.HOME = tmpRoot;
+process.env.USERPROFILE = tmpRoot;
+process.env.JARELA_DB_DIR = join(tmpRoot, ".jarela-dbdir");
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch {}
+});
+
+const { listToolsTool } = await import("./list-tools");
+
+interface Result {
+  tools: Array<{
+    name: string;
+    description: string;
+    category: string;
+    capability: string;
+    source: string;
+    group: string | null;
+  }>;
+  counts: {
+    total: number;
+    by_source: Record<string, number>;
+    by_capability: Record<string, number>;
+  };
+}
+
+function parse(s: string): Result {
+  return JSON.parse(s) as Result;
+}
+
+describe("list_tools", () => {
+  it("returns every built-in tool with category, capability, and source", async () => {
+    const out = parse(await listToolsTool.invoke({}));
+    expect(out.tools.length).toBeGreaterThan(0);
+    expect(out.counts.total).toBe(out.tools.length);
+
+    // Every entry has the documented shape.
+    for (const t of out.tools) {
+      expect(typeof t.name).toBe("string");
+      expect(typeof t.description).toBe("string");
+      expect(["read", "write", "execute"]).toContain(t.capability);
+      expect(["builtin", "external", "mcp"]).toContain(t.source);
+    }
+
+    // Sanity: list_tools itself is registered as builtin/Config/read.
+    const self = out.tools.find((t) => t.name === "list_tools");
+    expect(self).toBeDefined();
+    expect(self?.source).toBe("builtin");
+    expect(self?.category).toBe("Config");
+    expect(self?.capability).toBe("read");
+  });
+
+  it("filters by capability", async () => {
+    const out = parse(await listToolsTool.invoke({ capability: "read" }));
+    expect(out.tools.every((t) => t.capability === "read")).toBe(true);
+    expect(out.counts.total).toBe(out.tools.length);
+  });
+
+  it("filters by source", async () => {
+    const out = parse(await listToolsTool.invoke({ source: "builtin" }));
+    expect(out.tools.every((t) => t.source === "builtin")).toBe(true);
+  });
+
+  it("returns empty list (not error) when filters match nothing", async () => {
+    const out = parse(await listToolsTool.invoke({ source: "external", capability: "read" }));
+    // The clean-tmpdir HOME has no JARELA_TOOLS_DIR, so external is empty
+    // regardless of capability — verifying empty-result is a normal shape.
+    expect(out.tools).toEqual([]);
+    expect(out.counts.total).toBe(0);
+  });
+});

package/lib/tools/list-tools.ts

@@ -0,0 +1,84 @@
+// Read-only introspection tool — lets the agent enumerate every tool it has
+// access to right now (built-in + external + MCP), so it can answer
+// "what's in my toolbox / is X available" without the user having to
+// describe the project's tool surface in the prompt.
+
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import {
+  getAllToolsAsync,
+  getToolCategory,
+  getToolCapability,
+  getToolGroup,
+  getToolSource,
+  type ToolSource,
+} from "./index";
+import type { Capability, ToolCategory } from "./registry";
+import { registerTools } from "./registry";
+
+interface ToolSummary {
+  name: string;
+  description: string;
+  category: ToolCategory;
+  capability: Capability;
+  source: ToolSource;
+  group: string | null;
+}
+
+export const listToolsTool = tool(
+  async ({ category, capability, source }) => {
+    const all = await getAllToolsAsync();
+    const summaries: ToolSummary[] = all.map((t) => ({
+      name: t.name,
+      description: typeof t.description === "string" ? t.description : "",
+      category: getToolCategory(t.name),
+      capability: getToolCapability(t.name),
+      source: getToolSource(t.name),
+      group: getToolGroup(t.name),
+    }));
+
+    const filtered = summaries.filter((s) =>
+      (!category || s.category === category) &&
+      (!capability || s.capability === capability) &&
+      (!source || s.source === source),
+    );
+
+    const counts = {
+      total: filtered.length,
+      by_source: { builtin: 0, external: 0, mcp: 0 } as Record<ToolSource, number>,
+      by_capability: { read: 0, write: 0, execute: 0 } as Record<Capability, number>,
+    };
+    for (const s of filtered) {
+      counts.by_source[s.source]++;
+      counts.by_capability[s.capability]++;
+    }
+
+    return JSON.stringify({ tools: filtered, counts });
+  },
+  {
+    name: "list_tools",
+    description:
+      "List every tool currently available to this agent — built-in tools, " +
+      "external (~/.jarela/providers JS plugins), and MCP server tools — with " +
+      "category, capability (read/write/execute), and source. Read-only. " +
+      "Use this when the user asks 'what can you do?', when picking between " +
+      "tools for a task, or when troubleshooting whether a specific tool is " +
+      "registered. Optional filters narrow by category, capability, or source.",
+    schema: z.object({
+      category: z
+        .string()
+        .optional()
+        .describe("Optional category filter (e.g. 'Files', 'Mail', 'GitHub', 'MCP')"),
+      capability: z
+        .enum(["read", "write", "execute"])
+        .optional()
+        .describe("Optional capability filter — the safety class of the tool"),
+      source: z
+        .enum(["builtin", "external", "mcp"])
+        .optional()
+        .describe("Optional source filter — where the tool came from"),
+    }),
+  },
+);
+
+registerTools("Config", "read", [listToolsTool]);

package/lib/tools/mcp-servers-info.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-mcp-info-"));
+process.env.HOME = tmpRoot;
+process.env.USERPROFILE = tmpRoot;
+process.env.JARELA_DB_DIR = join(tmpRoot, ".jarela-dbdir");
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch {}
+});
+
+const { listMcpServersTool } = await import("./mcp-servers-info");
+const { upsertMcpServer } = await import("@/lib/stores/mcp-servers");
+
+interface Result {
+  servers: Array<{
+    name: string;
+    transport: string;
+    enabled: boolean;
+    last_error: string | null;
+    tool_count: number;
+  }>;
+  count: number;
+  enabled_count: number;
+  total_mcp_tool_count: number;
+  notes: string[];
+}
+
+function parse(s: string): Result {
+  return JSON.parse(s) as Result;
+}
+
+describe("list_mcp_servers", () => {
+  it("returns empty list with zero counts when no servers are configured", async () => {
+    const out = parse(await listMcpServersTool.invoke({}));
+    expect(out.servers).toEqual([]);
+    expect(out.count).toBe(0);
+    expect(out.enabled_count).toBe(0);
+    expect(out.notes.length).toBeGreaterThan(0);
+  });
+
+  it("surfaces configured servers with enabled state and transport", async () => {
+    upsertMcpServer({
+      name: "fake-stdio-server",
+      transport: "stdio",
+      spec: { command: "echo", args: ["hello"] },
+      enabled: false,
+    });
+    upsertMcpServer({
+      name: "fake-http-server",
+      transport: "http",
+      spec: { url: "http://localhost:9999" },
+      enabled: true,
+    });
+
+    const out = parse(await listMcpServersTool.invoke({}));
+    const names = out.servers.map((s) => s.name).sort();
+    expect(names).toEqual(["fake-http-server", "fake-stdio-server"]);
+
+    const stdioRow = out.servers.find((s) => s.name === "fake-stdio-server");
+    expect(stdioRow?.transport).toBe("stdio");
+    expect(stdioRow?.enabled).toBe(false);
+
+    const httpRow = out.servers.find((s) => s.name === "fake-http-server");
+    expect(httpRow?.transport).toBe("http");
+    expect(httpRow?.enabled).toBe(true);
+
+    expect(out.enabled_count).toBe(1);
+    expect(out.count).toBe(2);
+  });
+});

package/lib/tools/mcp-servers-info.ts

@@ -0,0 +1,71 @@
+// Read-only introspection of configured MCP servers — names, transports,
+// enabled/disabled state, last connection error, and the count of tools each
+// server contributes to the live tool pool. Lets the agent answer "why is
+// my Jira tool unavailable?" without bouncing the user through the UI.
+
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { listMcpServers } from "@/lib/stores/mcp-servers";
+import { getAllToolsAsync } from "./index";
+import { getToolSource } from "./index";
+import { registerTools } from "./registry";
+
+interface McpServerSummary {
+  name: string;
+  transport: "stdio" | "http";
+  enabled: boolean;
+  last_error: string | null;
+  tool_count: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export const listMcpServersTool = tool(
+  async () => {
+    const rows = listMcpServers();
+    const allTools = await getAllToolsAsync();
+    // MCP tools don't carry their server name as a structured field — for
+    // the per-server count we count every tool whose source is "mcp", and
+    // we surface the total separately. Per-server attribution would require
+    // a deeper hook into MultiServerMCPClient's tool-namespace metadata,
+    // which is a bigger change than this introspection step warrants today.
+    const totalMcp = allTools.filter((t) => getToolSource(t.name) === "mcp").length;
+
+    const servers: McpServerSummary[] = rows.map((r) => ({
+      name: r.name,
+      transport: r.transport,
+      enabled: r.enabled === 1,
+      last_error: r.last_error,
+      // Per-server tool count not yet attributable; surface total on every
+      // row for now and document the limitation in `notes` below.
+      tool_count: r.enabled === 1 ? totalMcp : 0,
+      created_at: r.created_at,
+      updated_at: r.updated_at,
+    }));
+
+    return JSON.stringify({
+      servers,
+      count: servers.length,
+      enabled_count: servers.filter((s) => s.enabled).length,
+      total_mcp_tool_count: totalMcp,
+      notes: [
+        "tool_count is an aggregate across all enabled MCP servers — per-server " +
+          "attribution requires deeper namespace tracking that's not implemented yet.",
+        "last_error shows the most recent connection error if any; null means " +
+          "the server has never failed since last config change.",
+      ],
+    });
+  },
+  {
+    name: "list_mcp_servers",
+    description:
+      "List every configured MCP server (stdio or http transport) with its " +
+      "enabled state, last connection error, and the aggregate count of MCP " +
+      "tools currently in the agent's pool. Read-only. Use this when " +
+      "diagnosing 'my <X> tool isn't working' — check enabled and last_error " +
+      "before assuming the tool itself is broken.",
+    schema: z.object({}),
+  },
+);
+
+registerTools("Config", "read", [listMcpServersTool]);

package/lib/tools/providers-info.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-providers-info-"));
+process.env.HOME = tmpRoot;
+process.env.USERPROFILE = tmpRoot;
+process.env.JARELA_DB_DIR = join(tmpRoot, ".jarela-dbdir");
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch {}
+});
+
+const { listProvidersTool, describeProviderTool } = await import("./providers-info");
+
+function parse<T = unknown>(s: string): T {
+  return JSON.parse(s) as T;
+}
+
+describe("list_providers", () => {
+  it("returns all built-in providers with source label", async () => {
+    const out = parse<{
+      providers: Array<{ name: string; source: string }>;
+      count: number;
+      builtin_count: number;
+      external_count: number;
+    }>(await listProvidersTool.invoke({}));
+
+    const names = out.providers.map((p) => p.name);
+    expect(names).toContain("anthropic");
+    expect(names).toContain("openai");
+    expect(names).toContain("gemini");
+    expect(out.providers.every((p) => p.source === "builtin" || p.source === "external")).toBe(true);
+    expect(out.count).toBe(out.providers.length);
+    expect(out.builtin_count + out.external_count).toBe(out.count);
+  });
+});
+
+describe("describe_provider", () => {
+  it("returns capability flags and known models for anthropic", async () => {
+    const out = parse<{
+      name: string;
+      source: string;
+      capabilities: Record<string, boolean>;
+      known_models: Array<{ model_id: string; context_length: number }>;
+    }>(await describeProviderTool.invoke({ name: "anthropic" }));
+
+    expect(out.name).toBe("anthropic");
+    expect(out.source).toBe("builtin");
+    expect(out.capabilities.chat).toBe(true);
+    expect(out.capabilities.invoke).toBe(true);
+    expect(out.capabilities.stream_invoke).toBe(true);
+    // Anthropic adapter does not implement embed today.
+    expect(out.capabilities.embed).toBe(false);
+    expect(out.known_models.length).toBeGreaterThan(0);
+    expect(out.known_models.some((m) => m.model_id.startsWith("claude-"))).toBe(true);
+  });
+
+  it("returns an error object (not throw) for unknown provider", async () => {
+    const out = parse<{ error?: string; hint?: string }>(
+      await describeProviderTool.invoke({ name: "nonexistent-provider-xyz" }),
+    );
+    expect(out.error).toBeDefined();
+    expect(out.hint).toMatch(/list_providers/);
+  });
+
+  it("returns an empty known_models list for providers without static catalog", async () => {
+    const out = parse<{ known_models: unknown[] }>(
+      await describeProviderTool.invoke({ name: "langchain" }),
+    );
+    expect(out.known_models).toEqual([]);
+  });
+});