@agent-native/core 0.201.0-nightly-20261005153421 → 0.201.0

package/dist/agent-sql/query.js

@@ -0,0 +1,514 @@
+import { AgentSqlSyntaxError, lexAgentSql, } from "./lexer.js";
+const CLAUSES = new Set([
+    "where",
+    "group",
+    "having",
+    "window",
+    "qualify",
+    "order",
+    "limit",
+    "offset",
+    "fetch",
+    "for",
+]);
+const JOIN_WORDS = new Set([
+    "join",
+    "inner",
+    "left",
+    "right",
+    "full",
+    "cross",
+    "natural",
+]);
+const RESERVED_SOURCE_WORDS = new Set([
+    ...CLAUSES,
+    ...JOIN_WORDS,
+    "select",
+    "with",
+    "from",
+    "as",
+    "on",
+    "using",
+    "outer",
+    "union",
+    "intersect",
+    "except",
+    "only",
+    "lateral",
+    "rows",
+    "table",
+    "values",
+    "tablesample",
+    "pivot",
+    "unpivot",
+    "match_recognize",
+]);
+function isName(token) {
+    return token?.kind === "word" || token?.kind === "quoted-identifier";
+}
+function word(token) {
+    return token?.kind === "word" ? token.value : undefined;
+}
+function punctuation(token, text) {
+    return token?.kind === "punctuation" && token.text === text;
+}
+class QueryReader {
+    sql;
+    tokens;
+    dialect;
+    sources = [];
+    ctes = [];
+    pairs = new Map();
+    constructor(sql, tokens, dialect) {
+        this.sql = sql;
+        this.tokens = tokens;
+        this.dialect = dialect;
+        if (tokens.length > 50_000)
+            this.fail("The SQL has too many tokens.", 0);
+        const stack = [];
+        for (let index = 0; index < tokens.length; index++) {
+            const token = tokens[index];
+            if (punctuation(token, "(") || punctuation(token, "[")) {
+                stack.push(index);
+                if (stack.length > 128)
+                    this.fail("The SQL is nested too deeply.", index);
+            }
+            else if (punctuation(token, ")") || punctuation(token, "]")) {
+                const open = stack.pop();
+                if (open === undefined ||
+                    (token.text === ")"
+                        ? tokens[open].text !== "("
+                        : tokens[open].text !== "[")) {
+                    this.fail("The SQL has mismatched delimiters.", index);
+                }
+                this.pairs.set(open, index);
+            }
+        }
+        if (stack.length > 0)
+            this.fail("The SQL has an unclosed delimiter.", stack[0]);
+    }
+    fail(message, index) {
+        throw new AgentSqlSyntaxError("unsupported_syntax", message, this.tokens[index]?.start ?? this.sql.length);
+    }
+    close(index) {
+        const close = this.pairs.get(index);
+        if (close === undefined)
+            this.fail("Expected a delimited SQL expression.", index);
+        return close;
+    }
+    name(token) {
+        // BigQuery dataset/table names preserve case even when unquoted.
+        const name = this.dialect === "postgres"
+            ? token.value
+            : token.kind === "word"
+                ? token.text
+                : token.value;
+        if (this.dialect === "postgres" &&
+            new TextEncoder().encode(name).length > 63) {
+            this.fail("Postgres identifiers longer than 63 bytes are not supported.", this.tokens.indexOf(token));
+        }
+        return name;
+    }
+    binding(name) {
+        return this.dialect === "bigquery"
+            ? name.replace(/[A-Z]/g, (letter) => letter.toLowerCase())
+            : name;
+    }
+    identifier(index) {
+        const token = this.tokens[index];
+        if (!isName(token) ||
+            (token.kind === "word" && RESERVED_SOURCE_WORDS.has(token.value))) {
+            this.fail("Expected an unambiguous SQL source identifier.", index);
+        }
+        return token;
+    }
+    queryStart(start, end) {
+        while (punctuation(this.tokens[start], "(") &&
+            this.close(start) === end - 1) {
+            start++;
+            end--;
+        }
+        const keyword = word(this.tokens[start]);
+        // TABLE reads a relation without FROM and must not become an ordinary expression.
+        if (this.dialect === "postgres" &&
+            (keyword === "table" || keyword === "values")) {
+            this.fail("Only SELECT query expressions are supported.", start);
+        }
+        return keyword === "select" || keyword === "with";
+    }
+    columns(start) {
+        const end = this.close(start);
+        let cursor = start + 1;
+        if (cursor === end)
+            this.fail("Expected at least one column name.", cursor);
+        while (cursor < end) {
+            this.identifier(cursor++);
+            if (cursor === end)
+                break;
+            if (!punctuation(this.tokens[cursor++], ",") || cursor === end) {
+                this.fail("Expected a comma-separated column name list.", cursor - 1);
+            }
+        }
+        return end + 1;
+    }
+    withClause(start, end, inherited) {
+        let cursor = start + 1;
+        const recursive = word(this.tokens[cursor]) === "recursive";
+        if (recursive)
+            cursor++;
+        const definitions = [];
+        const names = new Set();
+        while (cursor < end) {
+            const token = this.identifier(cursor++);
+            const cte = {
+                name: this.name(token),
+                quoted: token.kind === "quoted-identifier",
+                start: token.start,
+                end: token.end,
+            };
+            const key = this.binding(cte.name);
+            if (names.has(key))
+                this.fail("Duplicate CTE names are not supported.", cursor - 1);
+            names.add(key);
+            if (punctuation(this.tokens[cursor], "("))
+                cursor = this.columns(cursor);
+            if (word(this.tokens[cursor++]) !== "as")
+                this.fail("Expected AS in the CTE declaration.", cursor - 1);
+            if (this.dialect === "postgres") {
+                if (word(this.tokens[cursor]) === "not") {
+                    cursor++;
+                    if (word(this.tokens[cursor++]) !== "materialized")
+                        this.fail("Expected MATERIALIZED after NOT.", cursor - 1);
+                }
+                else if (word(this.tokens[cursor]) === "materialized")
+                    cursor++;
+            }
+            if (!punctuation(this.tokens[cursor], "("))
+                this.fail("Expected a parenthesized CTE query.", cursor);
+            const close = this.close(cursor);
+            if (close >= end)
+                this.fail("The CTE query exceeds its enclosing query.", cursor);
+            definitions.push({ cte, bodyStart: cursor + 1, bodyEnd: close });
+            cursor = close + 1;
+            if (!punctuation(this.tokens[cursor], ","))
+                break;
+            cursor++;
+        }
+        const scope = new Set(inherited);
+        if (recursive)
+            for (const name of names)
+                scope.add(name);
+        for (const definition of definitions) {
+            this.ctes.push(definition.cte);
+            this.query(definition.bodyStart, definition.bodyEnd, scope);
+            scope.add(this.binding(definition.cte.name));
+        }
+        return { start: cursor, scope };
+    }
+    query(start, end, inherited) {
+        while (punctuation(this.tokens[start], "(") &&
+            this.close(start) === end - 1) {
+            start++;
+            end--;
+        }
+        let scope = inherited;
+        if (word(this.tokens[start]) === "with")
+            ({ start, scope } = this.withClause(start, end, inherited));
+        let branch = start;
+        for (let cursor = start; cursor < end; cursor++) {
+            if (punctuation(this.tokens[cursor], "(") ||
+                punctuation(this.tokens[cursor], "[")) {
+                cursor = this.close(cursor);
+                continue;
+            }
+            const keyword = word(this.tokens[cursor]);
+            if (keyword !== "union" &&
+                keyword !== "intersect" &&
+                keyword !== "except")
+                continue;
+            // BigQuery's SELECT * EXCEPT(columns) is not a set operation.
+            if (this.dialect === "bigquery" &&
+                keyword === "except" &&
+                punctuation(this.tokens[cursor + 1], "(") &&
+                !this.queryStart(cursor + 2, this.close(cursor + 1)))
+                continue;
+            this.select(branch, cursor, scope);
+            cursor++;
+            if (word(this.tokens[cursor]) === "all" ||
+                word(this.tokens[cursor]) === "distinct")
+                cursor++;
+            branch = cursor;
+            cursor--;
+        }
+        this.select(branch, end, scope);
+    }
+    expression(start, end, scope) {
+        for (let cursor = start; cursor < end; cursor++) {
+            if (!punctuation(this.tokens[cursor], "(") &&
+                !punctuation(this.tokens[cursor], "["))
+                continue;
+            const close = this.close(cursor);
+            if (punctuation(this.tokens[cursor], "(") &&
+                this.queryStart(cursor + 1, close)) {
+                this.query(cursor + 1, close, scope);
+            }
+            else {
+                this.expression(cursor + 1, close, scope);
+            }
+            cursor = close;
+        }
+    }
+    select(start, end, scope) {
+        if (punctuation(this.tokens[start], "(")) {
+            const close = this.close(start);
+            if (!this.queryStart(start + 1, close))
+                this.fail("Only SELECT query expressions are supported.", start);
+            this.query(start + 1, close, scope);
+            if (close + 1 < end) {
+                if (!CLAUSES.has(word(this.tokens[close + 1]) ?? ""))
+                    this.fail("Unsupported text after a query expression.", close + 1);
+                this.expression(close + 1, end, scope);
+            }
+            return;
+        }
+        if (word(this.tokens[start]) !== "select")
+            this.fail("Only SELECT query expressions are supported.", start);
+        let sawFrom = false;
+        let afterFrom = false;
+        for (let cursor = start + 1; cursor < end; cursor++) {
+            if (punctuation(this.tokens[cursor], "(") ||
+                punctuation(this.tokens[cursor], "[")) {
+                const close = this.close(cursor);
+                this.expression(cursor, close + 1, scope);
+                cursor = close;
+                continue;
+            }
+            const keyword = word(this.tokens[cursor]);
+            if (keyword === "from") {
+                if (sawFrom || afterFrom)
+                    this.fail("Unexpected FROM at this query depth.", cursor);
+                sawFrom = true;
+                cursor = this.from(cursor + 1, end, scope) - 1;
+            }
+            else if (keyword && CLAUSES.has(keyword)) {
+                afterFrom = true;
+            }
+            else if (keyword === "select" ||
+                keyword === "with" ||
+                keyword === "join") {
+                this.fail("Unexpected query structure at this query depth.", cursor);
+            }
+        }
+    }
+    alias(cursor, end) {
+        let explicit = false;
+        if (word(this.tokens[cursor]) === "as") {
+            explicit = true;
+            cursor++;
+        }
+        const token = this.tokens[cursor];
+        if (cursor < end &&
+            isName(token) &&
+            (token.kind === "quoted-identifier" ||
+                !RESERVED_SOURCE_WORDS.has(token.value))) {
+            const alias = {
+                name: this.name(token),
+                quoted: token.kind === "quoted-identifier",
+            };
+            cursor++;
+            if (punctuation(this.tokens[cursor], "("))
+                cursor = this.columns(cursor);
+            return { cursor, alias };
+        }
+        if (explicit)
+            this.fail("Expected a source alias after AS.", cursor);
+        return { cursor };
+    }
+    source(start, end, scope, commaSeparated) {
+        let cursor = start;
+        const modifiers = [];
+        if (word(this.tokens[cursor]) === "lateral") {
+            modifiers.push("lateral");
+            cursor++;
+        }
+        const only = this.dialect === "postgres" && word(this.tokens[cursor]) === "only";
+        if (only) {
+            modifiers.push("only");
+            cursor++;
+        }
+        if (!only && punctuation(this.tokens[cursor], "(")) {
+            const close = this.close(cursor);
+            if (!this.queryStart(cursor + 1, close))
+                this.fail("Grouped tables and joins are not supported.", cursor);
+            this.query(cursor + 1, close, scope);
+            return this.alias(close + 1, end).cursor;
+        }
+        const wrapped = only && punctuation(this.tokens[cursor], "(");
+        const wrapper = cursor;
+        if (wrapped)
+            cursor++;
+        const first = this.identifier(cursor++);
+        let last = first;
+        const parts = this.dialect === "bigquery"
+            ? this.name(first).split(".")
+            : [this.name(first)];
+        while (punctuation(this.tokens[cursor], ".")) {
+            last = this.identifier(cursor + 1);
+            parts.push(...(this.dialect === "bigquery"
+                ? this.name(last).split(".")
+                : [this.name(last)]));
+            cursor += 2;
+        }
+        if (parts.some((part) => part.length === 0))
+            this.fail("Empty source path components are not supported.", start);
+        if (this.dialect === "bigquery" &&
+            parts.some((part) => /[*@$]/.test(part))) {
+            this.fail("Wildcard and decorated BigQuery tables are not supported.", start);
+        }
+        if (punctuation(this.tokens[cursor], "("))
+            this.fail("Table functions are not supported.", cursor);
+        if (wrapped) {
+            if (cursor !== this.close(wrapper))
+                this.fail("ONLY must contain exactly one relation name.", cursor);
+            cursor++;
+        }
+        const result = this.alias(cursor, end);
+        const name = parts[parts.length - 1];
+        this.sources.push({
+            name,
+            qualifiers: parts.slice(0, -1),
+            quoted: last.kind === "quoted-identifier",
+            start: first.start,
+            end: last.end,
+            cte: parts.length === 1 && scope.has(this.binding(name)),
+            commaSeparated,
+            modifiers,
+            ...(result.alias ? { alias: result.alias } : {}),
+        });
+        return result.cursor;
+    }
+    join(cursor) {
+        if (word(this.tokens[cursor]) === "natural")
+            cursor++;
+        const kind = word(this.tokens[cursor]);
+        if (kind === "inner" ||
+            kind === "left" ||
+            kind === "right" ||
+            kind === "full" ||
+            kind === "cross") {
+            cursor++;
+            if (word(this.tokens[cursor]) === "outer" &&
+                kind !== "inner" &&
+                kind !== "cross")
+                cursor++;
+        }
+        if (word(this.tokens[cursor]) !== "join")
+            this.fail("Unsupported JOIN structure.", cursor);
+        return cursor + 1;
+    }
+    from(start, end, scope) {
+        let cursor = this.source(start, end, scope, false);
+        while (cursor < end) {
+            const keyword = word(this.tokens[cursor]);
+            if (keyword && CLAUSES.has(keyword))
+                return cursor;
+            if (punctuation(this.tokens[cursor], ",")) {
+                cursor = this.source(cursor + 1, end, scope, true);
+            }
+            else if (keyword && JOIN_WORDS.has(keyword)) {
+                cursor = this.source(this.join(cursor), end, scope, false);
+            }
+            else if (keyword === "using") {
+                if (!punctuation(this.tokens[cursor + 1], "("))
+                    this.fail("Expected JOIN USING columns.", cursor + 1);
+                cursor = this.columns(cursor + 1);
+            }
+            else if (keyword === "on") {
+                const expressionStart = ++cursor;
+                while (cursor < end) {
+                    if (punctuation(this.tokens[cursor], "(") ||
+                        punctuation(this.tokens[cursor], "[")) {
+                        cursor = this.close(cursor) + 1;
+                        continue;
+                    }
+                    const next = word(this.tokens[cursor]);
+                    if (punctuation(this.tokens[cursor], ",") ||
+                        (next && (CLAUSES.has(next) || JOIN_WORDS.has(next))))
+                        break;
+                    cursor++;
+                }
+                if (cursor === expressionStart)
+                    this.fail("Expected a JOIN condition.", cursor);
+                this.expression(expressionStart, cursor, scope);
+            }
+            else {
+                this.fail("The SQL source boundary could not be established safely.", cursor);
+            }
+        }
+        return cursor;
+    }
+}
+/** Reads sources in a bounded SELECT grammar; unsupported source syntax throws. */
+export function readAgentSqlQuery(sql, options) {
+    const tokens = lexAgentSql(sql, options);
+    let end = tokens.length;
+    if (punctuation(tokens[end - 1], ";"))
+        end--;
+    if (end === 0)
+        throw new AgentSqlSyntaxError("unsupported_syntax", "The SQL query is empty.", 0);
+    const semicolon = tokens
+        .slice(0, end)
+        .find((token) => punctuation(token, ";"));
+    if (semicolon)
+        throw new AgentSqlSyntaxError("unsupported_syntax", "Expected exactly one SQL query.", semicolon.start);
+    const reader = new QueryReader(sql, tokens, options.dialect);
+    reader.query(0, end, new Set());
+    return {
+        sql,
+        dialect: options.dialect,
+        tokens,
+        sources: reader.sources.sort((left, right) => left.start - right.start),
+        ctes: reader.ctes.sort((left, right) => left.start - right.start),
+    };
+}
+/** Replaces only analyzed source-name spans, preserving all other source text. */
+export function rewriteAgentSqlQuerySources(query, replacer) {
+    const sources = [...query.sources].sort((left, right) => left.start - right.start);
+    const tokenStarts = new Map(query.tokens.map((token, index) => [token.start, index]));
+    const tokenEnds = new Map(query.tokens.map((token, index) => [token.end, index]));
+    let cursor = 0;
+    let sql = "";
+    for (const source of sources) {
+        if (!Number.isInteger(source.start) ||
+            !Number.isInteger(source.end) ||
+            source.start < cursor ||
+            source.end <= source.start ||
+            source.end > query.sql.length) {
+            throw new AgentSqlSyntaxError("unsupported_syntax", "SQL source spans overlap or exceed the query.", source.start);
+        }
+        const first = tokenStarts.get(source.start);
+        const last = tokenEnds.get(source.end);
+        if (first === undefined ||
+            last === undefined ||
+            last < first ||
+            (last - first) % 2 !== 0) {
+            throw new AgentSqlSyntaxError("unsupported_syntax", "SQL source spans must follow identifier token boundaries.", source.start);
+        }
+        for (let index = first; index <= last; index++) {
+            const token = query.tokens[index];
+            if (((index - first) % 2 === 0
+                ? !isName(token)
+                : !punctuation(token, ".")) ||
+                query.sql.slice(token.start, token.end) !== token.text) {
+                throw new AgentSqlSyntaxError("unsupported_syntax", "SQL source spans must contain exactly one identifier path.", source.start);
+            }
+        }
+        const replacement = replacer(source);
+        if (typeof replacement !== "string" || replacement.trim().length === 0) {
+            throw new AgentSqlSyntaxError("unsupported_syntax", "A SQL source replacement must be nonempty text.", source.start);
+        }
+        sql += query.sql.slice(cursor, source.start) + replacement;
+        cursor = source.end;
+    }
+    return sql + query.sql.slice(cursor);
+}

