agentool 0.0.1 → 1.0.0

package/dist/chunk-FAEGCFTO.js

@@ -0,0 +1,136 @@
+// src/task/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { randomBytes } from "crypto";
+function generateId() {
+  return randomBytes(4).toString("hex");
+}
+async function loadTasks(filePath) {
+  try {
+    const data = await readFile(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+async function saveTasks(filePath, tasks) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(tasks, null, 2), "utf-8");
+}
+function formatTask(t) {
+  return [
+    `ID: ${t.id}`,
+    `Subject: ${t.subject}`,
+    `Description: ${t.description}`,
+    `Status: ${t.status}`,
+    `Created: ${t.createdAt}`,
+    `Updated: ${t.updatedAt}`
+  ].join("\n");
+}
+function createTask(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const tasksFile = config.tasksFile ?? join(cwd, ".agentool", "tasks.json");
+  return tool({
+    description: "JSON file-based task tracker. Use this to create, get, update, list, and delete tasks. Each task has an id, subject, description, status, and timestamps.",
+    inputSchema: z.object({
+      action: z.enum(["create", "get", "update", "list", "delete"]).describe(
+        "The operation to perform"
+      ),
+      id: z.string().optional().describe(
+        "Task id (required for get, update, delete)"
+      ),
+      subject: z.string().optional().describe(
+        "Task subject (required for create, optional for update)"
+      ),
+      description: z.string().optional().describe(
+        "Task description (required for create, optional for update)"
+      ),
+      status: z.enum(["pending", "in_progress", "completed"]).optional().describe(
+        "Task status (optional for create/update, defaults to pending)"
+      )
+    }),
+    execute: async ({ action, id, subject, description, status }) => {
+      try {
+        switch (action) {
+          case "create":
+            return await createEntry(tasksFile, subject, description, status);
+          case "list":
+            return await listEntries(tasksFile);
+          case "get":
+            return await getEntry(tasksFile, id);
+          case "update":
+            return await updateEntry(tasksFile, id, subject, description, status);
+          case "delete":
+            return await deleteEntry(tasksFile, id);
+          default:
+            return `Error [task]: Unknown action "${String(action)}".`;
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task]: ${msg}`;
+      }
+    }
+  });
+}
+async function createEntry(filePath, subject, description, status) {
+  if (!subject) return "Error [task]: Subject is required for create action.";
+  if (!description) return "Error [task]: Description is required for create action.";
+  const tasks = await loadTasks(filePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: generateId(),
+    subject,
+    description,
+    status: status ?? "pending",
+    createdAt: now,
+    updatedAt: now
+  };
+  tasks.push(entry);
+  await saveTasks(filePath, tasks);
+  return `Created task ${entry.id}.
+${formatTask(entry)}`;
+}
+async function listEntries(filePath) {
+  const tasks = await loadTasks(filePath);
+  if (tasks.length === 0) return "No tasks found.";
+  return tasks.map(formatTask).join("\n---\n");
+}
+async function getEntry(filePath, id) {
+  if (!id) return "Error [task]: ID is required for get action.";
+  const tasks = await loadTasks(filePath);
+  const found = tasks.find((t) => t.id === id);
+  if (!found) return `Error [task]: Task "${id}" not found.`;
+  return formatTask(found);
+}
+async function updateEntry(filePath, id, subject, description, status) {
+  if (!id) return "Error [task]: ID is required for update action.";
+  const tasks = await loadTasks(filePath);
+  const idx = tasks.findIndex((t) => t.id === id);
+  if (idx === -1) return `Error [task]: Task "${id}" not found.`;
+  const entry = tasks[idx];
+  if (subject) entry.subject = subject;
+  if (description) entry.description = description;
+  if (status) entry.status = status;
+  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  tasks[idx] = entry;
+  await saveTasks(filePath, tasks);
+  return `Updated task ${id}.
+${formatTask(entry)}`;
+}
+async function deleteEntry(filePath, id) {
+  if (!id) return "Error [task]: ID is required for delete action.";
+  const tasks = await loadTasks(filePath);
+  const idx = tasks.findIndex((t) => t.id === id);
+  if (idx === -1) return `Error [task]: Task "${id}" not found.`;
+  tasks.splice(idx, 1);
+  await saveTasks(filePath, tasks);
+  return `Deleted task "${id}".`;
+}
+var task = createTask();
+
+export {
+  createTask,
+  task
+};

package/dist/chunk-FV2R5FFQ.cjs

@@ -0,0 +1,102 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/memory/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _promises = require('fs/promises');
+var _path = require('path');
+function sanitizeKey(key) {
+  if (!key || key.trim() === "") {
+    return { err: "Error [memory]: Key must not be empty." };
+  }
+  if (_chunkQZ5GS6HWcjs.containsPathTraversal.call(void 0, key)) {
+    return { err: "Error [memory]: Key contains path traversal and was rejected." };
+  }
+  const cleaned = key.replace(/^\.+/, "");
+  if (cleaned === "") {
+    return { err: "Error [memory]: Key must not be empty after stripping leading dots." };
+  }
+  return { ok: cleaned };
+}
+function createMemory(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const memoryDir = _nullishCoalesce(config.memoryDir, () => ( _path.join.call(void 0, cwd, ".agentool", "memory")));
+  return _ai.tool.call(void 0, {
+    description: "File-based key-value memory store. Use this to persist notes, context, or any text data across conversations. Supports write, read, list, and delete operations.",
+    inputSchema: _zod.z.object({
+      action: _zod.z.enum(["read", "write", "list", "delete"]).describe(
+        "The operation to perform: read, write, list, or delete"
+      ),
+      key: _zod.z.string().optional().describe(
+        "The memory key (required for read, write, delete)"
+      ),
+      content: _zod.z.string().optional().describe(
+        "The content to store (required for write)"
+      )
+    }),
+    execute: async ({ action, key, content }) => {
+      try {
+        if (action === "list") {
+          return await listKeys(memoryDir);
+        }
+        const result = sanitizeKey(key);
+        if ("err" in result) return result.err;
+        const safeKey = result.ok;
+        switch (action) {
+          case "write":
+            return await writeEntry(memoryDir, safeKey, content);
+          case "read":
+            return await readEntry(memoryDir, safeKey);
+          case "delete":
+            return await deleteEntry(memoryDir, safeKey);
+          default:
+            return `Error [memory]: Unknown action "${String(action)}".`;
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [memory]: ${msg}`;
+      }
+    }
+  });
+}
+async function writeEntry(dir, key, content) {
+  if (!content && content !== "") {
+    return "Error [memory]: Content is required for write action.";
+  }
+  await _promises.mkdir.call(void 0, dir, { recursive: true });
+  await _promises.writeFile.call(void 0, _path.join.call(void 0, dir, `${key}.md`), content, "utf-8");
+  return `Saved memory "${key}".`;
+}
+async function readEntry(dir, key) {
+  try {
+    return await _promises.readFile.call(void 0, _path.join.call(void 0, dir, `${key}.md`), "utf-8");
+  } catch (e) {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+async function listKeys(dir) {
+  try {
+    const files = await _promises.readdir.call(void 0, dir);
+    const keys = files.filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3));
+    if (keys.length === 0) return "No memory entries found.";
+    return keys.join("\n");
+  } catch (e2) {
+    return "No memory entries found.";
+  }
+}
+async function deleteEntry(dir, key) {
+  try {
+    await _promises.unlink.call(void 0, _path.join.call(void 0, dir, `${key}.md`));
+    return `Deleted memory "${key}".`;
+  } catch (e3) {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+var memory = createMemory();
+
+
+
+
+exports.createMemory = createMemory; exports.memory = memory;

package/dist/chunk-FW3UJ622.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/context-compaction/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var parametersSchema = _zod.z.object({
+  messages: _zod.z.array(
+    _zod.z.object({
+      role: _zod.z.string().describe("Message role (system, user, assistant)"),
+      content: _zod.z.string().describe("Message content")
+    })
+  ).describe("The conversation messages to compact"),
+  maxTokens: _zod.z.number().optional().describe(
+    "Target maximum tokens (default: config.maxTokens or 4096)"
+  )
+});
+function createContextCompaction(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Compact conversation history by summarizing older messages to reduce context size. Requires a summarize function in config. Returns compacted messages where total chars < maxTokens * 4.",
+    inputSchema: _ai.zodSchema.call(void 0, parametersSchema),
+    execute: async ({
+      messages,
+      maxTokens: inputMaxTokens
+    }) => {
+      const maxTokens = _nullishCoalesce(_nullishCoalesce(inputMaxTokens, () => ( config.maxTokens)), () => ( 4096));
+      const charBudget = maxTokens * 4;
+      const totalChars = messages.reduce(
+        (sum, m) => sum + m.content.length,
+        0
+      );
+      if (totalChars <= charBudget) {
+        return JSON.stringify({
+          compacted: false,
+          messages,
+          reason: "Already within token budget"
+        });
+      }
+      if (!config.summarize) {
+        return "Error [context-compaction]: No summarize function configured. Provide a summarize callback in the tool config.";
+      }
+      try {
+        const summary = await config.summarize(messages);
+        const compactedMessages = [{ role: "system", content: summary }];
+        return JSON.stringify({
+          compacted: true,
+          messages: compactedMessages,
+          originalCount: messages.length
+        });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [context-compaction]: Summarization failed: ${msg}`;
+      }
+    }
+  });
+}
+var contextCompaction = createContextCompaction();
+
+
+
+
+exports.createContextCompaction = createContextCompaction; exports.contextCompaction = contextCompaction;

package/dist/chunk-G3ITTPGX.js

@@ -0,0 +1,99 @@
+// src/shared/edit-helpers.ts
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'").replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'").replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"').replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+function findActualString(fileContent, searchString) {
+  if (fileContent.includes(searchString)) {
+    return searchString;
+  }
+  const normalizedSearch = normalizeQuotes(searchString);
+  const normalizedFile = normalizeQuotes(fileContent);
+  const searchIndex = normalizedFile.indexOf(normalizedSearch);
+  if (searchIndex !== -1) {
+    return fileContent.substring(
+      searchIndex,
+      searchIndex + searchString.length
+    );
+  }
+  return null;
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+  if (oldString === actualOldString) {
+    return newString;
+  }
+  const hasDoubleQuotes = actualOldString.includes(LEFT_DOUBLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingleQuotes = actualOldString.includes(LEFT_SINGLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDoubleQuotes && !hasSingleQuotes) {
+    return newString;
+  }
+  let result = newString;
+  if (hasDoubleQuotes) {
+    result = applyCurlyDoubleQuotes(result);
+  }
+  if (hasSingleQuotes) {
+    result = applyCurlySingleQuotes(result);
+  }
+  return result;
+}
+function applyEditToFile(originalContent, oldString, newString, replaceAll = false) {
+  const f = replaceAll ? (content, search, replace) => content.replaceAll(search, () => replace) : (content, search, replace) => content.replace(search, () => replace);
+  if (newString !== "") {
+    return f(originalContent, oldString, newString);
+  }
+  const stripTrailingNewline = !oldString.endsWith("\n") && originalContent.includes(oldString + "\n");
+  return stripTrailingNewline ? f(originalContent, oldString + "\n", newString) : f(originalContent, oldString, newString);
+}
+function isOpeningContext(chars, index) {
+  if (index === 0) {
+    return true;
+  }
+  const prev = chars[index - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || // em dash
+  prev === "\u2013";
+}
+function applyCurlyDoubleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === '"') {
+      result.push(
+        isOpeningContext(chars, i) ? LEFT_DOUBLE_CURLY_QUOTE : RIGHT_DOUBLE_CURLY_QUOTE
+      );
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+function applyCurlySingleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "'") {
+      const prev = i > 0 ? chars[i - 1] : void 0;
+      const next = i < chars.length - 1 ? chars[i + 1] : void 0;
+      const prevIsLetter = prev !== void 0 && new RegExp("\\p{L}", "u").test(prev);
+      const nextIsLetter = next !== void 0 && new RegExp("\\p{L}", "u").test(next);
+      if (prevIsLetter && nextIsLetter) {
+        result.push(RIGHT_SINGLE_CURLY_QUOTE);
+      } else {
+        result.push(
+          isOpeningContext(chars, i) ? LEFT_SINGLE_CURLY_QUOTE : RIGHT_SINGLE_CURLY_QUOTE
+        );
+      }
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+
+export {
+  findActualString,
+  preserveQuoteStyle,
+  applyEditToFile
+};

package/dist/chunk-HDKXSKMO.js

@@ -0,0 +1,30 @@
+// src/ask-user/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createAskUser(config = {}) {
+  return tool({
+    description: "Ask the user a question and wait for their response. Use this when you need clarification, confirmation, or additional information from the user before proceeding.",
+    inputSchema: z.object({
+      question: z.string().describe("The question to ask the user"),
+      options: z.array(z.string()).optional().describe("Optional list of suggested response options")
+    }),
+    execute: async ({ question, options }) => {
+      if (!config.onQuestion) {
+        return "Error [ask-user]: No onQuestion callback configured. Provide an onQuestion function in the tool config to enable user interaction.";
+      }
+      try {
+        const response = await config.onQuestion(question, options);
+        return response;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [ask-user]: Failed to get user response: ${msg}`;
+      }
+    }
+  });
+}
+var askUser = createAskUser();
+
+export {
+  createAskUser,
+  askUser
+};

package/dist/chunk-HZAQRHBT.js

@@ -0,0 +1,99 @@
+import {
+  executeRipgrep
+} from "./chunk-MJCAXASI.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/glob/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/shared/glob.ts
+import { isAbsolute, join, basename, dirname, sep } from "path";
+function extractGlobBaseDirectory(pattern) {
+  const globChars = /[*?[{]/;
+  const match = pattern.match(globChars);
+  if (!match || match.index === void 0) {
+    const dir = dirname(pattern);
+    const file = basename(pattern);
+    return { baseDir: dir, relativePattern: file };
+  }
+  const staticPrefix = pattern.slice(0, match.index);
+  const lastSepIndex = Math.max(
+    staticPrefix.lastIndexOf("/"),
+    staticPrefix.lastIndexOf(sep)
+  );
+  if (lastSepIndex === -1) {
+    return { baseDir: "", relativePattern: pattern };
+  }
+  let baseDir = staticPrefix.slice(0, lastSepIndex);
+  const relativePattern = pattern.slice(lastSepIndex + 1);
+  if (baseDir === "" && lastSepIndex === 0) {
+    baseDir = "/";
+  }
+  return { baseDir, relativePattern };
+}
+async function glob(pattern, cwd, options) {
+  const limit = options?.limit ?? 100;
+  const offset = options?.offset ?? 0;
+  let searchDir = cwd;
+  let searchPattern = pattern;
+  if (isAbsolute(pattern)) {
+    const { baseDir, relativePattern } = extractGlobBaseDirectory(pattern);
+    if (baseDir) {
+      searchDir = baseDir;
+      searchPattern = relativePattern;
+    }
+  }
+  const args = [
+    "--files",
+    "--glob",
+    searchPattern,
+    "--sort=modified",
+    "--hidden",
+    "--no-ignore"
+  ];
+  const allPaths = await executeRipgrep(args, searchDir, {
+    signal: options?.signal
+  });
+  const absolutePaths = allPaths.map(
+    (p) => isAbsolute(p) ? p : join(searchDir, p)
+  );
+  const truncated = absolutePaths.length > offset + limit;
+  const files = absolutePaths.slice(offset, offset + limit);
+  return { files, truncated };
+}
+
+// src/glob/index.ts
+function createGlob(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: 'Find files matching a glob pattern. Returns absolute file paths sorted by modification time (newest first). Supports patterns like "**/*.ts", "src/**/*.js", or "*.json".',
+    inputSchema: z.object({
+      pattern: z.string().describe("Glob pattern to match files against"),
+      path: z.string().optional().describe("Directory to search in. Defaults to the working directory.")
+    }),
+    execute: async ({ pattern, path }) => {
+      try {
+        const searchDir = path ? expandPath(path, cwd) : cwd;
+        const { files, truncated } = await glob(pattern, searchDir);
+        if (files.length === 0) {
+          return "No files found";
+        }
+        const header = truncated ? `Found ${files.length}+ files (results truncated)` : `Found ${files.length} files`;
+        return `${header}
+${files.join("\n")}`;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error [glob]: Failed to search for files: ${message}`;
+      }
+    }
+  });
+}
+var glob2 = createGlob();
+
+export {
+  createGlob,
+  glob2 as glob
+};

package/dist/chunk-I3ONDY7P.js

@@ -0,0 +1,46 @@
+// src/shared/path.ts
+import { homedir } from "os";
+import { isAbsolute, join, normalize, relative, resolve } from "path";
+function expandPath(inputPath, baseDir) {
+  const actualBaseDir = baseDir ?? process.cwd();
+  if (typeof inputPath !== "string") {
+    throw new TypeError(
+      `Path must be a string, received ${typeof inputPath}`
+    );
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(
+      `Base directory must be a string, received ${typeof actualBaseDir}`
+    );
+  }
+  if (inputPath.includes("\0") || actualBaseDir.includes("\0")) {
+    throw new Error("Path contains null bytes");
+  }
+  const trimmed = inputPath.trim();
+  if (!trimmed) {
+    return normalize(actualBaseDir);
+  }
+  if (trimmed === "~") {
+    return homedir();
+  }
+  if (trimmed.startsWith("~/")) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  if (isAbsolute(trimmed)) {
+    return normalize(trimmed);
+  }
+  return resolve(actualBaseDir, trimmed);
+}
+function toRelativePath(absolutePath, baseDir) {
+  const rel = relative(baseDir ?? process.cwd(), absolutePath);
+  return rel.startsWith("..") ? absolutePath : rel;
+}
+function containsPathTraversal(inputPath) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(inputPath);
+}
+
+export {
+  expandPath,
+  toRelativePath,
+  containsPathTraversal
+};

package/dist/chunk-I6KFFQPV.cjs

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/http-request/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createHttpRequest(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Make an HTTP request to a URL. Returns the response status, headers, and body. Use this for API interactions, webhook calls, and service health checks. Unlike web-fetch, this returns raw response data without markdown conversion.",
+    inputSchema: _zod.z.object({
+      method: _zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).describe("HTTP method"),
+      url: _zod.z.string().describe("The URL to send the request to"),
+      headers: _zod.z.record(_zod.z.string()).optional().describe("Request headers as key-value pairs"),
+      body: _zod.z.string().optional().describe("Request body (for POST, PUT, PATCH)"),
+      timeout: _zod.z.number().optional().describe("Request timeout in milliseconds (default: 30000)")
+    }),
+    execute: async ({ method, url, headers, body, timeout }) => {
+      try {
+        const timeoutMs = _nullishCoalesce(_nullishCoalesce(timeout, () => ( config.timeout)), () => ( 3e4));
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const mergedHeaders = { ...config.defaultHeaders, ...headers };
+        const response = await fetch(url, {
+          method,
+          headers: mergedHeaders,
+          body: ["POST", "PUT", "PATCH"].includes(method) ? body : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const responseBody = await response.text();
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        return JSON.stringify(
+          {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            body: responseBody
+          },
+          null,
+          2
+        );
+      } catch (error) {
+        const effectiveTimeout = _nullishCoalesce(_nullishCoalesce(timeout, () => ( config.timeout)), () => ( 3e4));
+        if (error instanceof Error && error.name === "AbortError") {
+          return `Error [http-request]: Request timed out after ${effectiveTimeout}ms for ${method} ${url}. Try increasing the timeout or verify the server is responsive.`;
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [http-request]: ${method} ${url} failed: ${msg}. Verify the URL is correct and the server is reachable.`;
+      }
+    }
+  });
+}
+var httpRequest = createHttpRequest();
+
+
+
+
+exports.createHttpRequest = createHttpRequest; exports.httpRequest = httpRequest;