@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/actions/context-signal-lexicon.d.ts

@@ -0,0 +1,17 @@
+import { type CharacterLanguage } from "@elizaos/shared";
+export type ContextSignalKey = "affirmative" | "calendar" | "draft_edit" | "gmail" | "link_entity" | "lifeops" | "lifeops_cadence" | "lifeops_complete" | "lifeops_delete" | "lifeops_escalation" | "lifeops_goal" | "lifeops_overview" | "lifeops_phone" | "lifeops_reminder_pref" | "lifeops_review" | "lifeops_skip" | "lifeops_snooze" | "lifeops_update" | "negative" | "read_channel" | "read_messages" | "search_conversations" | "search_entity" | "send_message" | "stream_control" | "temporal_followup" | "temporal_next" | "web_search";
+export type ContextSignalStrength = "strong" | "weak";
+export type ResolvedContextSignalSpec = {
+    locale: CharacterLanguage;
+    contextLimit: number;
+    strongTerms: string[];
+    weakTerms: string[];
+};
+export declare function resolveContextSignalSpec(key: ContextSignalKey, localeInput?: unknown, options?: {
+    includeAllLocales?: boolean;
+}): ResolvedContextSignalSpec;
+export declare function getContextSignalTerms(key: ContextSignalKey, strength: ContextSignalStrength, options?: {
+    includeAllLocales?: boolean;
+    locale?: unknown;
+}): string[];
+//# sourceMappingURL=context-signal-lexicon.d.ts.map

package/packages/agent/src/actions/context-signal-lexicon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-signal-lexicon.d.ts","sourceRoot":"","sources":["../../../../../src/actions/context-signal-lexicon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,UAAU,GACV,YAAY,GACZ,OAAO,GACP,aAAa,GACb,SAAS,GACT,iBAAiB,GACjB,kBAAkB,GAClB,gBAAgB,GAChB,oBAAoB,GACpB,cAAc,GACd,kBAAkB,GAClB,eAAe,GACf,uBAAuB,GACvB,gBAAgB,GAChB,cAAc,GACd,gBAAgB,GAChB,gBAAgB,GAChB,UAAU,GACV,cAAc,GACd,eAAe,GACf,sBAAsB,GACtB,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,GACf,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAUtD,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAmLF,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,gBAAgB,EACrB,WAAW,CAAC,EAAE,OAAO,EACrB,OAAO,CAAC,EAAE;IACR,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,GACA,yBAAyB,CAmB3B;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,CAAC,EAAE;IACR,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GACA,MAAM,EAAE,CAYV"}

package/packages/agent/src/actions/context-signal-lexicon.js

