@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/services/knowledge-graph/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/services/knowledge-graph/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAYH,eAAO,MAAM,kBAAkB,uDAA0B,CAAC;AAE1D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBxB,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBhC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBhC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuC/B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBvC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMvB,CAAC"}

package/services/knowledge-graph/schema.js

@@ -0,0 +1,119 @@
+/**
+ * Runtime-owned knowledge-graph schema: entities + typed relationships.
+ *
+ * These tables back the runtime `KnowledgeGraphService`. They live under the
+ * `app_lifeops` Postgres schema (the historical home) so the physical tables
+ * are unchanged — ownership moved from `@elizaos/plugin-personal-assistant`
+ * to the runtime, but no data migration or rename is involved.
+ *
+ * `life_entities` stores nodes (person, organization, place, project,
+ * concept, ...). Per-connector identity claims are stored in
+ * `life_entity_identities`; open-keyed extracted attributes in
+ * `life_entity_attributes`. The `(agent_id, entity_id)` pair is unique;
+ * `entityId === "self"` is the special user node.
+ *
+ * `life_relationships_v2` stores typed edges. `(agent_id, from_entity_id,
+ * to_entity_id, type)` is unique for active edges (a retired edge of the
+ * same triple may co-exist with a new active one). `cadence_days` is
+ * surfaced as a column-level shortcut for the cadence-overdue filter even
+ * though it also appears inside `metadata_json`.
+ */
+import { boolean, index, integer, pgSchema, real, text, unique, } from "drizzle-orm/pg-core";
+export const appLifeopsPgSchema = pgSchema("app_lifeops");
+export const lifeEntities = appLifeopsPgSchema.table("life_entities", {
+    entityId: text("entity_id").notNull(),
+    agentId: text("agent_id").notNull(),
+    type: text("type").notNull(),
+    preferredName: text("preferred_name").notNull(),
+    fullName: text("full_name"),
+    tagsJson: text("tags_json").notNull().default("[]"),
+    visibility: text("visibility").notNull().default("owner_agent_admin"),
+    stateLastObservedAt: text("state_last_observed_at"),
+    stateLastInboundAt: text("state_last_inbound_at"),
+    stateLastOutboundAt: text("state_last_outbound_at"),
+    stateLastInteractionPlatform: text("state_last_interaction_platform"),
+    legacyRelationshipId: text("legacy_relationship_id"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (t) => [
+    unique().on(t.agentId, t.entityId),
+    index("life_entities_agent_type_idx").on(t.agentId, t.type),
+    index("life_entities_agent_name_idx").on(t.agentId, t.preferredName),
+]);
+export const lifeEntityIdentities = appLifeopsPgSchema.table("life_entity_identities", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    entityId: text("entity_id").notNull(),
+    platform: text("platform").notNull(),
+    handle: text("handle").notNull(),
+    displayName: text("display_name"),
+    verified: boolean("verified").notNull().default(false),
+    confidence: real("confidence").notNull().default(0),
+    addedAt: text("added_at").notNull(),
+    addedVia: text("added_via").notNull(),
+    evidenceJson: text("evidence_json").notNull().default("[]"),
+}, (t) => [
+    unique().on(t.agentId, t.entityId, t.platform, t.handle),
+    index("life_entity_identities_lookup_idx").on(t.agentId, t.platform, t.handle),
+]);
+export const lifeEntityAttributes = appLifeopsPgSchema.table("life_entity_attributes", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    entityId: text("entity_id").notNull(),
+    key: text("key").notNull(),
+    valueJson: text("value_json").notNull().default("null"),
+    confidence: real("confidence").notNull().default(0),
+    evidenceJson: text("evidence_json").notNull().default("[]"),
+    updatedAt: text("updated_at").notNull(),
+}, (t) => [
+    unique().on(t.agentId, t.entityId, t.key),
+    index("life_entity_attributes_lookup_idx").on(t.agentId, t.entityId),
+]);
+export const lifeRelationshipsV2 = appLifeopsPgSchema.table("life_relationships_v2", {
+    relationshipId: text("relationship_id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    fromEntityId: text("from_entity_id").notNull(),
+    toEntityId: text("to_entity_id").notNull(),
+    type: text("type").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    cadenceDays: integer("cadence_days"),
+    stateLastObservedAt: text("state_last_observed_at"),
+    stateLastInteractionAt: text("state_last_interaction_at"),
+    stateInteractionCount: integer("state_interaction_count")
+        .notNull()
+        .default(0),
+    stateSentimentTrend: text("state_sentiment_trend"),
+    evidenceJson: text("evidence_json").notNull().default("[]"),
+    confidence: real("confidence").notNull().default(0),
+    source: text("source").notNull(),
+    status: text("status").notNull().default("active"),
+    retiredAt: text("retired_at"),
+    retiredReason: text("retired_reason"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (t) => [
+    index("life_relationships_v2_edge_idx").on(t.agentId, t.fromEntityId, t.toEntityId, t.type),
+    index("life_relationships_v2_to_idx").on(t.agentId, t.toEntityId),
+    index("life_relationships_v2_cadence_idx").on(t.agentId, t.cadenceDays, t.stateLastInteractionAt),
+]);
+export const lifeRelationshipAuditEvents = appLifeopsPgSchema.table("life_relationship_audit_events", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    relationshipId: text("relationship_id").notNull(),
+    kind: text("kind").notNull(),
+    detailsJson: text("details_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+}, (t) => [
+    index("life_relationship_audit_events_lookup_idx").on(t.agentId, t.relationshipId),
+]);
+/**
+ * Aggregate schema registered by the runtime "eliza" plugin so the SQL
+ * plugin migrates these tables whenever the runtime runs.
+ */
+export const knowledgeGraphSchema = {
+    lifeEntities,
+    lifeEntityIdentities,
+    lifeEntityAttributes,
+    lifeRelationshipsV2,
+    lifeRelationshipAuditEvents,
+};

package/services/knowledge-graph/service.d.ts

@@ -0,0 +1,35 @@
+/**
+ * KnowledgeGraphService — the runtime-owned entity/relationship knowledge
+ * graph, exposed as a registered runtime service.
+ *
+ * The graph is a runtime primitive: any plugin (LifeOps, relationships
+ * viewer, …) consumes it via `runtime.getService(...)` rather than
+ * constructing the DB-backed stores itself. The service is a thin factory
+ * over the per-agent {@link EntityStore} / {@link RelationshipStore}; the
+ * `agentId` is the multi-tenant partition key and defaults to
+ * `runtime.agentId`.
+ */
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import { EntityStore } from "./entity-store.ts";
+import { RelationshipStore } from "./relationship-store.ts";
+export declare const KNOWLEDGE_GRAPH_SERVICE = "eliza_knowledge_graph";
+export declare class KnowledgeGraphService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    static start(runtime: IAgentRuntime): Promise<KnowledgeGraphService>;
+    stop(): Promise<void>;
+    /**
+     * Per-agent entity store. `agentId` partitions the graph; it defaults to
+     * the runtime's agent id and may be overridden for admin/multi-tenant
+     * access (e.g. an admin entity inspecting another agent's graph).
+     */
+    getEntityStore(agentId?: string): EntityStore;
+    /** Per-agent typed-edge store. See {@link getEntityStore} for `agentId`. */
+    getRelationshipStore(agentId?: string): RelationshipStore;
+}
+/**
+ * Resolve the registered {@link KnowledgeGraphService}. Returns `null` when
+ * the runtime has not registered it (e.g. the "eliza" plugin is absent).
+ */
+export declare function resolveKnowledgeGraphService(runtime: IAgentRuntime): KnowledgeGraphService | null;
+//# sourceMappingURL=service.d.ts.map

package/services/knowledge-graph/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/services/knowledge-graph/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,eAAO,MAAM,uBAAuB,0BAA0B,CAAC;AAE/D,qBAAa,qBAAsB,SAAQ,OAAO;IAChD,OAAgB,WAAW,SAA2B;IAE7C,qBAAqB,SACkF;WAEnG,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIpE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAE3B;;;;OAIG;IACH,cAAc,CAAC,OAAO,GAAE,MAA6B,GAAG,WAAW;IAInE,4EAA4E;IAC5E,oBAAoB,CAClB,OAAO,GAAE,MAA6B,GACrC,iBAAiB;CAGrB;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,aAAa,GACrB,qBAAqB,GAAG,IAAI,CAE9B"}

package/services/knowledge-graph/service.js

@@ -0,0 +1,42 @@
+/**
+ * KnowledgeGraphService — the runtime-owned entity/relationship knowledge
+ * graph, exposed as a registered runtime service.
+ *
+ * The graph is a runtime primitive: any plugin (LifeOps, relationships
+ * viewer, …) consumes it via `runtime.getService(...)` rather than
+ * constructing the DB-backed stores itself. The service is a thin factory
+ * over the per-agent {@link EntityStore} / {@link RelationshipStore}; the
+ * `agentId` is the multi-tenant partition key and defaults to
+ * `runtime.agentId`.
+ */
+import { Service } from "@elizaos/core";
+import { EntityStore } from "./entity-store.js";
+import { RelationshipStore } from "./relationship-store.js";
+export const KNOWLEDGE_GRAPH_SERVICE = "eliza_knowledge_graph";
+export class KnowledgeGraphService extends Service {
+    static serviceType = KNOWLEDGE_GRAPH_SERVICE;
+    capabilityDescription = "Runtime knowledge graph: entity nodes, typed relationship edges, and identity-merge over app_lifeops tables";
+    static async start(runtime) {
+        return new KnowledgeGraphService(runtime);
+    }
+    async stop() { }
+    /**
+     * Per-agent entity store. `agentId` partitions the graph; it defaults to
+     * the runtime's agent id and may be overridden for admin/multi-tenant
+     * access (e.g. an admin entity inspecting another agent's graph).
+     */
+    getEntityStore(agentId = this.runtime.agentId) {
+        return new EntityStore(this.runtime, agentId);
+    }
+    /** Per-agent typed-edge store. See {@link getEntityStore} for `agentId`. */
+    getRelationshipStore(agentId = this.runtime.agentId) {
+        return new RelationshipStore(this.runtime, agentId);
+    }
+}
+/**
+ * Resolve the registered {@link KnowledgeGraphService}. Returns `null` when
+ * the runtime has not registered it (e.g. the "eliza" plugin is absent).
+ */
+export function resolveKnowledgeGraphService(runtime) {
+    return runtime.getService(KNOWLEDGE_GRAPH_SERVICE);
+}

package/services/knowledge-graph/sql.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Self-contained raw-SQL helpers for the runtime knowledge-graph stores.
+ *
+ * The entity/relationship stores issue raw SQL against the agent's database
+ * adapter. This is the minimal subset of encoders/parsers/runners those
+ * stores need; it is intentionally local to `@elizaos/agent` so the runtime
+ * knowledge graph carries no dependency on plugin-side SQL glue.
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+export declare function toText(value: unknown, fallback?: string): string;
+export declare function toNumber(value: unknown, fallback?: number): number;
+export declare function toBoolean(value: unknown, fallback?: boolean): boolean;
+export declare function parseJsonValue<T>(value: unknown, fallback: T): T;
+export declare function parseJsonRecord(value: unknown): Record<string, unknown>;
+export declare function parseJsonArray<T>(value: unknown): T[];
+export declare function executeRawSql(runtime: IAgentRuntime, sqlText: string): Promise<Array<Record<string, unknown>>>;
+export declare function sqlQuote(value: string): string;
+export declare function sqlText(value: string | null | undefined): string;
+export declare function sqlInteger(value: number | null | undefined): string;
+export declare function sqlNumber(value: number | null | undefined): string;
+export declare function sqlJson(value: unknown): string;
+//# sourceMappingURL=sql.d.ts.map

package/services/knowledge-graph/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../../src/services/knowledge-graph/sql.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAiBnD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAK,GAAG,MAAM,CAI5D;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAI,GAAG,MAAM,CAO7D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,UAAQ,GAAG,OAAO,CASnE;AAMD,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAchE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMvE;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,EAAE,CAKrD;AAkCD,wBAAsB,aAAa,CACjC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAKzC;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAGhE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAInE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAIlE;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE9C"}

package/services/knowledge-graph/sql.js

@@ -0,0 +1,142 @@
+/**
+ * Self-contained raw-SQL helpers for the runtime knowledge-graph stores.
+ *
+ * The entity/relationship stores issue raw SQL against the agent's database
+ * adapter. This is the minimal subset of encoders/parsers/runners those
+ * stores need; it is intentionally local to `@elizaos/agent` so the runtime
+ * knowledge graph carries no dependency on plugin-side SQL glue.
+ */
+let cachedSqlRaw = null;
+function asObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+export function toText(value, fallback = "") {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined)
+        return fallback;
+    return String(value);
+}
+export function toNumber(value, fallback = 0) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return fallback;
+}
+export function toBoolean(value, fallback = false) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(normalized))
+            return true;
+        if (["0", "false", "no", "off"].includes(normalized))
+            return false;
+    }
+    return fallback;
+}
+function isMissingJsonValue(value) {
+    return value === null || value === undefined || value === "";
+}
+export function parseJsonValue(value, fallback) {
+    if (isMissingJsonValue(value))
+        return fallback;
+    if (typeof value !== "string") {
+        if (typeof value === "object")
+            return value;
+        throw new Error(`[KnowledgeGraphSql] Expected JSON string or object, received ${typeof value}`);
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`[KnowledgeGraphSql] Invalid JSON value: ${message}`);
+    }
+}
+export function parseJsonRecord(value) {
+    if (isMissingJsonValue(value))
+        return {};
+    const parsed = parseJsonValue(value, null);
+    const object = asObject(parsed);
+    if (object)
+        return object;
+    throw new Error("[KnowledgeGraphSql] Expected JSON object");
+}
+export function parseJsonArray(value) {
+    if (isMissingJsonValue(value))
+        return [];
+    const parsed = parseJsonValue(value, null);
+    if (Array.isArray(parsed))
+        return parsed;
+    throw new Error("[KnowledgeGraphSql] Expected JSON array");
+}
+function extractRows(result) {
+    if (Array.isArray(result)) {
+        return result
+            .map((row) => asObject(row))
+            .filter((row) => row !== null);
+    }
+    const object = asObject(result);
+    if (!object)
+        return [];
+    const rows = object.rows;
+    if (!Array.isArray(rows))
+        return [];
+    return rows
+        .map((row) => asObject(row))
+        .filter((row) => row !== null);
+}
+async function getSqlRaw() {
+    if (cachedSqlRaw)
+        return cachedSqlRaw;
+    const drizzle = (await import("drizzle-orm"));
+    cachedSqlRaw = drizzle.sql.raw;
+    return cachedSqlRaw;
+}
+function getRuntimeDb(runtime) {
+    const db = runtime.adapter.db;
+    if (!db || typeof db.execute !== "function") {
+        throw new Error("runtime database adapter unavailable");
+    }
+    return db;
+}
+export async function executeRawSql(runtime, sqlText) {
+    const raw = await getSqlRaw();
+    const db = getRuntimeDb(runtime);
+    const result = await db.execute(raw(sqlText));
+    return extractRows(result);
+}
+export function sqlQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export function sqlText(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    return sqlQuote(value);
+}
+export function sqlInteger(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    if (!Number.isFinite(value))
+        throw new Error("invalid numeric SQL literal");
+    return String(Math.trunc(value));
+}
+export function sqlNumber(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    if (!Number.isFinite(value))
+        throw new Error("invalid numeric SQL literal");
+    return String(value);
+}
+export function sqlJson(value) {
+    return sqlQuote(JSON.stringify(value ?? null));
+}

