canary-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,906 @@
+// src/buffer.ts
+import { gzipSync } from "zlib";
+import https from "https";
+import http from "http";
+var MAX_LEN = 1e4;
+var BATCH_SIZE = 100;
+var FLUSH_INTERVAL_MS = 1e4;
+var MAX_EVENTS_PER_SESSION = 500;
+var MAX_SESSION_CACHE_EVENTS = 5e3;
+var RETRY_ATTEMPTS = 3;
+var RETRY_BACKOFF_MS = [1e3, 2e3, 4e3];
+var EventBuffer = class {
+  _buffer = [];
+  _sessionCache = /* @__PURE__ */ new Map();
+  _sessionCacheEventCount = 0;
+  _apiKey;
+  _endpoint;
+  _timer = null;
+  _stopped = false;
+  /** Reference to the original (unpatched) https.request for anti-recursion. */
+  _originalRequest;
+  constructor(apiKey, endpoint = "http://localhost:8000", autoFlush = true, originalRequest) {
+    this._apiKey = apiKey;
+    this._endpoint = endpoint.replace(/\/+$/, "");
+    this._originalRequest = originalRequest ?? https.request;
+    if (autoFlush) {
+      this._timer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+      this._timer.unref();
+    }
+  }
+  /** Add an event to the ring buffer. */
+  push(event) {
+    if (this._buffer.length >= MAX_LEN) {
+      this._buffer.shift();
+    }
+    this._buffer.push(event);
+    const sessionId = event.framework_session_id;
+    if (typeof sessionId === "string" && sessionId) {
+      if (this._sessionCacheEventCount < MAX_SESSION_CACHE_EVENTS) {
+        let sessionEvents = this._sessionCache.get(sessionId);
+        if (!sessionEvents) {
+          sessionEvents = [];
+          this._sessionCache.set(sessionId, sessionEvents);
+        }
+        if (sessionEvents.length < MAX_EVENTS_PER_SESSION) {
+          sessionEvents.push(event);
+          this._sessionCacheEventCount++;
+        }
+      }
+    }
+  }
+  /** Return a copy of events for the given session from the cache. */
+  getSessionEvents(sessionId) {
+    return [...this._sessionCache.get(sessionId) ?? []];
+  }
+  /** Remove session events from the cache. */
+  clearSession(sessionId) {
+    const events = this._sessionCache.get(sessionId);
+    if (events) {
+      this._sessionCacheEventCount = Math.max(
+        0,
+        this._sessionCacheEventCount - events.length
+      );
+      this._sessionCache.delete(sessionId);
+    }
+  }
+  /** Remove and return up to `count` events from the buffer. */
+  drain(count) {
+    const n = Math.min(count, this._buffer.length);
+    return this._buffer.splice(0, n);
+  }
+  /** Get all buffered events (without draining). For reporter access. */
+  peek() {
+    return [...this._buffer];
+  }
+  /** Number of buffered events. */
+  get length() {
+    return this._buffer.length;
+  }
+  /** Drain a batch and send to backend. */
+  async flush() {
+    const events = this.drain(BATCH_SIZE);
+    if (events.length === 0) return;
+    for (let attempt = 0; attempt < RETRY_ATTEMPTS; attempt++) {
+      try {
+        await this._send(events);
+        return;
+      } catch {
+        if (attempt < RETRY_ATTEMPTS - 1) {
+          await sleep(RETRY_BACKOFF_MS[attempt]);
+        }
+      }
+    }
+  }
+  /** Stop flush timer and drain all remaining events. */
+  async shutdown() {
+    this._stopped = true;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    while (this._buffer.length > 0) {
+      const events = this.drain(BATCH_SIZE);
+      if (events.length === 0) break;
+      for (let attempt = 0; attempt < RETRY_ATTEMPTS; attempt++) {
+        try {
+          await this._send(events);
+          break;
+        } catch {
+          if (attempt === RETRY_ATTEMPTS - 1) {
+          } else {
+            await sleep(RETRY_BACKOFF_MS[attempt]);
+          }
+        }
+      }
+    }
+  }
+  /** POST events to the backend with gzip compression. */
+  _send(events) {
+    const payload = JSON.stringify({
+      events,
+      sdk_version: "0.1.0"
+    });
+    const compressed = gzipSync(Buffer.from(payload, "utf-8"));
+    const url = new URL(`${this._endpoint}/v1/events`);
+    const isHttps = url.protocol === "https:";
+    const requestFn = isHttps ? this._originalRequest : http.request;
+    return new Promise((resolve, reject) => {
+      const req = requestFn(
+        {
+          hostname: url.hostname,
+          port: url.port || (isHttps ? 443 : 80),
+          path: url.pathname,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Encoding": "gzip",
+            Authorization: `Bearer ${this._apiKey}`,
+            "Content-Length": compressed.length
+          },
+          timeout: 5e3
+        },
+        (res) => {
+          res.resume();
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}`));
+          }
+        }
+      );
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timeout"));
+      });
+      req.write(compressed);
+      req.end();
+    });
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/interceptors/http.ts
+import http2 from "http";
+import https2 from "https";
+import { performance } from "perf_hooks";
+
+// src/domains.ts
+var COMMON_API_DOMAINS = {
+  // Payments
+  "api.stripe.com": "stripe",
+  "hooks.stripe.com": "stripe",
+  "api.squareup.com": "square",
+  "api.paypal.com": "paypal",
+  "api.braintreegateway.com": "braintree",
+  // AI / ML
+  "api.openai.com": "openai",
+  "api.anthropic.com": "anthropic",
+  "api.cohere.ai": "cohere",
+  "generativelanguage.googleapis.com": "google-ai",
+  "api.replicate.com": "replicate",
+  "api-inference.huggingface.co": "huggingface",
+  "api.mistral.ai": "mistral",
+  // Communication
+  "api.twilio.com": "twilio",
+  "api.sendgrid.com": "sendgrid",
+  "api.mailgun.net": "mailgun",
+  "api.postmarkapp.com": "postmark",
+  "api.resend.com": "resend",
+  // Developer tools
+  "api.github.com": "github",
+  "gitlab.com": "gitlab",
+  "api.slack.com": "slack",
+  "discord.com": "discord",
+  "api.linear.app": "linear",
+  // Cloud / Infrastructure
+  "api.cloudflare.com": "cloudflare",
+  "api.vercel.com": "vercel",
+  "api.heroku.com": "heroku",
+  "api.netlify.com": "netlify",
+  // Data / Analytics
+  "api.segment.io": "segment",
+  "api.mixpanel.com": "mixpanel",
+  "api.amplitude.com": "amplitude",
+  // Productivity / SaaS
+  "api.notion.so": "notion",
+  "api.airtable.com": "airtable",
+  "api.hubspot.com": "hubspot",
+  "api.salesforce.com": "salesforce",
+  // Social
+  "graph.facebook.com": "facebook",
+  "api.twitter.com": "twitter",
+  "api.x.com": "twitter",
+  // Finance
+  "api.plaid.com": "plaid",
+  "sandbox.plaid.com": "plaid",
+  // Commerce
+  "api.shopify.com": "shopify",
+  // Maps / Location
+  "maps.googleapis.com": "google-maps",
+  // Auth
+  "api.auth0.com": "auth0",
+  // Search
+  "api.algolia.com": "algolia",
+  // Storage
+  "api.supabase.co": "supabase",
+  "api.firebase.google.com": "firebase"
+};
+var DOMAIN_SUFFIXES = {};
+for (const [domain, provider] of Object.entries(COMMON_API_DOMAINS)) {
+  const parts = domain.split(".");
+  if (parts.length >= 2) {
+    const registrable = parts.slice(-2).join(".");
+    DOMAIN_SUFFIXES[registrable] = provider;
+  }
+}
+function matchProvider(host) {
+  host = host.toLowerCase().trim();
+  if (host in COMMON_API_DOMAINS) {
+    return COMMON_API_DOMAINS[host];
+  }
+  const parts = host.split(".");
+  if (parts.length >= 2) {
+    const registrable = parts.slice(-2).join(".");
+    if (registrable in DOMAIN_SUFFIXES) {
+      return DOMAIN_SUFFIXES[registrable];
+    }
+  }
+  return null;
+}
+
+// src/normalize.ts
+var UUID_RE = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/g;
+var STRIPE_ID_RE = /^[a-z]{2,4}_[A-Za-z0-9]*\d[A-Za-z0-9]*$/;
+var NUMERIC_RE = /^\d{2,}$/;
+function normalizeEndpoint(path) {
+  path = path.split("?")[0].split("#")[0];
+  path = path.replace(UUID_RE, "{id}");
+  const parts = path.split("/");
+  const normalized = [];
+  for (const part of parts) {
+    if (!part) {
+      normalized.push(part);
+    } else if (part === "{id}") {
+      normalized.push(part);
+    } else if (STRIPE_ID_RE.test(part)) {
+      normalized.push("{id}");
+    } else if (NUMERIC_RE.test(part)) {
+      normalized.push("{id}");
+    } else {
+      normalized.push(part);
+    }
+  }
+  return normalized.join("/");
+}
+
+// src/extract.ts
+var COMMON_RESPONSE_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "status",
+  "object",
+  "type",
+  "finish_reason",
+  "stop_reason",
+  "error_code",
+  "error_message",
+  "usage",
+  "created",
+  "currency",
+  "livemode"
+]);
+var USAGE_KEYS = /* @__PURE__ */ new Set([
+  "prompt_tokens",
+  "completion_tokens",
+  "total_tokens",
+  "input_tokens",
+  "output_tokens"
+]);
+var MAX_BODY_SIZE = 4096;
+function extractResponseFields(body) {
+  if (body.length > MAX_BODY_SIZE) {
+    body = body.slice(0, MAX_BODY_SIZE);
+  }
+  let data;
+  try {
+    data = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return void 0;
+  }
+  const obj = data;
+  const result = {};
+  for (const key of COMMON_RESPONSE_KEYS) {
+    if (key in obj) {
+      const val = obj[key];
+      if (key === "usage" && typeof val === "object" && val !== null && !Array.isArray(val)) {
+        const usageObj = val;
+        const usage = {};
+        for (const uk of USAGE_KEYS) {
+          if (uk in usageObj) {
+            usage[uk] = usageObj[uk];
+          }
+        }
+        if (Object.keys(usage).length > 0) {
+          result["usage"] = usage;
+        }
+      } else {
+        result[key] = val;
+      }
+    }
+  }
+  if (!("finish_reason" in result) && "choices" in obj) {
+    const choices = obj["choices"];
+    if (Array.isArray(choices) && choices.length > 0) {
+      const choice = choices[0];
+      if (typeof choice === "object" && choice !== null && "finish_reason" in choice) {
+        result["finish_reason"] = choice["finish_reason"];
+      }
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+
+// src/agent-detect.ts
+var AGENT_ENV_MAP = [
+  { envKey: "CLAUDE_CODE", name: "claude_code" },
+  { envKey: "CURSOR_TRACE_ID", name: "cursor" },
+  { envKey: "OPENCLAW_SESSION_ID", name: "openclaw", versionKey: "OPENCLAW_VERSION" },
+  { envKey: "WINDSURF_SESSION_ID", name: "windsurf" },
+  { envKey: "CLINE_TASK_ID", name: "cline" },
+  { envKey: "AIDER_VERSION", name: "aider", versionKey: "AIDER_VERSION" },
+  { envKey: "DEVIN_SESSION_ID", name: "devin" },
+  { envKey: "CODEX_CLI", name: "codex" },
+  { envKey: "GITHUB_COPILOT", name: "github_copilot" },
+  { envKey: "CODY_SESSION_ID", name: "sourcegraph_cody" }
+];
+var cachedInfo = null;
+function detectAgent() {
+  if (cachedInfo) return cachedInfo;
+  for (const entry of AGENT_ENV_MAP) {
+    const val = process.env[entry.envKey];
+    if (val !== void 0) {
+      cachedInfo = {
+        agent_name: entry.name,
+        agent_version: entry.versionKey ? process.env[entry.versionKey] ?? null : null
+      };
+      return cachedInfo;
+    }
+  }
+  cachedInfo = { agent_name: null, agent_version: null };
+  return cachedInfo;
+}
+function resetAgentCache() {
+  cachedInfo = null;
+}
+
+// src/context.ts
+var sessionStorage = new AsyncLocalStorage();
+var sdkInstanceId = randomUUID().replace(/-/g, "");
+var callSequence = 0;
+function getSessionSignals() {
+  callSequence++;
+  const store = sessionStorage.getStore();
+  const signals = {
+    sdk_instance_id: sdkInstanceId,
+    process_id: process.pid,
+    call_sequence: callSequence
+  };
+  if (store?.frameworkSessionId) {
+    signals.framework_session_id = store.frameworkSessionId;
+  }
+  const agentInfo = detectAgent();
+  if (agentInfo.agent_name) {
+    signals.agent_name = agentInfo.agent_name;
+  }
+  if (agentInfo.agent_version) {
+    signals.agent_version = agentInfo.agent_version;
+  }
+  return signals;
+}
+function setFrameworkSession(sessionId) {
+  const store = sessionStorage.getStore();
+  if (store) {
+    store.frameworkSessionId = sessionId;
+  }
+}
+function clearFrameworkSession() {
+  const store = sessionStorage.getStore();
+  if (store) {
+    store.frameworkSessionId = "";
+  }
+}
+function runWithSession(sessionId, fn) {
+  return sessionStorage.run({ frameworkSessionId: sessionId }, fn);
+}
+
+// src/interceptors/http.ts
+var MAX_BODY_CAPTURE = 4096;
+var originalHttpRequest = http2.request;
+var originalHttpGet = http2.get;
+var originalHttpsRequest = https2.request;
+var originalHttpsGet = https2.get;
+var _buffer = null;
+function wrapRequest(original, defaultProtocol) {
+  return function patchedRequest(...args) {
+    let url;
+    let options;
+    let callback;
+    if (typeof args[0] === "string" || args[0] instanceof URL) {
+      url = args[0];
+      if (typeof args[1] === "function") {
+        callback = args[1];
+      } else {
+        options = args[1];
+        callback = args[2];
+      }
+    } else {
+      options = args[0];
+      callback = args[1];
+      url = "";
+    }
+    let hostname;
+    let pathname = "/";
+    let method = "GET";
+    if (typeof url === "string" && url) {
+      try {
+        const parsed = new URL(url);
+        hostname = parsed.hostname;
+        pathname = parsed.pathname;
+      } catch {
+        hostname = void 0;
+      }
+    } else if (url instanceof URL) {
+      hostname = url.hostname;
+      pathname = url.pathname;
+    }
+    if (options) {
+      hostname = hostname || options.hostname || options.host;
+      if (options.path) pathname = options.path;
+      if (options.method) method = options.method;
+    }
+    if (hostname && hostname.includes(":")) {
+      hostname = hostname.split(":")[0];
+    }
+    const provider = hostname ? matchProvider(hostname) : null;
+    if (!provider || !_buffer) {
+      return original.apply(this, args);
+    }
+    const start = performance.now();
+    const signals = getSessionSignals();
+    const wrappedCallback = (res) => {
+      const chunks = [];
+      let totalSize = 0;
+      res.on("data", (chunk) => {
+        if (totalSize < MAX_BODY_CAPTURE) {
+          chunks.push(chunk);
+          totalSize += chunk.length;
+        }
+      });
+      res.on("end", () => {
+        const latencyMs = performance.now() - start;
+        const status = res.statusCode ?? 0;
+        const body = Buffer.concat(chunks).toString("utf-8").slice(0, MAX_BODY_CAPTURE);
+        const event = {
+          event_type: "http",
+          provider,
+          endpoint_pattern: normalizeEndpoint(pathname),
+          method: method.toUpperCase(),
+          status,
+          latency_ms: Math.round(latencyMs * 100) / 100,
+          ts: Date.now() / 1e3,
+          ...signals
+        };
+        if (status >= 400) {
+          event.error_body = body;
+        } else if (status >= 200 && status < 300) {
+          const fields = extractResponseFields(body);
+          if (fields) {
+            event.response_fields = fields;
+          }
+        }
+        _buffer.push(event);
+      });
+      if (callback) callback(res);
+    };
+    if (typeof args[0] === "string" || args[0] instanceof URL) {
+      if (options) {
+        return original.call(this, args[0], options, wrappedCallback);
+      } else {
+        return original.call(this, args[0], wrappedCallback);
+      }
+    } else {
+      return original.call(this, options, wrappedCallback);
+    }
+  };
+}
+function patchHttp(buffer) {
+  _buffer = buffer;
+  http2.request = wrapRequest(originalHttpRequest, "http:");
+  http2.get = wrapRequest(originalHttpGet, "http:");
+  https2.request = wrapRequest(originalHttpsRequest, "https:");
+  https2.get = wrapRequest(originalHttpsGet, "https:");
+}
+function unpatchHttp() {
+  _buffer = null;
+  http2.request = originalHttpRequest;
+  http2.get = originalHttpGet;
+  https2.request = originalHttpsRequest;
+  https2.get = originalHttpsGet;
+}
+
+// src/interceptors/fetch.ts
+import { performance as performance2 } from "perf_hooks";
+var MAX_BODY_CAPTURE2 = 4096;
+var CLONE_READ_TIMEOUT_MS = 5e3;
+var _originalFetch = null;
+var _buffer2 = null;
+function patchFetch(buffer) {
+  if (typeof globalThis.fetch === "undefined") return;
+  _originalFetch = globalThis.fetch;
+  _buffer2 = buffer;
+  globalThis.fetch = async function patchedFetch(input, init2) {
+    let url;
+    let method = "GET";
+    try {
+      if (typeof input === "string") {
+        url = new URL(input);
+      } else if (input instanceof URL) {
+        url = input;
+      } else if (input instanceof Request) {
+        url = new URL(input.url);
+        method = input.method;
+      } else {
+        return _originalFetch(input, init2);
+      }
+    } catch {
+      return _originalFetch(input, init2);
+    }
+    if (init2?.method) method = init2.method;
+    const provider = matchProvider(url.hostname);
+    if (!provider || !_buffer2) {
+      return _originalFetch(input, init2);
+    }
+    const start = performance2.now();
+    const signals = getSessionSignals();
+    const response = await _originalFetch(input, init2);
+    const latencyMs = performance2.now() - start;
+    const status = response.status;
+    let body = "";
+    try {
+      const clone = response.clone();
+      const text = await Promise.race([
+        clone.text(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("timeout")), CLONE_READ_TIMEOUT_MS)
+        )
+      ]);
+      body = text.slice(0, MAX_BODY_CAPTURE2);
+    } catch {
+    }
+    const event = {
+      event_type: "http",
+      provider,
+      endpoint_pattern: normalizeEndpoint(url.pathname),
+      method: method.toUpperCase(),
+      status,
+      latency_ms: Math.round(latencyMs * 100) / 100,
+      ts: Date.now() / 1e3,
+      ...signals
+    };
+    if (status >= 400) {
+      event.error_body = body;
+    } else if (status >= 200 && status < 300 && body) {
+      const fields = extractResponseFields(body);
+      if (fields) {
+        event.response_fields = fields;
+      }
+    }
+    _buffer2.push(event);
+    return response;
+  };
+}
+function unpatchFetch() {
+  if (_originalFetch) {
+    globalThis.fetch = _originalFetch;
+    _originalFetch = null;
+  }
+  _buffer2 = null;
+}
+
+// src/reporter.ts
+var MAX_FRICTION_POINTS = 10;
+var MAX_FRICTION_LENGTH = 200;
+var SessionReporter = class {
+  /**
+   * Analyze events and return feedback events for each session.
+   */
+  generateFeedback(events) {
+    const sessions = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      if (event.event_type === "feedback") continue;
+      const sid = event.framework_session_id;
+      let list = sessions.get(sid);
+      if (!list) {
+        list = [];
+        sessions.set(sid, list);
+      }
+      list.push(event);
+    }
+    const feedbackEvents = [];
+    for (const [sessionId, sessionEvents] of sessions) {
+      const feedback = this._analyzeSession(sessionId, sessionEvents);
+      if (feedback) feedbackEvents.push(feedback);
+    }
+    return feedbackEvents;
+  }
+  _analyzeSession(sessionId, events) {
+    const httpEvents = events.filter((e) => e.event_type === "http");
+    const actionEvents = events.filter(
+      (e) => e.event_type === "action"
+    );
+    if (httpEvents.length === 0 && actionEvents.length === 0) return null;
+    const errorEvents = httpEvents.filter(
+      (e) => typeof e.status === "number" && e.status >= 400
+    );
+    const totalCalls = httpEvents.length;
+    const errorCount = errorEvents.length;
+    const errorRate = totalCalls > 0 ? errorCount / totalCalls : 0;
+    const worked = errorRate < 0.5;
+    const frictionPoints = this._extractFrictionPoints(errorEvents);
+    const context = this._buildContext(httpEvents, actionEvents, errorCount);
+    const errorProviders = [
+      ...new Set(
+        errorEvents.map((e) => e.provider).filter((p) => typeof p === "string")
+      )
+    ].sort();
+    const feedback = {
+      event_type: "feedback",
+      source: "auto_report",
+      worked,
+      context,
+      ts: Date.now() / 1e3
+    };
+    if (frictionPoints.length > 0) {
+      feedback.friction_points = frictionPoints;
+    }
+    if (sessionId) {
+      feedback.framework_session_id = sessionId;
+    }
+    if (errorProviders.length > 0) {
+      feedback.provider = errorProviders[0];
+    }
+    return feedback;
+  }
+  _extractFrictionPoints(errorEvents) {
+    const frictionPoints = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const event of errorEvents) {
+      const provider = event.provider ?? "unknown";
+      const endpoint = event.endpoint_pattern ?? "";
+      const errorBody = event.error_body ?? "";
+      const status = event.status ?? 0;
+      let point;
+      if (!errorBody) {
+        point = `${provider} ${endpoint}: HTTP ${status}`;
+      } else {
+        const message = this._extractErrorMessage(errorBody);
+        point = `${provider} ${endpoint}: ${message}`;
+      }
+      point = point.slice(0, MAX_FRICTION_LENGTH);
+      if (!seen.has(point)) {
+        seen.add(point);
+        frictionPoints.push(point);
+      }
+      if (frictionPoints.length >= MAX_FRICTION_POINTS) break;
+    }
+    return frictionPoints;
+  }
+  _extractErrorMessage(errorBody) {
+    try {
+      const data = JSON.parse(errorBody);
+      if (typeof data === "object" && data !== null) {
+        for (const key of ["message", "error", "detail", "error_message"]) {
+          const val = data[key];
+          if (typeof val === "string") return val;
+          if (typeof val === "object" && val !== null) {
+            const msg = val.message ?? val.type;
+            if (msg) return String(msg);
+          }
+        }
+      }
+    } catch {
+    }
+    const firstLine = errorBody.trim().split("\n")[0];
+    return firstLine.slice(0, MAX_FRICTION_LENGTH);
+  }
+  _buildContext(httpEvents, actionEvents, errorCount) {
+    const parts = [];
+    const providers = [
+      ...new Set(
+        httpEvents.map((e) => e.provider).filter((p) => typeof p === "string")
+      )
+    ].sort();
+    if (providers.length > 0) {
+      parts.push(`APIs: ${providers.join(", ")}`);
+    }
+    const pages = actionEvents.filter((e) => e.action_type === "page_navigate" && e.action_args).map((e) => e.action_args?.url).filter((u) => typeof u === "string" && u.length > 0);
+    if (pages.length > 0) {
+      parts.push(`${pages.length} pages visited`);
+    }
+    if (httpEvents.length > 0) {
+      parts.push(`${httpEvents.length} HTTP calls, ${errorCount} errors`);
+    }
+    if (actionEvents.length > 0) {
+      parts.push(`${actionEvents.length} browser actions`);
+    }
+    return parts.length > 0 ? parts.join("; ") : "Session completed";
+  }
+};
+
+// src/adapters/mcp.ts
+import { performance as performance3 } from "perf_hooks";
+var MAX_RESULT_SIZE = 4096;
+var CanaryMCPMiddleware = class {
+  _buffer;
+  _sessionId;
+  constructor(buffer, sessionId) {
+    this._buffer = buffer;
+    this._sessionId = sessionId;
+  }
+  /**
+   * Wrap a tool handler to capture execution time, arguments, and results.
+   */
+  wrap(handler, toolName) {
+    const self = this;
+    const wrapped = async function(...args) {
+      const start = performance3.now();
+      let result;
+      let error;
+      try {
+        result = await handler.apply(this, args);
+      } catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        self._pushEvent(toolName, args, void 0, error, start);
+        throw err;
+      }
+      self._pushEvent(toolName, args, result, void 0, start);
+      return result;
+    };
+    return wrapped;
+  }
+  /**
+   * Manually record a tool call event.
+   */
+  onToolCall(toolName, args, result, error, latencyMs) {
+    const event = {
+      event_type: "action",
+      source: "mcp",
+      action_type: toolName,
+      action_args: args,
+      latency_ms: latencyMs ?? 0,
+      ts: Date.now() / 1e3
+    };
+    if (error) {
+      event.action_result = { error };
+      event.status = 500;
+    } else if (result !== void 0) {
+      const serialized = JSON.stringify(result);
+      event.action_result = {
+        value: serialized.length > MAX_RESULT_SIZE ? serialized.slice(0, MAX_RESULT_SIZE) : serialized
+      };
+    }
+    if (this._sessionId) {
+      event.framework_session_id = this._sessionId;
+    }
+    this._buffer.push(event);
+  }
+  _pushEvent(toolName, args, result, error, startTime) {
+    const latencyMs = performance3.now() - startTime;
+    let argsObj = {};
+    if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+      argsObj = args[0];
+    } else if (args.length > 0) {
+      argsObj = { args };
+    }
+    this.onToolCall(toolName, argsObj, result, error, latencyMs);
+  }
+};
+
+// src/index.ts
+var _initialized = false;
+var _buffer3 = null;
+var _autoReport = true;
+function init(config) {
+  if (_initialized) return;
+  if (!config.apiKey.startsWith("cnry_sk_")) {
+    throw new Error(
+      "Invalid API key: must start with 'cnry_sk_'. Get your key at https://app.canary.dev"
+    );
+  }
+  const endpoint = config.endpoint ?? "http://localhost:8000";
+  _autoReport = config.autoReport ?? true;
+  const autoFlush = config.autoFlush ?? true;
+  _buffer3 = new EventBuffer(
+    config.apiKey,
+    endpoint,
+    autoFlush,
+    originalHttpsRequest
+  );
+  patchHttp(_buffer3);
+  patchFetch(_buffer3);
+  _initialized = true;
+}
+async function shutdown() {
+  if (!_initialized || !_buffer3) return;
+  unpatchHttp();
+  unpatchFetch();
+  if (_autoReport) {
+    const reporter = new SessionReporter();
+    const allEvents = _buffer3.peek();
+    const feedbackEvents = reporter.generateFeedback(allEvents);
+    for (const event of feedbackEvents) {
+      _buffer3.push(event);
+    }
+  }
+  await _buffer3.shutdown();
+  _buffer3 = null;
+  _initialized = false;
+}
+function survey(options) {
+  if (!_buffer3) {
+    throw new Error("Canary SDK not initialized. Call init() first.");
+  }
+  const agentInfo = detectAgent();
+  const event = {
+    event_type: "feedback",
+    source: "manual",
+    worked: options.worked ?? true,
+    context: options.context ?? "",
+    ts: Date.now() / 1e3,
+    agent_name: agentInfo.agent_name ?? void 0,
+    agent_version: agentInfo.agent_version ?? void 0
+  };
+  if (options.frictionPoints && options.frictionPoints.length > 0) {
+    event.friction_points = options.frictionPoints;
+  }
+  if (options.provider) {
+    event.provider = options.provider;
+  }
+  if (options.sessionId) {
+    event.framework_session_id = options.sessionId;
+  }
+  _buffer3.push(event);
+}
+function getBuffer() {
+  return _buffer3;
+}
+export {
+  COMMON_API_DOMAINS,
+  CanaryMCPMiddleware,
+  EventBuffer,
+  SessionReporter,
+  clearFrameworkSession,
+  detectAgent,
+  extractResponseFields,
+  getBuffer,
+  getSessionSignals,
+  init,
+  matchProvider,
+  normalizeEndpoint,
+  resetAgentCache,
+  runWithSession,
+  setFrameworkSession,
+  shutdown,
+  survey
+};
+//# sourceMappingURL=index.js.map