@yourgpt/copilot-sdk 0.1.0

package/dist/chunk-2ZCWVAAK.cjs

@@ -0,0 +1,1915 @@
+'use strict';
+
+// src/core/tools/screenshot.ts
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var DEFAULT_OPTIONS = {
+  element: isBrowser ? document.body : null,
+  quality: 0.8,
+  format: "png",
+  maxWidth: 1920,
+  maxHeight: 1080,
+  includeCursor: false
+};
+var html2canvasPromise = null;
+async function getHtml2Canvas() {
+  if (!html2canvasPromise) {
+    html2canvasPromise = import('html2canvas').then((mod) => mod.default);
+  }
+  return html2canvasPromise;
+}
+async function captureScreenshot(options = {}) {
+  if (!isBrowser) {
+    throw new Error(
+      "Screenshot capture is only available in browser environment"
+    );
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const element = opts.element || document.body;
+  const rect = element.getBoundingClientRect();
+  let width = rect.width || window.innerWidth;
+  let height = rect.height || window.innerHeight;
+  const scale = Math.min(opts.maxWidth / width, opts.maxHeight / height, 1);
+  width = Math.round(width * scale);
+  height = Math.round(height * scale);
+  let canvas;
+  try {
+    const html2canvas = await getHtml2Canvas();
+    canvas = await html2canvas(element, {
+      scale,
+      useCORS: true,
+      // Enable cross-origin images
+      allowTaint: false,
+      // Don't allow tainted canvas
+      backgroundColor: null,
+      // Transparent background (uses element's bg)
+      logging: false,
+      // Disable internal logging
+      width: rect.width,
+      height: rect.height,
+      windowWidth: window.innerWidth,
+      windowHeight: window.innerHeight,
+      scrollX: 0,
+      scrollY: 0,
+      x: rect.left + window.scrollX,
+      y: rect.top + window.scrollY
+    });
+  } catch (error) {
+    canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (ctx) {
+      createPlaceholder(ctx, width, height, element, String(error));
+    }
+  }
+  const mimeType = `image/${opts.format === "jpeg" ? "jpeg" : opts.format}`;
+  let data;
+  try {
+    data = canvas.toDataURL(mimeType, opts.quality);
+  } catch (e) {
+    if (e instanceof DOMException && e.name === "SecurityError") {
+      console.warn(
+        "[Copilot SDK] Canvas tainted by cross-origin content. Creating placeholder."
+      );
+      const cleanCanvas = document.createElement("canvas");
+      cleanCanvas.width = width;
+      cleanCanvas.height = height;
+      const cleanCtx = cleanCanvas.getContext("2d");
+      if (cleanCtx) {
+        createPlaceholder(
+          cleanCtx,
+          width,
+          height,
+          element,
+          "Cross-origin content blocked"
+        );
+        data = cleanCanvas.toDataURL(mimeType, opts.quality);
+      } else {
+        throw new Error("Failed to create placeholder canvas");
+      }
+    } else {
+      throw e;
+    }
+  }
+  return {
+    data,
+    format: opts.format,
+    width: canvas.width,
+    height: canvas.height,
+    timestamp: Date.now()
+  };
+}
+function createPlaceholder(ctx, width, height, element, errorMessage) {
+  ctx.fillStyle = "#f0f0f0";
+  ctx.fillRect(0, 0, width, height);
+  ctx.strokeStyle = "#ddd";
+  ctx.lineWidth = 2;
+  ctx.strokeRect(2, 2, width - 4, height - 4);
+  ctx.fillStyle = "#666";
+  ctx.font = "14px system-ui, sans-serif";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  const tagName = element.tagName.toLowerCase();
+  const id = element.id ? `#${element.id}` : "";
+  const className = element.className ? `.${String(element.className).split(" ")[0]}` : "";
+  ctx.fillText(
+    `Screenshot: <${tagName}${id}${className}>`,
+    width / 2,
+    height / 2 - 20
+  );
+  ctx.fillText(
+    `${Math.round(width)}\xD7${Math.round(height)}px`,
+    width / 2,
+    height / 2
+  );
+  if (errorMessage) {
+    ctx.fillStyle = "#999";
+    ctx.font = "12px system-ui, sans-serif";
+    ctx.fillText(
+      `Error: ${errorMessage.slice(0, 50)}`,
+      width / 2,
+      height / 2 + 20
+    );
+  }
+}
+function isScreenshotSupported() {
+  return isBrowser && typeof document.createElement === "function";
+}
+async function resizeScreenshot(screenshot, maxWidth, maxHeight) {
+  if (!isBrowser) {
+    throw new Error("Resize is only available in browser environment");
+  }
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      const scale = Math.min(maxWidth / img.width, maxHeight / img.height, 1);
+      const width = Math.round(img.width * scale);
+      const height = Math.round(img.height * scale);
+      const canvas = document.createElement("canvas");
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to create canvas context"));
+        return;
+      }
+      ctx.drawImage(img, 0, 0, width, height);
+      const data = canvas.toDataURL(`image/${screenshot.format}`, 0.8);
+      resolve({
+        ...screenshot,
+        data,
+        width,
+        height,
+        timestamp: Date.now()
+      });
+    };
+    img.onerror = () => reject(new Error("Failed to load screenshot"));
+    img.src = screenshot.data;
+  });
+}
+
+// src/core/tools/console.ts
+var isBrowser2 = typeof window !== "undefined" && typeof console !== "undefined";
+var capturedLogs = [];
+var isCapturing = false;
+var captureOptions;
+var originalMethods = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+var DEFAULT_OPTIONS2 = {
+  types: ["log", "info", "warn", "error", "debug"],
+  limit: 100,
+  filter: () => true
+};
+function argsToMessage(args) {
+  return args.map((arg) => {
+    if (arg === null) return "null";
+    if (arg === void 0) return "undefined";
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+    try {
+      return JSON.stringify(arg, null, 2);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function getStackTrace() {
+  try {
+    const error = new Error();
+    const stack = error.stack?.split("\n").slice(3).join("\n");
+    return stack;
+  } catch {
+    return void 0;
+  }
+}
+function createInterceptor(type) {
+  return (...args) => {
+    originalMethods[type].apply(console, args);
+    if (!captureOptions.types.includes(type)) {
+      return;
+    }
+    const entry = {
+      type,
+      message: argsToMessage(args),
+      args: args.length > 1 ? args : void 0,
+      timestamp: Date.now()
+    };
+    if (type === "error" || type === "warn") {
+      entry.stack = getStackTrace();
+    }
+    if (args[0] instanceof Error) {
+      entry.stack = args[0].stack;
+    }
+    if (!captureOptions.filter(entry)) {
+      return;
+    }
+    capturedLogs.push(entry);
+    while (capturedLogs.length > captureOptions.limit) {
+      capturedLogs.shift();
+    }
+  };
+}
+function startConsoleCapture(options = {}) {
+  if (!isBrowser2) {
+    console.warn("Console capture is only available in browser environment");
+    return;
+  }
+  if (isCapturing) {
+    console.warn("Console capture already active");
+    return;
+  }
+  captureOptions = { ...DEFAULT_OPTIONS2, ...options };
+  isCapturing = true;
+  Object.keys(originalMethods).forEach((type) => {
+    console[type] = createInterceptor(type);
+  });
+}
+function stopConsoleCapture() {
+  if (!isCapturing) {
+    return;
+  }
+  isCapturing = false;
+  Object.keys(originalMethods).forEach((type) => {
+    console[type] = originalMethods[type];
+  });
+}
+function getConsoleLogs(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  let logs = [...capturedLogs];
+  if (opts.types.length < Object.keys(originalMethods).length) {
+    logs = logs.filter((entry) => opts.types.includes(entry.type));
+  }
+  if (opts.filter !== DEFAULT_OPTIONS2.filter) {
+    logs = logs.filter(opts.filter);
+  }
+  const totalCaptured = logs.length;
+  logs = logs.slice(-opts.limit);
+  return {
+    logs,
+    totalCaptured
+  };
+}
+function clearConsoleLogs() {
+  capturedLogs = [];
+}
+function isConsoleCaptureActive() {
+  return isCapturing;
+}
+function getConsoleErrors(limit = 50) {
+  return getConsoleLogs({
+    types: ["error"],
+    limit
+  }).logs;
+}
+function getConsoleWarnings(limit = 50) {
+  return getConsoleLogs({
+    types: ["warn"],
+    limit
+  }).logs;
+}
+function formatLogsForAI(logs) {
+  if (logs.length === 0) {
+    return "No console logs captured.";
+  }
+  const formatted = logs.map((entry, index) => {
+    const time = new Date(entry.timestamp).toISOString();
+    const typeIcon = {
+      error: "\u274C",
+      warn: "\u26A0\uFE0F",
+      log: "\u{1F4DD}",
+      info: "\u2139\uFE0F",
+      debug: "\u{1F50D}"
+    }[entry.type];
+    let text = `[${index + 1}] ${typeIcon} [${entry.type.toUpperCase()}] ${time}
+`;
+    text += `    ${entry.message}`;
+    if (entry.stack) {
+      const stackLines = entry.stack.split("\n").slice(0, 3);
+      text += `
+    Stack:
+${stackLines.map((l) => `      ${l.trim()}`).join("\n")}`;
+    }
+    return text;
+  });
+  return `Console Logs (${logs.length} entries):
+
+${formatted.join("\n\n")}`;
+}
+function captureCurrentLogs(options = {}) {
+  if (isCapturing) {
+    return getConsoleLogs(options);
+  }
+  return getConsoleLogs(options);
+}
+if (isBrowser2) {
+  window.addEventListener("beforeunload", () => {
+    stopConsoleCapture();
+  });
+}
+
+// src/core/tools/network.ts
+var isBrowser3 = typeof window !== "undefined";
+var capturedRequests = [];
+var isCapturing2 = false;
+var captureOptions2;
+var originalFetch = isBrowser3 ? window.fetch.bind(window) : null;
+var originalXHROpen = isBrowser3 ? XMLHttpRequest.prototype.open : null;
+var originalXHRSend = isBrowser3 ? XMLHttpRequest.prototype.send : null;
+var DEFAULT_OPTIONS3 = {
+  limit: 50,
+  failedOnly: true,
+  methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+  includeUrls: [],
+  excludeUrls: [],
+  captureRequestBody: true,
+  captureResponseBody: true,
+  maxBodySize: 1e4
+  // 10KB
+};
+function sanitizeHeaders(headers) {
+  const sensitiveHeaders = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "api-key",
+    "x-auth-token"
+  ];
+  const result = {};
+  if (!headers) {
+    return result;
+  }
+  const entries = headers instanceof Headers ? Array.from(headers.entries()) : Object.entries(headers);
+  for (const [key, value] of entries) {
+    if (sensitiveHeaders.includes(key.toLowerCase())) {
+      result[key] = "[REDACTED]";
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function truncateBody(body, maxSize) {
+  if (body === null || body === void 0) {
+    return body;
+  }
+  try {
+    const str = typeof body === "string" ? body : JSON.stringify(body);
+    if (str.length > maxSize) {
+      return `${str.slice(0, maxSize)}... [truncated, total: ${str.length} chars]`;
+    }
+    return body;
+  } catch {
+    return "[Unable to serialize body]";
+  }
+}
+function matchesPatterns(url, patterns) {
+  if (patterns.length === 0) return false;
+  return patterns.some((pattern) => pattern.test(url));
+}
+function shouldCapture(url, method, failed) {
+  if (captureOptions2.failedOnly && !failed) {
+    return false;
+  }
+  if (!captureOptions2.methods.includes(method)) {
+    return false;
+  }
+  if (matchesPatterns(url, captureOptions2.excludeUrls)) {
+    return false;
+  }
+  if (captureOptions2.includeUrls.length > 0 && !matchesPatterns(url, captureOptions2.includeUrls)) {
+    return false;
+  }
+  return true;
+}
+function addCapturedRequest(entry) {
+  capturedRequests.push(entry);
+  while (capturedRequests.length > captureOptions2.limit) {
+    capturedRequests.shift();
+  }
+}
+function createFetchInterceptor() {
+  return async function interceptedFetch(input, init) {
+    const startTime = Date.now();
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init?.method?.toUpperCase() || "GET";
+    let requestBody;
+    if (captureOptions2.captureRequestBody && init?.body) {
+      try {
+        if (typeof init.body === "string") {
+          requestBody = JSON.parse(init.body);
+        } else {
+          requestBody = init.body;
+        }
+      } catch {
+        requestBody = init.body;
+      }
+    }
+    try {
+      const response = await originalFetch(input, init);
+      const duration = Date.now() - startTime;
+      const failed = !response.ok;
+      if (shouldCapture(url, method, failed)) {
+        let responseBody;
+        if (captureOptions2.captureResponseBody && failed) {
+          try {
+            const clone = response.clone();
+            const text = await clone.text();
+            try {
+              responseBody = JSON.parse(text);
+            } catch {
+              responseBody = text;
+            }
+          } catch {
+            responseBody = "[Unable to read response body]";
+          }
+        }
+        const entry = {
+          url,
+          method,
+          status: response.status,
+          statusText: response.statusText,
+          failed,
+          requestHeaders: sanitizeHeaders(
+            init?.headers
+          ),
+          responseHeaders: sanitizeHeaders(response.headers),
+          requestBody: truncateBody(requestBody, captureOptions2.maxBodySize),
+          responseBody: truncateBody(responseBody, captureOptions2.maxBodySize),
+          duration,
+          timestamp: startTime
+        };
+        addCapturedRequest(entry);
+      }
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (shouldCapture(url, method, true)) {
+        const entry = {
+          url,
+          method,
+          status: 0,
+          statusText: "Network Error",
+          failed: true,
+          requestBody: truncateBody(requestBody, captureOptions2.maxBodySize),
+          duration,
+          timestamp: startTime,
+          error: error instanceof Error ? error.message : String(error)
+        };
+        addCapturedRequest(entry);
+      }
+      throw error;
+    }
+  };
+}
+function startNetworkCapture(options = {}) {
+  if (!isBrowser3) {
+    console.warn("Network capture is only available in browser environment");
+    return;
+  }
+  if (isCapturing2) {
+    console.warn("Network capture already active");
+    return;
+  }
+  captureOptions2 = { ...DEFAULT_OPTIONS3, ...options };
+  isCapturing2 = true;
+  window.fetch = createFetchInterceptor();
+  XMLHttpRequest.prototype.open = function(method, url, async = true, username, password) {
+    this._captureData = {
+      method: method.toUpperCase(),
+      url: url.toString(),
+      startTime: 0
+    };
+    return originalXHROpen.call(
+      this,
+      method,
+      url,
+      async,
+      username,
+      password
+    );
+  };
+  XMLHttpRequest.prototype.send = function(body) {
+    const xhr = this;
+    if (xhr._captureData) {
+      xhr._captureData.startTime = Date.now();
+      if (captureOptions2.captureRequestBody && body) {
+        try {
+          if (typeof body === "string") {
+            xhr._captureData.requestBody = JSON.parse(body);
+          } else {
+            xhr._captureData.requestBody = body;
+          }
+        } catch {
+          xhr._captureData.requestBody = body;
+        }
+      }
+      const originalOnReadyStateChange = xhr.onreadystatechange;
+      xhr.onreadystatechange = function(event) {
+        if (xhr.readyState === XMLHttpRequest.DONE) {
+          const duration = Date.now() - xhr._captureData.startTime;
+          const failed = xhr.status === 0 || xhr.status >= 400;
+          if (shouldCapture(xhr._captureData.url, xhr._captureData.method, failed)) {
+            let responseBody;
+            if (captureOptions2.captureResponseBody && failed) {
+              try {
+                responseBody = xhr.responseType === "" || xhr.responseType === "text" ? JSON.parse(xhr.responseText) : xhr.response;
+              } catch {
+                responseBody = xhr.responseText || xhr.response;
+              }
+            }
+            const entry = {
+              url: xhr._captureData.url,
+              method: xhr._captureData.method,
+              status: xhr.status,
+              statusText: xhr.statusText,
+              failed,
+              requestBody: truncateBody(
+                xhr._captureData.requestBody,
+                captureOptions2.maxBodySize
+              ),
+              responseBody: truncateBody(
+                responseBody,
+                captureOptions2.maxBodySize
+              ),
+              duration,
+              timestamp: xhr._captureData.startTime
+            };
+            addCapturedRequest(entry);
+          }
+        }
+        if (originalOnReadyStateChange) {
+          originalOnReadyStateChange.call(xhr, event);
+        }
+      };
+    }
+    return originalXHRSend.call(this, body);
+  };
+}
+function stopNetworkCapture() {
+  if (!isBrowser3 || !isCapturing2) {
+    return;
+  }
+  isCapturing2 = false;
+  window.fetch = originalFetch;
+  XMLHttpRequest.prototype.open = originalXHROpen;
+  XMLHttpRequest.prototype.send = originalXHRSend;
+}
+function getNetworkRequests(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS3, ...options };
+  let requests = [...capturedRequests];
+  if (opts.failedOnly) {
+    requests = requests.filter((r) => r.failed);
+  }
+  if (opts.methods.length < DEFAULT_OPTIONS3.methods.length) {
+    requests = requests.filter((r) => opts.methods.includes(r.method));
+  }
+  if (opts.includeUrls.length > 0) {
+    requests = requests.filter((r) => matchesPatterns(r.url, opts.includeUrls));
+  }
+  if (opts.excludeUrls.length > 0) {
+    requests = requests.filter(
+      (r) => !matchesPatterns(r.url, opts.excludeUrls)
+    );
+  }
+  const totalCaptured = requests.length;
+  requests = requests.slice(-opts.limit);
+  return {
+    requests,
+    totalCaptured
+  };
+}
+function clearNetworkRequests() {
+  capturedRequests = [];
+}
+function isNetworkCaptureActive() {
+  return isCapturing2;
+}
+function getFailedRequests(limit = 20) {
+  return getNetworkRequests({ failedOnly: true, limit }).requests;
+}
+function formatRequestsForAI(requests) {
+  if (requests.length === 0) {
+    return "No network requests captured.";
+  }
+  const formatted = requests.map((req, index) => {
+    const time = new Date(req.timestamp).toISOString();
+    const statusIcon = req.failed ? "\u274C" : "\u2705";
+    let text = `[${index + 1}] ${statusIcon} ${req.method} ${req.url}
+`;
+    text += `    Status: ${req.status} ${req.statusText}
+`;
+    text += `    Duration: ${req.duration}ms
+`;
+    text += `    Time: ${time}`;
+    if (req.error) {
+      text += `
+    Error: ${req.error}`;
+    }
+    if (req.responseBody && req.failed) {
+      const bodyStr = typeof req.responseBody === "string" ? req.responseBody : JSON.stringify(req.responseBody, null, 2);
+      text += `
+    Response Body:
+      ${bodyStr.split("\n").join("\n      ")}`;
+    }
+    return text;
+  });
+  return `Network Requests (${requests.length} entries):
+
+${formatted.join("\n\n")}`;
+}
+if (isBrowser3) {
+  window.addEventListener("beforeunload", () => {
+    stopNetworkCapture();
+  });
+}
+
+// src/core/tools/intentDetector.ts
+var SCREENSHOT_KEYWORDS = [
+  // Visual references
+  "see",
+  "seeing",
+  "look",
+  "looking",
+  "looks",
+  "appear",
+  "appears",
+  "show",
+  "showing",
+  "shows",
+  "display",
+  "displays",
+  "displayed",
+  "visible",
+  "invisible",
+  // UI elements
+  "screen",
+  "page",
+  "ui",
+  "interface",
+  "layout",
+  "design",
+  "button",
+  "input",
+  "form",
+  "modal",
+  "popup",
+  "menu",
+  "dropdown",
+  "sidebar",
+  "header",
+  "footer",
+  "navbar",
+  "navigation",
+  "image",
+  "icon",
+  "text",
+  "font",
+  "color",
+  "style",
+  "css",
+  "alignment",
+  "position",
+  "spacing",
+  // Visual issues
+  "broken",
+  "misaligned",
+  "overlapping",
+  "cutoff",
+  "overflow",
+  "blank",
+  "empty",
+  "missing",
+  "wrong",
+  "weird",
+  "strange",
+  "different",
+  "changed"
+];
+var CONSOLE_KEYWORDS = [
+  // Errors
+  "error",
+  "errors",
+  "exception",
+  "exceptions",
+  "crash",
+  "crashed",
+  "crashing",
+  "bug",
+  "bugs",
+  "buggy",
+  "broken",
+  "break",
+  "breaks",
+  // Issues
+  "issue",
+  "issues",
+  "problem",
+  "problems",
+  "not working",
+  "doesnt work",
+  "doesn't work",
+  "stopped working",
+  "fails",
+  "failed",
+  "failing",
+  "failure",
+  // Debug references
+  "debug",
+  "debugging",
+  "console",
+  "log",
+  "logs",
+  "warning",
+  "warnings",
+  "warn",
+  "stack",
+  "stacktrace",
+  "trace",
+  "traceback",
+  // State issues
+  "undefined",
+  "null",
+  "nan",
+  "typeerror",
+  "referenceerror",
+  "syntaxerror",
+  "unexpected",
+  "uncaught"
+];
+var NETWORK_KEYWORDS = [
+  // API references
+  "api",
+  "apis",
+  "endpoint",
+  "endpoints",
+  "request",
+  "requests",
+  "response",
+  "responses",
+  "fetch",
+  "fetching",
+  // HTTP
+  "http",
+  "https",
+  "rest",
+  "graphql",
+  "post",
+  "get",
+  "put",
+  "delete",
+  "patch",
+  // Issues
+  "timeout",
+  "timeouts",
+  "timed out",
+  "slow",
+  "loading",
+  "loads",
+  "load",
+  "forever",
+  // Status
+  "404",
+  "500",
+  "401",
+  "403",
+  "400",
+  "not found",
+  "unauthorized",
+  "forbidden",
+  "server error",
+  "bad request",
+  // Data
+  "data",
+  "json",
+  "payload",
+  "body",
+  "headers",
+  "cors",
+  "network",
+  "connection",
+  "backend",
+  "server"
+];
+var DEFAULT_THRESHOLDS = {
+  suggest: 0.3};
+function normalizeText(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function findMatches(text, keywords) {
+  const normalizedText = normalizeText(text);
+  const words = new Set(normalizedText.split(" "));
+  const matches = [];
+  for (const keyword of keywords) {
+    const normalizedKeyword = normalizeText(keyword);
+    if (words.has(normalizedKeyword)) {
+      matches.push(keyword);
+      continue;
+    }
+    if (normalizedKeyword.includes(" ") && normalizedText.includes(normalizedKeyword)) {
+      matches.push(keyword);
+      continue;
+    }
+    const pattern = new RegExp(`\\b${normalizedKeyword}`, "i");
+    if (pattern.test(normalizedText)) {
+      matches.push(keyword);
+    }
+  }
+  return [...new Set(matches)];
+}
+function calculateConfidence(matches, totalKeywords, textLength) {
+  if (matches.length === 0) return 0;
+  const matchRatio = Math.min(matches.length / 5, 1);
+  const multiMatchBonus = matches.length > 2 ? 0.2 : matches.length > 1 ? 0.1 : 0;
+  const lengthPenalty = textLength < 20 ? 0.2 : 0;
+  return Math.min(matchRatio * 0.7 + multiMatchBonus - lengthPenalty, 1);
+}
+function detectIntent(message) {
+  const screenshotMatches = findMatches(message, SCREENSHOT_KEYWORDS);
+  const consoleMatches = findMatches(message, CONSOLE_KEYWORDS);
+  const networkMatches = findMatches(message, NETWORK_KEYWORDS);
+  const textLength = message.length;
+  const confidence = {
+    screenshot: calculateConfidence(
+      screenshotMatches,
+      SCREENSHOT_KEYWORDS.length,
+      textLength
+    ),
+    console: calculateConfidence(
+      consoleMatches,
+      CONSOLE_KEYWORDS.length,
+      textLength
+    ),
+    network: calculateConfidence(
+      networkMatches,
+      NETWORK_KEYWORDS.length,
+      textLength
+    )
+  };
+  const suggestedTools = [];
+  if (confidence.screenshot >= DEFAULT_THRESHOLDS.suggest) {
+    suggestedTools.push("screenshot");
+  }
+  if (confidence.console >= DEFAULT_THRESHOLDS.suggest) {
+    suggestedTools.push("console");
+  }
+  if (confidence.network >= DEFAULT_THRESHOLDS.suggest) {
+    suggestedTools.push("network");
+  }
+  suggestedTools.sort((a, b) => confidence[b] - confidence[a]);
+  return {
+    suggestedTools,
+    confidence,
+    matchedKeywords: {
+      screenshot: screenshotMatches,
+      console: consoleMatches,
+      network: networkMatches
+    }
+  };
+}
+function hasToolSuggestions(message) {
+  const result = detectIntent(message);
+  return result.suggestedTools.length > 0;
+}
+function getPrimaryTool(message) {
+  const result = detectIntent(message);
+  return result.suggestedTools[0] || null;
+}
+function generateSuggestionReason(result) {
+  if (result.suggestedTools.length === 0) {
+    return "";
+  }
+  const reasons = [];
+  if (result.suggestedTools.includes("screenshot")) {
+    const keywords = result.matchedKeywords.screenshot.slice(0, 3);
+    reasons.push(`visual elements mentioned (${keywords.join(", ")})`);
+  }
+  if (result.suggestedTools.includes("console")) {
+    const keywords = result.matchedKeywords.console.slice(0, 3);
+    reasons.push(`potential errors indicated (${keywords.join(", ")})`);
+  }
+  if (result.suggestedTools.includes("network")) {
+    const keywords = result.matchedKeywords.network.slice(0, 3);
+    reasons.push(`API/network issues suggested (${keywords.join(", ")})`);
+  }
+  return `Based on your message: ${reasons.join("; ")}.`;
+}
+function createCustomDetector(customKeywords) {
+  const extendedScreenshot = [
+    ...SCREENSHOT_KEYWORDS,
+    ...customKeywords.screenshot || []
+  ];
+  const extendedConsole = [
+    ...CONSOLE_KEYWORDS,
+    ...customKeywords.console || []
+  ];
+  const extendedNetwork = [
+    ...NETWORK_KEYWORDS,
+    ...customKeywords.network || []
+  ];
+  return function detectCustomIntent(message) {
+    const screenshotMatches = findMatches(message, extendedScreenshot);
+    const consoleMatches = findMatches(message, extendedConsole);
+    const networkMatches = findMatches(message, extendedNetwork);
+    const textLength = message.length;
+    const confidence = {
+      screenshot: calculateConfidence(
+        screenshotMatches,
+        extendedScreenshot.length,
+        textLength
+      ),
+      console: calculateConfidence(
+        consoleMatches,
+        extendedConsole.length,
+        textLength
+      ),
+      network: calculateConfidence(
+        networkMatches,
+        extendedNetwork.length,
+        textLength
+      )
+    };
+    const suggestedTools = [];
+    if (confidence.screenshot >= DEFAULT_THRESHOLDS.suggest) {
+      suggestedTools.push("screenshot");
+    }
+    if (confidence.console >= DEFAULT_THRESHOLDS.suggest) {
+      suggestedTools.push("console");
+    }
+    if (confidence.network >= DEFAULT_THRESHOLDS.suggest) {
+      suggestedTools.push("network");
+    }
+    suggestedTools.sort((a, b) => confidence[b] - confidence[a]);
+    return {
+      suggestedTools,
+      confidence,
+      matchedKeywords: {
+        screenshot: screenshotMatches,
+        console: consoleMatches,
+        network: networkMatches
+      }
+    };
+  };
+}
+
+// src/core/types/tools.ts
+function tool(config) {
+  return {
+    description: config.description,
+    location: config.location ?? "client",
+    // Display configuration
+    title: config.title,
+    executingTitle: config.executingTitle,
+    completedTitle: config.completedTitle,
+    // Schema and handlers
+    inputSchema: config.inputSchema ?? {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    handler: config.handler,
+    render: config.render,
+    available: config.available,
+    needsApproval: config.needsApproval,
+    approvalMessage: config.approvalMessage,
+    aiResponseMode: config.aiResponseMode,
+    aiContext: config.aiContext
+  };
+}
+function toolToOpenAIFormat(tool2) {
+  return {
+    type: "function",
+    function: {
+      name: tool2.name,
+      description: tool2.description,
+      parameters: tool2.inputSchema
+    }
+  };
+}
+function toolToAnthropicFormat(tool2) {
+  return {
+    name: tool2.name,
+    description: tool2.description,
+    input_schema: tool2.inputSchema
+  };
+}
+function createToolResult(toolCallId, response) {
+  return {
+    toolCallId,
+    content: JSON.stringify(response),
+    success: response.success,
+    error: response.error
+  };
+}
+function success(data, message) {
+  return {
+    success: true,
+    data,
+    message
+  };
+}
+function failure(error) {
+  return {
+    success: false,
+    error
+  };
+}
+
+// src/core/tools/builtin/screenshot.ts
+var screenshotTool = tool({
+  description: "Capture a screenshot of the user's current screen/viewport. Use this when the user asks you to look at their screen, see what they're seeing, help with visual issues, or debug UI problems.",
+  location: "client",
+  inputSchema: {
+    type: "object",
+    properties: {
+      quality: {
+        type: "number",
+        description: "Image quality from 0 to 1 (default: 0.8)",
+        minimum: 0,
+        maximum: 1
+      }
+    },
+    required: []
+  },
+  needsApproval: true,
+  approvalMessage: "Allow AI to capture a screenshot of your screen?",
+  handler: async (params) => {
+    if (!isScreenshotSupported()) {
+      return failure("Screenshot capture is not supported in this environment");
+    }
+    try {
+      const options = {};
+      if (params.quality !== void 0) {
+        options.quality = params.quality;
+      }
+      const result = await captureScreenshot(options);
+      return {
+        success: true,
+        message: `Screenshot captured (${result.width}x${result.height}). The image is shared in the conversation.`,
+        addAsUserMessage: true,
+        data: {
+          attachment: {
+            type: "image",
+            data: result.data,
+            mimeType: `image/${result.format}`,
+            filename: "screenshot.png"
+          },
+          dimensions: {
+            width: result.width,
+            height: result.height
+          }
+        }
+      };
+    } catch (error) {
+      return failure(
+        error instanceof Error ? error.message : "Screenshot capture failed"
+      );
+    }
+  }
+});
+function createScreenshotTool(options) {
+  return tool({
+    ...screenshotTool,
+    needsApproval: options?.needsApproval ?? true,
+    approvalMessage: options?.approvalMessage ?? "Allow AI to capture a screenshot of your screen?",
+    handler: async (params) => {
+      if (!isScreenshotSupported()) {
+        return failure(
+          "Screenshot capture is not supported in this environment"
+        );
+      }
+      try {
+        const result = await captureScreenshot({
+          quality: params.quality ?? options?.defaultQuality ?? 0.8
+        });
+        return {
+          success: true,
+          message: `Screenshot captured (${result.width}x${result.height}). The image is shared in the conversation.`,
+          addAsUserMessage: true,
+          data: {
+            attachment: {
+              type: "image",
+              data: result.data,
+              mimeType: `image/${result.format}`,
+              filename: "screenshot.png"
+            },
+            dimensions: {
+              width: result.width,
+              height: result.height
+            }
+          }
+        };
+      } catch (error) {
+        return failure(
+          error instanceof Error ? error.message : "Screenshot capture failed"
+        );
+      }
+    }
+  });
+}
+
+// src/core/tools/builtin/console.ts
+var consoleLogsTool = tool({
+  description: "Get recent console logs from the browser. Use this when debugging JavaScript errors, checking for warnings, or understanding what's happening in the application.",
+  location: "client",
+  inputSchema: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum number of logs to return (default: 50)"
+      },
+      types: {
+        type: "array",
+        description: "Filter by log types: 'error', 'warn', 'info', 'log', 'debug'",
+        items: {
+          type: "string",
+          enum: ["error", "warn", "info", "log", "debug"]
+        }
+      }
+    },
+    required: []
+  },
+  needsApproval: true,
+  approvalMessage: "Allow AI to access browser console logs?",
+  handler: async (params) => {
+    try {
+      if (!isConsoleCaptureActive()) {
+        startConsoleCapture();
+      }
+      const logs = getConsoleLogs({
+        limit: params.limit || 50,
+        types: params.types
+      });
+      const formattedLogs = formatLogsForAI(logs.logs);
+      return success(
+        {
+          logs: formattedLogs,
+          count: logs.logs.length,
+          totalCaptured: logs.totalCaptured
+        },
+        `Retrieved ${logs.logs.length} console logs`
+      );
+    } catch (error) {
+      return failure(
+        error instanceof Error ? error.message : "Failed to get console logs"
+      );
+    }
+  }
+});
+function createConsoleLogsTool(options) {
+  return tool({
+    ...consoleLogsTool,
+    needsApproval: options?.needsApproval ?? true,
+    approvalMessage: options?.approvalMessage ?? "Allow AI to access browser console logs?",
+    handler: async (params) => {
+      try {
+        if (!isConsoleCaptureActive()) {
+          startConsoleCapture();
+        }
+        const logs = getConsoleLogs({
+          limit: params.limit || options?.defaultLimit || 50,
+          types: params.types
+        });
+        const formattedLogs = formatLogsForAI(logs.logs);
+        return success(
+          {
+            logs: formattedLogs,
+            count: logs.logs.length,
+            totalCaptured: logs.totalCaptured
+          },
+          `Retrieved ${logs.logs.length} console logs`
+        );
+      } catch (error) {
+        return failure(
+          error instanceof Error ? error.message : "Failed to get console logs"
+        );
+      }
+    }
+  });
+}
+
+// src/core/tools/builtin/network.ts
+var networkRequestsTool = tool({
+  description: "Get recent network requests from the browser. Use this when debugging API calls, checking for failed requests, analyzing network activity, or troubleshooting connectivity issues.",
+  location: "client",
+  inputSchema: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum number of requests to return (default: 20)"
+      },
+      failedOnly: {
+        type: "boolean",
+        description: "Only return failed requests (status >= 400)"
+      }
+    },
+    required: []
+  },
+  needsApproval: true,
+  approvalMessage: "Allow AI to access network request history?",
+  handler: async (params) => {
+    try {
+      if (!isNetworkCaptureActive()) {
+        startNetworkCapture();
+      }
+      const requests = getNetworkRequests({
+        limit: params.limit || 20,
+        failedOnly: params.failedOnly
+      });
+      const formattedRequests = formatRequestsForAI(requests.requests);
+      return success(
+        {
+          requests: formattedRequests,
+          count: requests.requests.length,
+          totalCaptured: requests.totalCaptured
+        },
+        `Retrieved ${requests.requests.length} network requests`
+      );
+    } catch (error) {
+      return failure(
+        error instanceof Error ? error.message : "Failed to get network requests"
+      );
+    }
+  }
+});
+function createNetworkRequestsTool(options) {
+  return tool({
+    ...networkRequestsTool,
+    needsApproval: options?.needsApproval ?? true,
+    approvalMessage: options?.approvalMessage ?? "Allow AI to access network request history?",
+    handler: async (params) => {
+      try {
+        if (!isNetworkCaptureActive()) {
+          startNetworkCapture();
+        }
+        const requests = getNetworkRequests({
+          limit: params.limit || options?.defaultLimit || 20,
+          failedOnly: params.failedOnly
+        });
+        const formattedRequests = formatRequestsForAI(requests.requests);
+        return success(
+          {
+            requests: formattedRequests,
+            count: requests.requests.length,
+            totalCaptured: requests.totalCaptured
+          },
+          `Retrieved ${requests.requests.length} network requests`
+        );
+      } catch (error) {
+        return failure(
+          error instanceof Error ? error.message : "Failed to get network requests"
+        );
+      }
+    }
+  });
+}
+
+// src/core/tools/builtin/index.ts
+var builtinTools = {
+  capture_screenshot: {
+    name: "capture_screenshot",
+    ...screenshotTool
+  },
+  get_console_logs: {
+    name: "get_console_logs",
+    ...consoleLogsTool
+  },
+  get_network_requests: {
+    name: "get_network_requests",
+    ...networkRequestsTool
+  }
+};
+
+// src/core/utils/id.ts
+function generateId(prefix = "id") {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateMessageId() {
+  return generateId("msg");
+}
+function generateThreadId() {
+  return generateId("thread");
+}
+function generateToolCallId() {
+  return generateId("call");
+}
+
+// src/core/types/message.ts
+function parseToolCallArgs(toolCall) {
+  try {
+    return JSON.parse(toolCall.function.arguments);
+  } catch {
+    return {};
+  }
+}
+function createToolCall(id, name, args) {
+  return {
+    id,
+    type: "function",
+    function: {
+      name,
+      arguments: JSON.stringify(args)
+    }
+  };
+}
+function createMessage(partial) {
+  return {
+    id: partial.id ?? generateMessageId(),
+    thread_id: partial.thread_id,
+    role: partial.role,
+    content: partial.content ?? null,
+    tool_calls: partial.tool_calls,
+    tool_call_id: partial.tool_call_id,
+    metadata: partial.metadata,
+    created_at: partial.created_at ?? /* @__PURE__ */ new Date()
+  };
+}
+function createUserMessage(content, options) {
+  return createMessage({
+    id: options?.id,
+    thread_id: options?.thread_id,
+    role: "user",
+    content,
+    metadata: options?.attachments ? { attachments: options.attachments } : void 0
+  });
+}
+function createAssistantMessage(content, options) {
+  const metadata = {};
+  if (options?.thinking) metadata.thinking = options.thinking;
+  if (options?.sources) metadata.sources = options.sources;
+  if (options?.model) metadata.model = options.model;
+  return createMessage({
+    id: options?.id,
+    thread_id: options?.thread_id,
+    role: "assistant",
+    content,
+    tool_calls: options?.tool_calls,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  });
+}
+function createToolMessage(toolCallId, result, options) {
+  return createMessage({
+    id: options?.id,
+    thread_id: options?.thread_id,
+    role: "tool",
+    content: JSON.stringify(result),
+    tool_call_id: toolCallId
+  });
+}
+function hasToolCalls(message) {
+  return message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+}
+function isToolResult(message) {
+  return message.role === "tool" && !!message.tool_call_id;
+}
+
+// src/core/types/config.ts
+var DEFAULT_MODELS = {
+  openai: "gpt-4o",
+  anthropic: "claude-3-5-sonnet-latest",
+  google: "gemini-pro",
+  groq: "llama-3.1-70b-versatile",
+  ollama: "llama3",
+  custom: "default"
+};
+function getDefaultModel(provider) {
+  return DEFAULT_MODELS[provider] || "default";
+}
+
+// src/core/types/actions.ts
+function actionToTool(action) {
+  const properties = {};
+  const required = [];
+  if (action.parameters) {
+    for (const [name, param] of Object.entries(action.parameters)) {
+      properties[name] = parameterToJsonSchema(param);
+      if (param.required) {
+        required.push(name);
+      }
+    }
+  }
+  return {
+    type: "function",
+    function: {
+      name: action.name,
+      description: action.description,
+      parameters: {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      }
+    }
+  };
+}
+function parameterToJsonSchema(param) {
+  const schema = {
+    type: param.type
+  };
+  if (param.description) {
+    schema.description = param.description;
+  }
+  if (param.enum) {
+    schema.enum = param.enum;
+  }
+  if (param.default !== void 0) {
+    schema.default = param.default;
+  }
+  if (param.properties) {
+    schema.properties = {};
+    for (const [name, prop] of Object.entries(param.properties)) {
+      schema.properties[name] = parameterToJsonSchema(prop);
+    }
+  }
+  if (param.items) {
+    schema.items = parameterToJsonSchema(param.items);
+  }
+  return schema;
+}
+
+// src/core/types/events.ts
+function parseStreamEvent(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function serializeStreamEvent(event) {
+  return JSON.stringify(event);
+}
+function formatSSE(event) {
+  return `data: ${serializeStreamEvent(event)}
+
+`;
+}
+
+// src/core/types/thread.ts
+function generateThreadTitle(content) {
+  const trimmed = content.trim();
+  if (trimmed.length <= 50) return trimmed;
+  return trimmed.substring(0, 47) + "...";
+}
+
+// src/core/utils/stream.ts
+function parseSSELine(line) {
+  if (!line.startsWith("data: ")) {
+    return null;
+  }
+  const data = line.slice(6).trim();
+  if (data === "[DONE]") {
+    return { type: "done" };
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function* streamSSE(response) {
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const event = parseSSELine(line);
+        if (event) {
+          yield event;
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseSSELine(buffer);
+      if (event) {
+        yield event;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createSSEStream(generator) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of generator) {
+          const data = `data: ${JSON.stringify(event)}
+
+`;
+          controller.enqueue(encoder.encode(data));
+        }
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      } catch (error) {
+        const errorEvent = {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        };
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify(errorEvent)}
+
+`)
+        );
+        controller.close();
+      }
+    }
+  });
+}
+
+// src/core/utils/zod-to-json-schema.ts
+function isZodSchema(value) {
+  return value !== null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function getZodTypeName(schema) {
+  if (!isZodSchema(schema)) return "unknown";
+  const def = schema._def;
+  return def.typeName || "unknown";
+}
+function getZodDescription(schema) {
+  if (!isZodSchema(schema)) return void 0;
+  const def = schema._def;
+  return def.description;
+}
+function zodToJsonSchema(schema) {
+  if (!isZodSchema(schema)) {
+    return { type: "string" };
+  }
+  const typeName = getZodTypeName(schema);
+  const description = getZodDescription(schema);
+  const def = schema._def;
+  switch (typeName) {
+    case "ZodString": {
+      const result2 = { type: "string" };
+      if (description) result2.description = description;
+      const checks = def.checks;
+      if (checks) {
+        for (const check of checks) {
+          if (check.kind === "min") result2.minLength = check.value;
+          if (check.kind === "max") result2.maxLength = check.value;
+          if (check.kind === "regex") result2.pattern = String(check.value);
+        }
+      }
+      return result2;
+    }
+    case "ZodNumber": {
+      const result2 = { type: "number" };
+      if (description) result2.description = description;
+      const checks = def.checks;
+      if (checks) {
+        for (const check of checks) {
+          if (check.kind === "min") result2.minimum = check.value;
+          if (check.kind === "max") result2.maximum = check.value;
+          if (check.kind === "int") result2.type = "integer";
+        }
+      }
+      return result2;
+    }
+    case "ZodBoolean": {
+      const result2 = { type: "boolean" };
+      if (description) result2.description = description;
+      return result2;
+    }
+    case "ZodEnum": {
+      const values = def.values;
+      const result2 = {
+        type: typeof values[0] === "number" ? "number" : "string",
+        enum: values
+      };
+      if (description) result2.description = description;
+      return result2;
+    }
+    case "ZodArray": {
+      const innerType = def.type;
+      const result2 = {
+        type: "array",
+        items: zodToJsonSchema(innerType)
+      };
+      if (description) result2.description = description;
+      return result2;
+    }
+    case "ZodObject": {
+      const shape = def.shape;
+      const shapeObj = typeof shape === "function" ? shape() : shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shapeObj)) {
+        properties[key] = zodToJsonSchema(value);
+        const fieldTypeName = getZodTypeName(value);
+        if (fieldTypeName !== "ZodOptional" && fieldTypeName !== "ZodNullable") {
+          required.push(key);
+        }
+      }
+      const result2 = {
+        type: "object",
+        properties
+      };
+      if (required.length > 0) result2.required = required;
+      if (description) result2.description = description;
+      return result2;
+    }
+    case "ZodOptional":
+    case "ZodNullable": {
+      const innerType = def.innerType;
+      return zodToJsonSchema(innerType);
+    }
+    case "ZodDefault": {
+      const innerType = def.innerType;
+      const defaultValue = def.defaultValue;
+      const result2 = zodToJsonSchema(innerType);
+      result2.default = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+      return result2;
+    }
+    case "ZodLiteral": {
+      const value = def.value;
+      return {
+        type: typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string",
+        enum: [value],
+        description
+      };
+    }
+    case "ZodUnion": {
+      const options = def.options;
+      if (options && options.length > 0) {
+        return zodToJsonSchema(options[0]);
+      }
+      return { type: "string" };
+    }
+    default:
+      const result = { type: "string" };
+      if (description) result.description = description;
+      return result;
+  }
+}
+function zodObjectToInputSchema(schema) {
+  const jsonSchema = zodToJsonSchema(schema);
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    const typeName = getZodTypeName(schema);
+    throw new Error(
+      `Expected a Zod object schema, got ${typeName}. Converted to: ${JSON.stringify(jsonSchema)}`
+    );
+  }
+  return {
+    type: "object",
+    properties: jsonSchema.properties,
+    required: jsonSchema.required
+  };
+}
+function defineTool(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    location: config.location,
+    inputSchema: zodObjectToInputSchema(config.schema),
+    handler: config.handler,
+    render: config.render,
+    available: config.available,
+    // Display config
+    title: config.title,
+    executingTitle: config.executingTitle,
+    completedTitle: config.completedTitle,
+    // AI response control
+    aiResponseMode: config.aiResponseMode,
+    aiContext: config.aiContext,
+    // Approval
+    needsApproval: config.needsApproval,
+    approvalMessage: config.approvalMessage
+  };
+}
+function defineClientTool(config) {
+  return defineTool({ ...config, location: "client" });
+}
+function defineServerTool(config) {
+  return defineTool({ ...config, location: "server" });
+}
+
+// src/core/system-prompt.ts
+function defaultSystemMessage(contextString, additionalInstructions) {
+  return `
+You are a helpful, efficient, and professional AI assistant.
+
+Help the user achieve their goals efficiently, without unnecessary fluff, while maintaining professionalism.
+Be polite, respectful, and prefer brevity over verbosity.
+
+${contextString ? `The user has provided you with the following context:
+\`\`\`
+${contextString}
+\`\`\`
+
+` : ""}You have access to functions you can call to take actions or get more information.
+
+Assist the user as best you can. Ask clarifying questions if needed, but if you can reasonably fill in the blanks yourself, do so.
+
+When calling a function, call it without extra commentary.
+If a function returns an error:
+- If the error is from incorrect parameters, you may retry with corrected arguments.
+- If the error source is unclear, do not retry.
+` + (additionalInstructions ? `
+${additionalInstructions}` : "");
+}
+
+// src/core/services/storage.ts
+var CLOUD_MAX_FILE_SIZE = 25 * 1024 * 1024;
+var DEFAULT_YOURGPT_ENDPOINT = "https://api.yourgpt.ai";
+function createCloudStorage(config) {
+  const endpoint = config.endpoint || DEFAULT_YOURGPT_ENDPOINT;
+  const maxFileSize = config.maxFileSize || CLOUD_MAX_FILE_SIZE;
+  return {
+    /**
+     * Check if cloud storage is available
+     * Premium API keys start with "ygpt_"
+     */
+    isAvailable() {
+      return Boolean(config.apiKey?.startsWith("ygpt_"));
+    },
+    /**
+     * Upload file to managed cloud storage
+     */
+    async upload(file, options) {
+      if (file.size > maxFileSize) {
+        const sizeMB = (maxFileSize / (1024 * 1024)).toFixed(0);
+        throw new Error(`File size exceeds ${sizeMB}MB limit`);
+      }
+      const presignResponse = await fetch(`${endpoint}/v1/storage/upload-url`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          filename: file.name,
+          mimeType: file.type,
+          size: file.size
+        })
+      });
+      if (!presignResponse.ok) {
+        const error = await presignResponse.text();
+        throw new Error(`Failed to get upload URL: ${error}`);
+      }
+      const { uploadUrl, publicUrl, expiresIn } = await presignResponse.json();
+      const uploadResponse = await fetch(uploadUrl, {
+        method: "PUT",
+        body: file,
+        headers: {
+          "Content-Type": file.type
+        }
+      });
+      if (!uploadResponse.ok) {
+        throw new Error(`Failed to upload file: ${uploadResponse.statusText}`);
+      }
+      return {
+        url: publicUrl,
+        expiresAt: expiresIn ? Date.now() + expiresIn * 1e3 : void 0
+      };
+    }
+  };
+}
+function getAttachmentTypeFromMime(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("video/")) return "video";
+  return "file";
+}
+async function processFileToAttachment(file, storage) {
+  const type = getAttachmentTypeFromMime(file.type);
+  if (storage?.isAvailable()) {
+    const { url } = await storage.upload(file);
+    return {
+      type,
+      url,
+      mimeType: file.type,
+      filename: file.name
+    };
+  }
+  const data = await fileToBase64(file);
+  return {
+    type,
+    data,
+    mimeType: file.type,
+    filename: file.name
+  };
+}
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (typeof reader.result === "string") {
+        resolve(reader.result);
+      } else {
+        reject(new Error("Failed to read file as base64"));
+      }
+    };
+    reader.onerror = () => reject(new Error("Failed to read file"));
+    reader.readAsDataURL(file);
+  });
+}
+
+exports.CLOUD_MAX_FILE_SIZE = CLOUD_MAX_FILE_SIZE;
+exports.DEFAULT_MODELS = DEFAULT_MODELS;
+exports.DEFAULT_YOURGPT_ENDPOINT = DEFAULT_YOURGPT_ENDPOINT;
+exports.actionToTool = actionToTool;
+exports.builtinTools = builtinTools;
+exports.captureCurrentLogs = captureCurrentLogs;
+exports.captureScreenshot = captureScreenshot;
+exports.clearConsoleLogs = clearConsoleLogs;
+exports.clearNetworkRequests = clearNetworkRequests;
+exports.consoleLogsTool = consoleLogsTool;
+exports.createAssistantMessage = createAssistantMessage;
+exports.createCloudStorage = createCloudStorage;
+exports.createConsoleLogsTool = createConsoleLogsTool;
+exports.createCustomDetector = createCustomDetector;
+exports.createMessage = createMessage;
+exports.createNetworkRequestsTool = createNetworkRequestsTool;
+exports.createSSEStream = createSSEStream;
+exports.createScreenshotTool = createScreenshotTool;
+exports.createToolCall = createToolCall;
+exports.createToolMessage = createToolMessage;
+exports.createToolResult = createToolResult;
+exports.createUserMessage = createUserMessage;
+exports.defaultSystemMessage = defaultSystemMessage;
+exports.defineClientTool = defineClientTool;
+exports.defineServerTool = defineServerTool;
+exports.defineTool = defineTool;
+exports.detectIntent = detectIntent;
+exports.failure = failure;
+exports.formatLogsForAI = formatLogsForAI;
+exports.formatRequestsForAI = formatRequestsForAI;
+exports.formatSSE = formatSSE;
+exports.generateId = generateId;
+exports.generateMessageId = generateMessageId;
+exports.generateSuggestionReason = generateSuggestionReason;
+exports.generateThreadId = generateThreadId;
+exports.generateThreadTitle = generateThreadTitle;
+exports.generateToolCallId = generateToolCallId;
+exports.getAttachmentTypeFromMime = getAttachmentTypeFromMime;
+exports.getConsoleErrors = getConsoleErrors;
+exports.getConsoleLogs = getConsoleLogs;
+exports.getConsoleWarnings = getConsoleWarnings;
+exports.getDefaultModel = getDefaultModel;
+exports.getFailedRequests = getFailedRequests;
+exports.getNetworkRequests = getNetworkRequests;
+exports.getPrimaryTool = getPrimaryTool;
+exports.hasToolCalls = hasToolCalls;
+exports.hasToolSuggestions = hasToolSuggestions;
+exports.isConsoleCaptureActive = isConsoleCaptureActive;
+exports.isNetworkCaptureActive = isNetworkCaptureActive;
+exports.isScreenshotSupported = isScreenshotSupported;
+exports.isToolResult = isToolResult;
+exports.networkRequestsTool = networkRequestsTool;
+exports.parseSSELine = parseSSELine;
+exports.parseStreamEvent = parseStreamEvent;
+exports.parseToolCallArgs = parseToolCallArgs;
+exports.processFileToAttachment = processFileToAttachment;
+exports.resizeScreenshot = resizeScreenshot;
+exports.screenshotTool = screenshotTool;
+exports.serializeStreamEvent = serializeStreamEvent;
+exports.startConsoleCapture = startConsoleCapture;
+exports.startNetworkCapture = startNetworkCapture;
+exports.stopConsoleCapture = stopConsoleCapture;
+exports.stopNetworkCapture = stopNetworkCapture;
+exports.streamSSE = streamSSE;
+exports.success = success;
+exports.tool = tool;
+exports.toolToAnthropicFormat = toolToAnthropicFormat;
+exports.toolToOpenAIFormat = toolToOpenAIFormat;
+exports.zodObjectToInputSchema = zodObjectToInputSchema;
+exports.zodToJsonSchema = zodToJsonSchema;
+//# sourceMappingURL=chunk-2ZCWVAAK.cjs.map
+//# sourceMappingURL=chunk-2ZCWVAAK.cjs.map