package/services/mcp-marketplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-marketplace.d.ts","sourceRoot":"","sources":["../../src/services/mcp-marketplace.ts"],"names":[],"mappings":"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"}

package/services/mcp-marketplace.js

@@ -0,0 +1,200 @@
+/**
+ * MCP Marketplace Service
+ *
+ * Fetches MCP servers from the official registry and manages local config.
+ */
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability.js";
+const MCP_REGISTRY_BASE_URL = "https://registry.modelcontextprotocol.io";
+export async function searchMcpMarketplace(query, limit = 30) {
+    const url = `${MCP_REGISTRY_BASE_URL}/v0/servers`;
+    const searchSpan = createIntegrationTelemetrySpan({
+        boundary: "mcp",
+        operation: "search_registry_servers",
+    });
+    let resp;
+    try {
+        resp = await fetch(url, {
+            headers: {
+                Accept: "application/json",
+            },
+        });
+    }
+    catch (err) {
+        searchSpan.failure({ error: err });
+        throw err;
+    }
+    if (!resp.ok) {
+        searchSpan.failure({ statusCode: resp.status, errorKind: "http_error" });
+        throw new Error(`Registry API error: ${resp.status} ${resp.statusText}`);
+    }
+    let data;
+    try {
+        data = (await resp.json());
+    }
+    catch (err) {
+        searchSpan.failure({ error: err, statusCode: resp.status });
+        throw err;
+    }
+    const results = [];
+    const seenNames = new Set();
+    for (const entry of data.servers) {
+        const server = entry.server;
+        const meta = entry._meta?.["io.modelcontextprotocol.registry/official"];
+        if (!meta?.isLatest)
+            continue;
+        if (seenNames.has(server.name))
+            continue;
+        seenNames.add(server.name);
+        if (query) {
+            const q = query.toLowerCase();
+            const matchName = server.name.toLowerCase().includes(q);
+            const matchTitle = server.title?.toLowerCase().includes(q);
+            const matchDesc = server.description.toLowerCase().includes(q);
+            if (!matchName && !matchTitle && !matchDesc)
+                continue;
+        }
+        let connectionType = "remote";
+        let connectionUrl;
+        let npmPackage;
+        let dockerImage;
+        if (server.remotes && server.remotes.length > 0) {
+            connectionType = "remote";
+            connectionUrl = server.remotes[0].url;
+        }
+        else if (server.packages && server.packages.length > 0) {
+            const pkg = server.packages[0];
+            connectionType = "stdio";
+            if (pkg.registryType === "npm") {
+                npmPackage = pkg.identifier;
+            }
+            else if (pkg.registryType === "oci") {
+                dockerImage = pkg.identifier;
+            }
+        }
+        results.push({
+            id: `${server.name}@${server.version}`,
+            name: server.name,
+            title: server.title || server.name.split("/").pop() || server.name,
+            description: server.description || "No description",
+            version: server.version,
+            connectionType,
+            connectionUrl,
+            npmPackage,
+            dockerImage,
+            repositoryUrl: server.repository?.url,
+            websiteUrl: server.websiteUrl,
+            iconUrl: server.icons?.[0]?.src,
+            publishedAt: meta?.publishedAt,
+            isLatest: true,
+        });
+        if (results.length >= limit)
+            break;
+    }
+    searchSpan.success({ statusCode: resp.status });
+    return { results };
+}
+export async function getMcpServerDetails(name) {
+    const url = `${MCP_REGISTRY_BASE_URL}/v0/servers/${encodeURIComponent(name)}`;
+    const detailsSpan = createIntegrationTelemetrySpan({
+        boundary: "mcp",
+        operation: "get_registry_server_details",
+    });
+    let resp;
+    try {
+        resp = await fetch(url, {
+            headers: { Accept: "application/json" },
+        });
+    }
+    catch (err) {
+        detailsSpan.failure({ error: err });
+        throw err;
+    }
+    if (!resp.ok) {
+        if (resp.status === 404) {
+            detailsSpan.success({ statusCode: resp.status });
+            return null;
+        }
+        detailsSpan.failure({ statusCode: resp.status, errorKind: "http_error" });
+        throw new Error(`Registry API error: ${resp.status}`);
+    }
+    let data;
+    try {
+        data = (await resp.json());
+    }
+    catch (err) {
+        detailsSpan.failure({ error: err, statusCode: resp.status });
+        throw err;
+    }
+    detailsSpan.success({ statusCode: resp.status });
+    return data.server;
+}
+export function generateMcpConfigFromRegistry(server) {
+    if (server.connectionType === "remote" && server.connectionUrl) {
+        return {
+            type: "streamable-http",
+            url: server.connectionUrl,
+        };
+    }
+    else if (server.connectionType === "stdio" && server.npmPackage) {
+        return {
+            type: "stdio",
+            command: "npx",
+            args: ["-y", server.npmPackage],
+        };
+    }
+    else if (server.connectionType === "stdio" && server.dockerImage) {
+        return {
+            type: "stdio",
+            command: "docker",
+            args: ["run", "-i", "--rm", server.dockerImage],
+        };
+    }
+    return null;
+}
+export function generateMcpConfigFromServerDetails(server, envValues, headerValues) {
+    if (server.remotes && server.remotes.length > 0) {
+        const remote = server.remotes[0];
+        const config = {
+            type: remote.type || "streamable-http",
+            url: remote.url,
+        };
+        if (headerValues && Object.keys(headerValues).length > 0) {
+            config.headers = { ...headerValues };
+        }
+        return config;
+    }
+    if (server.packages && server.packages.length > 0) {
+        const pkg = server.packages[0];
+        if (pkg.registryType === "npm") {
+            const args = ["-y", pkg.identifier];
+            if (pkg.packageArguments) {
+                for (const arg of pkg.packageArguments) {
+                    if (arg.default) {
+                        args.push(arg.default);
+                    }
+                }
+            }
+            const config = {
+                type: "stdio",
+                command: "npx",
+                args,
+            };
+            if (envValues && Object.keys(envValues).length > 0) {
+                config.env = { ...envValues };
+            }
+            return config;
+        }
+        if (pkg.registryType === "oci") {
+            const config = {
+                type: "stdio",
+                command: "docker",
+                args: ["run", "-i", "--rm", pkg.identifier],
+            };
+            if (envValues && Object.keys(envValues).length > 0) {
+                config.env = { ...envValues };
+            }
+            return config;
+        }
+    }
+    return null;
+}

