@langwatch/mcp-server 2.1.0 → 3.0.0

package/dist/{chunk-UJPXFA26.js → chunk-HHMNZAPD.js}

@@ -79,7 +79,54 @@ function createRateLimiter({
     }
   };
 }
-var VERIFY_PATH = "/api/me/project";
+var VERIFY_PATH = "/api/v1/me/project";
+function sweepVerdicts(cache) {
+  const now = Date.now();
+  for (const [key, entry] of cache) {
+    if (now >= entry.expiresAt) cache.delete(key);
+  }
+}
+function rememberVerdict({
+  cache,
+  hashed,
+  valid,
+  maxEntries,
+  ttlMs
+}) {
+  if (cache.size >= maxEntries) {
+    sweepVerdicts(cache);
+    while (cache.size >= maxEntries) {
+      const oldest = cache.keys().next();
+      if (oldest.done) break;
+      cache.delete(oldest.value);
+    }
+  }
+  cache.set(hashed, { valid, expiresAt: Date.now() + ttlMs });
+}
+async function askVerifyEndpoint({
+  endpoint,
+  apiKey,
+  fetchImpl,
+  requestTimeoutMs
+}) {
+  let response;
+  try {
+    response = await fetchImpl(`${endpoint}${VERIFY_PATH}`, {
+      method: "GET",
+      headers: { "X-Auth-Token": apiKey },
+      // An upstream that accepts the connection and never answers would
+      // otherwise leave the in-flight promise unsettled, parking every
+      // request for this key behind it until the socket dies.
+      signal: AbortSignal.timeout(requestTimeoutMs)
+    });
+  } catch {
+    return null;
+  }
+  await response.body?.cancel().catch(() => void 0);
+  if (response.ok) return true;
+  if (response.status === 401 || response.status === 403) return false;
+  return null;
+}
 function createApiKeyVerifier({
   endpoint,
   positiveTtlMs = 6e4,
@@ -90,45 +137,15 @@ function createApiKeyVerifier({
 }) {
   const cache = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
-  function sweep() {
-    const now = Date.now();
-    for (const [key, entry] of cache) {
-      if (now >= entry.expiresAt) cache.delete(key);
-    }
-  }
-  function remember(hashed, valid) {
-    if (cache.size >= maxEntries) {
-      sweep();
-      while (cache.size >= maxEntries) {
-        const oldest = cache.keys().next();
-        if (oldest.done) break;
-        cache.delete(oldest.value);
-      }
-    }
-    cache.set(hashed, {
-      valid,
-      expiresAt: Date.now() + (valid ? positiveTtlMs : negativeTtlMs)
-    });
-  }
-  async function askApi(apiKey) {
-    let response;
-    try {
-      response = await fetchImpl(`${endpoint}${VERIFY_PATH}`, {
-        method: "GET",
-        headers: { "X-Auth-Token": apiKey },
-        // An upstream that accepts the connection and never answers would
-        // otherwise leave the in-flight promise unsettled, parking every
-        // request for this key behind it until the socket dies.
-        signal: AbortSignal.timeout(requestTimeoutMs)
-      });
-    } catch {
-      return null;
-    }
-    await response.body?.cancel().catch(() => void 0);
-    if (response.ok) return true;
-    if (response.status === 401 || response.status === 403) return false;
-    return null;
-  }
+  const sweep = () => sweepVerdicts(cache);
+  const remember = (hashed, valid) => rememberVerdict({
+    cache,
+    hashed,
+    valid,
+    maxEntries,
+    ttlMs: valid ? positiveTtlMs : negativeTtlMs
+  });
+  const askApi = (apiKey) => askVerifyEndpoint({ endpoint, apiKey, fetchImpl, requestTimeoutMs });
   return {
     async verify(apiKey) {
       const hashed = hashApiKey(apiKey);
@@ -152,45 +169,55 @@ function createApiKeyVerifier({
     }
   };
 }
+function releaseSlot({ countByKey }, apiKey) {
+  const hashed = hashApiKey(apiKey);
+  const next = (countByKey.get(hashed) ?? 1) - 1;
+  if (next <= 0) countByKey.delete(hashed);
+  else countByKey.set(hashed, next);
+}
+function dropSession({
+  table,
+  sessionId,
+  record
+}) {
+  table.sessions.delete(sessionId);
+  releaseSlot(table, record.apiKey);
+}
+function reserveSlot({
+  table,
+  apiKey
+}) {
+  const hashed = hashApiKey(apiKey);
+  table.countByKey.set(hashed, (table.countByKey.get(hashed) ?? 0) + 1);
+  let settled = false;
+  return {
+    commit({ sessionId, transport }) {
+      if (settled) return;
+      settled = true;
+      const existing = table.sessions.get(sessionId);
+      if (existing) dropSession({ table, sessionId, record: existing });
+      table.sessions.set(sessionId, {
+        transport,
+        apiKey,
+        lastActivityAt: Date.now()
+      });
+    },
+    release() {
+      if (settled) return;
+      settled = true;
+      releaseSlot(table, apiKey);
+    }
+  };
+}
 function createSessionStore({
   maxAgeMs,
   closeTransport
 }) {
   const sessions = /* @__PURE__ */ new Map();
   const countByKey = /* @__PURE__ */ new Map();
-  function decrement(apiKey) {
-    const hashed = hashApiKey(apiKey);
-    const next = (countByKey.get(hashed) ?? 1) - 1;
-    if (next <= 0) countByKey.delete(hashed);
-    else countByKey.set(hashed, next);
-  }
-  function drop(sessionId, record) {
-    sessions.delete(sessionId);
-    decrement(record.apiKey);
-  }
-  function reserve(apiKey) {
-    const hashed = hashApiKey(apiKey);
-    countByKey.set(hashed, (countByKey.get(hashed) ?? 0) + 1);
-    let settled = false;
-    return {
-      commit({ sessionId, transport }) {
-        if (settled) return;
-        settled = true;
-        const existing = sessions.get(sessionId);
-        if (existing) drop(sessionId, existing);
-        sessions.set(sessionId, {
-          transport,
-          apiKey,
-          lastActivityAt: Date.now()
-        });
-      },
-      release() {
-        if (settled) return;
-        settled = true;
-        decrement(apiKey);
-      }
-    };
-  }
+  const table = { sessions, countByKey };
+  const reserve = (apiKey) => reserveSlot({ table, apiKey });
+  const drop = (sessionId, record) => dropSession({ table, sessionId, record });
   return {
     get(sessionId) {
       return sessions.get(sessionId);
@@ -264,4 +291,4 @@ export {
   createSessionStore,
   admitOAuthToken
 };
-//# sourceMappingURL=chunk-UJPXFA26.js.map
+//# sourceMappingURL=chunk-HHMNZAPD.js.map

package/dist/chunk-HLQJXUR6.js

@@ -0,0 +1,67 @@
+import {
+  deletedTriggerSchema,
+  testFireResultSchema,
+  triggerFirePageSchema,
+  triggerSchema
+} from "./chunk-3YLN3ATJ.js";
+import {
+  makeRequest
+} from "./chunk-7CZQDZ2K.js";
+
+// src/langwatch-api-triggers.ts
+import { z } from "zod";
+async function listTriggers() {
+  return z.array(triggerSchema).parse(await makeRequest("GET", "/api/v1/triggers"));
+}
+async function getTrigger(id) {
+  return triggerSchema.parse(
+    await makeRequest("GET", `/api/v1/triggers/${encodeURIComponent(id)}`)
+  );
+}
+async function createTrigger(input) {
+  return triggerSchema.parse(
+    await makeRequest("POST", "/api/v1/triggers", {
+      ...input,
+      actionParams: input.actionParams ?? {}
+    })
+  );
+}
+async function updateTrigger({ id, ...data }) {
+  return triggerSchema.parse(
+    await makeRequest("PATCH", `/api/v1/triggers/${encodeURIComponent(id)}`, data)
+  );
+}
+async function testFireTrigger(id) {
+  return testFireResultSchema.parse(
+    await makeRequest("POST", `/api/v1/triggers/${encodeURIComponent(id)}/test-fire`)
+  );
+}
+async function listTriggerFires({
+  id,
+  limit,
+  cursor
+}) {
+  const query = new URLSearchParams();
+  if (limit !== void 0) query.set("limit", String(limit));
+  if (cursor) query.set("cursor", cursor);
+  const search = query.toString() ? `?${query.toString()}` : "";
+  return triggerFirePageSchema.parse(
+    await makeRequest("GET", `/api/v1/triggers/${encodeURIComponent(id)}/fires${search}`)
+  );
+}
+async function deleteTrigger(id) {
+  return deletedTriggerSchema.parse(
+    await makeRequest("DELETE", `/api/v1/triggers/${encodeURIComponent(id)}`)
+  );
+}
+
+export {
+  listTriggers,
+  getTrigger,
+  createTrigger,
+  updateTrigger,
+  testFireTrigger,
+  listTriggerFires,
+  deleteTrigger
+};
+//# sourceMappingURL=chunk-HLQJXUR6.js.map

package/dist/{chunk-JTQJRNFJ.js → chunk-KILVK3FS.js}

@@ -1,16 +1,16 @@
 import {
   makeRequest
-} from "./chunk-GELJ2MQR.js";
+} from "./chunk-7CZQDZ2K.js";
 
 // src/langwatch-api-model-providers.ts
 async function listModelProviders() {
-  return makeRequest("GET", "/api/model-providers");
+  return makeRequest("GET", "/api/v1/model-providers");
 }
 async function setModelProvider(params) {
   const { provider, ...data } = params;
   return makeRequest(
     "PUT",
-    `/api/model-providers/${encodeURIComponent(provider)}`,
+    `/api/v1/model-providers/${encodeURIComponent(provider)}`,
     data
   );
 }
@@ -19,4 +19,4 @@ export {
   listModelProviders,
   setModelProvider
 };
-//# sourceMappingURL=chunk-JTQJRNFJ.js.map
+//# sourceMappingURL=chunk-KILVK3FS.js.map

package/dist/chunk-MOCU5XWF.js

@@ -0,0 +1,79 @@
+import {
+  makeRequest
+} from "./chunk-7CZQDZ2K.js";
+
+// src/langwatch-api-dashboards.ts
+var dashboardPath = (dashboardId) => `/api/v1/dashboards/${encodeURIComponent(dashboardId)}`;
+var widgetPath = (dashboardId, widgetId) => `${dashboardPath(dashboardId)}/widgets/${encodeURIComponent(widgetId)}`;
+async function listDashboards() {
+  return makeRequest("GET", "/api/v1/dashboards");
+}
+async function getDashboard({ dashboardId }) {
+  return makeRequest("GET", dashboardPath(dashboardId));
+}
+async function createDashboard({ name }) {
+  return makeRequest("POST", "/api/v1/dashboards", { name });
+}
+async function updateDashboard({
+  dashboardId,
+  ...changes
+}) {
+  return makeRequest("PATCH", dashboardPath(dashboardId), changes);
+}
+async function deleteDashboard({
+  dashboardId
+}) {
+  return makeRequest("DELETE", dashboardPath(dashboardId));
+}
+async function listWidgetsOnDashboard({
+  dashboardId
+}) {
+  return makeRequest("GET", `${dashboardPath(dashboardId)}/widgets`);
+}
+async function createWidgetOnDashboard({
+  dashboardId,
+  ...data
+}) {
+  return makeRequest(
+    "POST",
+    `${dashboardPath(dashboardId)}/widgets`,
+    data
+  );
+}
+async function getWidgetOnDashboard({
+  dashboardId,
+  widgetId
+}) {
+  return makeRequest("GET", widgetPath(dashboardId, widgetId));
+}
+async function updateWidgetOnDashboard({
+  dashboardId,
+  widgetId,
+  ...changes
+}) {
+  return makeRequest(
+    "PATCH",
+    widgetPath(dashboardId, widgetId),
+    changes
+  );
+}
+async function deleteWidgetOnDashboard({
+  dashboardId,
+  widgetId
+}) {
+  await makeRequest("DELETE", widgetPath(dashboardId, widgetId));
+}
+
+export {
+  listDashboards,
+  getDashboard,
+  createDashboard,
+  updateDashboard,
+  deleteDashboard,
+  listWidgetsOnDashboard,
+  createWidgetOnDashboard,
+  getWidgetOnDashboard,
+  updateWidgetOnDashboard,
+  deleteWidgetOnDashboard
+};
+//# sourceMappingURL=chunk-MOCU5XWF.js.map

package/dist/chunk-O2WGVCED.js

@@ -0,0 +1,41 @@
+import {
+  makeRequest
+} from "./chunk-7CZQDZ2K.js";
+
+// src/langwatch-api-analytics-reports.ts
+var reportPath = (reportId) => `/api/v1/analytics/reports/${encodeURIComponent(reportId)}`;
+async function listAnalyticsReports() {
+  return makeRequest("GET", "/api/v1/analytics/reports");
+}
+async function getAnalyticsReport({
+  reportId
+}) {
+  return makeRequest("GET", reportPath(reportId));
+}
+async function createAnalyticsReport({
+  name
+}) {
+  return makeRequest("POST", "/api/v1/analytics/reports", {
+    name
+  });
+}
+async function renameAnalyticsReport({
+  reportId,
+  name
+}) {
+  return makeRequest("PATCH", reportPath(reportId), { name });
+}
+async function deleteAnalyticsReport({
+  reportId
+}) {
+  return makeRequest("DELETE", reportPath(reportId));
+}
+
+export {
+  listAnalyticsReports,
+  getAnalyticsReport,
+  createAnalyticsReport,
+  renameAnalyticsReport,
+  deleteAnalyticsReport
+};
+//# sourceMappingURL=chunk-O2WGVCED.js.map

package/dist/{chunk-HV4DWKBI.js → chunk-O7EMWEVJ.js}

@@ -9,9 +9,7 @@ var runPlanScopeSchema = z.discriminatedUnion("mode", [
   z.object({
     mode: z.literal("labels"),
     labels: z.array(z.string()).describe("The labels to select scenarios by")
-  }).describe(
-    "The non-archived scenarios carrying at least one of the given labels"
-  ),
+  }).describe("The non-archived scenarios carrying at least one of the given labels"),
   z.object({ mode: z.literal("scenarios") }).describe("The scenarios named in scenarioIds, picked by hand")
 ]);
 var runParametersSchema = z.record(
@@ -43,4 +41,4 @@ export {
   runPlanTargetSchema,
   toWireTargets
 };
-//# sourceMappingURL=chunk-HV4DWKBI.js.map
+//# sourceMappingURL=chunk-O7EMWEVJ.js.map

package/dist/{chunk-UFOYFYI7.js → chunk-QXLMHLRC.js}

@@ -1,29 +1,26 @@
 import {
   makeRequest
-} from "./chunk-GELJ2MQR.js";
+} from "./chunk-7CZQDZ2K.js";
 
 // src/langwatch-api-workflows.ts
 async function listWorkflows() {
-  return makeRequest("GET", "/api/workflows");
+  return makeRequest("GET", "/api/v1/workflows");
 }
 async function getWorkflow(id) {
   return makeRequest(
     "GET",
-    `/api/workflows/${encodeURIComponent(id)}`
+    `/api/v1/workflows/${encodeURIComponent(id)}`
   );
 }
 async function runWorkflow(id, input) {
   return makeRequest(
     "POST",
-    `/api/workflows/${encodeURIComponent(id)}/run`,
+    `/api/v1/workflows/${encodeURIComponent(id)}/run`,
     input ?? {}
   );
 }
 async function deleteWorkflow(id) {
-  return makeRequest(
-    "DELETE",
-    `/api/workflows/${encodeURIComponent(id)}`
-  );
+  return makeRequest("DELETE", `/api/v1/workflows/${encodeURIComponent(id)}`);
 }
 
 export {
@@ -32,4 +29,4 @@ export {
   runWorkflow,
   deleteWorkflow
 };
-//# sourceMappingURL=chunk-UFOYFYI7.js.map
+//# sourceMappingURL=chunk-QXLMHLRC.js.map