@langwatch/mcp-server 2.0.0 → 2.2.0

package/dist/chunk-3YLN3ATJ.js

@@ -0,0 +1,241 @@
+// src/schemas/triggers.ts
+import { z } from "zod";
+var triggerActionSchema = z.enum([
+  "SEND_EMAIL",
+  "SEND_SLACK_MESSAGE",
+  "SEND_WEBHOOK",
+  "ADD_TO_DATASET",
+  "ADD_TO_ANNOTATION_QUEUE"
+]);
+var alertTypeSchema = z.enum(["CRITICAL", "WARNING", "INFO"]);
+var emailActionParamsSchema = z.object({
+  members: z.array(z.string()).min(1).describe("Who receives the email. Any address, not only teammates.")
+}).passthrough();
+var slackActionParamsSchema = z.object({
+  slackIntegrationId: z.string().optional().describe(
+    "The Slack connection to post through (an organization connection or one of this project's; they are listed in LangWatch under Settings, Integrations, Slack). A bot connection also needs `slackChannelId`; a webhook connection needs nothing else. Preferred over `slackWebhook` and `slackBotToken`."
+  ),
+  slackDelivery: z.enum(["webhook", "bot"]).optional().describe(
+    "How the message reaches Slack. `webhook` posts to an incoming webhook URL, `bot` posts as the LangWatch Slack app. With `slackIntegrationId` it follows the connection's kind. Absent without a connection means `webhook`."
+  ),
+  slackWebhook: z.string().optional().describe(
+    "Legacy, accepted for one release: an incoming webhook URL (https://hooks.slack.com/...). It is stored as a Slack connection and the automation keeps only the connection id. Send `slackIntegrationId` instead."
+  ),
+  slackChannelId: z.string().optional().describe("The channel the bot posts in, for a bot connection or `bot` delivery."),
+  slackBotToken: z.string().optional().describe(
+    "Legacy, accepted for one release: a bot token, stored as a Slack connection. It never reads back. Send `slackIntegrationId` instead."
+  ),
+  slackBotTokenSet: z.boolean().optional().describe(
+    "Legacy. Read: whether an automation not yet moved to a connection stores its own bot token. Write: true keeps it."
+  )
+}).passthrough();
+var webhookActionParamsSchema = z.object({
+  url: z.string().describe("Where the request goes. https only, and not a private host."),
+  method: z.enum(["POST", "PUT", "PATCH"]).optional(),
+  headers: z.record(z.string(), z.string()).optional().describe(
+    "Static headers sent with every delivery. The values are credentials: they read back as [redacted], and sending [redacted] back keeps the stored ones. Changing `url` means sending the values again in the same call."
+  ),
+  bodyTemplate: z.string().nullable().optional().describe(
+    "A Liquid template for the JSON body. Absent sends the standard LangWatch envelope."
+  ),
+  signingSecret: z.string().nullable().optional().describe("Signs every delivery so the receiver can verify it.")
+}).passthrough();
+var datasetActionParamsSchema = z.object({
+  datasetId: z.string().describe("The dataset matched traces are appended to."),
+  datasetMapping: z.object({
+    mapping: z.record(z.string(), z.unknown()),
+    expansions: z.array(z.string()).optional()
+  }).describe("How a trace becomes a row in that dataset.")
+}).passthrough();
+var annotationQueueActionParamsSchema = z.object({
+  annotators: z.array(z.object({ id: z.string(), name: z.string() })).min(1).describe("Who the queued items go to.")
+}).passthrough();
+var actionParamsSchema = z.union([
+  emailActionParamsSchema,
+  slackActionParamsSchema,
+  webhookActionParamsSchema,
+  datasetActionParamsSchema,
+  annotationQueueActionParamsSchema
+]);
+var slackActionParamsWriteSchema = slackActionParamsSchema.superRefine((params, ctx) => {
+  const delivery = params.slackDelivery ?? "webhook";
+  if (delivery === "bot" && !params.slackChannelId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slackChannelId"],
+      message: params.slackIntegrationId ? "a bot connection needs the channel to post in" : "bot delivery needs the channel to post in"
+    });
+  }
+  if (params.slackIntegrationId) return;
+  if (delivery === "webhook" && !params.slackWebhook) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slackIntegrationId"],
+      message: "name the Slack connection to post through"
+    });
+  }
+  if (delivery === "bot" && !params.slackBotToken && params.slackBotTokenSet !== true) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slackIntegrationId"],
+      message: "bot delivery needs the Slack connection to post through"
+    });
+  }
+});
+var ACTION_PARAMS_SCHEMA_BY_ACTION = {
+  SEND_EMAIL: emailActionParamsSchema,
+  SEND_SLACK_MESSAGE: slackActionParamsWriteSchema,
+  SEND_WEBHOOK: webhookActionParamsSchema,
+  ADD_TO_DATASET: datasetActionParamsSchema,
+  ADD_TO_ANNOTATION_QUEUE: annotationQueueActionParamsSchema
+};
+function validateActionParamsForAction({
+  action,
+  actionParams
+}) {
+  const schema = ACTION_PARAMS_SCHEMA_BY_ACTION[action] ?? actionParamsSchema;
+  const parsed = schema.safeParse(actionParams);
+  if (parsed.success) return { ok: true };
+  const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(actionParams)"}: ${issue.message}`).join("; ");
+  return {
+    ok: false,
+    message: `actionParams does not fit ${action} \u2014 ${issues}`
+  };
+}
+var TRIGGER_FILTERS_DESCRIPTION = [
+  "Trace conditions as a JSON object string.",
+  'Unkeyed fields take a list of values: {"traces.error":["true"]}.',
+  'Keyed fields nest a key above the list. evaluations.* is keyed by the MONITOR id (the `id` from `platform_list_monitors` / GET /api/v1/monitors, not its evaluatorId): {"evaluations.passed":{"<monitorId>":["false"]}}.',
+  'metadata.value is keyed by the metadata key: {"metadata.value":{"<key>":["true"]}}.',
+  "A keyed field sent as a bare list, or keyed by anything but a monitor id, is refused."
+].join(" ");
+var TRIGGER_FILTER_QUERY_DESCRIPTION = [
+  "Trace query in the syntax the traces view uses; the alternative to `filters`, and it supersedes them.",
+  'Examples: status:error \xB7 evaluator:"<evaluator name>" AND evaluatorVerdict:fail \xB7 trace.attribute.<key>:<value>.'
+].join(" ");
+var SLACK_DELIVERY_NOTE = 'For SEND_SLACK_MESSAGE, send {"slackIntegrationId":"<connection id>"} for a webhook connection, or {"slackIntegrationId":"<connection id>","slackChannelId":"C..."} for a bot connection. Slack connections are listed and added in LangWatch under Settings, Integrations, Slack (organization-wide or for one project); they are also listed by GET /api/v1/slack-connections and `langwatch slack-connection list`, or ask the user for the id. slackIntegrationId is preferred: a legacy {"slackWebhook":"https://hooks.slack.com/..."} or {"slackDelivery":"bot","slackBotToken":"xoxb-...","slackChannelId":"C..."} is still accepted for one release and is stored as a connection. A Slack automation with no connection will never post.';
+var graphAlertSchema = z.object({
+  seriesName: z.string().describe("The series on the graph to watch."),
+  operator: z.enum(["gt", "lt", "gte", "lte", "eq"]),
+  threshold: z.number(),
+  timePeriod: z.union([
+    z.literal(1),
+    z.literal(5),
+    z.literal(15),
+    z.literal(30),
+    z.literal(60),
+    z.literal(1440)
+  ]).describe("The window, in minutes, the series is read over.")
+}).describe("The rule an alert fires by. Send it with `customGraphId` and `alertType`.");
+var reportSchema = z.object({
+  source: z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("dashboard"),
+      dashboardId: z.string()
+    }),
+    z.object({
+      kind: z.literal("customGraph"),
+      customGraphId: z.string()
+    }),
+    z.object({
+      kind: z.literal("traceQuery"),
+      filters: z.record(z.string(), z.unknown()).optional(),
+      metric: z.string().optional(),
+      topN: z.number().int().min(1).max(100).optional()
+    })
+  ]).describe("What the report renders: a dashboard, one graph, or a table of traces."),
+  schedule: z.object({
+    cron: z.string().describe(
+      'A 5-field cron expression (minute hour day-of-month month day-of-week), for example "0 9 * * 1". It can send at most every 15 minutes.'
+    ),
+    timezone: z.string().describe('An IANA timezone, for example "Europe/Amsterdam" or "UTC".')
+  }).describe("When it sends."),
+  compareToPrevious: z.boolean().optional().describe("Include a this-period-versus-last comparison.")
+}).describe(
+  "What a scheduled report renders and when. Send it with a channel that can carry a message: email or Slack."
+);
+var templatesSchema = z.object({
+  slackTemplateType: z.enum(["string", "block_kit"]).nullable().optional(),
+  slackTemplate: z.string().nullable().optional(),
+  emailSubjectTemplate: z.string().nullable().optional(),
+  emailBodyTemplate: z.string().nullable().optional()
+}).describe(
+  "The Liquid templates the message is rendered from. Absent fields render the LangWatch default."
+);
+var notificationCadenceSchema = z.enum(["immediate", "5min_digest", "15min_digest", "hourly_digest"]).describe(
+  "How often a notification automation may send. A new one starts on a five-minute digest."
+);
+var triggerSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  action: z.string(),
+  /** Where it delivers. The rule it fires by is stated separately, below,
+   *  the same way a write states it. */
+  actionParams: z.record(z.string(), z.unknown()).default({}),
+  graphAlert: graphAlertSchema.nullable().optional(),
+  // A read stays tolerant of a deployment that words this differently; a
+  // write is held to `reportSchema`.
+  report: z.record(z.string(), z.unknown()).nullable().optional(),
+  filters: z.record(z.string(), z.unknown()).default({}),
+  filterQuery: z.string().nullable().optional(),
+  kind: z.string().optional(),
+  customGraphId: z.string().nullable().optional(),
+  notificationCadence: z.string().nullable().optional(),
+  traceDebounceMs: z.number().nullable().optional(),
+  templates: z.record(z.string(), z.unknown()).optional(),
+  active: z.boolean(),
+  message: z.string().nullable(),
+  alertType: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  platformUrl: z.string().optional()
+}).passthrough();
+var triggerFireSchema = z.object({
+  id: z.string(),
+  triggerId: z.string(),
+  customGraphId: z.string().nullable(),
+  firedAt: z.string(),
+  resolvedAt: z.string().nullable()
+}).passthrough();
+var triggerFirePageSchema = z.union([
+  z.array(triggerFireSchema).transform((fires) => ({ fires, nextCursor: null })),
+  z.object({
+    fires: z.array(triggerFireSchema).optional(),
+    data: z.array(triggerFireSchema).optional(),
+    nextCursor: z.string().nullable().optional()
+  }).transform(({ fires, data, nextCursor }) => ({
+    fires: fires ?? data ?? [],
+    nextCursor: nextCursor ?? null
+  }))
+]);
+var testFireResultSchema = z.object({
+  channel: z.string(),
+  recipientCount: z.number(),
+  usedDefault: z.boolean(),
+  missingVariables: z.array(z.string()).default([]),
+  errors: z.array(z.string()).default([]),
+  httpStatus: z.number().optional()
+}).passthrough();
+var deletedTriggerSchema = z.object({
+  id: z.string(),
+  deleted: z.boolean()
+});
+
+export {
+  triggerActionSchema,
+  alertTypeSchema,
+  actionParamsSchema,
+  validateActionParamsForAction,
+  TRIGGER_FILTERS_DESCRIPTION,
+  TRIGGER_FILTER_QUERY_DESCRIPTION,
+  SLACK_DELIVERY_NOTE,
+  graphAlertSchema,
+  reportSchema,
+  templatesSchema,
+  notificationCadenceSchema,
+  triggerSchema,
+  triggerFirePageSchema,
+  testFireResultSchema,
+  deletedTriggerSchema
+};
+//# sourceMappingURL=chunk-3YLN3ATJ.js.map