package/dist/catalog.json

@@ -10,30 +10,30 @@
   "@radix-ui/react-popover": "^1.1.19",
   "@radix-ui/react-select": "^2.3.3",
   "@radix-ui/react-tooltip": "^1.2.12",
-  "@tiptap/core": "3.30.1",
-  "@tiptap/extension-blockquote": "3.30.1",
-  "@tiptap/extension-bold": "3.30.1",
-  "@tiptap/extension-bubble-menu": "3.30.1",
-  "@tiptap/extension-code-block-lowlight": "3.30.1",
-  "@tiptap/extension-collaboration": "3.30.1",
-  "@tiptap/extension-collaboration-caret": "3.30.1",
-  "@tiptap/extension-color": "3.30.1",
-  "@tiptap/extension-floating-menu": "3.30.1",
-  "@tiptap/extension-horizontal-rule": "3.30.1",
-  "@tiptap/extension-image": "3.30.1",
-  "@tiptap/extension-link": "3.30.1",
-  "@tiptap/extension-list": "3.30.1",
-  "@tiptap/extension-placeholder": "3.30.1",
-  "@tiptap/extension-table": "3.30.1",
-  "@tiptap/extension-table-cell": "3.30.1",
-  "@tiptap/extension-table-header": "3.30.1",
-  "@tiptap/extension-table-row": "3.30.1",
-  "@tiptap/extension-task-item": "3.30.1",
-  "@tiptap/extension-task-list": "3.30.1",
-  "@tiptap/extension-text-style": "3.30.1",
-  "@tiptap/pm": "3.30.1",
-  "@tiptap/react": "3.30.1",
-  "@tiptap/starter-kit": "3.30.1",
+  "@tiptap/core": "3.31.4",
+  "@tiptap/extension-blockquote": "3.31.4",
+  "@tiptap/extension-bold": "3.31.4",
+  "@tiptap/extension-bubble-menu": "3.31.4",
+  "@tiptap/extension-code-block-lowlight": "3.31.4",
+  "@tiptap/extension-collaboration": "3.31.4",
+  "@tiptap/extension-collaboration-caret": "3.31.4",
+  "@tiptap/extension-color": "3.31.4",
+  "@tiptap/extension-floating-menu": "3.31.4",
+  "@tiptap/extension-horizontal-rule": "3.31.4",
+  "@tiptap/extension-image": "3.31.4",
+  "@tiptap/extension-link": "3.31.4",
+  "@tiptap/extension-list": "3.31.4",
+  "@tiptap/extension-placeholder": "3.31.4",
+  "@tiptap/extension-table": "3.31.4",
+  "@tiptap/extension-table-cell": "3.31.4",
+  "@tiptap/extension-table-header": "3.31.4",
+  "@tiptap/extension-table-row": "3.31.4",
+  "@tiptap/extension-task-item": "3.31.4",
+  "@tiptap/extension-task-list": "3.31.4",
+  "@tiptap/extension-text-style": "3.31.4",
+  "@tiptap/pm": "3.31.4",
+  "@tiptap/react": "3.31.4",
+  "@tiptap/starter-kit": "3.31.4",
   "@tiptap/y-tiptap": "3.0.7",
   "@tabler/icons-react": "3.44.0",
   "@tailwindcss/vite": "^4.2.4",

