@agent-native/core 0.133.3 → 0.134.1

package/corpus/core/src/tracking/providers.ts

@@ -13,6 +13,7 @@
  * automatically by the core-routes plugin).
  */
 
+import { reshapeTrackedExceptionProperties } from "./posthog-exception.js";
 import { registerTrackingProvider } from "./registry.js";
 import type { TrackingProvider, TrackingEvent } from "./types.js";
 
@@ -162,27 +163,61 @@ function isPostHogAiObservabilityEvent(eventName: string): boolean {
   return eventName.startsWith("$ai_");
 }
 
-function createPostHogProvider(apiKey: string, host: string): TrackingProvider {
+/**
+ * `$ai_*` and `$exception` are ingested through PostHog's dedicated endpoint
+ * rather than `/capture/`, and `$exception` additionally has to carry
+ * `$exception_list` — the framework's own `captureException()` emits camelCase
+ * fields that PostHog would otherwise render as an empty, ungroupable issue.
+ */
+function createPostHogProvider(
+  apiKey: string,
+  host: string,
+  errorTracking: boolean,
+): TrackingProvider {
+  const sendToEventsEndpoint = (
+    event: TrackingEvent,
+    properties: Record<string, unknown> | undefined,
+    distinctId: string,
+  ): void => {
+    enqueue(
+      `${host}/i/v0/e/`,
+      JSON.stringify({
+        api_key: apiKey,
+        event: event.name,
+        properties: {
+          distinct_id: distinctId,
+          ...properties,
+          timestamp: event.timestamp,
+        },
+      }),
+    );
+  };
+
   return {
     name: "posthog",
     track(event: TrackingEvent) {
       const distinctId = event.userId || "anonymous";
       if (isPostHogAiObservabilityEvent(event.name)) {
-        enqueue(
-          `${host}/i/v0/e/`,
-          JSON.stringify({
-            api_key: apiKey,
-            event: event.name,
-            properties: {
-              distinct_id: distinctId,
-              ...event.properties,
-              timestamp: event.timestamp,
-            },
-          }),
-        );
+        sendToEventsEndpoint(event, event.properties, distinctId);
         return;
       }
 
+      if (event.name === "$exception") {
+        // `POSTHOG_ERROR_TRACKING=false` keeps product analytics flowing while
+        // another backend owns crashes. Drop rather than downgrade to
+        // `/capture/`: a malformed exception is what this branch exists to
+        // prevent.
+        if (!errorTracking) return;
+        const reshaped = reshapeTrackedExceptionProperties(event.properties);
+        if (reshaped) {
+          sendToEventsEndpoint(event, reshaped, distinctId);
+          return;
+        }
+        // No recognizable exception fields. Fall through to `/capture/` so the
+        // event is still recorded as-is rather than becoming an issue with
+        // nothing in it.
+      }
+
       enqueue(
         `${host}/capture/`,
         JSON.stringify({
@@ -213,6 +248,42 @@ function createPostHogProvider(apiKey: string, host: string): TrackingProvider {
   };
 }
 
+/**
+ * Send one event to PostHog only, bypassing the provider fan-out.
+ *
+ * For payloads whose *shape* is PostHog-specific and whose *content* other
+ * backends must not receive. `track()` broadcasts to every configured provider,
+ * so a PostHog-only integration (e.g. enabling a survey id) would otherwise
+ * start exporting that integration's content — including user-authored text —
+ * to Mixpanel, Amplitude, webhooks, and Agent Native Analytics as a side
+ * effect nobody opted into.
+ *
+ * Returns `false` when PostHog is not configured, so callers can tell "not
+ * sent" from "sent".
+ */
+export function sendPostHogEvent(
+  name: string,
+  properties: Record<string, unknown>,
+  distinctId: string,
+): boolean {
+  const apiKey = process.env.POSTHOG_API_KEY;
+  if (!apiKey) return false;
+  const host = (process.env.POSTHOG_HOST || POSTHOG_DEFAULT_HOST).replace(
+    /\/+$/,
+    "",
+  );
+  enqueue(
+    `${host}/capture/`,
+    JSON.stringify({
+      api_key: apiKey,
+      event: name,
+      distinct_id: distinctId,
+      properties: { ...properties, timestamp: new Date().toISOString() },
+    }),
+  );
+  return true;
+}
+
 // ─── Mixpanel ──────────────────────────────────────────────────────────────
 
 function createMixpanelProvider(token: string): TrackingProvider {
@@ -383,7 +454,13 @@ export function registerBuiltinProviders(): void {
       /\/+$/,
       "",
     );
-    registerTrackingProvider(createPostHogProvider(posthogKey, host));
+    registerTrackingProvider(
+      createPostHogProvider(
+        posthogKey,
+        host,
+        process.env.POSTHOG_ERROR_TRACKING?.trim().toLowerCase() !== "false",
+      ),
+    );
   }
 
   const mixpanelToken = process.env.MIXPANEL_TOKEN;

package/corpus/core/src/tracking/redaction.ts

@@ -0,0 +1,105 @@
+/**
+ * Bounding and redaction helpers shared by every exception emitter.
+ *
+ * Kept free of `process.env` and Node built-ins so the browser bundle can use
+ * the same rules — an exception shaped one way on the server and another way
+ * in the client is how a leak ships in only one of them.
+ */
+
+export const MAX_MESSAGE_LENGTH = 1000;
+export const MAX_STACK_LENGTH = 8000;
+export const MAX_TAGS = 30;
+export const MAX_EXTRA_KEYS = 30;
+export const MAX_EXTRA_VALUE_LENGTH = 1000;
+
+const SECRET_RE = /\b(?:bearer|basic)\s+[^\s]+/gi;
+
+export const SECRET_KEY_RE =
+  /(?:authorization|cookie|set[-_]?cookie|token|secret|password|passwd|pwd|api[-_]?key|apikey|credential)/i;
+
+export function redact(value: string): string {
+  return value
+    .replace(SECRET_RE, (match) => `${match.split(/\s+/, 1)[0]} <redacted>`)
+    .replace(
+      /([A-Za-z0-9_$.-]*(?:authorization|cookie|token|secret|password|passwd|pwd|api[-_]?key|apikey|credential)[A-Za-z0-9_$.-]*\s*[:=]\s*)([^\s,;}]+)/gi,
+      "$1<redacted>",
+    );
+}
+
+export function boundedText(value: unknown, max: number): string {
+  const text = typeof value === "string" ? value : String(value ?? "");
+  const safe = redact(text);
+  return safe.length > max ? safe.slice(0, max) : safe;
+}
+
+export function safeValue(value: unknown, depth = 2): unknown {
+  if (
+    value == null ||
+    typeof value === "boolean" ||
+    typeof value === "number"
+  ) {
+    return value;
+  }
+  if (typeof value === "string")
+    return boundedText(value, MAX_EXTRA_VALUE_LENGTH);
+  if (depth <= 0) return boundedText(value, MAX_EXTRA_VALUE_LENGTH);
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map((item) => safeValue(item, depth - 1));
+  }
+  if (typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (Object.keys(out).length >= MAX_EXTRA_KEYS) break;
+      const safeKey = boundedText(key, 100);
+      out[safeKey] = SECRET_KEY_RE.test(safeKey)
+        ? "<redacted>"
+        : safeValue(child, depth - 1);
+    }
+    return out;
+  }
+  return boundedText(value, MAX_EXTRA_VALUE_LENGTH);
+}
+
+export function safeTags(
+  tags: Record<string, string | undefined> | undefined,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(tags ?? {})) {
+    if (Object.keys(out).length >= MAX_TAGS) break;
+    // Skip, don't stop: callers build tag objects with optional entries
+    // (`{ ...tags, route, method, userAgent }`), so breaking on the first
+    // undefined dropped every tag after it depending on key order.
+    if (value == null) continue;
+    const safeKey = boundedText(key, 100);
+    out[safeKey] = SECRET_KEY_RE.test(safeKey)
+      ? "<redacted>"
+      : boundedText(value, 200);
+  }
+  return out;
+}
+
+export interface ExceptionParts {
+  type: string;
+  message: string;
+  stack?: string;
+}
+
+/** Split an unknown thrown value into bounded, redacted type/message/stack. */
+export function exceptionParts(error: unknown): ExceptionParts {
+  if (error instanceof Error) {
+    return {
+      type: boundedText(error.name || "Error", 200),
+      message: boundedText(
+        error.message || error.name || "Error",
+        MAX_MESSAGE_LENGTH,
+      ),
+      ...(error.stack
+        ? { stack: boundedText(error.stack, MAX_STACK_LENGTH) }
+        : {}),
+    };
+  }
+  return {
+    type: "Error",
+    message: boundedText(error, MAX_MESSAGE_LENGTH),
+  };
+}

package/corpus/templates/clips/changelog/2026-07-29-meeting-notes-no-longer-transcribe-the-other-side-twice-when.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+Meeting notes no longer transcribe the other side twice when you are on speakers instead of headphones

package/corpus/templates/clips/desktop/src/hooks/useMeetingTranscription.ts

@@ -8,11 +8,14 @@ import {
   appendFinalTranscript,
   onFinalTranscript,
   restartTranscriptionEngine,
-  speakerFor,
   startTranscriptionEngine,
   stopTranscriptionEngine,
+  transcriptFullText,
+  transcriptLineFromSegment,
+  transcriptSegments,
   type SourcedTranscriptSegment,
   type TranscriptionEngine,
+  type TranscriptLine,
 } from "../lib/transcription-engine";
 import { normalizeServerUrl } from "../lib/url";
 
@@ -31,8 +34,7 @@ export interface MeetingTranscriptionPayload {
 interface MeetingTranscriptionSession {
   meetingId: string;
   recordingId: string;
-  lines: string[];
-  segments: SourcedTranscriptSegment[];
+  lines: TranscriptLine[];
   unlisten: Array<() => void>;
   flushTimer: ReturnType<typeof setTimeout> | null;
   stopping: boolean;
@@ -52,6 +54,22 @@ interface MeetingTranscriptionSession {
   dirtySeq: number;
 }
 
+/** What the pill overlay needs to render a line: text, side, and timestamp.
+ *  The verbatim segments stay behind in the session. */
+interface PillTranscriptLine {
+  text: string;
+  source: "mic" | "system";
+  startMs?: number;
+}
+
+function pillTranscriptLines(lines: TranscriptLine[]): PillTranscriptLine[] {
+  return lines.map((line) => ({
+    text: line.text,
+    source: line.source,
+    startMs: line.startMs ?? undefined,
+  }));
+}
+
 type CallClipsAction = <T>(
   name: string,
   body: Record<string, unknown>,
@@ -79,11 +97,7 @@ export function useMeetingTranscription({
   const pendingPillInitRef = useRef<{
     meetingId: string;
     initialNotes: string;
-    preloadedLines?: Array<{
-      text: string;
-      source: "mic" | "system";
-      startMs?: number;
-    }>;
+    preloadedLines?: PillTranscriptLine[];
   } | null>(null);
 
   const normalizedServerUrl = useMemo(
@@ -119,8 +133,8 @@ export function useMeetingTranscription({
     const run = (async () => {
       await callClipsAction("save-browser-transcript", {
         recordingId: session.recordingId,
-        fullText: session.lines.join("\n\n"),
-        segments: session.segments,
+        fullText: transcriptFullText(session.lines),
+        segments: transcriptSegments(session.lines),
         source: session.engine,
         overwriteReady: true,
       });
@@ -314,7 +328,6 @@ export function useMeetingTranscription({
           meetingId: resolvedMeetingId,
           recordingId,
           lines: [],
-          segments: [],
           unlisten: [],
           flushTimer: null,
           stopping: false,
@@ -363,13 +376,7 @@ export function useMeetingTranscription({
                   })),
                 }
               : event;
-            if (
-              appendFinalTranscript(
-                timelineEvent,
-                session.lines,
-                session.segments,
-              )
-            ) {
+            if (appendFinalTranscript(timelineEvent, session.lines)) {
               scheduleFlush();
             }
           }),
@@ -539,11 +546,7 @@ export function useMeetingTranscription({
             pendingPillInitRef.current = {
               meetingId: resolvedMeetingId,
               initialNotes,
-              preloadedLines: session.segments.map((segment) => ({
-                text: segment.text,
-                source: segment.source,
-                startMs: segment.startMs,
-              })),
+              preloadedLines: pillTranscriptLines(session.lines),
             };
             emit("clips:meeting-notes-init", {
               meetingId: resolvedMeetingId,
@@ -561,25 +564,16 @@ export function useMeetingTranscription({
                   source?: "mic" | "system";
                 }>;
                 if (segs.length > 0) {
-                  const preloadedLineStrings = segs.map(
-                    (s) => `${speakerFor(s.source)}: ${s.text}`,
+                  const storedLines = segs.map((s) =>
+                    transcriptLineFromSegment({
+                      startMs: s.startMs ?? 0,
+                      endMs: s.endMs ?? 0,
+                      text: s.text,
+                      source: s.source ?? "mic",
+                    }),
                   );
-                  const preloadedSegments = segs.map((s) => ({
-                    startMs: s.startMs ?? 0,
-                    endMs: s.endMs ?? 0,
-                    text: s.text,
-                    source: s.source ?? ("mic" as const),
-                  }));
-                  session.lines = [...preloadedLineStrings, ...session.lines];
-                  session.segments = [
-                    ...preloadedSegments,
-                    ...session.segments,
-                  ];
-                  const preloadedLines = session.segments.map((s) => ({
-                    text: s.text,
-                    source: s.source,
-                    startMs: s.startMs,
-                  }));
+                  session.lines = [...storedLines, ...session.lines];
+                  const preloadedLines = pillTranscriptLines(session.lines);
                   // Store in ref so clips:pill-ready can re-emit if the
                   // pill window mounts after this fetch resolves.
                   if (
@@ -648,15 +642,10 @@ export function useMeetingTranscription({
             .then((history) => {
               if (sessionRef.current !== session) return;
               const historyLines = history.segments.map(
-                (segment) => `${speakerFor(segment.source)}: ${segment.text}`,
+                transcriptLineFromSegment,
               );
               session.lines = [...historyLines, ...session.lines];
-              session.segments = [...history.segments, ...session.segments];
-              const preloadedLines = session.segments.map((segment) => ({
-                text: segment.text,
-                source: segment.source,
-                startMs: segment.startMs,
-              }));
+              const preloadedLines = pillTranscriptLines(session.lines);
               if (pendingPillInitRef.current?.meetingId === resolvedMeetingId) {
                 pendingPillInitRef.current = {
                   ...pendingPillInitRef.current,

package/corpus/templates/clips/desktop/src/lib/transcription-capture.ts

@@ -19,7 +19,10 @@ import {
   startTranscriptionEngine,
   stopTranscriptionEngine,
   TranscriptionEngine,
+  transcriptFullText,
+  transcriptSegments,
   type SourcedTranscriptSegment,
+  type TranscriptLine,
 } from "./transcription-engine";
 
 /** Grace period after stop for whisper to emit any flushed trailing finals. */
@@ -307,8 +310,7 @@ export async function startTranscriptionCapture(
     voiceProcessing?: boolean;
   },
 ): Promise<TranscriptionCapture | null> {
-  const lines: string[] = [];
-  const segments: SourcedTranscriptSegment[] = [];
+  const lines: TranscriptLine[] = [];
   let disposed = false;
   let paused = false;
   let desiredPaused = false;
@@ -331,8 +333,8 @@ export async function startTranscriptionCapture(
   };
 
   const captured = (): CapturedTranscript => ({
-    text: lines.join("\n\n").trim(),
-    segments,
+    text: transcriptFullText(lines),
+    segments: transcriptSegments(lines),
   });
 
   let engine: TranscriptionEngine;
@@ -340,7 +342,7 @@ export async function startTranscriptionCapture(
     unlistens.push(
       await onFinalTranscript((event) => {
         if (disposed) return;
-        appendFinalTranscript(event, lines, segments);
+        appendFinalTranscript(event, lines);
       }),
     );