@@ -0,0 +1,206 @@
+import { getValidationKeywordTerms, normalizeCharacterLanguage, } from "@elizaos/shared";
+const DEFAULT_CONTEXT_LIMIT = 8;
+const CONTEXT_SIGNAL_SPECS = {
+    affirmative: {
+        contextLimit: 4,
+        keywordKeys: {
+            strong: "contextSignal.affirmative.strong",
+        },
+    },
+    draft_edit: {
+        contextLimit: 4,
+        keywordKeys: {
+            strong: "contextSignal.draft_edit.strong",
+        },
+    },
+    negative: {
+        contextLimit: 4,
+        keywordKeys: {
+            strong: "contextSignal.negative.strong",
+        },
+    },
+    temporal_followup: {
+        contextLimit: 6,
+        keywordKeys: {
+            strong: "contextSignal.temporal_followup.strong",
+        },
+    },
+    temporal_next: {
+        contextLimit: 6,
+        keywordKeys: {
+            strong: "contextSignal.temporal_next.strong",
+        },
+    },
+    gmail: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.gmail.strong",
+            weak: "contextSignal.gmail.weak",
+        },
+    },
+    lifeops: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops.strong",
+            weak: "contextSignal.lifeops.weak",
+        },
+    },
+    lifeops_cadence: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_cadence.strong",
+        },
+    },
+    lifeops_complete: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_complete.strong",
+        },
+    },
+    lifeops_delete: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_delete.strong",
+        },
+    },
+    lifeops_overview: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_overview.strong",
+        },
+    },
+    lifeops_reminder_pref: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_reminder_pref.strong",
+        },
+    },
+    lifeops_skip: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_skip.strong",
+        },
+    },
+    lifeops_snooze: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_snooze.strong",
+        },
+    },
+    lifeops_escalation: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_escalation.strong",
+        },
+    },
+    lifeops_goal: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_goal.strong",
+        },
+    },
+    lifeops_phone: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_phone.strong",
+        },
+    },
+    lifeops_review: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_review.strong",
+        },
+    },
+    lifeops_update: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.lifeops_update.strong",
+        },
+    },
+    link_entity: {
+        contextLimit: 8,
+        keywordKeys: {
+            strong: "contextSignal.link_entity.strong",
+        },
+    },
+    calendar: {
+        contextLimit: 12,
+        keywordKeys: {
+            strong: "contextSignal.calendar.strong",
+            weak: "contextSignal.calendar.weak",
+        },
+    },
+    web_search: {
+        contextLimit: 6,
+        keywordKeys: {
+            strong: "contextSignal.web_search.strong",
+            weak: "contextSignal.web_search.weak",
+        },
+    },
+    send_message: {
+        keywordKeys: {
+            strong: "contextSignal.send_message.strong",
+            weak: "contextSignal.send_message.weak",
+        },
+    },
+    search_conversations: {
+        keywordKeys: {
+            strong: "contextSignal.search_conversations.strong",
+            weak: "contextSignal.search_conversations.weak",
+        },
+    },
+    read_channel: {
+        keywordKeys: {
+            strong: "contextSignal.read_channel.strong",
+            weak: "contextSignal.read_channel.weak",
+        },
+    },
+    read_messages: {
+        keywordKeys: {
+            strong: "contextSignal.read_messages.strong",
+            weak: "contextSignal.read_messages.weak",
+        },
+    },
+    stream_control: {
+        keywordKeys: {
+            strong: "contextSignal.stream_control.strong",
+            weak: "contextSignal.stream_control.weak",
+        },
+    },
+    search_entity: {
+        keywordKeys: {
+            strong: "contextSignal.search_entity.strong",
+            weak: "contextSignal.search_entity.weak",
+        },
+    },
+};
+export function resolveContextSignalSpec(key, localeInput, options) {
+    const locale = normalizeCharacterLanguage(localeInput);
+    const spec = CONTEXT_SIGNAL_SPECS[key];
+    const includeAllLocales = options?.includeAllLocales ?? false;
+    return {
+        locale,
+        contextLimit: spec.contextLimit ?? DEFAULT_CONTEXT_LIMIT,
+        strongTerms: getValidationKeywordTerms(spec.keywordKeys.strong, {
+            includeAllLocales,
+            locale,
+        }),
+        weakTerms: spec.keywordKeys.weak
+            ? getValidationKeywordTerms(spec.keywordKeys.weak, {
+                includeAllLocales,
+                locale,
+            })
+            : [],
+    };
+}
+export function getContextSignalTerms(key, strength, options) {
+    const spec = CONTEXT_SIGNAL_SPECS[key];
+    const keywordKey = strength === "strong" ? spec.keywordKeys.strong : spec.keywordKeys.weak;
+    if (!keywordKey) {
+        return [];
+    }
+    return getValidationKeywordTerms(keywordKey, {
+        includeAllLocales: options?.includeAllLocales ?? false,
+        locale: options?.locale,
+    });
+}