package/dist/client/analytics/index.d.ts

@@ -1,2 +1,2 @@
-export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, type AgentChatLifecycleEvent, type CaptureExceptionContext, type CapturedExceptionEvent, type ClientCaptureContext, type ConfigureTrackingOptions, type ErrorCaptureConfigOptions, type ExceptionBreadcrumb, type ExceptionLevel, type FirstTouchAttribution, type SessionReplayContext, type SessionReplayLinkOptions, type SessionReplayOptions, type SessionReplayStartResult, type SessionReplayUrlMatcher, type TrackingIdentityUser, } from "../analytics.js";
+export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, type AgentChatLifecycleEvent, type CaptureExceptionContext, type CapturedExceptionEvent, type ClientCaptureContext, type ConfigureTrackingOptions, type ErrorCaptureConfigOptions, type ExceptionBreadcrumb, type ExceptionLevel, type FirstTouchAttribution, type SessionReplayContext, type SessionReplayLinkOptions, type SessionReplayOptions, type SessionReplayStartResult, type SessionReplayUrlMatcher, type TrackingIdentityUser, } from "../analytics.js";
 export { track } from "../track.js";

package/dist/client/analytics/index.js

@@ -1,2 +1,2 @@
-export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, } from "../analytics.js";
+export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, } from "../analytics.js";
 export { track } from "../track.js";

