langwatch 1.9.0 → 1.11.0

package/dist/agent/index.js

@@ -0,0 +1,1468 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent/index.ts
+var agent_exports = {};
+__export(agent_exports, {
+  AGENT_TRANSPORTS: () => AGENT_TRANSPORTS,
+  AgentParameterError: () => AgentParameterError,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS,
+  MAX_TIMEOUT_MS: () => MAX_TIMEOUT_MS,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  connectAgent: () => connectAgent,
+  normalizeReply: () => normalizeReply,
+  parameterSpecsFromSchema: () => parameterSpecsFromSchema,
+  resolveConnectUrl: () => resolveConnectUrl,
+  resolveEnvironment: () => resolveEnvironment,
+  resolveHttpConnectUrl: () => resolveHttpConnectUrl,
+  resolveTransport: () => resolveTransport,
+  sanitizeEnvironment: () => sanitizeEnvironment,
+  toParameterSchema: () => toParameterSchema
+});
+module.exports = __toCommonJS(agent_exports);
+
+// src/logger/index.ts
+var logLevelOrder = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var ConsoleLogger = class {
+  constructor(options = { level: "warn" }) {
+    this.debug = (message, ...args) => {
+      if (this.shouldLog("debug")) console.debug(this.format(message), ...args);
+    };
+    this.info = (message, ...args) => {
+      if (this.shouldLog("info")) console.info(this.format(message), ...args);
+    };
+    this.warn = (message, ...args) => {
+      if (this.shouldLog("warn")) console.warn(this.format(message), ...args);
+    };
+    this.error = (message, ...args) => {
+      if (this.shouldLog("error")) console.error(this.format(message), ...args);
+    };
+    this.level = options.level;
+    this.prefix = options.prefix;
+  }
+  shouldLog(level) {
+    return logLevelOrder[level] >= logLevelOrder[this.level];
+  }
+  format(message) {
+    return this.prefix ? `[${this.prefix}] ${message}` : message;
+  }
+};
+
+// src/agent/client.ts
+var import_api = require("@opentelemetry/api");
+
+// src/agent/identity.ts
+var os = __toESM(require("os"));
+var import_node_crypto = require("crypto");
+
+// package.json
+var version = "1.11.0";
+
+// src/internal/constants.ts
+var LANGWATCH_SDK_VERSION = version;
+var DEFAULT_ENDPOINT = "https://app.langwatch.ai";
+
+// src/internal/endpoint.ts
+var isSet = (value) => typeof value === "string" && value.trim() !== "";
+var normalizeEndpoint = (endpoint) => {
+  const trimmed = endpoint.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed[end - 1] === "/") end--;
+  return trimmed.slice(0, end);
+};
+var resolveEndpoint = (endpoint) => {
+  for (const candidate of [endpoint, process.env.LANGWATCH_ENDPOINT]) {
+    if (!isSet(candidate)) continue;
+    const normalized = normalizeEndpoint(candidate);
+    if (normalized !== "") return normalized;
+  }
+  return normalizeEndpoint(DEFAULT_ENDPOINT);
+};
+
+// src/agent/identity.ts
+var DEFAULT_ENVIRONMENT = "development";
+var ENVIRONMENT_MAX_LENGTH = 32;
+var ENVIRONMENT_VARIABLES = [
+  "LANGWATCH_AGENT_ENVIRONMENT",
+  "APP_ENV",
+  "ENVIRONMENT",
+  "NODE_ENV"
+];
+var isSet2 = (value) => typeof value === "string" && value.trim() !== "";
+function sanitizeEnvironment(name) {
+  const cleaned = name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, ENVIRONMENT_MAX_LENGTH).replace(/-+$/g, "");
+  return cleaned === "" ? DEFAULT_ENVIRONMENT : cleaned;
+}
+function resolveEnvironment({
+  explicit,
+  env = process.env
+}) {
+  if (isSet2(explicit)) return sanitizeEnvironment(explicit);
+  for (const name of ENVIRONMENT_VARIABLES) {
+    const value = env[name];
+    if (isSet2(value)) return sanitizeEnvironment(value);
+  }
+  return DEFAULT_ENVIRONMENT;
+}
+var isTruthy = (value) => {
+  if (!isSet2(value)) return false;
+  const lowered = value.trim().toLowerCase();
+  return lowered !== "0" && lowered !== "false" && lowered !== "no" && lowered !== "off";
+};
+function resolveEnabled({
+  explicit,
+  env = process.env
+}) {
+  const flag = env.LANGWATCH_AGENT_CONNECT;
+  if (isSet2(flag) && !isTruthy(flag)) return false;
+  if (explicit !== void 0) return explicit;
+  return !isTruthy(env.CI);
+}
+function resolveInstanceLabel({
+  explicit,
+  env = process.env
+}) {
+  if (isSet2(explicit)) return explicit.trim();
+  const fromEnv = env.LANGWATCH_AGENT_INSTANCE_LABEL;
+  return isSet2(fromEnv) ? fromEnv.trim() : void 0;
+}
+var HOST_LABEL_MAX_LENGTH = 24;
+function hostLabel(hostname) {
+  return hostname.toLowerCase().replace(/\.(local|lan|home|localdomain)$/i, "").replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, HOST_LABEL_MAX_LENGTH);
+}
+var readHostname = (machine) => {
+  try {
+    return hostLabel(machine.hostname());
+  } catch {
+    return "";
+  }
+};
+var readUsername = (machine) => {
+  try {
+    return machine.userInfo().username;
+  } catch {
+    return "";
+  }
+};
+function buildInstance({
+  label,
+  machine = os
+}) {
+  return {
+    id: `inst_${(0, import_node_crypto.randomUUID)().replace(/-/g, "")}`,
+    hostname: readHostname(machine),
+    username: readUsername(machine),
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...label ? { label } : {},
+    inFlightCallIds: []
+  };
+}
+var SDK_IDENTITY = {
+  name: "langwatch-typescript",
+  version: LANGWATCH_SDK_VERSION,
+  language: "typescript"
+};
+var USER_AGENT = `langwatch-typescript/${LANGWATCH_SDK_VERSION}`;
+var CONNECT_PATH = "/api/v1/agents/connect";
+function resolveConnectUrl(endpoint) {
+  const base = resolveEndpoint(endpoint);
+  const socketBase = base.replace(
+    /^http(s?):\/\//i,
+    (_match, secure) => secure ? "wss://" : "ws://"
+  );
+  return `${socketBase}${CONNECT_PATH}`;
+}
+function resolveHttpConnectUrl(endpoint) {
+  return `${resolveEndpoint(endpoint)}${CONNECT_PATH}`;
+}
+function buildConnectHeaders({
+  apiKey,
+  projectId
+}) {
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "User-Agent": USER_AGENT
+  };
+  if (isSet2(projectId)) headers["X-Project-Id"] = projectId;
+  return headers;
+}
+
+// src/agent/protocol.ts
+var PROTOCOL_VERSION = 1;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isString = (value) => typeof value === "string";
+var isMessageList = (value) => Array.isArray(value) && value.every((item) => isRecord(item) && isString(item.role));
+var isStringList = (value) => Array.isArray(value) && value.every(isString);
+var readRegistered = (frame) => {
+  if (!Array.isArray(frame.agents) || !isString(frame.instanceId)) return null;
+  const agents = [];
+  for (const entry of frame.agents) {
+    if (!isRecord(entry) || !isString(entry.name)) return null;
+    const id = isString(entry.id) ? entry.id : isString(entry.agentId) ? entry.agentId : null;
+    if (id === null) return null;
+    agents.push({
+      name: entry.name,
+      environment: isString(entry.environment) ? entry.environment : "",
+      id,
+      url: isString(entry.url) ? entry.url : "",
+      parameterNotes: isStringList(entry.parameterNotes) ? entry.parameterNotes : []
+    });
+  }
+  return {
+    type: "registered",
+    protocol: typeof frame.protocol === "number" ? frame.protocol : PROTOCOL_VERSION,
+    agents,
+    heartbeatIntervalMs: typeof frame.heartbeatIntervalMs === "number" ? frame.heartbeatIntervalMs : 1e4,
+    instanceId: frame.instanceId
+  };
+};
+var readRefused = (frame) => ({
+  type: "refused",
+  protocol: typeof frame.protocol === "number" ? frame.protocol : PROTOCOL_VERSION,
+  code: isString(frame.code) ? frame.code : "agent_register_refused",
+  message: isString(frame.message) ? frame.message : "The platform refused the registration.",
+  ...isRecord(frame.meta) ? { meta: frame.meta } : {}
+});
+var readParams = (value) => {
+  if (!isRecord(value)) return {};
+  const params = {};
+  for (const [name, item] of Object.entries(value)) {
+    if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+      params[name] = item;
+    }
+  }
+  return params;
+};
+var readDeadline = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (isString(value)) {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+};
+var readCall = (frame) => {
+  if (!isString(frame.callId) || !isString(frame.agentId)) return null;
+  const messages = isMessageList(frame.messages) ? frame.messages : [];
+  const run = isRecord(frame.run) ? frame.run : {};
+  return {
+    type: "call",
+    protocol: typeof frame.protocol === "number" ? frame.protocol : PROTOCOL_VERSION,
+    callId: frame.callId,
+    agentId: frame.agentId,
+    threadId: isString(frame.threadId) ? frame.threadId : "",
+    messages,
+    newMessages: isMessageList(frame.newMessages) ? frame.newMessages : messages,
+    params: readParams(frame.params),
+    session: frame.session === void 0 ? null : frame.session,
+    traceparent: isString(frame.traceparent) ? frame.traceparent : null,
+    deadlineAt: readDeadline(frame.deadlineAt),
+    run: {
+      ...isString(run.scenarioRunId) ? { scenarioRunId: run.scenarioRunId } : {},
+      ...isString(run.scenarioName) ? { scenarioName: run.scenarioName } : {},
+      ...isString(run.batchRunId) ? { batchRunId: run.batchRunId } : {}
+    }
+  };
+};
+function parseServerFrame(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed) || !isString(parsed.type)) return null;
+  switch (parsed.type) {
+    case "registered":
+      return readRegistered(parsed);
+    case "refused":
+      return readRefused(parsed);
+    case "call":
+      return readCall(parsed);
+    case "cancel":
+      return isString(parsed.callId) ? {
+        type: "cancel",
+        protocol: typeof parsed.protocol === "number" ? parsed.protocol : PROTOCOL_VERSION,
+        callId: parsed.callId
+      } : null;
+    default:
+      return null;
+  }
+}
+function serializeFrame(frame) {
+  return JSON.stringify(frame);
+}
+function traceIdFromTraceparent(traceparent) {
+  if (!traceparent) return null;
+  const parts = traceparent.trim().split("-");
+  const traceId = parts[1];
+  if (parts.length < 4 || !traceId || !/^[0-9a-f]{32}$/i.test(traceId)) return null;
+  return traceId.toLowerCase();
+}
+
+// src/agent/schema.ts
+var AgentParameterError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "agent_parameter_invalid";
+    this.name = "AgentParameterError";
+  }
+};
+var ACCEPTED_FORMS = `parameters must be a definition map ({ model: { options: [...], default: '...' } }), a Standard JSON Schema object (one with "~standard".jsonSchema), or a JSON Schema object ({ type: 'object', properties })`;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStandardJsonSchema = (value) => {
+  if (!isRecord2(value)) return false;
+  const standard = value["~standard"];
+  return isRecord2(standard) && isRecord2(standard.jsonSchema);
+};
+var isJsonSchemaObject = (value) => isRecord2(value) && value.type === "object" && isRecord2(value.properties);
+var isDefinitionMap = (value) => isRecord2(value) && Object.values(value).every(isRecord2);
+var definitionType = (definition) => {
+  if (definition.type) return definition.type;
+  if (definition.options) return "string";
+  const value = definition.default;
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  return "string";
+};
+var definitionMapToSchema = (definitions) => {
+  const properties = {};
+  const required = [];
+  for (const [name, definition] of Object.entries(definitions)) {
+    const property = { type: definitionType(definition) };
+    if (definition.options) property.enum = [...definition.options];
+    if (definition.default !== void 0) property.default = definition.default;
+    else required.push(name);
+    if (definition.description !== void 0) property.description = definition.description;
+    properties[name] = property;
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) schema.required = required;
+  return schema;
+};
+var readStandardJsonSchema = (input) => {
+  const converter = input["~standard"].jsonSchema;
+  const options = { target: "draft-2020-12" };
+  const schema = converter.input?.(options) ?? converter.output?.(options);
+  if (schema === void 0) {
+    throw new AgentParameterError(`the "~standard".jsonSchema converter has no input function; ${ACCEPTED_FORMS}`);
+  }
+  if (!isRecord2(schema)) {
+    throw new AgentParameterError(`the "~standard".jsonSchema converter returned no object; ${ACCEPTED_FORMS}`);
+  }
+  return schema;
+};
+function toParameterSchema(input) {
+  if (input === void 0) return { type: "object", properties: {} };
+  if (isStandardJsonSchema(input)) return readStandardJsonSchema(input);
+  if (isJsonSchemaObject(input)) return input;
+  if (isDefinitionMap(input)) return definitionMapToSchema(input);
+  throw new AgentParameterError(ACCEPTED_FORMS);
+}
+var specType = (property) => {
+  const type = Array.isArray(property.type) ? property.type.find((item) => item !== "null") : property.type;
+  if (type === "number" || type === "integer") return "number";
+  if (type === "boolean") return "boolean";
+  return "string";
+};
+var scalar = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : void 0;
+function parameterSpecsFromSchema(schema) {
+  const properties = isRecord2(schema.properties) ? schema.properties : {};
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const specs = [];
+  for (const [name, raw] of Object.entries(properties)) {
+    const property = isRecord2(raw) ? raw : {};
+    const spec = { name, type: specType(property) };
+    const options = Array.isArray(property.enum) ? property.enum.filter((item) => typeof item === "string") : void 0;
+    if (options && options.length > 0) spec.options = options;
+    const fallback = scalar(property.default);
+    if (fallback !== void 0) spec.default = fallback;
+    if (typeof property.description === "string") spec.description = property.description;
+    spec.required = fallback === void 0 && required.has(name);
+    specs.push(spec);
+  }
+  return specs;
+}
+var coerce = ({
+  spec,
+  value
+}) => {
+  if (spec.type === "number") {
+    const asNumber = typeof value === "number" ? value : Number(value);
+    if (typeof value === "boolean" || !Number.isFinite(asNumber) || String(value).trim() === "") {
+      throw new AgentParameterError(`parameter "${spec.name}" must be a number, got ${JSON.stringify(value)}`);
+    }
+    return asNumber;
+  }
+  if (spec.type === "boolean") {
+    if (typeof value === "boolean") return value;
+    if (value === "true") return true;
+    if (value === "false") return false;
+    throw new AgentParameterError(`parameter "${spec.name}" must be true or false, got ${JSON.stringify(value)}`);
+  }
+  const asString = typeof value === "string" ? value : String(value);
+  if (spec.options && !spec.options.includes(asString)) {
+    throw new AgentParameterError(
+      `parameter "${spec.name}" must be one of ${spec.options.join(", ")}, got ${JSON.stringify(value)}`
+    );
+  }
+  return asString;
+};
+function resolveParameterValues({
+  specs,
+  supplied
+}) {
+  const values = { ...supplied ?? {} };
+  for (const spec of specs) {
+    const value = values[spec.name];
+    if (value === void 0) {
+      if (spec.default !== void 0) {
+        values[spec.name] = spec.default;
+        continue;
+      }
+      if (!spec.required) continue;
+      throw new AgentParameterError(`parameter "${spec.name}" is required and the run did not supply it`);
+    }
+    values[spec.name] = coerce({ spec, value });
+  }
+  return values;
+}
+var issuePath = (issue) => (issue.path ?? []).map(
+  (segment) => typeof segment === "object" && segment !== null ? String(segment.key) : String(segment)
+).join(".");
+async function validateParameterValues({
+  schema,
+  values
+}) {
+  const standard = schema["~standard"];
+  const result = await standard.validate?.(values);
+  if (result === void 0) return values;
+  if (result.issues) {
+    const detail = result.issues.map((issue) => {
+      const path = issuePath(issue);
+      return path ? `${path}: ${issue.message}` : issue.message;
+    }).join("; ");
+    throw new AgentParameterError(`parameters refused by the schema: ${detail}`);
+  }
+  const parsed = isRecord2(result.value) ? result.value : {};
+  return { ...values, ...parsed };
+}
+function createParameterReader({
+  input,
+  specs
+}) {
+  const schema = isStandardJsonSchema(input) ? input : void 0;
+  return async (supplied) => {
+    const values = resolveParameterValues({ specs, supplied });
+    return schema ? validateParameterValues({ schema, values }) : values;
+  };
+}
+
+// src/agent/transport.ts
+var import_node_module = require("module");
+var AGENT_TRANSPORTS = ["websocket", "http"];
+var INSTANCE_TOKEN_HEADER = "X-Agent-Instance-Token";
+var isSet3 = (value) => typeof value === "string" && value.trim() !== "";
+function resolveTransport({
+  explicit,
+  env = process.env
+}) {
+  const candidate = isSet3(explicit) ? explicit : env.LANGWATCH_AGENT_TRANSPORT;
+  return isSet3(candidate) && candidate.trim().toLowerCase() === "http" ? "http" : "websocket";
+}
+var NoWebSocketError = class extends Error {
+  constructor() {
+    super("the ws package is not installed, so no socket can carry the API key header");
+    this.name = "NoWebSocketError";
+  }
+};
+var textOf = (data) => {
+  if (typeof data === "string") return data;
+  if (Buffer.isBuffer(data)) return data.toString("utf8");
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+  return String(data);
+};
+var wrapWs = (socket) => {
+  const closeListeners = [];
+  let closed = false;
+  const emitClose = (code) => {
+    if (closed) return;
+    closed = true;
+    for (const listener of closeListeners) listener(code);
+  };
+  socket.on("close", (code) => emitClose(code));
+  return {
+    send: (data) => socket.send(data),
+    close: (code, reason) => socket.close(code, reason),
+    terminate: () => socket.terminate(),
+    onOpen: (listener) => socket.on("open", listener),
+    onMessage: (listener) => socket.on("message", (data) => listener(textOf(data))),
+    onClose: (listener) => closeListeners.push(listener),
+    onError: (listener) => socket.on("error", listener),
+    onPing: (listener) => socket.on("ping", listener),
+    onUpgradeRefused: (listener) => socket.on("unexpected-response", (request, response) => {
+      listener(response.statusCode ?? 0);
+      response.resume();
+      request.destroy();
+      emitClose(1006);
+    })
+  };
+};
+var wsConstructor = () => {
+  try {
+    const loaded = (0, import_node_module.createRequire)(__filename)("ws");
+    return typeof loaded.WebSocket === "function" ? loaded.WebSocket : null;
+  } catch {
+    return null;
+  }
+};
+var defaultSocketFactory = ({ url, headers }) => {
+  const Ws = wsConstructor();
+  if (!Ws) throw new NoWebSocketError();
+  return wrapWs(new Ws(url, { headers }));
+};
+var SESSION_LOST_CLOSE_CODE = 1012;
+var POST_RETRY_DELAYS_MS = [250, 500, 1e3];
+var EMPTY_POLL_FLOOR_MS = 250;
+var CLOSE_DEADLINE_MS = 500;
+var describe = (error) => error instanceof Error ? error.message : String(error);
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms).unref());
+var HttpLongPollSocket = class {
+  constructor(options) {
+    this.messageListeners = [];
+    this.closeListeners = [];
+    this.errorListeners = [];
+    this.pingListeners = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    this.polls = new AbortController();
+    this.frames = new AbortController();
+    this.outbox = Promise.resolve();
+    this.token = null;
+    this.closed = false;
+    this.closeEmitted = false;
+    this.settleRegistered = () => void 0;
+    this.url = options.url;
+    this.headers = options.headers;
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new Error("the HTTP transport needs a global fetch; run on Node 20 or later");
+    }
+    this.fetchImpl = fetchImpl;
+    this.registered = new Promise((resolve) => {
+      this.settleRegistered = resolve;
+    });
+  }
+  send(data) {
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (frame.type === "register") {
+      void this.register(data);
+      return;
+    }
+    if (frame.type === "ack" && typeof frame.callId === "string") this.inFlight.add(frame.callId);
+    if (frame.type === "result" && typeof frame.callId === "string") this.inFlight.delete(frame.callId);
+    this.outbox = this.outbox.then(() => this.registered).then(() => this.post(data)).catch(() => void 0);
+  }
+  /**
+   * Stops polling, lets the frames already queued go out, then reports the
+   * close. The wait is bounded: on the deadline the frame requests are aborted
+   * and the close is reported anyway, so a request that never answers cannot
+   * hold the connection open.
+   */
+  close(code = 1e3) {
+    this.closed = true;
+    this.polls.abort();
+    const deadline = setTimeout(() => {
+      this.frames.abort();
+      this.emitClose(code);
+    }, CLOSE_DEADLINE_MS);
+    deadline.unref();
+    void this.outbox.finally(() => {
+      clearTimeout(deadline);
+      this.emitClose(code);
+    });
+  }
+  terminate() {
+    this.closed = true;
+    this.polls.abort();
+    this.frames.abort();
+    this.emitClose(1006);
+  }
+  onOpen(listener) {
+    setTimeout(() => {
+      if (!this.closed) listener();
+    }, 0);
+  }
+  onMessage(listener) {
+    this.messageListeners.push(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.push(listener);
+  }
+  onError(listener) {
+    this.errorListeners.push(listener);
+  }
+  onPing(listener) {
+    this.pingListeners.push(listener);
+  }
+  requestHeaders() {
+    return {
+      ...this.headers,
+      "Content-Type": "application/json",
+      ...this.token ? { [INSTANCE_TOKEN_HEADER]: this.token } : {}
+    };
+  }
+  async register(data) {
+    let response;
+    try {
+      response = await this.fetchImpl(`${this.url}/register`, {
+        method: "POST",
+        headers: this.requestHeaders(),
+        body: data,
+        signal: this.polls.signal
+      });
+    } catch (error) {
+      if (!this.closed) this.fail(`could not reach ${this.url}/register (${describe(error)})`, 1006);
+      return;
+    }
+    const body = await this.jsonOf(response);
+    const frame = body && typeof body.frame === "object" && body.frame !== null ? body.frame : null;
+    if (!frame) {
+      this.fail(`the register request was answered with HTTP ${response.status}`, 1006);
+      return;
+    }
+    if (typeof body?.instanceToken === "string") this.token = body.instanceToken;
+    this.settleRegistered();
+    this.emitMessage(JSON.stringify(frame));
+    if (frame.type !== "registered") return;
+    if (!this.token) {
+      this.fail("the register answer carried no instance token", 1006);
+      return;
+    }
+    void this.pollLoop();
+  }
+  async pollLoop() {
+    while (!this.closed && this.token) {
+      const query = this.inFlight.size > 0 ? `?inFlight=${encodeURIComponent([...this.inFlight].join(","))}` : "";
+      const startedAt = Date.now();
+      let response;
+      try {
+        response = await this.fetchImpl(`${this.url}/poll${query}`, {
+          method: "GET",
+          headers: this.requestHeaders(),
+          signal: this.polls.signal
+        });
+      } catch (error) {
+        if (!this.closed) this.fail(`the poll failed (${describe(error)})`, 1006);
+        return;
+      }
+      if (this.closed) return;
+      if (response.status === 410) {
+        this.fail("the platform no longer knows this instance, registering again", SESSION_LOST_CLOSE_CODE);
+        return;
+      }
+      const body = await this.jsonOf(response);
+      if (!response.ok) {
+        const answered = body && typeof body.frame === "object" && body.frame !== null ? body.frame : null;
+        if (answered) this.emitMessage(JSON.stringify(answered));
+        if (answered?.type === "refused") {
+          return;
+        }
+        this.fail(`the poll was answered with HTTP ${response.status}`, 1006);
+        return;
+      }
+      const frames = Array.isArray(body?.frames) ? body.frames : [];
+      for (const frame of frames) {
+        const entry = frame;
+        if (entry.type === "cancel" && typeof entry.callId === "string") this.inFlight.delete(entry.callId);
+        this.emitMessage(JSON.stringify(frame));
+      }
+      for (const listener of this.pingListeners) listener();
+      if (frames.length === 0) {
+        const elapsedMs = Date.now() - startedAt;
+        if (elapsedMs < EMPTY_POLL_FLOOR_MS) await wait(EMPTY_POLL_FLOOR_MS - elapsedMs);
+      }
+    }
+  }
+  async post(data) {
+    if (!this.token) return;
+    for (let attempt = 0; ; attempt += 1) {
+      if (this.frames.signal.aborted) return;
+      let response = null;
+      try {
+        response = await this.fetchImpl(`${this.url}/frames`, {
+          method: "POST",
+          headers: this.requestHeaders(),
+          body: `{"frames":[${data}]}`,
+          signal: this.frames.signal
+        });
+      } catch {
+        if (this.frames.signal.aborted) return;
+        response = null;
+      }
+      if (response?.ok) return;
+      if (response?.status === 410) {
+        this.fail("the platform no longer knows this instance, registering again", SESSION_LOST_CLOSE_CODE);
+        return;
+      }
+      if (response && response.status < 500) return;
+      const delay = POST_RETRY_DELAYS_MS[attempt];
+      if (delay === void 0) {
+        this.fail(`a frame could not be posted after ${attempt} retries`, 1006);
+        return;
+      }
+      await wait(delay);
+    }
+  }
+  async jsonOf(response) {
+    try {
+      const parsed = await response.json();
+      return typeof parsed === "object" && parsed !== null ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  fail(message, code) {
+    for (const listener of this.errorListeners) listener(new Error(message));
+    this.closed = true;
+    this.polls.abort();
+    this.frames.abort();
+    this.emitClose(code);
+  }
+  emitMessage(data) {
+    for (const listener of this.messageListeners) listener(data);
+  }
+  emitClose(code) {
+    if (this.closeEmitted) return;
+    this.closeEmitted = true;
+    this.settleRegistered();
+    for (const listener of this.closeListeners) listener(code);
+  }
+};
+
+// src/agent/client.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,
+  maxMs = RECONNECT_MAX_MS,
+  random = Math.random
+}) {
+  const exponential = Math.min(maxMs, baseMs * 2 ** Math.min(attempt, 16));
+  const jittered = exponential * (0.75 + random() * 0.5);
+  return Math.round(Math.min(maxMs, Math.max(baseMs, jittered)));
+}
+var NOT_CONNECTED = "not connected to LangWatch";
+function refusalAdvice(frame) {
+  switch (frame.code) {
+    case "project_required": {
+      const projects = Array.isArray(frame.meta?.projects) ? frame.meta.projects : [];
+      const listed = projects.map((project) => {
+        const entry = project;
+        const id = typeof entry.id === "string" ? entry.id : "";
+        const name = typeof entry.name === "string" ? entry.name : "";
+        return name && id ? `${name} (${id})` : id || name;
+      }).filter((line) => line !== "");
+      return `the API key reaches more than one project. Set LANGWATCH_PROJECT_ID to one of: ${listed.length > 0 ? listed.join(", ") : "the projects the key reaches"}.`;
+    }
+    case "api_key_invalid":
+      return "the API key is not valid. Set LANGWATCH_API_KEY to a key from the project settings.";
+    case "key_type_not_allowed":
+      return "this key type cannot connect agents. Set LANGWATCH_API_KEY to a personal or project API key.";
+    case "permission_denied":
+      return "the API key cannot manage scenarios. Use a key with the scenarios:manage permission.";
+    case "protocol_invalid":
+      return `${frame.message} Update the langwatch package to a version that speaks protocol ${PROTOCOL_VERSION} or later.`;
+    case "replica_count_unsupported":
+      return `${frame.message} Connected agents on a LangWatch deployment without Redis need one app replica.`;
+    case "parameters_invalid":
+    case "environment_invalid":
+      return frame.message;
+    default:
+      return `${frame.message} (${frame.code})`;
+  }
+}
+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 = [];
+    this.byId = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.upgradeStatus = null;
+    this.transportAnnounced = false;
+    this.socket = null;
+    this.registered = false;
+    this.stopped = false;
+    /** True while a socket is closed on purpose to register the full agent list again. */
+    this.restarting = false;
+    this.attempt = 0;
+    this.connectTimer = null;
+    this.watchdog = null;
+    this.heartbeatIntervalMs = 1e4;
+    this.closeWaiters = [];
+    this.lastError = null;
+    this.failureNoticeAt = null;
+    this.gaveUp = false;
+    this.instance = buildInstance({ label: config.instanceLabel });
+    this.url = resolveConnectUrl(config.endpoint);
+    this.httpUrl = resolveHttpConnectUrl(config.endpoint);
+    this.activeTransport = resolveTransport({ explicit: config.transport });
+    this.headers = buildConnectHeaders({ apiKey: config.apiKey, projectId: config.projectId });
+    this.logger = config.logger;
+    this.openSocket = config.socketFactory ?? defaultSocketFactory;
+    this.backoff = config.backoff ?? { baseMs: RECONNECT_BASE_MS, maxMs: RECONNECT_MAX_MS };
+    this.failureNoticeIntervalMs = config.failureNoticeIntervalMs ?? FAILURE_NOTICE_INTERVAL_MS;
+  }
+  get instanceId() {
+    return this.instance.id;
+  }
+  /** The transport the client speaks now. */
+  get transport() {
+    return this.activeTransport;
+  }
+  get isRegistered() {
+    return this.registered;
+  }
+  /** True once the client gave up: refused, or no socket implementation. No timer is left behind. */
+  get isStopped() {
+    return this.stopped;
+  }
+  /** True while a reconnect is scheduled with a timer that keeps the process up. */
+  get hasPendingConnect() {
+    return this.connectTimer?.hasRef() ?? false;
+  }
+  /** True while the client is between attempts or inside one, with the process kept up. */
+  get isRetrying() {
+    if (this.stopped) return false;
+    return this.connectTimer ? this.connectTimer.hasRef() : this.socket !== null;
+  }
+  /** Adds an agent and connects on the next tick, or reconnects when a socket is already open. */
+  addAgent(runtime) {
+    this.agents.push(runtime);
+    if (this.gaveUp) {
+      this.logger.debug(`agent "${runtime.name}" ${NOT_CONNECTED}: the connection gave up earlier in this process`);
+      return;
+    }
+    this.stopped = false;
+    if (this.socket) {
+      this.restartSocket();
+      return;
+    }
+    this.scheduleConnect(0);
+  }
+  /** Closes the socket and connects again at once, keeping the reconnect loop. */
+  restartSocket() {
+    const socket = this.socket;
+    if (!socket) return;
+    this.restarting = true;
+    try {
+      socket.close(1e3, "agents changed");
+    } catch {
+      this.restarting = false;
+      this.socket = null;
+      this.scheduleConnect(0);
+    }
+  }
+  /** Removes an agent; the last one leaving deregisters and closes the socket. */
+  async removeAgent(runtime) {
+    const index = this.agents.indexOf(runtime);
+    if (index !== -1) this.agents.splice(index, 1);
+    for (const [id, agent] of this.byId) if (agent === runtime) this.byId.delete(id);
+    if (this.agents.length === 0) {
+      await this.disconnect();
+      return;
+    }
+    this.restartSocket();
+  }
+  /** Sends deregister, closes the socket and stops reconnecting. */
+  async disconnect() {
+    this.stopped = true;
+    this.clearTimers();
+    const socket = this.socket;
+    if (!socket) return;
+    if (this.registered) this.send({ type: "deregister", protocol: PROTOCOL_VERSION });
+    const closed = new Promise((resolve) => this.closeWaiters.push(resolve));
+    try {
+      socket.close(1e3, "deregister");
+    } catch {
+    }
+    const grace = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        try {
+          socket.terminate();
+        } catch {
+        }
+        resolve();
+      }, CLOSE_GRACE_MS);
+      timer.unref();
+    });
+    await Promise.race([closed, grace]);
+  }
+  /** Deregister with no wait, for a process that is already exiting. */
+  shutdownNow() {
+    this.stopped = true;
+    this.clearTimers();
+    if (!this.socket) return;
+    try {
+      if (this.registered) this.send({ type: "deregister", protocol: PROTOCOL_VERSION });
+      this.socket.close(1e3, "deregister");
+    } catch {
+    }
+  }
+  agentNames() {
+    return this.agents.map((agent) => `"${agent.name}"`).join(", ") || "the agent";
+  }
+  /**
+   * The reconnect timer keeps its ref on purpose: a script whose only job is
+   * the agent must stay up while it retries. Giving up clears every timer.
+   */
+  scheduleConnect(delayMs) {
+    if (this.stopped || this.connectTimer || this.socket) return;
+    this.connectTimer = setTimeout(() => {
+      this.connectTimer = null;
+      this.connect();
+    }, delayMs);
+  }
+  clearTimers() {
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+    if (this.watchdog) {
+      clearTimeout(this.watchdog);
+      this.watchdog = null;
+    }
+  }
+  giveUp(reason) {
+    this.stopped = true;
+    this.gaveUp = true;
+    this.clearTimers();
+    this.logger.warn(`agent ${this.agentNames()} ${NOT_CONNECTED}: ${reason}`);
+  }
+  connect() {
+    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 });
+    } catch (error) {
+      if (error instanceof NoWebSocketError) {
+        this.giveUp(
+          "the ws package is not installed. Run npm install ws; the platform reads the API key from a request header, and only ws can send it."
+        );
+        return;
+      }
+      this.lastError = describeError(error);
+      this.onClosed();
+      return;
+    }
+    this.socket = socket;
+    socket.onOpen(() => this.guard(() => this.send(this.registerFrame())));
+    socket.onMessage((data) => this.guard(() => this.onMessage(data)));
+    socket.onError((error) => {
+      this.lastError = describeError(error);
+    });
+    socket.onPing(() => this.armWatchdog());
+    socket.onUpgradeRefused?.((status) => {
+      this.upgradeStatus = status;
+    });
+    socket.onClose((code) => this.guard(() => this.onClosed(code)));
+  }
+  onClosed(code) {
+    const wasRegistered = this.registered;
+    const restarting = this.restarting;
+    this.restarting = false;
+    this.socket = null;
+    this.registered = false;
+    if (this.watchdog) {
+      clearTimeout(this.watchdog);
+      this.watchdog = null;
+    }
+    for (const waiter of this.closeWaiters.splice(0)) waiter();
+    if (this.stopped) return;
+    if (this.upgradeStatus !== null && this.activeTransport === "websocket") {
+      const status = this.upgradeStatus;
+      this.upgradeStatus = null;
+      this.activeTransport = "http";
+      this.logger.warn(
+        `the WebSocket upgrade to ${this.url} was answered with HTTP ${status}; using the HTTP transport at ${this.httpUrl} instead`
+      );
+      this.scheduleConnect(0);
+      return;
+    }
+    if (restarting) {
+      this.scheduleConnect(0);
+      return;
+    }
+    const delay = reconnectDelayMs({ attempt: this.attempt, ...this.backoff });
+    this.attempt += 1;
+    this.noteDisconnected({ wasRegistered, code });
+    this.scheduleConnect(delay);
+  }
+  /**
+   * One warning when the platform cannot be reached, one when a live
+   * connection is lost, and silence while the retries run: the same notice
+   * repeats only after the notice interval, and a reconnect resets it.
+   */
+  noteDisconnected({ wasRegistered, code }) {
+    const now = Date.now();
+    if (wasRegistered) {
+      this.logger.warn(
+        `lost the connection to LangWatch${code === void 0 ? "" : ` (${code})`}, reconnecting with backoff`
+      );
+      this.failureNoticeAt = now;
+      return;
+    }
+    const stale = this.failureNoticeAt === null || now - this.failureNoticeAt >= this.failureNoticeIntervalMs;
+    if (!stale) return;
+    this.failureNoticeAt = now;
+    const cause = this.lastError ? ` (${this.lastError})` : "";
+    this.logger.warn(
+      `agent ${this.agentNames()} ${NOT_CONNECTED}: could not reach ${this.url}${cause}. Check LANGWATCH_ENDPOINT and the network; retrying with backoff.`
+    );
+  }
+  armWatchdog() {
+    if (this.watchdog) clearTimeout(this.watchdog);
+    const socket = this.socket;
+    if (!socket) return;
+    this.watchdog = setTimeout(() => {
+      this.watchdog = null;
+      this.logger.warn("no heartbeat from LangWatch, reconnecting");
+      try {
+        socket.terminate();
+      } catch {
+      }
+    }, Math.max(15e3, this.heartbeatIntervalMs * 3));
+  }
+  registerFrame() {
+    return {
+      type: "register",
+      protocol: PROTOCOL_VERSION,
+      sdk: SDK_IDENTITY,
+      instance: { ...this.instance, inFlightCallIds: [...this.inFlight.keys()] },
+      agents: this.agents.map((agent) => agent.register)
+    };
+  }
+  send(frame) {
+    const socket = this.socket;
+    if (!socket) return;
+    try {
+      socket.send(serializeFrame(frame));
+    } catch (error) {
+      this.logger.debug(`could not send ${frame.type}: ${describeError(error)}`);
+    }
+  }
+  onMessage(data) {
+    const frame = parseServerFrame(data);
+    if (!frame) {
+      this.logger.debug("dropped a frame the SDK does not know");
+      return;
+    }
+    this.armWatchdog();
+    switch (frame.type) {
+      case "registered":
+        this.onRegistered(frame);
+        return;
+      case "refused":
+        this.onRefused(frame);
+        return;
+      case "call":
+        void this.onCall(frame);
+        return;
+      case "cancel": {
+        const call = this.inFlight.get(frame.callId);
+        if (!call) return;
+        call.cancelled = true;
+        this.releaseCall({ callId: frame.callId, entry: call });
+        return;
+      }
+    }
+  }
+  onRefused(frame) {
+    this.giveUp(refusalAdvice(frame));
+    try {
+      this.socket?.close(1e3, frame.code);
+    } catch {
+    }
+  }
+  onRegistered(frame) {
+    this.registered = true;
+    this.attempt = 0;
+    if (this.failureNoticeAt !== null) {
+      this.logger.info("connected to LangWatch");
+      this.failureNoticeAt = null;
+    }
+    if (this.activeTransport === "http" && !this.transportAnnounced) {
+      this.transportAnnounced = true;
+      this.logger.info(`connected to LangWatch over HTTP long polling at ${this.httpUrl}`);
+    }
+    this.heartbeatIntervalMs = frame.heartbeatIntervalMs;
+    if (frame.instanceId && frame.instanceId !== this.instance.id) this.instance.id = frame.instanceId;
+    this.byId.clear();
+    for (const entry of frame.agents) {
+      const runtime = this.agents.find(
+        (agent) => agent.name === entry.name && agent.environment === entry.environment
+      );
+      if (!runtime) continue;
+      this.byId.set(entry.id, runtime);
+      this.logger.info(
+        `agent "${entry.name}" (${entry.environment}) is online${entry.url ? `: ${entry.url}` : ""}`
+      );
+      for (const note of entry.parameterNotes) this.logger.warn(`agent "${entry.name}": ${note}`);
+    }
+    this.armWatchdog();
+  }
+  async onCall(frame) {
+    const runtime = this.byId.get(frame.agentId);
+    if (!runtime) {
+      this.sendError({
+        callId: frame.callId,
+        code: "agent_call_failed",
+        message: `no agent registered as ${frame.agentId}`
+      });
+      return;
+    }
+    const busy = [...this.inFlight.values()].filter((call2) => call2.runtime === runtime).length;
+    if (busy >= runtime.concurrency) {
+      this.sendError({
+        callId: frame.callId,
+        code: "agent_busy",
+        message: `agent "${runtime.name}" has ${busy} call${busy === 1 ? "" : "s"} in flight, its limit`
+      });
+      return;
+    }
+    if (frame.deadlineAt !== null && frame.deadlineAt <= Date.now()) {
+      this.sendError({
+        callId: frame.callId,
+        code: "agent_call_timeout",
+        message: "the call deadline passed before it started"
+      });
+      return;
+    }
+    const entry = { runtime, cancelled: false, timer: null };
+    this.inFlight.set(frame.callId, entry);
+    let params;
+    try {
+      params = await runtime.readParams(frame.params);
+    } catch (error) {
+      this.releaseCall({ callId: frame.callId, entry });
+      this.sendError({
+        callId: frame.callId,
+        code: "agent_parameter_invalid",
+        message: describeError(error)
+      });
+      return;
+    }
+    if (entry.cancelled) {
+      this.releaseCall({ callId: frame.callId, entry });
+      return;
+    }
+    this.send({ type: "ack", protocol: PROTOCOL_VERSION, callId: frame.callId });
+    this.armCallDeadline({ frame, entry, runtime });
+    const parent = frame.traceparent ? import_api.propagation.extract(import_api.context.active(), { traceparent: frame.traceparent }) : import_api.context.active();
+    const traceId = import_api.trace.getSpanContext(parent)?.traceId ?? traceIdFromTraceparent(frame.traceparent) ?? "";
+    const call = {
+      messages: frame.messages,
+      newMessages: frame.newMessages,
+      threadId: frame.threadId,
+      session: frame.session,
+      params,
+      traceId
+    };
+    try {
+      const result = await import_api.context.with(parent, () => runtime.run(call));
+      if (entry.cancelled) return;
+      this.send({
+        type: "result",
+        protocol: PROTOCOL_VERSION,
+        callId: frame.callId,
+        output: result.output,
+        ...result.session === void 0 ? {} : { session: result.session }
+      });
+    } catch (error) {
+      if (entry.cancelled) return;
+      const code = error instanceof AgentParameterError ? error.code : "agent_call_failed";
+      const message = describeError(error);
+      this.logger.warn(`agent "${runtime.name}" call ${frame.callId} failed: ${message}`);
+      this.sendError({ callId: frame.callId, code, message });
+    } finally {
+      this.releaseCall({ callId: frame.callId, entry });
+    }
+  }
+  /** Frees the slot the call holds and drops its deadline timer. */
+  releaseCall({ callId, entry }) {
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+      entry.timer = null;
+    }
+    if (this.inFlight.get(callId) === entry) this.inFlight.delete(callId);
+  }
+  /**
+   * The call ends on its deadline: one timeout result, and the slot is free
+   * from that moment. A handler that never returns then costs one call, not
+   * every call after it.
+   */
+  armCallDeadline({
+    frame,
+    entry,
+    runtime
+  }) {
+    const fromDeadline = frame.deadlineAt === null ? Infinity : frame.deadlineAt - Date.now();
+    const limit = Math.min(fromDeadline, runtime.timeoutMs);
+    if (!Number.isFinite(limit)) return;
+    const timer = setTimeout(() => {
+      entry.timer = null;
+      if (entry.cancelled) return;
+      entry.cancelled = true;
+      this.releaseCall({ callId: frame.callId, entry });
+      this.logger.warn(
+        `agent "${runtime.name}" call ${frame.callId} passed its ${limit} ms limit`
+      );
+      this.sendError({
+        callId: frame.callId,
+        code: "agent_call_timeout",
+        message: `the call passed the ${limit} ms limit of agent "${runtime.name}"`
+      });
+    }, Math.max(0, limit));
+    timer.unref();
+    entry.timer = timer;
+  }
+  sendError({ callId, code, message }) {
+    this.send({ type: "result", protocol: PROTOCOL_VERSION, callId, error: { code, message } });
+  }
+  guard(action) {
+    try {
+      action();
+    } catch (error) {
+      this.logger.error(`agent client error: ${describeError(error)}`);
+    }
+  }
+};
+var shared = null;
+var sharedKey = null;
+var hooksInstalled = false;
+var noticesGiven = /* @__PURE__ */ new Set();
+var testOverrides = {};
+var signalHandlers = /* @__PURE__ */ new Map();
+var onShutdownSignal = (signal) => {
+  const client = shared;
+  const finish = () => {
+    const handler = signalHandlers.get(signal);
+    if (handler) process.removeListener(signal, handler);
+    if (process.listenerCount(signal) === 0) process.kill(process.pid, signal);
+  };
+  if (!client) {
+    finish();
+    return;
+  }
+  void client.disconnect().finally(finish);
+};
+var onBeforeExit = () => {
+  shared?.shutdownNow();
+};
+var installShutdownHooks = () => {
+  if (hooksInstalled) return;
+  hooksInstalled = true;
+  for (const signal of SHUTDOWN_SIGNALS) {
+    const handler = () => onShutdownSignal(signal);
+    signalHandlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  process.on("beforeExit", onBeforeExit);
+};
+function warnOnce({ logger, key, message }) {
+  if (noticesGiven.has(key)) {
+    logger.debug(message);
+    return;
+  }
+  noticesGiven.add(key);
+  logger.warn(message);
+}
+function getSharedClient(config) {
+  const key = `${config.endpoint ?? ""}|${config.projectId ?? ""}|${config.apiKey}`;
+  if (shared) {
+    if (sharedKey !== key) {
+      warnOnce({
+        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"
+      });
+    }
+    return shared;
+  }
+  shared = new AgentClient({ ...config, ...testOverrides });
+  sharedKey = key;
+  installShutdownHooks();
+  return shared;
+}
+
+// src/agent/define.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 3e5;
+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 };
+  if (Array.isArray(reply) && reply.every(isMessage)) return { output: reply };
+  if (isMessage(reply)) return { output: reply };
+  if (typeof reply === "object" && reply !== null && "output" in reply) {
+    const { output, session } = reply;
+    const normalized = normalizeReply(output);
+    return session === void 0 ? normalized : { output: normalized.output, session };
+  }
+  throw new Error(
+    "the agent handler must return a string, a message, a list of messages, or { output, session }"
+  );
+}
+var clampTimeout = ({ timeoutMs, logger, name }) => {
+  if (timeoutMs === void 0) return DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return DEFAULT_TIMEOUT_MS;
+  if (timeoutMs > MAX_TIMEOUT_MS) {
+    logger.warn(`agent "${name}": timeoutMs ${timeoutMs} is above the ${MAX_TIMEOUT_MS} cap, using the cap`);
+    return MAX_TIMEOUT_MS;
+  }
+  return Math.floor(timeoutMs);
+};
+var readApiKey = (explicit) => {
+  const candidate = explicit ?? process.env.LANGWATCH_API_KEY;
+  return typeof candidate === "string" && candidate.trim() !== "" ? candidate.trim() : void 0;
+};
+var readProjectId = (explicit) => {
+  const candidate = explicit ?? process.env.LANGWATCH_PROJECT_ID;
+  return typeof candidate === "string" && candidate.trim() !== "" ? candidate.trim() : void 0;
+};
+function connectAgent(options, handler) {
+  const logger = options.logger ?? new ConsoleLogger({ level: "info", prefix: "LangWatch" });
+  const name = options.name?.trim();
+  if (!name) throw new Error("connectAgent needs a name");
+  const environment = resolveEnvironment({ explicit: options.environment });
+  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 runHandler = async (call) => normalizeReply(await handler(call));
+  const readParams2 = createParameterReader({ input: options.parameters, specs });
+  const invoke = async (call) => {
+    const params = await readParams2(call.params);
+    return runHandler({
+      messages: call.messages,
+      newMessages: call.newMessages ?? call.messages,
+      threadId: call.threadId ?? `local_${Date.now().toString(36)}`,
+      session: call.session ?? null,
+      params,
+      traceId: call.traceId ?? ""
+    });
+  };
+  const runtime = {
+    name,
+    environment,
+    register: {
+      name,
+      environment,
+      parameters,
+      concurrency,
+      timeoutMs,
+      ...options.sticky ? { sticky: true } : {}
+    },
+    readParams: readParams2,
+    concurrency,
+    timeoutMs,
+    run: runHandler
+  };
+  let detach;
+  if (!resolveEnabled({ explicit: options.enabled })) {
+    logger.debug(`agent "${name}" not connected to LangWatch: the connection is disabled`);
+  } else {
+    const apiKey = readApiKey(options.apiKey);
+    if (!apiKey) {
+      warnOnce({
+        logger,
+        key: "no-api-key",
+        message: `agent "${name}" not connected to LangWatch: no API key. Set LANGWATCH_API_KEY to run simulations against it.`
+      });
+    } else {
+      const client = getSharedClient({
+        apiKey,
+        endpoint: options.endpoint,
+        projectId: readProjectId(options.projectId),
+        instanceLabel: resolveInstanceLabel({ explicit: options.instanceLabel }),
+        transport: options.transport,
+        logger
+      });
+      client.addAgent(runtime);
+      detach = () => client.removeAgent(runtime);
+    }
+  }
+  const connected = Object.assign(invoke, {
+    environment,
+    parameters,
+    disconnect: async () => {
+      if (!detach) return;
+      const release = detach;
+      detach = void 0;
+      await release();
+    }
+  });
+  Object.defineProperty(connected, "name", { value: name, configurable: true });
+  return connected;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_TRANSPORTS,
+  AgentParameterError,
+  DEFAULT_TIMEOUT_MS,
+  MAX_TIMEOUT_MS,
+  PROTOCOL_VERSION,
+  connectAgent,
+  normalizeReply,
+  parameterSpecsFromSchema,
+  resolveConnectUrl,
+  resolveEnvironment,
+  resolveHttpConnectUrl,
+  resolveTransport,
+  sanitizeEnvironment,
+  toParameterSchema
+});
+//# sourceMappingURL=index.js.map