@agent-native/core 0.200.0-nightly-20261002124406 → 0.200.0

package/dist/search/tokenize.js

@@ -0,0 +1,367 @@
+/**
+ * Search tokens, computed in JavaScript for both the index and the query.
+ *
+ * Postgres's text parser depends on the database's locale: on some locales it
+ * drops Japanese text entirely, and PGlite and Neon don't agree. So core never
+ * asks Postgres to tokenize. It builds `tsvector` and `tsquery` literals
+ * itself, and the database only stores, indexes, and matches them. The same
+ * code tokenizes documents and queries, so they always agree.
+ *
+ * Rules:
+ * - Text is NFKC-normalized and lowercased. There is no stemming and there are
+ *   no stopwords.
+ * - A word is a run of letters, numbers, and combining marks. Everything else
+ *   separates words, so `snake_case`, `kebab-case`, URLs, and paths become
+ *   their parts at consecutive positions, and a query for the same text
+ *   matches them as a phrase.
+ * - A camelCase or PascalCase word is indexed whole and as its parts, so
+ *   "camelCase", "camel", and "case camel" all find it.
+ * - A word longer than Postgres's 2,046-byte limit keeps its longest prefix
+ *   that fits.
+ * - Chinese, Japanese, and Korean runs become overlapping character pairs,
+ *   because they have no spaces to split on. A query becomes the same pairs
+ *   as a phrase, which matches exactly that substring. A run's last character
+ *   starts no pair, so it is also indexed alone, and a one-character query
+ *   finds every character as a prefix.
+ */
+const WORD = /[\p{L}\p{N}\p{M}]+/gu;
+const CJK = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}]/u;
+const UPPERCASE = /\p{Lu}/u;
+const CAMEL_LOWER_UPPER = /([\p{Ll}\p{N}])(\p{Lu})/gu;
+const CAMEL_ACRONYM = /(\p{Lu})(\p{Lu}\p{Ll})/gu;
+/** Postgres limits, from tsvector.h. */
+const MAX_POSITION = 16_383;
+const MAX_POSITIONS_PER_LEXEME = 255;
+const MAX_LEXEME_BYTES = 2_046;
+/**
+ * Postgres evaluates a phrase recursively, one level per word, and a phrase
+ * of about 10,000 words exhausts the stack: native Postgres errors and PGlite
+ * silently returns no rows. `termTsquery` refuses a longer term.
+ */
+const MAX_QUERY_LEXEMES = 2_048;
+/**
+ * Budget for a vector's estimated size. Postgres rejects a vector whose
+ * lexemes alone take 1 MB, so this stays well under that.
+ */
+const MAX_VECTOR_BYTES = 900_000;
+/** Per-lexeme overhead: its entry and position count. */
+const LEXEME_OVERHEAD_BYTES = 6;
+/** One stored position. */
+const POSITION_BYTES = 2;
+/** Normalized form used for title and summary comparisons. */
+export function normalizeSearchText(value) {
+    return value.normalize("NFKC").trim().toLowerCase().replace(/\s+/g, " ");
+}
+function segments(word) {
+    if (!CJK.test(word))
+        return [{ text: word, cjk: false }];
+    const out = [];
+    for (const char of word) {
+        const cjk = CJK.test(char);
+        const last = out[out.length - 1];
+        if (last && last.cjk === cjk)
+            last.text += char;
+        else
+            out.push({ text: char, cjk });
+    }
+    return out;
+}
+function cjkPairs(text) {
+    const chars = Array.from(text);
+    if (chars.length < 2)
+        return chars;
+    const pairs = [];
+    for (let index = 0; index < chars.length - 1; index += 1) {
+        pairs.push(chars[index] + chars[index + 1]);
+    }
+    return pairs;
+}
+function camelParts(word) {
+    if (!UPPERCASE.test(word))
+        return [word];
+    return word
+        .replace(CAMEL_LOWER_UPPER, "$1\u0000$2")
+        .replace(CAMEL_ACRONYM, "$1\u0000$2")
+        .split("\u0000")
+        .filter(Boolean);
+}
+/** UTF-8 length without encoding: 1-3 bytes per UTF-16 unit, 4 per pair. */
+export function utf8ByteLength(value) {
+    let bytes = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
+            bytes += 4;
+            index += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+/**
+ * A word longer than Postgres allows keeps its longest prefix that fits, the
+ * same in documents and queries, so it still matches and still holds its
+ * place in a phrase.
+ */
+function fitLexeme(lexeme) {
+    if (lexeme.length * 3 <= MAX_LEXEME_BYTES)
+        return lexeme;
+    let bytes = 0;
+    let end = 0;
+    for (const char of lexeme) {
+        bytes += utf8ByteLength(char);
+        if (bytes > MAX_LEXEME_BYTES)
+            break;
+        end += char.length;
+    }
+    return lexeme.slice(0, end);
+}
+/**
+ * Document tokens with positions starting at `start`. Returns the next free
+ * position so several fields can share one position space.
+ */
+export function documentTokens(text, start = 1) {
+    const tokens = [];
+    const next = eachDocumentToken(text, start, (lexeme, position) => {
+        tokens.push({ lexeme, position });
+    });
+    return { tokens, next };
+}
+/**
+ * Calls `visit` with each document token, in order, without collecting
+ * them: a large document has millions. Returns the next free position.
+ */
+function eachDocumentToken(text, start, visit) {
+    let position = start;
+    const push = (lexeme, at) => visit(fitLexeme(lexeme), at);
+    for (const match of text.normalize("NFKC").matchAll(WORD)) {
+        for (const segment of segments(match[0])) {
+            if (segment.cjk) {
+                const pairs = cjkPairs(segment.text);
+                for (const pair of pairs)
+                    push(pair, position++);
+                // The last character also stands alone, at the last pair's position.
+                const last = Array.from(segment.text).at(-1);
+                if (pairs.at(-1) !== last)
+                    push(last, position - 1);
+                continue;
+            }
+            const parts = camelParts(segment.text);
+            const whole = segment.text.toLowerCase();
+            if (parts.length < 2) {
+                push(whole, position++);
+                continue;
+            }
+            // The whole word sits at its first and last part's positions, so a
+            // phrase can reach it from either side.
+            const first = position;
+            for (const part of parts)
+                push(part.toLowerCase(), position++);
+            push(whole, first);
+            push(whole, position - 1);
+        }
+    }
+    return position;
+}
+function queryWords(text) {
+    const words = [];
+    for (const match of text.normalize("NFKC").matchAll(WORD)) {
+        for (const segment of segments(match[0])) {
+            if (segment.cjk) {
+                for (const pair of cjkPairs(segment.text)) {
+                    words.push({ lexeme: pair, parts: [] });
+                }
+                continue;
+            }
+            const parts = camelParts(segment.text);
+            words.push({
+                lexeme: fitLexeme(segment.text.toLowerCase()),
+                parts: parts.length < 2
+                    ? []
+                    : parts.map((part) => fitLexeme(part.toLowerCase())),
+            });
+        }
+    }
+    return words;
+}
+/**
+ * Query lexemes for one term, in order. Unlike documents, a query word is
+ * never split on case: "camelCase" looks for the whole word, which documents
+ * index alongside its parts.
+ */
+export function queryLexemes(text) {
+    return queryWords(text).map((word) => word.lexeme);
+}
+function quoteLexeme(lexeme) {
+    return `'${lexeme.replace(/\\/g, "\\\\").replace(/'/g, "''")}'`;
+}
+/** Whether this entry starts a run of one weight; entries are in field order. */
+function startsWeightRun(list, index) {
+    return index === 0 || list[index].weight !== list[index - 1].weight;
+}
+/**
+ * Adds a word's next position within Postgres's 255. The word's first
+ * position in each field always stays, so it still counts as being in that
+ * field. Returns false when a position had to be dropped.
+ */
+function addPosition(list, entry) {
+    const previous = list[list.length - 1];
+    if (previous.position === entry.position && previous.weight === entry.weight)
+        return true;
+    if (list.length < MAX_POSITIONS_PER_LEXEME) {
+        list.push(entry);
+        return true;
+    }
+    if (previous.weight === entry.weight)
+        return false;
+    for (let index = list.length - 1; index > 0; index -= 1) {
+        if (!startsWeightRun(list, index)) {
+            list.splice(index, 1);
+            list.push(entry);
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * A `tsvector` for the fields, in order, sharing one position space with a
+ * gap between fields, so a phrase never spans two of them. Postgres keeps at
+ * most 255 positions per word and none past 16,383. Past the last position,
+ * each field's words collapse onto its own position, because Postgres merges
+ * equal positions and keeps only the higher weight. A word over 255
+ * positions keeps its first position in each field. A very large document
+ * keeps one position per word in each field, and one with more distinct
+ * words than fit keeps the words that come first, so the vector stays under
+ * Postgres's size limit. Any of these makes `positionsComplete` false; each
+ * keeps which fields hold each word.
+ */
+export function buildSearchVector(fields) {
+    const entries = new Map();
+    let position = 1;
+    let positionsComplete = true;
+    // The smallest the vector can be: each word once. A word past the budget
+    // can never be kept, so from then on new words aren't collected.
+    let minimumBytes = 0;
+    let full = false;
+    fields.forEach((field, fieldIndex) => {
+        if (!field.text)
+            return;
+        const ceiling = MAX_POSITION - (fields.length - 1 - fieldIndex);
+        const next = eachDocumentToken(field.text, position, (lexeme, at) => {
+            if (at > ceiling)
+                positionsComplete = false;
+            const entry = { position: Math.min(at, ceiling), weight: field.weight };
+            const list = entries.get(lexeme);
+            if (list) {
+                if (!addPosition(list, entry))
+                    positionsComplete = false;
+                return;
+            }
+            const bytes = utf8ByteLength(lexeme) + LEXEME_OVERHEAD_BYTES + POSITION_BYTES;
+            if (full || minimumBytes + bytes > MAX_VECTOR_BYTES) {
+                full = true;
+                return;
+            }
+            minimumBytes += bytes;
+            entries.set(lexeme, [entry]);
+        });
+        if (next > position)
+            position = next + 1;
+    });
+    let positionCount = 0;
+    for (const positions of entries.values())
+        positionCount += positions.length;
+    const keepAllPositions = minimumBytes + (positionCount - entries.size) * POSITION_BYTES <=
+        MAX_VECTOR_BYTES;
+    const parts = [];
+    let total = 0;
+    let keptEveryLexeme = !full;
+    for (const [lexeme, positions] of entries) {
+        const kept = keepAllPositions
+            ? positions
+            : positions.filter((_, index) => startsWeightRun(positions, index));
+        total +=
+            utf8ByteLength(lexeme) +
+                LEXEME_OVERHEAD_BYTES +
+                kept.length * POSITION_BYTES;
+        if (total > MAX_VECTOR_BYTES) {
+            keptEveryLexeme = false;
+            break;
+        }
+        parts.push(`${quoteLexeme(lexeme)}:${kept
+            .map((entry) => `${entry.position}${entry.weight}`)
+            .join(",")}`);
+    }
+    return {
+        literal: parts.join(" "),
+        positionsComplete: positionsComplete && keepAllPositions && keptEveryLexeme,
+    };
+}
+/**
+ * A term with more words than the index can match. The query can't be
+ * answered from the index; the app's fallback search can answer it.
+ */
+export class SearchTermTooLongError extends RangeError {
+    constructor() {
+        super(`A search term can have at most ${MAX_QUERY_LEXEMES} words.`);
+        this.name = "SearchTermTooLongError";
+    }
+}
+/**
+ * One term as a `tsquery` literal: a single lexeme, or a phrase of adjacent
+ * lexemes. Returns null when the term has nothing to match. Throws
+ * `SearchTermTooLongError` past `MAX_QUERY_LEXEMES`, which Postgres can't
+ * evaluate.
+ */
+export function termTsquery(text, options = {}) {
+    const words = queryWords(text);
+    if (!words.length)
+        return null;
+    const size = words.reduce((total, word) => total + 1 + word.parts.length, 0);
+    if (size > MAX_QUERY_LEXEMES)
+        throw new SearchTermTooLongError();
+    const weights = options.weights ?? "";
+    const operand = (lexeme, prefix) => {
+        const flags = (prefix && options.prefix ? "*" : "") + weights;
+        return flags ? `${quoteLexeme(lexeme)}:${flags}` : quoteLexeme(lexeme);
+    };
+    if (options.anyOrder) {
+        return [
+            ...new Set(words.map((word, index) => operand(word.lexeme, index === words.length - 1))),
+        ].join(" & ");
+    }
+    if (words.length === 1)
+        return operand(words[0].lexeme, true);
+    // Inside a phrase a camelCase word is its whole lexeme or its parts: the
+    // document holds the whole word only at its first and last part, so the
+    // whole alone can't span the parts between its neighbors.
+    return words
+        .map((word, index) => {
+        const last = index === words.length - 1;
+        const whole = operand(word.lexeme, last);
+        if (!word.parts.length)
+            return whole;
+        const parts = word.parts
+            .map((part, partIndex) => operand(part, last && partIndex === word.parts.length - 1))
+            .join(" <-> ");
+        return `(${whole} | ${parts})`;
+    })
+        .join(" <-> ");
+}
+/** Whether a term is more than one lexeme, so it matches as a phrase. */
+export function isPhraseTerm(text) {
+    return queryLexemes(text).length > 1;
+}
+export function anyOfTsquery(parts) {
+    const present = parts.filter((part) => !!part);
+    if (!present.length)
+        return null;
+    return present.length === 1
+        ? present[0]
+        : present.map((part) => `(${part})`).join(" | ");
+}

package/dist/server/action-change-marker-write.js

@@ -1,7 +1,8 @@
 import { publishActionChangeFastPath } from "../action-change-fast-path.js";
 import { ACTION_CHANGE_MARKER_KEY, actionChangeMarkerSession, actionChangeMarkerValue, } from "../action-change-marker.js";
 import { appStatePut } from "../application-state/store.js";
-import { getRequestOrgId, getRequestUserEmail } from "./request-context.js";
+import { runAfterWriteDrains } from "../resource-changes/store.js";
+import { getRequestOrgId, getRequestRunContext, getRequestUserEmail, } from "./request-context.js";
 export function actionChangeTarget(options) {
     const owner = options.owner ?? getRequestUserEmail() ?? undefined;
     return {
@@ -17,6 +18,9 @@ export async function writeActionChangeMarker(options) {
         nonce: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
     };
     const sessionId = actionChangeMarkerSession(target);
+    // The action changed data, so the database is awake: let change-feed
+    // consumers such as the search index catch up without delaying the caller.
+    runAfterWriteDrains(getRequestRunContext()?.waitUntil);
     if (!sessionId)
         return;
     publishActionChangeFastPath(target);

package/dist/server/agent-chat/run-code-tools.d.ts

@@ -3,4 +3,11 @@ import type { SandboxCodeEvaluator } from "../../coding-tools/run-code.js";
 export declare function loadRunCodeToolEntries(supplier: () => Record<string, ActionEntry>, runCodeOptions?: {
     bridgeTools?: string[];
     evaluator?: SandboxCodeEvaluator;
+    /**
+     * Names of actions the app defines itself. These entries are spread after
+     * the app's actions, so a same-named entry here would silently replace the
+     * app's version (and drop its `mcpTool` exposure). Leave those names to
+     * the app.
+     */
+    appActionNames?: Iterable<string>;
 }): Promise<Record<string, ActionEntry>>;

package/dist/server/agent-chat/run-code-tools.js

@@ -1,5 +1,12 @@
 import { getAppConfig } from "../../app-config/index.js";
 export async function loadRunCodeToolEntries(supplier, runCodeOptions) {
+    const entries = await createRunCodeToolEntries(supplier, runCodeOptions);
+    for (const name of runCodeOptions?.appActionNames ?? []) {
+        delete entries[name];
+    }
+    return entries;
+}
+async function createRunCodeToolEntries(supplier, runCodeOptions) {
     try {
         const { createRunCodeEntry, createGetCodeExecutionEntry } = await import("../../coding-tools/run-code.js");
         const { createToolOrchestrationEntry } = await import("../../coding-tools/tool-orchestration.js");

package/dist/server/agent-chat-plugin.d.ts

@@ -5,10 +5,14 @@ import { foldAssistantTurn, type ThreadSuggestionRun } from "../agent/thread-dat
 import type { AgentChatEvent, AgentChatScope } from "../agent/types.js";
 import { type QueuedMessage } from "../chat-threads/store.js";
 import type { ResolvedKeyReference } from "../secrets/substitution.js";
+import { type TrackingMeta } from "../tracking/registry.js";
 import { handleSharedThreadRequest, type SharedThreadRouteDependencies } from "./agent-chat/shared-thread.js";
 export { handleSharedThreadRequest };
 export type { SharedThreadRouteDependencies };
-export declare function trackAgentChatRunLifecycle(event: "run_started" | "run_finished" | "run_no_reply", threadId: string | undefined, attemptId: string | undefined, userId?: string, properties?: Record<string, unknown>, appId?: string): void;
+type AgentChatRunTrackingSource = Pick<TrackingMeta, "userId" | "authUserId" | "anonymousId" | "sessionId"> & {
+    isSyntheticTraffic?: boolean;
+};
+export declare function trackAgentChatRunLifecycle(event: "run_started" | "run_finished" | "run_no_reply", threadId: string | undefined, attemptId: string | undefined, userId?: string, properties?: Record<string, unknown>, appId?: string, trackingSource?: AgentChatRunTrackingSource): void;
 import { buildSelectedA2AReceiverContext, createA2AEngineToolSurface, DEFAULT_DELEGATED_MAX_ITERATIONS, DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKENS, DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS, isSelectedA2AReceiver, runA2AAgentLoop, runMCPAgentLoop, assembleA2AFinalResponse, buildPublicAgentA2ASkills } from "./agent-chat/action-filters-a2a.js";
 import { _agentChatPromptSectionsForTests } from "./agent-chat/framework-prompts.js";
 import { type AgentChatPluginOptions, type NitroPluginDef } from "./agent-chat/plugin-options.js";

package/dist/server/agent-chat-plugin.js

@@ -71,15 +71,18 @@ import { getModelFamilyOverlay } from "./prompts/index.js";
 import { mountRealtimeVoiceRoutes } from "./realtime-voice.js";
 import { runWithRequestContext, getRequestContext, getRequestOrgId, getRequestUserEmail, getRequestRunContext, ensureRequestRunContext, } from "./request-context.js";
 export { handleSharedThreadRequest };
-export function trackAgentChatRunLifecycle(event, threadId, attemptId, userId, properties = {}, appId) {
-    if (!threadId?.trim() || !attemptId?.trim())
+export function trackAgentChatRunLifecycle(event, threadId, attemptId, userId, properties = {}, appId, trackingSource) {
+    if (!threadId?.trim() ||
+        !attemptId?.trim() ||
+        trackingSource?.isSyntheticTraffic === true) {
         return;
+    }
     track(event, {
         ...properties,
         ...(appId ? { app_name: appId, template_name: appId } : {}),
         thread_id: threadId,
         attempt_id: attemptId,
-    }, runLifecycleTrackingSource(userId));
+    }, trackingSource ?? runLifecycleTrackingSource(userId));
 }
 /**
  * The run's owner is set on the run context only once its system prompt is
@@ -1392,6 +1395,7 @@ export function createAgentChatPlugin(options) {
             () => filterRuntimeActionsToSurface(prodRunCodeToolActions), {
                 bridgeTools: options?.codeExecution?.bridgeTools,
                 evaluator: productionEvaluator,
+                appActionNames: Object.keys(templateScriptsAll),
             });
             const leanRunCodeTool = await loadRunCodeToolEntries(
             // Lean prompt mode intentionally exposes a much smaller action
@@ -1399,6 +1403,7 @@ export function createAgentChatPlugin(options) {
             () => filterRuntimeActionsToSurface(leanRunCodeToolActions), {
                 bridgeTools: options?.codeExecution?.bridgeTools,
                 evaluator: productionEvaluator,
+                appActionNames: Object.keys(templateScriptsAll),
             });
             // Full coding tool registry (bash/read/edit/write) for "trusted" prod.
             // In dev mode this is handled separately via devHandler below.
@@ -1431,6 +1436,7 @@ export function createAgentChatPlugin(options) {
                 ? await loadRunCodeToolEntries(() => filterRuntimeActionsToSurface(devRunCodeToolActions), {
                     bridgeTools: options?.codeExecution?.bridgeTools,
                     evaluator: "node",
+                    appActionNames: Object.keys(templateScriptsAll),
                 })
                 : {};
             // Registry `generateCorpusToolsPrompt` (below) reads from to decide what
@@ -2656,7 +2662,7 @@ export function createAgentChatPlugin(options) {
             }
             // Callback to persist agent response when run finishes (even if client disconnected).
             // Reconstructs the assistant message from buffered events and appends to thread_data.
-            const onRunComplete = async (run, threadId) => {
+            const onRunComplete = async (run, threadId, trackingSource) => {
                 const runThreadId = String(run?.threadId ?? threadId ?? "");
                 const chatScope = getRequestRunContext()?.chatScope;
                 const assistantMsg = buildAssistantMessage(run.events ?? [], run.runId, {
@@ -2682,9 +2688,9 @@ export function createAgentChatPlugin(options) {
                     ...(failureCode?.type === "error"
                         ? { failure_code: failureCode.errorCode ?? "unknown" }
                         : {}),
-                }, options?.appId);
+                }, options?.appId, trackingSource);
                 if (!assistantMsg) {
-                    trackAgentChatRunLifecycle("run_no_reply", runThreadId || undefined, run.runId, getRequestRunContext()?.owner, {}, options?.appId);
+                    trackAgentChatRunLifecycle("run_no_reply", runThreadId || undefined, run.runId, getRequestRunContext()?.owner, {}, options?.appId, trackingSource);
                 }
                 if (!threadId) {
                     if (runThreadId)
@@ -3535,10 +3541,10 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     trackAgentChatRunLifecycle("run_started", threadId, runId, runCtx?.owner, {}, options?.appId);
                     await runPreAgentTurnAutosave(options?.onAgentTurnStart, runCtx?.chatScope, { threadId, runId });
                 },
-                onRunComplete: async (run, threadId) => {
+                onRunComplete: async (run, threadId, trackingSource) => {
                     if (threadId)
                         _runSendByThread.delete(threadId);
-                    await onRunComplete(run, threadId);
+                    await onRunComplete(run, threadId, trackingSource);
                 },
                 resolveAdditionalActions: ({ ownerEmail, orgId }) => getMcpActionEntriesForPrincipal(ownerEmail, orgId),
                 // Resolve owner from session for usage attribution in hosted prod
@@ -3588,10 +3594,10 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         }
                         trackAgentChatRunLifecycle("run_started", threadId, runId, runCtx?.owner, {}, options?.appId);
                     },
-                    onRunComplete: async (run, threadId) => {
+                    onRunComplete: async (run, threadId, trackingSource) => {
                         if (threadId)
                             _runSendByThread.delete(threadId);
-                        await onRunComplete(run, threadId);
+                        await onRunComplete(run, threadId, trackingSource);
                     },
                     resolveOwnerEmail: getOwnerFromEvent,
                 })
@@ -3790,10 +3796,10 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         trackAgentChatRunLifecycle("run_started", threadId, runId, runCtx?.owner, {}, options?.appId);
                         await runPreAgentTurnAutosave(options?.onAgentTurnStart, runCtx?.chatScope, { threadId, runId });
                     },
-                    onRunComplete: async (run, threadId) => {
+                    onRunComplete: async (run, threadId, trackingSource) => {
                         if (threadId)
                             _runSendByThread.delete(threadId);
-                        await onRunComplete(run, threadId);
+                        await onRunComplete(run, threadId, trackingSource);
                     },
                 });
             }

package/dist/server/agent-engine-api-key-route.d.ts

@@ -66,12 +66,12 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     code: any;
 } | {
     errorCode?: undefined;
-    error?: undefined;
     code?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
+    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,17 +8,17 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
     scope?: undefined;
 } | {
     ok: boolean;
     error: any;
     scope?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     scope: "org" | "user";
-    error?: undefined;
 }>>;
 export interface DefaultModelSelectionRequest {
     engine: string;

package/dist/server/release-schema.js

@@ -221,6 +221,10 @@ const FRAMEWORK_SCHEMA_ENSURES = [
         "RemoteRunEvents",
         () => import("../integrations/remote-run-events-store.js").then((m) => m.ensureTable()),
     ],
+    [
+        "ResourceChanges",
+        () => import("../resource-changes/store.js").then((m) => m.ensureResourceChangeTables()),
+    ],
     [
         "ResourceVersions",
         () => import("../history/store.js").then((m) => m.ensureResourceVersionsTable()),
@@ -245,6 +249,10 @@ const FRAMEWORK_SCHEMA_ENSURES = [
         "SchedulerHealth",
         () => import("../jobs/scheduler-health.js").then((m) => m.ensureHealthTable()),
     ],
+    [
+        "SearchIndex",
+        () => import("../search/index-store.js").then((m) => m.ensureSearchIndexTables()),
+    ],
     [
         "Settings",
         () => import("../settings/store.js").then((m) => m.ensureTable()),

package/dist/triggers/actions/manage-automation.d.ts

@@ -14,7 +14,6 @@ declare const _default: import("../../action.js").ActionDefinition<{
     executionCwd?: string;
 }, {
     deleted?: undefined;
-    enabled?: undefined;
     created: boolean;
     name: string;
     scope: "organization" | "personal";
@@ -25,24 +24,25 @@ declare const _default: import("../../action.js").ActionDefinition<{
     reasoningEffort: "auto" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh";
     webhookPath: string;
     nextRun: string;
+    enabled?: undefined;
     executionHostId?: undefined;
     executionEngine?: undefined;
     executionCwd?: undefined;
 } | {
-    enabled?: undefined;
-    nextRun?: undefined;
     created?: undefined;
     scope?: undefined;
     triggerType?: undefined;
     event?: undefined;
     deleted: boolean;
     name: string;
+    enabled?: undefined;
     schedule?: undefined;
     timezone?: undefined;
     reasoningEffort?: undefined;
     executionHostId?: undefined;
     executionEngine?: undefined;
     executionCwd?: undefined;
+    nextRun?: undefined;
     webhookPath?: undefined;
 } | {
     deleted?: undefined;