package/packages/agent/src/actions/context-signal.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared context-signal validation helpers for action `validate()` functions.
+ *
+ * Actions that are only relevant when the recent conversation mentions certain
+ * keywords can use these helpers to avoid bloating the LLM action context on
+ * every turn.
+ *
+ * A single keyword match (strong or weak) is always enough to activate.
+ * False positives are cheap (extra action in the LLM menu); false negatives
+ * are expensive (action unavailable when needed).
+ *
+ * @module actions/context-signal
+ */
+import { type AgentContext, type Memory, type State } from "@elizaos/core";
+import { collectKeywordTermMatches, textIncludesKeywordTerm } from "@elizaos/shared";
+import { type ContextSignalKey } from "./context-signal-lexicon.ts";
+import { recentConversationTexts as collectRecentConversationTexts } from "./recent-conversation-texts.ts";
+export { collectKeywordTermMatches, textIncludesKeywordTerm };
+export declare function collectKeywordTermMatchesForKey(texts: string[], key: ContextSignalKey, options?: {
+    includeAllLocales?: boolean;
+    locale?: unknown;
+    strength?: "strong" | "weak";
+}): Set<string>;
+export declare function messageText(message: Memory): string;
+/**
+ * Fast synchronous signal check using only `state` (no DB round-trip).
+ * Returns true if ANY strong or weak term matches in the current message
+ * or recent conversation.
+ */
+export declare function hasContextSignalSync(message: Memory, state: State | undefined, strongTerms: readonly string[], weakTerms?: readonly string[], contextLimit?: number): boolean;
+export declare function hasContextSignalSyncForKey(message: Memory, state: State | undefined, key: ContextSignalKey, options?: {
+    contextLimit?: number;
+    includeAllLocales?: boolean;
+    locale?: unknown;
+}): boolean;
+export declare function hasSelectedActionContext(message: Memory, state: State | undefined, actionContexts: readonly AgentContext[]): boolean;
+export declare function hasSelectedContextOrSignalSync(message: Memory, state: State | undefined, actionContexts: readonly AgentContext[], strongTerms: readonly string[], weakTerms?: readonly string[], contextLimit?: number): boolean;
+/**
+ * Full async signal check with DB memory fallback.
+ * Returns true if ANY strong or weak term matches.
+ */
+export declare function hasContextSignal(runtime: Parameters<typeof collectRecentConversationTexts>[0]["runtime"], message: Memory, state: State | undefined, strongTerms: readonly string[], weakTerms?: readonly string[], contextLimit?: number): Promise<boolean>;
+export declare function hasContextSignalForKey(runtime: Parameters<typeof collectRecentConversationTexts>[0]["runtime"], message: Memory, state: State | undefined, key: ContextSignalKey, options?: {
+    contextLimit?: number;
+    includeAllLocales?: boolean;
+    locale?: unknown;
+}): Promise<boolean>;
+//# sourceMappingURL=context-signal.d.ts.map

package/packages/agent/src/actions/context-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-signal.d.ts","sourceRoot":"","sources":["../../../../../src/actions/context-signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,MAAM,EACX,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,uBAAuB,IAAI,8BAA8B,EAE1D,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,CAAC;AA6D9D,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE;IACR,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CAC9B,GACA,GAAG,CAAC,MAAM,CAAC,CAMb;AAID,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKnD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,SAAS,GAAE,SAAS,MAAM,EAAO,EACjC,YAAY,SAAI,GACf,OAAO,CAuBT;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GACA,OAAO,CAYT;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,cAAc,EAAE,SAAS,YAAY,EAAE,GACtC,OAAO,CAeT;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,cAAc,EAAE,SAAS,YAAY,EAAE,EACvC,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,SAAS,GAAE,SAAS,MAAM,EAAO,EACjC,YAAY,SAAI,GACf,OAAO,CAWT;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,EACxE,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,SAAS,GAAE,SAAS,MAAM,EAAO,EACjC,YAAY,SAAI,GACf,OAAO,CAAC,OAAO,CAAC,CAkClB;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,EACxE,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GACA,OAAO,CAAC,OAAO,CAAC,CAiBlB"}

package/packages/agent/src/actions/context-signal.js

