langwatch 1.12.1 → 1.13.0

package/dist/agent/index.mjs

@@ -44,7 +44,7 @@ import * as os from "os";
 import { randomUUID } from "crypto";
 
 // package.json
-var version = "1.12.1";
+var version = "1.13.0";
 
 // src/internal/constants.ts
 var LANGWATCH_SDK_VERSION = version;
@@ -449,6 +449,213 @@ function createParameterReader({
 
 // src/agent/transport.ts
 import { createRequire } from "module";
+
+// src/internal/http/langwatchFetch.ts
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var FOLLOWING_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var MAX_FOLLOW_HOPS = 5;
+var CREDENTIAL_HEADERS = [
+  "authorization",
+  "cookie",
+  "proxy-authorization",
+  "x-api-key",
+  "x-auth-token",
+  "x-project-id"
+];
+var LangWatchRedirectError = class extends Error {
+  constructor({
+    url,
+    location,
+    status
+  }) {
+    super(
+      `LangWatch refused to follow a redirect from ${url} to ${location ?? "an unknown location"} (HTTP ${status}). Set the endpoint to the final URL.`
+    );
+    this.name = "LangWatchRedirectError";
+    this.url = url;
+    this.location = location;
+    this.status = status;
+  }
+};
+var warnedOrigins = /* @__PURE__ */ new Set();
+var isRedirect = (response) => response.type === "opaqueredirect" || REDIRECT_STATUSES.has(response.status);
+var isStream = (body) => typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+var abortError = (signal) => {
+  const reason = signal.reason;
+  if (reason instanceof Error) return reason;
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("This operation was aborted", "AbortError");
+  }
+  return Object.assign(new Error("This operation was aborted"), { name: "AbortError" });
+};
+var discard = (spare) => {
+  void spare?.body?.cancel().catch(() => void 0);
+};
+var replayBody = async ({
+  spare,
+  signal
+}) => {
+  if (!signal) return spare.arrayBuffer();
+  if (signal.aborted) throw abortError(signal);
+  const aborted = new Promise((_, reject) => {
+    signal.addEventListener("abort", () => reject(abortError(signal)), { once: true });
+  });
+  void aborted.catch(() => void 0);
+  try {
+    return await Promise.race([spare.arrayBuffer(), aborted]);
+  } catch (error) {
+    discard(spare);
+    throw error;
+  }
+};
+var requestUrl = (input) => {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+};
+var parseHop = ({
+  url,
+  location
+}) => {
+  try {
+    const from = new URL(url);
+    return { from, to: new URL(location, from) };
+  } catch {
+    return null;
+  }
+};
+var isSchemeUpgrade = ({ from, to }) => from.protocol === "http:" && to.protocol === "https:" && from.hostname === to.hostname && from.port === to.port;
+var schemeUpgradeTarget = ({
+  url,
+  location
+}) => {
+  const hop = parseHop({ url, location });
+  if (hop === null || !isSchemeUpgrade(hop)) return null;
+  const { from, to } = hop;
+  if (from.pathname !== to.pathname) return null;
+  if (from.search !== to.search) return null;
+  to.hash = "";
+  return to.href;
+};
+var followTarget = ({
+  url,
+  location
+}) => {
+  const hop = parseHop({ url, location });
+  if (hop === null) return null;
+  const { from, to } = hop;
+  if (to.protocol !== "http:" && to.protocol !== "https:") return null;
+  if (from.protocol === "https:" && to.protocol === "http:") return null;
+  to.hash = "";
+  return to.href;
+};
+var keepsCredentials = ({ from, to }) => from.origin === to.origin || isSchemeUpgrade({ from, to });
+var withoutCredentials = (headers) => {
+  const stripped = new Headers(headers);
+  for (const name of CREDENTIAL_HEADERS) stripped.delete(name);
+  return stripped;
+};
+var warnOnce = ({ url, logger }) => {
+  const { origin, host } = new URL(url);
+  if (warnedOrigins.has(origin)) return;
+  warnedOrigins.add(origin);
+  logger.warn(
+    `LangWatch endpoint ${origin} redirected to https. Set the endpoint to https://${host} to skip the extra round trip.`
+  );
+};
+var refusalOf = ({
+  url,
+  response
+}) => new LangWatchRedirectError({
+  url,
+  location: response.headers.get("location"),
+  status: response.status
+});
+var effectiveRequest = ({
+  input,
+  init
+}) => typeof Request !== "undefined" && input instanceof Request ? new Request(input, { ...init, redirect: "manual" }) : null;
+var follow = async ({
+  send,
+  log,
+  effective,
+  init,
+  url,
+  method,
+  first
+}) => {
+  let headers = new Headers(effective?.headers ?? init?.headers);
+  const signal = effective?.signal ?? init?.signal;
+  let current = url;
+  let response = first;
+  for (let hop = 0; hop < MAX_FOLLOW_HOPS; hop++) {
+    const location = response.headers.get("location");
+    const target = location === null ? null : followTarget({ url: current, location });
+    if (target === null) throw refusalOf({ url: current, response });
+    const from = new URL(current);
+    const to = new URL(target);
+    if (!keepsCredentials({ from, to })) headers = withoutCredentials(headers);
+    if (isSchemeUpgrade({ from, to })) warnOnce({ url: current, logger: log });
+    current = target;
+    response = effective ? await send(new Request(target, { method, headers, signal, redirect: "manual" })) : await send(target, { ...init, method, headers, body: void 0, redirect: "manual" });
+    if (!isRedirect(response)) return response;
+  }
+  throw refusalOf({ url: current, response });
+};
+var upgrade = async ({
+  send,
+  log,
+  effective,
+  init,
+  url,
+  first,
+  spare
+}) => {
+  const location = first.headers.get("location");
+  const refused = refusalOf({ url, response: first });
+  const target = location === null ? null : schemeUpgradeTarget({ url, location });
+  if (location === null || first.status === 303 || target === null || isStream(init?.body)) {
+    discard(spare);
+    throw refused;
+  }
+  warnOnce({ url, logger: log });
+  const second = effective ? await send(
+    new Request(target, {
+      method: effective.method,
+      headers: effective.headers,
+      body: spare ? await replayBody({ spare, signal: effective.signal }) : null,
+      signal: effective.signal,
+      redirect: "manual"
+    })
+  ) : await send(target, { ...init, redirect: "manual" });
+  if (!isRedirect(second)) return second;
+  throw refusalOf({ url: target, response: second });
+};
+var createLangWatchFetch = ({
+  fetch: fetchImpl,
+  logger
+} = {}) => {
+  const send = fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  const log = logger ?? new ConsoleLogger({ level: "warn", prefix: "LangWatch" });
+  return async (input, init) => {
+    const url = requestUrl(input);
+    const effective = effectiveRequest({ input, init });
+    const method = (effective?.method ?? init?.method ?? "GET").toUpperCase();
+    const spare = effective !== null && effective.body !== null ? effective.clone() : null;
+    const first = effective ? await send(effective) : await send(input, { ...init, redirect: "manual" });
+    if (!isRedirect(first)) {
+      discard(spare);
+      return first;
+    }
+    const hop = { send, log, effective, init, url, first };
+    if (!FOLLOWING_METHODS.has(method)) return upgrade({ ...hop, spare });
+    discard(spare);
+    return follow({ ...hop, method });
+  };
+};
+var langwatchFetch = createLangWatchFetch();
+
+// src/agent/transport.ts
 var AGENT_TRANSPORTS = ["websocket", "http"];
 var INSTANCE_TOKEN_HEADER = "X-Agent-Instance-Token";
 var isSet3 = (value) => typeof value === "string" && value.trim() !== "";
@@ -533,7 +740,7 @@ var HttpLongPollSocket = class {
     this.settleRegistered = () => void 0;
     this.url = options.url;
     this.headers = options.headers;
-    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const fetchImpl = options.fetch ?? (typeof globalThis.fetch === "function" ? langwatchFetch : void 0);
     if (typeof fetchImpl !== "function") {
       throw new Error("the HTTP transport needs a global fetch; run on Node 20 or later");
     }
@@ -734,10 +941,9 @@ var HttpLongPollSocket = class {
   }
 };
 
-// src/agent/client.ts
+// src/agent/reconnect.ts
 var RECONNECT_BASE_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
-var FAILURE_NOTICE_INTERVAL_MS = 5 * 6e4;
 function reconnectDelayMs({
   attempt,
   baseMs = RECONNECT_BASE_MS,
@@ -748,6 +954,22 @@ function reconnectDelayMs({
   const jittered = exponential * (0.75 + random() * 0.5);
   return Math.round(Math.min(maxMs, Math.max(baseMs, jittered)));
 }
+function watchdogDelayMs(heartbeatIntervalMs) {
+  return Math.max(15e3, heartbeatIntervalMs * 3);
+}
+var describeError = (error) => error instanceof Error ? error.message : String(error);
+function openTransportSocket({
+  transport,
+  websocketUrl,
+  httpUrl,
+  headers,
+  socketFactory = defaultSocketFactory
+}) {
+  return transport === "http" ? new HttpLongPollSocket({ url: httpUrl, headers }) : socketFactory({ url: websocketUrl, headers });
+}
+
+// src/agent/client.ts
+var FAILURE_NOTICE_INTERVAL_MS = 5 * 6e4;
 var NOT_CONNECTED = "not connected to LangWatch";
 function refusalAdvice(frame) {
   switch (frame.code) {
@@ -780,7 +1002,6 @@ function refusalAdvice(frame) {
 }
 var SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM"];
 var CLOSE_GRACE_MS = 500;
-var describeError = (error) => error instanceof Error ? error.message : String(error);
 var AgentClient = class {
   constructor(config) {
     this.agents = [];
@@ -941,7 +1162,13 @@ var AgentClient = class {
     if (this.stopped || this.socket) return;
     let socket;
     try {
-      socket = this.activeTransport === "http" ? new HttpLongPollSocket({ url: this.httpUrl, headers: this.headers }) : this.openSocket({ url: this.url, headers: this.headers });
+      socket = openTransportSocket({
+        transport: this.activeTransport,
+        websocketUrl: this.url,
+        httpUrl: this.httpUrl,
+        headers: this.headers,
+        socketFactory: this.openSocket
+      });
     } catch (error) {
       if (error instanceof NoWebSocketError) {
         this.giveUp(
@@ -1029,7 +1256,7 @@ var AgentClient = class {
         socket.terminate();
       } catch {
       }
-    }, Math.max(15e3, this.heartbeatIntervalMs * 3));
+    }, watchdogDelayMs(this.heartbeatIntervalMs));
   }
   registerFrame() {
     return {
@@ -1292,7 +1519,7 @@ var installShutdownHooks = () => {
   }
   process.on("beforeExit", onBeforeExit);
 };
-function warnOnce({ logger, key, message }) {
+function warnOnce2({ logger, key, message }) {
   if (noticesGiven.has(key)) {
     logger.debug(message);
     return;
@@ -1304,7 +1531,7 @@ function getSharedClient(config) {
   const key = `${config.endpoint ?? ""}|${config.projectId ?? ""}|${config.apiKey}`;
   if (shared) {
     if (sharedKey !== key) {
-      warnOnce({
+      warnOnce2({
         logger: config.logger,
         key: "credentials-differ",
         message: "connectAgent: this process already has an agent connection with other credentials or endpoint; the first ones are used"
@@ -1321,6 +1548,7 @@ function getSharedClient(config) {
 // src/agent/define.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_TIMEOUT_MS = 3e5;
+var DEFAULT_CONCURRENCY = 10;
 var isMessage = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.role === "string";
 function normalizeReply(reply) {
   if (typeof reply === "string") return { output: reply };
@@ -1360,10 +1588,7 @@ function connectAgent(options, handler) {
   const parameters = toParameterSchema(options.parameters);
   const specs = parameterSpecsFromSchema(parameters);
   const timeoutMs = clampTimeout({ timeoutMs: options.timeoutMs, logger, name });
-  const concurrency = Math.max(
-    1,
-    Math.floor(options.concurrency ?? (environment === DEFAULT_ENVIRONMENT ? 1 : 4))
-  );
+  const concurrency = Math.max(1, Math.floor(options.concurrency ?? DEFAULT_CONCURRENCY));
   const runHandler = async (call) => normalizeReply(await handler(call));
   const readParams2 = createParameterReader({ input: options.parameters, specs });
   const invoke = async (call) => {
@@ -1399,7 +1624,7 @@ function connectAgent(options, handler) {
   } else {
     const apiKey = readApiKey(options.apiKey);
     if (!apiKey) {
-      warnOnce({
+      warnOnce2({
         logger,
         key: "no-api-key",
         message: `agent "${name}" not connected to LangWatch: no API key. Set LANGWATCH_API_KEY to run simulations against it.`