package/dist/chunk-5FNCQRCX.js

@@ -0,0 +1,91 @@
+import {
+  getBoard
+} from "./chunk-K2I7Z3LZ.js";
+import {
+  LangWatchApiError,
+  makeRequest
+} from "./chunk-UWLE5T2F.js";
+
+// src/langwatch-api-dashboard-widgets.ts
+async function createDashboardWidget(params) {
+  const { projectId, ...data } = params;
+  return makeRequest(
+    "POST",
+    `/api/v1/projects/${encodeURIComponent(projectId)}/analytics/dashboard-widgets`,
+    data
+  );
+}
+async function getDashboardWidget(params) {
+  return makeRequest(
+    "GET",
+    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}`
+  );
+}
+async function updateDashboardWidget(params) {
+  const { projectId, widgetId, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/projects/${encodeURIComponent(projectId)}/analytics/dashboard-widgets/${encodeURIComponent(widgetId)}`,
+    data
+  );
+}
+async function assignDashboardWidgetToDashboard(params) {
+  return makeRequest(
+    "POST",
+    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}/dashboard`,
+    { dashboardId: params.dashboardId }
+  );
+}
+async function deleteDashboardWidget(params) {
+  await makeRequest(
+    "DELETE",
+    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}`
+  );
+}
+
+// src/tools/dashboard-exists.ts
+async function assertDashboardExists({
+  projectId,
+  dashboardId
+}) {
+  try {
+    await getBoard({ projectId, boardId: dashboardId });
+  } catch (error) {
+    if (error instanceof LangWatchApiError && error.status === 404) {
+      throw new Error(
+        `No dashboard with ID "${dashboardId}" was found in this project. Use list_dashboard_boards to find a valid dashboard ID.`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/tools/dashboard-widget-queries.ts
+var MAX_DASHBOARD_WIDGET_QUERIES = 8;
+function normalizeDashboardWidgetQueries({
+  queries
+}) {
+  const normalized = Array.isArray(queries) ? queries : Object.entries(queries).map(([name, sql]) => ({ name, sql }));
+  if (normalized.length === 0) {
+    throw new Error(
+      "Provide at least one named LWQL query in `queries`. Validate each query's SQL first with run_query."
+    );
+  }
+  if (normalized.length > MAX_DASHBOARD_WIDGET_QUERIES) {
+    throw new Error(
+      `A widget may declare at most ${MAX_DASHBOARD_WIDGET_QUERIES} queries, got ${normalized.length}.`
+    );
+  }
+  return normalized;
+}
+
+export {
+  createDashboardWidget,
+  getDashboardWidget,
+  updateDashboardWidget,
+  assignDashboardWidgetToDashboard,
+  deleteDashboardWidget,
+  assertDashboardExists,
+  normalizeDashboardWidgetQueries
+};
+//# sourceMappingURL=chunk-5FNCQRCX.js.map

package/dist/chunk-6YZUOD34.js

@@ -0,0 +1,55 @@
+// src/tools/format-suite-details.ts
+function describeMapping(mapping) {
+  return mapping.type === "value" ? JSON.stringify(mapping.value) : `${mapping.sourceId}.${mapping.path.join(".")}`;
+}
+function formatSuiteFields(fields) {
+  if (!fields || fields.length === 0) return [];
+  return ["\n## Fields", ...fields.map((field) => `- ${field.identifier} (${field.type})`)];
+}
+function formatEvaluatorAttachments(evaluators) {
+  if (!evaluators || evaluators.length === 0) return [];
+  const lines = ["\n## Evaluators"];
+  for (const attachment of evaluators) {
+    const gate = attachment.required ? "required" : "reports only";
+    lines.push(`- ${attachment.evaluatorId} (${gate}, attachment ${attachment.id})`);
+    for (const [input, mapping] of Object.entries(attachment.mappings)) {
+      lines.push(`  - ${input}: ${describeMapping(mapping)}`);
+    }
+  }
+  return lines;
+}
+var PENDING_EVALUATION_STATUS = "PENDING_EVALUATION";
+function formatRunStatus(status) {
+  if (status === PENDING_EVALUATION_STATUS) return "evaluating";
+  if (status === "SUCCESS") return "pass";
+  if (status === "FAILED") return "FAIL";
+  return status;
+}
+function pendingEvaluationNote(status) {
+  if (status !== PENDING_EVALUATION_STATUS) return [];
+  return [
+    "> The evaluators attached to this run have not been recorded yet. A required one may still fail it, so read the verdict again once the status changes."
+  ];
+}
+function formatEvaluations(evaluations) {
+  if (!evaluations || evaluations.length === 0) return [];
+  const lines = ["\n## Evaluators"];
+  for (const evaluation of evaluations) {
+    const parts = [evaluation.status];
+    if (evaluation.score !== void 0) parts.push(`score ${evaluation.score}`);
+    if (evaluation.label !== void 0) parts.push(evaluation.label);
+    if (evaluation.required) parts.push("required");
+    lines.push(`- **${evaluation.name}**: ${parts.join(", ")}`);
+    if (evaluation.details) lines.push(`  ${evaluation.details}`);
+  }
+  return lines;
+}
+
+export {
+  formatSuiteFields,
+  formatEvaluatorAttachments,
+  formatRunStatus,
+  pendingEvaluationNote,
+  formatEvaluations
+};
+//# sourceMappingURL=chunk-6YZUOD34.js.map

package/dist/{chunk-WVI5CJ6S.js → chunk-7AQLPVFL.js}

@@ -1,6 +1,6 @@
 import {
   escapeMarkdown
-} from "./chunk-NUFPTHKU.js";
+} from "./chunk-FOKVY3BK.js";
 
 // src/tools/format-dataset-mutation.ts
 function formatDatasetMutationDetails(result) {
@@ -18,4 +18,4 @@ function formatDatasetMutationDetails(result) {
 export {
   formatDatasetMutationDetails
 };
-//# sourceMappingURL=chunk-WVI5CJ6S.js.map
+//# sourceMappingURL=chunk-7AQLPVFL.js.map

package/dist/chunk-7VNSRCXO.js

@@ -0,0 +1,129 @@
+import {
+  LangWatchApiError,
+  makeRequest
+} from "./chunk-UWLE5T2F.js";
+
+// src/langwatch-api-datasets.ts
+var DATASET_PREVIEW_MAX_RECORDS = 100;
+var DATASET_PREVIEW_MAX_BYTES = 1024 * 1024;
+async function listDatasets(params) {
+  const query = new URLSearchParams();
+  if (params?.page != null) query.set("page", String(params.page));
+  if (params?.limit != null) query.set("limit", String(params.limit));
+  const qs = query.toString();
+  const path = qs ? `/api/v1/dataset?${qs}` : "/api/v1/dataset";
+  return makeRequest("GET", path);
+}
+async function getDataset(slugOrId) {
+  const page = await readPreviewPage(slugOrId);
+  if (!page?.dataset) {
+    return makeRequest(
+      "GET",
+      `/api/v1/dataset/${encodeURIComponent(slugOrId)}`
+    );
+  }
+  const data = [];
+  let bytes = 0;
+  for (const record of page.data) {
+    bytes += JSON.stringify(record).length;
+    if (bytes > DATASET_PREVIEW_MAX_BYTES) break;
+    data.push(record);
+  }
+  const { id, name, slug, columnTypes, createdAt, updatedAt } = page.dataset;
+  const totalRecords = page.pagination.total;
+  return {
+    id,
+    name,
+    slug,
+    columnTypes,
+    createdAt,
+    updatedAt,
+    data,
+    totalRecords,
+    omittedRecords: Math.max(0, totalRecords - data.length)
+  };
+}
+async function readPreviewPage(slugOrId) {
+  let limit = DATASET_PREVIEW_MAX_RECORDS;
+  for (; ; ) {
+    try {
+      return await listDatasetRecords({ slugOrId, page: 1, limit });
+    } catch (error) {
+      if (!(error instanceof LangWatchApiError)) throw error;
+      if (error.status === 404) return null;
+      if (error.status !== 413 || limit <= 1) throw error;
+      limit = smallerLimit(limit, error.responseBody);
+    }
+  }
+}
+function smallerLimit(limit, responseBody) {
+  const half = Math.max(1, Math.floor(limit / 2));
+  try {
+    const suggested = JSON.parse(responseBody).meta?.suggestedLimit;
+    const usable = typeof suggested === "number" && Number.isInteger(suggested) && suggested >= 1 && suggested < limit;
+    return usable ? suggested : half;
+  } catch {
+    return half;
+  }
+}
+async function createDataset(data) {
+  return makeRequest("POST", "/api/v1/dataset", data);
+}
+async function updateDataset(params) {
+  const { slugOrId, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/dataset/${encodeURIComponent(slugOrId)}`,
+    data
+  );
+}
+async function deleteDataset(slugOrId) {
+  return makeRequest(
+    "DELETE",
+    `/api/v1/dataset/${encodeURIComponent(slugOrId)}`
+  );
+}
+async function createDatasetRecords(params) {
+  const { slugOrId, entries } = params;
+  return makeRequest("POST", `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records`, {
+    entries
+  });
+}
+async function updateDatasetRecord(params) {
+  const { slugOrId, recordId, entry } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records/${encodeURIComponent(recordId)}`,
+    { entry }
+  );
+}
+async function deleteDatasetRecords(params) {
+  const { slugOrId, recordIds } = params;
+  return makeRequest("DELETE", `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records`, {
+    recordIds
+  });
+}
+async function listDatasetRecords(params) {
+  const { slugOrId } = params;
+  const query = new URLSearchParams();
+  if (params.page != null) query.set("page", String(params.page));
+  if (params.limit != null) query.set("limit", String(params.limit));
+  const qs = query.toString();
+  const path = `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records${qs ? `?${qs}` : ""}`;
+  return makeRequest("GET", path);
+}
+
+export {
+  DATASET_PREVIEW_MAX_RECORDS,
+  DATASET_PREVIEW_MAX_BYTES,
+  listDatasets,
+  getDataset,
+  createDataset,
+  updateDataset,
+  deleteDataset,
+  createDatasetRecords,
+  updateDatasetRecord,
+  deleteDatasetRecords,
+  listDatasetRecords
+};
+//# sourceMappingURL=chunk-7VNSRCXO.js.map

package/dist/{chunk-7RHG56OH.js → chunk-B4J3PJLX.js}

@@ -1,6 +1,6 @@
 import {
   makeRequest
-} from "./chunk-A2LEVYQ5.js";
+} from "./chunk-UWLE5T2F.js";
 
 // src/langwatch-api-projects.ts
 async function listProjects(params) {
@@ -8,37 +8,38 @@ async function listProjects(params) {
   if (params?.page) query.set("page", String(params.page));
   if (params?.limit) query.set("limit", String(params.limit));
   const qs = query.toString() ? `?${query}` : "";
-  return makeRequest("GET", `/api/projects${qs}`);
+  return makeRequest("GET", `/api/v1/projects${qs}`);
 }
 async function getProject(id) {
   return makeRequest(
     "GET",
-    `/api/projects/${encodeURIComponent(id)}`
+    `/api/v1/projects/${encodeURIComponent(id)}`
   );
 }
+async function getCurrentProject() {
+  return makeRequest("GET", "/api/v1/me/project");
+}
 async function createProject(data) {
-  return makeRequest("POST", "/api/projects", data);
+  return makeRequest("POST", "/api/v1/projects", data);
 }
 async function updateProject(params) {
   const { id, ...data } = params;
   return makeRequest(
     "PATCH",
-    `/api/projects/${encodeURIComponent(id)}`,
+    `/api/v1/projects/${encodeURIComponent(id)}`,
     data
   );
 }
 async function archiveProject(id) {
-  return makeRequest(
-    "DELETE",
-    `/api/projects/${encodeURIComponent(id)}`
-  );
+  return makeRequest("DELETE", `/api/v1/projects/${encodeURIComponent(id)}`);
 }
 
 export {
   listProjects,
   getProject,
+  getCurrentProject,
   createProject,
   updateProject,
   archiveProject
 };
-//# sourceMappingURL=chunk-7RHG56OH.js.map
+//# sourceMappingURL=chunk-B4J3PJLX.js.map

package/dist/{chunk-ZXKLPC2E.js → chunk-BIIKE3EI.js}

@@ -24,4 +24,4 @@ function parseRelativeDate(input) {
 export {
   parseRelativeDate
 };
-//# sourceMappingURL=chunk-ZXKLPC2E.js.map
+//# sourceMappingURL=chunk-BIIKE3EI.js.map

package/dist/{chunk-37SMPMQS.js → chunk-DMM3JQ42.js}

@@ -1,7 +1,12 @@
 // src/utils/format-evaluations.ts
 function formatEvaluationLines(evaluations) {
   return evaluations.map((evaluation) => {
-    const status = evaluation.passed === true ? "PASSED" : evaluation.passed === false ? "FAILED" : "N/A";
+    let status = "N/A";
+    if (evaluation.passed === true) {
+      status = "PASSED";
+    } else if (evaluation.passed === false) {
+      status = "FAILED";
+    }
     return `- **${evaluation.name || evaluation.evaluator_id}**: ${status}${evaluation.score != null ? ` (score: ${evaluation.score})` : ""}${evaluation.label ? ` [${evaluation.label}]` : ""}`;
   });
 }
@@ -9,4 +14,4 @@ function formatEvaluationLines(evaluations) {
 export {
   formatEvaluationLines
 };
-//# sourceMappingURL=chunk-37SMPMQS.js.map
+//# sourceMappingURL=chunk-DMM3JQ42.js.map

package/dist/{chunk-NUFPTHKU.js → chunk-FOKVY3BK.js}

@@ -6,4 +6,4 @@ function escapeMarkdown(value) {
 export {
   escapeMarkdown
 };
-//# sourceMappingURL=chunk-NUFPTHKU.js.map
+//# sourceMappingURL=chunk-FOKVY3BK.js.map

package/dist/{chunk-WT4PO4A3.js → chunk-H6WGMG2T.js}

@@ -33,21 +33,23 @@ function initConfig(args) {
   state.globalConfig = {
     apiKey: args.apiKey || process.env.LANGWATCH_API_KEY,
     endpoint: normalizeEndpoint(args.endpoint ?? "") || normalizeEndpoint(process.env.LANGWATCH_ENDPOINT ?? "") || "https://app.langwatch.ai",
-    projectId: process.env.LANGWATCH_PROJECT_ID
+    projectId: args.projectId ?? process.env.LANGWATCH_PROJECT_ID
   };
 }
-function getConfig() {
+function tryGetConfig() {
   const state = getGlobalState();
-  const scoped = state.configStorage.getStore();
-  if (scoped) return scoped;
-  if (!state.globalConfig) {
+  return state.configStorage.getStore() ?? state.globalConfig;
+}
+function getConfig() {
+  const config = tryGetConfig();
+  if (!config) {
     console.error(
       "[MCP config] getConfig() failed: globalConfig is null, no scoped config active. Was initConfig() called? Stack:",
       new Error().stack
     );
     throw new Error("Config not initialized");
   }
-  return state.globalConfig;
+  return config;
 }
 function requireApiKey() {
   const config = getConfig();
@@ -71,8 +73,9 @@ function runWithConfig(config, fn) {
 
 export {
   initConfig,
+  tryGetConfig,
   getConfig,
   requireApiKey,
   runWithConfig
 };
-//# sourceMappingURL=chunk-WT4PO4A3.js.map
+//# sourceMappingURL=chunk-H6WGMG2T.js.map