@@ -0,0 +1,153 @@
+/**
+ * Shared context-signal validation helpers for action `validate()` functions.
+ *
+ * Actions that are only relevant when the recent conversation mentions certain
+ * keywords can use these helpers to avoid bloating the LLM action context on
+ * every turn.
+ *
+ * A single keyword match (strong or weak) is always enough to activate.
+ * False positives are cheap (extra action in the LLM menu); false negatives
+ * are expensive (action unavailable when needed).
+ *
+ * @module actions/context-signal
+ */
+import { getActiveRoutingContextsForTurn, } from "@elizaos/core";
+import { collectKeywordTermMatches, textIncludesKeywordTerm, } from "@elizaos/shared";
+import { getContextSignalTerms, resolveContextSignalSpec, } from "./context-signal-lexicon.js";
+import { recentConversationTexts as collectRecentConversationTexts, recentConversationTextsFromState, } from "./recent-conversation-texts.js";
+export { collectKeywordTermMatches, textIncludesKeywordTerm };
+function resolveContextSignalLocale(runtime, state, localeOverride) {
+    if (localeOverride !== undefined) {
+        return localeOverride;
+    }
+    const stateRecord = state && typeof state === "object"
+        ? state
+        : undefined;
+    const values = stateRecord?.values && typeof stateRecord.values === "object"
+        ? stateRecord.values
+        : undefined;
+    const config = stateRecord?.config && typeof stateRecord.config === "object"
+        ? stateRecord.config
+        : undefined;
+    const ui = config?.ui && typeof config.ui === "object"
+        ? config.ui
+        : undefined;
+    const runtimeCharacter = runtime?.character && typeof runtime.character === "object"
+        ? runtime.character
+        : undefined;
+    const runtimeSettings = runtimeCharacter?.settings && typeof runtimeCharacter.settings === "object"
+        ? runtimeCharacter.settings
+        : undefined;
+    const runtimeUi = runtimeSettings?.ui && typeof runtimeSettings.ui === "object"
+        ? runtimeSettings.ui
+        : undefined;
+    return [
+        values?.preferredLanguage,
+        values?.language,
+        stateRecord?.preferredLanguage,
+        ui?.language,
+        runtimeUi?.language,
+        runtimeSettings?.language,
+        runtime?.getSetting?.("preferredLanguage"),
+        runtime?.getSetting?.("language"),
+        runtime?.getSetting?.("ui.language"),
+    ].find((candidate) => typeof candidate === "string" && candidate.trim().length > 0);
+}
+export function collectKeywordTermMatchesForKey(texts, key, options) {
+    const strength = options?.strength ?? "strong";
+    return collectKeywordTermMatches(texts, getContextSignalTerms(key, strength, options));
+}
+// ── Public API ───────────────────────────────────────────────────────────
+export function messageText(message) {
+    const content = message?.content;
+    if (!content)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return typeof content.text === "string" ? content.text : "";
+}
+/**
+ * Fast synchronous signal check using only `state` (no DB round-trip).
+ * Returns true if ANY strong or weak term matches in the current message
+ * or recent conversation.
+ */
+export function hasContextSignalSync(message, state, strongTerms, weakTerms = [], contextLimit = 8) {
+    const texts = [
+        ...recentConversationTextsFromState(state, contextLimit),
+        messageText(message).trim(),
+    ].filter((t) => t.length > 0);
+    if (texts.length === 0)
+        return false;
+    if (strongTerms.length > 0 &&
+        collectKeywordTermMatches(texts, strongTerms).size > 0) {
+        return true;
+    }
+    if (weakTerms.length > 0 &&
+        collectKeywordTermMatches(texts, weakTerms).size > 0) {
+        return true;
+    }
+    return false;
+}
+export function hasContextSignalSyncForKey(message, state, key, options) {
+    const locale = resolveContextSignalLocale(null, state, options?.locale);
+    const spec = resolveContextSignalSpec(key, locale, {
+        includeAllLocales: options?.includeAllLocales ?? true,
+    });
+    return hasContextSignalSync(message, state, spec.strongTerms, spec.weakTerms, options?.contextLimit ?? spec.contextLimit);
+}
+export function hasSelectedActionContext(message, state, actionContexts) {
+    const actionContextIds = actionContexts
+        .map((context) => `${context}`.toLowerCase())
+        .filter((context) => context !== "general" && !context.startsWith("page"));
+    if (actionContextIds.length === 0) {
+        return false;
+    }
+    const activeContexts = new Set(getActiveRoutingContextsForTurn(state, message)
+        .map((context) => `${context}`.toLowerCase())
+        .filter((context) => context !== "general" && !context.startsWith("page")));
+    return actionContextIds.some((context) => activeContexts.has(context));
+}
+export function hasSelectedContextOrSignalSync(message, state, actionContexts, strongTerms, weakTerms = [], contextLimit = 8) {
+    if (hasSelectedActionContext(message, state, actionContexts)) {
+        return true;
+    }
+    return hasContextSignalSync(message, state, strongTerms, weakTerms, contextLimit);
+}
+/**
+ * Full async signal check with DB memory fallback.
+ * Returns true if ANY strong or weak term matches.
+ */
+export async function hasContextSignal(runtime, message, state, strongTerms, weakTerms = [], contextLimit = 8) {
+    const stateTexts = recentConversationTextsFromState(state, contextLimit);
+    let texts;
+    if (stateTexts.length >= contextLimit) {
+        texts = stateTexts;
+    }
+    else {
+        texts = await collectRecentConversationTexts({
+            runtime,
+            message,
+            state,
+            limit: contextLimit,
+        });
+    }
+    texts = [...texts, messageText(message).trim()].filter((t) => t.length > 0);
+    if (texts.length === 0)
+        return false;
+    if (strongTerms.length > 0 &&
+        collectKeywordTermMatches(texts, strongTerms).size > 0) {
+        return true;
+    }
+    if (weakTerms.length > 0 &&
+        collectKeywordTermMatches(texts, weakTerms).size > 0) {
+        return true;
+    }
+    return false;
+}
+export async function hasContextSignalForKey(runtime, message, state, key, options) {
+    const locale = resolveContextSignalLocale(runtime, state, options?.locale);
+    const spec = resolveContextSignalSpec(key, locale, {
+        includeAllLocales: options?.includeAllLocales ?? true,
+    });
+    return hasContextSignal(runtime, message, state, spec.strongTerms, spec.weakTerms, options?.contextLimit ?? spec.contextLimit);
+}