package/services/media-generation.d.ts

@@ -0,0 +1,10 @@
+import { type IAgentRuntime, IMediaGenerationService, type MediaGenerationRequest, type MediaGenerationResponse } from "@elizaos/core";
+export declare class AgentMediaGenerationService extends IMediaGenerationService {
+    static readonly serviceType: "media_generation";
+    readonly capabilityDescription: string;
+    static start(runtime: IAgentRuntime): Promise<AgentMediaGenerationService>;
+    stop(): Promise<void>;
+    canGenerateMedia(request: Pick<MediaGenerationRequest, "mediaType" | "audioKind">): boolean;
+    generateMedia(request: MediaGenerationRequest): Promise<MediaGenerationResponse>;
+}
+//# sourceMappingURL=media-generation.d.ts.map

package/services/media-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-generation.d.ts","sourceRoot":"","sources":["../../src/services/media-generation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,uBAAuB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAE7B,MAAM,eAAe,CAAC;AAuBvB,qBAAa,2BAA4B,SAAQ,uBAAuB;IACtE,gBAAyB,WAAW,qBAAgC;IAEpE,SAAkB,qBAAqB,EAAE,MAAM,CACiC;WAEnE,KAAK,CAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,2BAA2B,CAAC;IAIjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAE3B,gBAAgB,CACd,OAAO,EAAE,IAAI,CAAC,sBAAsB,EAAE,WAAW,GAAG,WAAW,CAAC,GAC/D,OAAO;IAmBJ,aAAa,CACjB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,uBAAuB,CAAC;CAgFpC"}