@wrongstack/core 0.313.1 → 0.316.2

package/dist/chunk-3BDV7RL3.js

@@ -0,0 +1,211 @@
+import {
+  SESSION_MARKER_EVENT_TYPES,
+  isSystemInjectedMessage,
+  projectSessionMarkers
+} from "./chunk-ULMAQV3T.js";
+
+// src/types/session-timeline.ts
+function projectSessionToolMeta(events) {
+  const out = [];
+  for (const event of events) {
+    if (event.type !== "tool_call_end") continue;
+    out.push({
+      id: event.id,
+      name: event.name,
+      durationMs: event.durationMs,
+      // `outputSize` is the legacy name for the same number; prefer the modern
+      // field but fall back so old journals keep their tool card stats.
+      outputBytes: event.outputBytes ?? event.outputSize,
+      outputTokens: event.outputTokens,
+      outputLines: event.outputLines,
+      ok: event.ok,
+      agentId: event.agentId
+    });
+  }
+  return out;
+}
+function projectLastRequestTokens(events) {
+  if (!events) return void 0;
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const event = events[i];
+    if (event?.type !== "llm_response") continue;
+    const usage = event.usage;
+    const total = usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+    return total > 0 ? total : void 0;
+  }
+  return void 0;
+}
+function toolMetaIndex(meta) {
+  const index = /* @__PURE__ */ new Map();
+  if (!meta) return index;
+  for (const entry of meta) index.set(entry.id, entry);
+  return index;
+}
+function imagesOf(blocks) {
+  const images = [];
+  for (const block of blocks) {
+    if (block.type !== "image") continue;
+    images.push({
+      mediaType: block.source.media_type,
+      data: block.source.data,
+      url: block.source.url
+    });
+  }
+  return images.length > 0 ? images : void 0;
+}
+function resultText(content) {
+  return typeof content === "string" ? content : JSON.stringify(content);
+}
+function projectSessionTimeline(input) {
+  const {
+    messages,
+    events,
+    thinkingPlacement = "inline",
+    textBlocks = "split",
+    textSeparator = "",
+    hideSystemInjections = true
+  } = input;
+  const markers = input.markers ?? (events ? projectSessionMarkers(events, input.markerSources ?? SESSION_MARKER_EVENT_TYPES) : []);
+  const meta = toolMetaIndex(input.toolMeta ?? (events ? projectSessionToolMeta(events) : void 0));
+  const backbone = [];
+  const toolEntries = /* @__PURE__ */ new Map();
+  let thinkingIndex = 0;
+  let lastTs = "";
+  const pushText = (role, raw, ts, final) => {
+    const text = raw.trim();
+    if (!text) return;
+    if (hideSystemInjections && isSystemInjectedMessage(text)) return;
+    if (role === "assistant") backbone.push({ kind: "assistant", ts, text, final });
+    else if (role === "system") backbone.push({ kind: "system", ts, text });
+    else backbone.push({ kind: "user", ts, text });
+  };
+  const pushThinking = (text, ts) => {
+    if (!text.trim()) return;
+    thinkingIndex += 1;
+    backbone.push({ kind: "thinking", ts, text, index: thinkingIndex });
+  };
+  for (const message of messages) {
+    const ts = message.ts ?? lastTs;
+    if (message.ts) lastTs = message.ts;
+    if (typeof message.content === "string") {
+      pushText(message.role, message.content, ts, true);
+      continue;
+    }
+    const blocks = message.content;
+    if (thinkingPlacement === "inline") {
+      for (const block of blocks) {
+        if (block.type === "thinking") pushThinking(block.thinking, ts);
+      }
+    }
+    const images = message.role === "user" ? imagesOf(blocks) : void 0;
+    const final = !blocks.some((block) => block.type === "tool_use");
+    const textParts = [];
+    const flushText = () => {
+      if (textBlocks === "join") return;
+      const text = textParts.join(textSeparator).trim();
+      if (text) pushText(message.role, text, ts, final);
+      textParts.length = 0;
+    };
+    if (textBlocks === "join") {
+      const joined = blocks.filter((block) => block.type === "text").map((block) => block.text).join(textSeparator).trim();
+      if (joined) pushText(message.role, joined, ts, final);
+    }
+    for (const block of blocks) {
+      if (block.type === "text") {
+        textParts.push(block.text);
+        continue;
+      }
+      if (block.type === "tool_use") {
+        flushText();
+        const known2 = meta.get(block.id);
+        const entry = {
+          kind: "tool",
+          ts,
+          toolUseId: block.id,
+          name: block.name,
+          input: block.input,
+          // Left undefined until a tool_result arrives: an unfinished call is
+          // not a failed one.
+          ok: known2?.ok,
+          durationMs: known2?.durationMs,
+          outputBytes: known2?.outputBytes,
+          outputTokens: known2?.outputTokens,
+          outputLines: known2?.outputLines,
+          agentId: known2?.agentId
+        };
+        backbone.push(entry);
+        toolEntries.set(block.id, entry);
+        continue;
+      }
+      if (block.type !== "tool_result") continue;
+      flushText();
+      const existing = toolEntries.get(block.tool_use_id);
+      if (existing) {
+        existing.output = resultText(block.content);
+        existing.ok = !block.is_error;
+        toolEntries.delete(block.tool_use_id);
+        continue;
+      }
+      const known = meta.get(block.tool_use_id);
+      backbone.push({
+        kind: "tool",
+        ts,
+        toolUseId: block.tool_use_id,
+        name: block.name ?? known?.name ?? block.tool_use_id,
+        output: resultText(block.content),
+        ok: !block.is_error,
+        durationMs: known?.durationMs,
+        outputBytes: known?.outputBytes,
+        outputTokens: known?.outputTokens,
+        outputLines: known?.outputLines,
+        agentId: known?.agentId
+      });
+    }
+    flushText();
+    if (thinkingPlacement === "merged-after") {
+      const joined = blocks.filter(
+        (block) => block.type === "thinking"
+      ).map((block) => block.thinking).join("\n\n");
+      pushThinking(joined.trim(), ts);
+    }
+    if (images) {
+      const last = backbone[backbone.length - 1];
+      if (last?.kind === "user" && last.ts === ts) last.images = images;
+      else backbone.push({ kind: "user", ts, text: "", images });
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < backbone.length && j < markers.length) {
+    const marker = markers[j];
+    if (marker.ts < backbone[i].ts) {
+      out.push(markerEntry(marker));
+      j += 1;
+    } else {
+      out.push(backbone[i]);
+      i += 1;
+    }
+  }
+  while (i < backbone.length) out.push(backbone[i++]);
+  while (j < markers.length) out.push(markerEntry(markers[j++]));
+  return out;
+}
+function markerEntry(marker) {
+  return {
+    kind: "marker",
+    ts: marker.ts,
+    source: marker.source,
+    level: marker.level,
+    text: marker.text,
+    agentId: marker.agentId,
+    detail: marker.detail
+  };
+}
+
+export {
+  projectSessionToolMeta,
+  projectLastRequestTokens,
+  projectSessionTimeline
+};
+//# sourceMappingURL=chunk-3BDV7RL3.js.map

package/dist/{chunk-NFAYHPRH.js → chunk-3ECENVHL.js}

@@ -4,7 +4,7 @@ import {
 import {
   ERROR_CODES,
   WrongStackError
-} from "./chunk-WOEZV3Q4.js";
+} from "./chunk-25LSLC3G.js";
 
 // src/types/quota-regex.ts
 var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)(?:\s+(?:has|have))?(?:\s+been)?[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|(?:usage|credit)[-_\s]*(?:quota|limit)(?![-_\w])|usage[-_\s]*(?:limit|quota)[-_\s]*(?:reached|exceeded|for)/i;
@@ -29,6 +29,9 @@ function effectiveInputTokens(usage) {
 function freshInputTokens(usage) {
   return Math.max(0, effectiveInputTokens(usage) - (usage.cacheRead ?? 0));
 }
+function totalUsageTokens(usage) {
+  return effectiveInputTokens(usage) + usage.output;
+}
 function promptCacheHitRatio(usage) {
   const total = effectiveInputTokens(usage);
   if (!Number.isFinite(total) || total <= 0) return 0;
@@ -37,18 +40,15 @@ function promptCacheHitRatio(usage) {
 }
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|maximum context|max.*tokens?.*exceeded|(?:prompt|request|input|messages?).{0,12}too (?:large|long)|exceeds the context|\btokens\b.*exceed|too many tokens|reduce the length|resulted in \d+ tokens|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
-var RATE_LIMIT_EXCEEDED_RE = /rate[-_\s]*limit[-_\s]*exceeded/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
+  const messageText = [message, body?.message, type].filter(Boolean).join("\n");
+  const text = [messageText, body?.raw].filter(Boolean).join("\n");
   if (status === 0) return "network";
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
-  if (QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
+  if (QUOTA_EXHAUSTED_RE.test(messageText)) return "quota_exhausted";
   if (status === 402) return "quota_exhausted";
-  if (status === 429 && body?.message && body.type !== "rate_limit_exceeded" && RATE_LIMIT_EXCEEDED_RE.test(body.message)) {
-    return "quota_exhausted";
-  }
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
@@ -311,8 +311,10 @@ export {
   isReasoningEffort,
   effectiveInputTokens,
   freshInputTokens,
+  totalUsageTokens,
   promptCacheHitRatio,
   classifyProviderError,
+  MAX_RESET_HINT_MS,
   parseResetHintMs,
   isRetryableKind,
   isFallbackWorthy,
@@ -320,4 +322,4 @@ export {
   isContextOverflowShaped,
   StreamHangError
 };
-//# sourceMappingURL=chunk-NFAYHPRH.js.map
+//# sourceMappingURL=chunk-3ECENVHL.js.map