package/packages/agent/src/actions/database.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Polymorphic DATABASE action.
+ *
+ * Single action that dispatches across the database introspection ops:
+ *   - list_tables    : enumerate user tables with row counts and columns.
+ *   - get_table      : page rows from a specific table (limit/offset/sort).
+ *   - query          : execute raw SQL (read-only by default).
+ *   - search_vectors : embed text and return top-k semantic memory matches.
+ *
+ * All ops talk directly to the in-process runtime adapter (Drizzle ORM via
+ * `runtime.adapter.db`) and `runtime.searchMemories` / `runtime.useModel`.
+ * No HTTP. The previous LIST_DATABASE_TABLES / GET_TABLE_DATA /
+ * EXECUTE_DATABASE_QUERY / SEARCH_VECTORS actions hit /api/database/* — that
+ * server route layer is still used by the dashboard UI but is now bypassed
+ * for the agent's own tool surface.
+ */
+import type { Action, IAgentRuntime } from "@elizaos/core";
+export declare function registerVectorSearchCategory(runtime: IAgentRuntime): void;
+export declare const databaseAction: Action;
+//# sourceMappingURL=database.d.ts.map

package/packages/agent/src/actions/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../../../src/actions/database.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EACV,MAAM,EAGN,aAAa,EAGd,MAAM,eAAe,CAAC;AA8RvB,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAIzE;AAuYD,eAAO,MAAM,cAAc,EAAE,MA6J5B,CAAC"}