@tangle-network/agent-app 0.60.215 → 0.60.217

package/dist/turn-health/index.js

@@ -3,297 +3,18 @@ import {
   sizedBatches
 } from "../chunk-5UQJ7F3P.js";
 import {
-  postSlackAlert
-} from "../chunk-F2VX6TTJ.js";
-
-// src/turn-health/classify.ts
-var ARTIFACT_PART_KINDS = /* @__PURE__ */ new Set(["file", "image", "work-product", "plan", "interaction"]);
-var KNOWN_NON_OUTPUT_PART_KINDS = /* @__PURE__ */ new Set([
-  "reasoning",
-  "step-start",
-  "step-finish",
-  "source",
-  "source-url",
-  "data"
-]);
-var SAMPLE_CHARS = 120;
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : null;
-}
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-function isUnparseableJson(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return false;
-  try {
-    JSON.parse(trimmed);
-    return false;
-  } catch {
-    return true;
-  }
-}
-var SETTLED_TOOL_STATUSES = /* @__PURE__ */ new Set(["completed", "complete", "success", "done"]);
-var FAILED_TOOL_STATUSES = /* @__PURE__ */ new Set(["error", "failed"]);
-function classifyTurnOutcome(input) {
-  const reasons = [];
-  if (input.failed) {
-    reasons.push({
-      kind: "turn_failed",
-      reason: nonEmptyString(input.failureReason) ?? "unspecified"
-    });
-  }
-  const parts = Array.isArray(input.parts) ? input.parts : [];
-  let hasVisibleText = nonEmptyString(input.finalText) !== null;
-  let artifactCount = 0;
-  let toolCalls = 0;
-  const opaqueTypes = [];
-  let interpretedParts = 0;
-  for (const raw of parts) {
-    const part = asRecord(raw);
-    if (!part) continue;
-    const type = typeof part.type === "string" ? part.type : "";
-    if (type === "text") {
-      interpretedParts += 1;
-      if (nonEmptyString(part.text) !== null) hasVisibleText = true;
-      continue;
-    }
-    if (ARTIFACT_PART_KINDS.has(type)) {
-      interpretedParts += 1;
-      artifactCount += 1;
-      continue;
-    }
-    if (KNOWN_NON_OUTPUT_PART_KINDS.has(type)) {
-      interpretedParts += 1;
-      continue;
-    }
-    if (type !== "tool") {
-      opaqueTypes.push(type || "(missing type)");
-      continue;
-    }
-    interpretedParts += 1;
-    toolCalls += 1;
-    const tool = nonEmptyString(part.tool) ?? "unknown";
-    const state = asRecord(part.state);
-    const status = typeof state?.status === "string" ? state.status : "unknown";
-    const toolInput = state?.input;
-    const inputRecord = asRecord(toolInput);
-    const rejection = nonEmptyString(inputRecord?.error) ?? nonEmptyString(state?.error);
-    if (rejection && SETTLED_TOOL_STATUSES.has(status)) {
-      reasons.push({
-        kind: "tool_call_rejected",
-        // The payload names the tool the model MEANT to call; the part's own
-        // `tool` is the harness's placeholder for a rejected call.
-        tool: nonEmptyString(inputRecord?.tool) ?? tool,
-        error: rejection.slice(0, 200)
-      });
-      continue;
-    }
-    if (typeof toolInput === "string" && isUnparseableJson(toolInput)) {
-      reasons.push({
-        kind: "malformed_tool_call",
-        tool,
-        inputLength: toolInput.length,
-        sample: toolInput.slice(0, SAMPLE_CHARS)
-      });
-      continue;
-    }
-    if (!SETTLED_TOOL_STATUSES.has(status) && !FAILED_TOOL_STATUSES.has(status)) {
-      reasons.push({ kind: "tool_call_no_effect", tool, status });
-    }
-  }
-  const partsReadable = opaqueTypes.length === 0;
-  const uniqueOpaque = [...new Set(opaqueTypes)];
-  const unreadable = opaqueTypes.length > 0 && interpretedParts === 0 && !hasVisibleText;
-  if (unreadable) {
-    reasons.push({ kind: "unreadable_turn", partTypes: uniqueOpaque });
-    return {
-      healthy: false,
-      severity: "warning",
-      reasons,
-      toolCalls,
-      unreadable: true,
-      partsReadable: false,
-      opaquePartTypes: uniqueOpaque,
-      // Structurally 0 here — `unreadable` is only reached when
-      // `interpretedParts === 0`. Carried rather than hardcoded so the field
-      // has one source on every return path.
-      interpretedParts
-    };
-  }
-  if (input.gated) {
-    reasons.push({ kind: "answered_without_model" });
-  } else if (!input.failed && !hasVisibleText && artifactCount === 0) {
-    reasons.push({
-      kind: "empty_completion",
-      outputTokens: input.outputTokens ?? null,
-      partCount: parts.length,
-      ...input.durationMs !== void 0 ? { durationMs: input.durationMs } : {}
-    });
-  }
-  return {
-    healthy: reasons.length === 0,
-    severity: severityOf(reasons),
-    reasons,
-    toolCalls,
-    unreadable: false,
-    partsReadable,
-    opaquePartTypes: uniqueOpaque,
-    interpretedParts
-  };
-}
-function severityOf(reasons) {
-  if (reasons.length === 0) return null;
-  const critical = reasons.some(
-    (r) => r.kind === "empty_completion" || r.kind === "turn_failed" || r.kind === "tool_call_rejected"
-  );
-  return critical ? "critical" : "warning";
-}
-function describeReason(reason) {
-  switch (reason.kind) {
-    case "empty_completion":
-      return `completed with NO output (${reason.partCount} parts, outputTokens=${reason.outputTokens ?? "unknown"})`;
-    case "malformed_tool_call":
-      return `tool \`${reason.tool}\` arguments did not parse (${reason.inputLength} chars): ${reason.sample}`;
-    case "tool_call_no_effect":
-      return `tool \`${reason.tool}\` left no effect (status=${reason.status})`;
-    case "turn_failed":
-      return `turn failed: ${reason.reason}`;
-    case "tool_call_rejected":
-      return `tool \`${reason.tool}\` was REJECTED but settled as completed: ${reason.error}`;
-    case "answered_without_model":
-      return "answered by a pre-producer gate \u2014 the model never ran";
-    case "unreadable_turn":
-      return `turn could not be read: every part had an uninterpretable type (${reason.partTypes.join(
-        ", "
-      )})`;
-  }
-}
-
-// src/turn-health/sink.ts
-function turnAlert(input) {
-  const kinds = [...new Set(input.reasons.map((r) => r.kind))].sort();
-  return {
-    product: input.product,
-    severity: input.severity,
-    // Keyed by product + reason kinds ONLY. A blank-completion storm across
-    // 200 turns is one incident, not 200 pages.
-    key: `turn:${input.product}:${kinds.join("+")}`,
-    title: `${input.product}: turn completed but delivered nothing (${kinds.join(", ")})`,
-    details: input.reasons.map(describeReason),
-    data: {
-      kinds,
-      ...input.threadId ? { threadId: input.threadId } : {},
-      ...input.turnId ? { turnId: input.turnId } : {},
-      ...input.model ? { model: input.model } : {}
-    },
-    at: input.at ?? Date.now()
-  };
-}
-function createWebhookAlertSink(options) {
-  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-  return {
-    async deliver(alert) {
-      const icon = alert.severity === "critical" ? ":rotating_light:" : ":warning:";
-      const lines = [
-        `${icon} *${alert.title}*`,
-        ...alert.details.map((d) => `\u2022 ${d}`),
-        `_${new Date(alert.at).toISOString()}_`
-      ];
-      const response = await fetchImpl(options.webhookUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ text: lines.join("\n") })
-      });
-      if (!response.ok) {
-        throw new Error(`alert webhook responded ${response.status}`);
-      }
-    }
-  };
-}
-function createSlackBotAlertSink(options) {
-  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-  return {
-    async deliver(alert) {
-      const icon = alert.severity === "critical" ? ":rotating_light:" : ":warning:";
-      const lines = [
-        `${icon} *${alert.title}*`,
-        ...alert.details.map((d) => `\u2022 ${d}`),
-        `_${new Date(alert.at).toISOString()}_`
-      ];
-      const outcome = await postSlackAlert({
-        token: options.botToken,
-        channel: options.channel,
-        text: lines.join("\n"),
-        attempts: 1,
-        // Preserve the public minimal-fetch seam without owning a second Slack
-        // request builder or response parser. Real callers use native fetch.
-        fetchImpl: options.fetchImpl ? (async (url, init) => {
-          const response = await fetchImpl(String(url), {
-            method: init?.method ?? "POST",
-            headers: Object.fromEntries(new Headers(init?.headers)),
-            body: String(init?.body ?? "")
-          });
-          return new Response(await response.text?.() ?? "", { status: response.status });
-        }) : void 0
-      });
-      if (!outcome.delivered) throw new Error(`Slack alert failed (${outcome.reason}): ${outcome.detail}`);
-    }
-  };
-}
-function createConsoleAlertSink(log = console.error) {
-  return {
-    async deliver(alert) {
-      log(
-        `[turn-health] ${alert.severity.toUpperCase()} ${alert.title} :: ${alert.details.join(" | ")}`
-      );
-    }
-  };
-}
-function createMultiAlertSink(sinks) {
-  return {
-    async deliver(alert) {
-      const settled = await Promise.allSettled(sinks.map((s) => s.deliver(alert)));
-      const failures = settled.filter((r) => r.status === "rejected");
-      if (failures.length === sinks.length && sinks.length > 0) {
-        throw new Error("every alert sink failed");
-      }
-    }
-  };
-}
-function createMemoryThrottleStore() {
-  const seen = /* @__PURE__ */ new Map();
-  return {
-    async lastSentAt(key) {
-      return seen.get(key) ?? null;
-    },
-    async markSent(key, at) {
-      seen.set(key, at);
-    }
-  };
-}
-function createThrottledAlertSink(inner, options) {
-  const store = options.store ?? createMemoryThrottleStore();
-  return {
-    async deliver(alert) {
-      const last = await store.lastSentAt(alert.key);
-      if (last !== null && alert.at - last < options.windowMs) return;
-      await inner.deliver(alert);
-      await store.markSent(alert.key, alert.at);
-    }
-  };
-}
-function createGuardedAlertSink(inner, onError = (e) => console.error("[turn-health] alert delivery failed", e)) {
-  return {
-    async deliver(alert) {
-      try {
-        await inner.deliver(alert);
-      } catch (error) {
-        onError(error);
-      }
-    }
-  };
-}
+  classifyTurnOutcome,
+  createConsoleAlertSink,
+  createGuardedAlertSink,
+  createMemoryThrottleStore,
+  createMultiAlertSink,
+  createSlackBotAlertSink,
+  createThrottledAlertSink,
+  createWebhookAlertSink,
+  describeReason,
+  turnAlert
+} from "../chunk-CD2LQXY6.js";
+import "../chunk-F2VX6TTJ.js";
 
 // src/turn-health/lifecycle.ts
 function errorText(error) {