package/dist/client/analytics.d.ts

@@ -81,6 +81,8 @@ export interface FirstTouchAttribution {
     vector_source?: string;
     landing_path?: string;
     landing_referrer?: string;
+    site_referrer?: string;
+    site_landing_path?: string;
     landed_at?: string;
     capture_truncated?: string;
 }
@@ -88,6 +90,12 @@ export declare function getAnalyticsIdentityKey(): string | undefined;
 export declare function getAnalyticsAnonymousId(): string | undefined;
 export declare function getAnalyticsSessionId(): string | undefined;
 export declare function getFirstTouchAttribution(): FirstTouchAttribution | null;
+/**
+ * Store the visitor's first touch now instead of in `configureTracking()`,
+ * for a page that reads it before tracking starts. It runs once per page
+ * load, so tracking's own capture is then a no-op.
+ */
+export declare function captureAttribution(): void;
 export declare function setSentryUser(user: TrackingIdentityUser | null, orgId?: string | null): void;
 export declare function setTrackingIdentity(user: TrackingIdentityUser | null, orgId?: string | null): void;
 export interface ClientCaptureContext {

package/dist/client/analytics.js

@@ -1,6 +1,7 @@
 import { recordTrackingEvent } from "../observability/tracing.js";
 import { AGENT_NATIVE_LIFECYCLE_EVENTS, canonicalTrackingEvent, legacyLifecycleEvent, normalizeTrackingDimension, withCanonicalTrackingProperties, } from "../shared/analytics-events.js";
 import { ANALYTICS_CLIENT_PLATFORM_PROPERTY, } from "../shared/analytics-platform.js";
+import { resolveLaneEndpoint } from "../shared/environment-lanes.js";
 import { classifyErrorNoise, } from "../shared/error-noise.js";
 import { llmConnectionTrackingProperties, } from "../shared/llm-connection.js";
 import { loadOptionalPeer } from "../shared/optional-peer.js";
@@ -80,6 +81,8 @@ const FIRST_TOUCH_QUERY_FIELDS = [
     "gclid",
     "msclkid",
     "vector_source",
+    "site_referrer",
+    "site_landing_path",
 ];
 const FIRST_TOUCH_COOKIE_FIELD_PRIORITY = [
     "gclid",
@@ -94,6 +97,8 @@ const FIRST_TOUCH_COOKIE_FIELD_PRIORITY = [
     "utm_term",
     "landing_path",
     "landing_referrer",
+    "site_referrer",
+    "site_landing_path",
     "landed_at",
 ];
 let _firstTouchCaptured = false;
@@ -513,6 +518,16 @@ export function getFirstTouchAttribution() {
         return null;
     }
 }
+/**
+ * Store the visitor's first touch now instead of in `configureTracking()`,
+ * for a page that reads it before tracking starts. It runs once per page
+ * load, so tracking's own capture is then a no-op.
+ */
+export function captureAttribution() {
+    if (isSyntheticBrowserTraffic())
+        return;
+    captureFirstTouchAttribution();
+}
 function isLocalAnalyticsHostname(hostname) {
     const h = (hostname || "").toLowerCase();
     return (h === "localhost" ||
@@ -1696,11 +1711,11 @@ function sendAgentNativeAnalytics(name, properties) {
             ?.VITE_AGENT_NATIVE_ANALYTICS_PUBLIC_KEY;
     if (!publicKey)
         return;
-    const endpoint = _agentNativeAnalyticsEndpoint ||
+    const endpoint = resolveLaneEndpoint(_agentNativeAnalyticsEndpoint ||
         window.__AGENT_NATIVE_CONFIG__?.agentNativeAnalyticsEndpoint ||
         import.meta.env
             ?.VITE_AGENT_NATIVE_ANALYTICS_ENDPOINT ||
-        AGENT_NATIVE_ANALYTICS_DEFAULT_ENDPOINT;
+        AGENT_NATIVE_ANALYTICS_DEFAULT_ENDPOINT, window.location.hostname);
     const userId = typeof properties.userId === "string" ? properties.userId : undefined;
     const body = JSON.stringify({
         publicKey,