@elizaos/autonomous 2.0.0-alpha.72 → 2.0.0-alpha.73

package/src/services/fallback-training-service.ts

@@ -0,0 +1,196 @@
+import crypto from "node:crypto";
+import type { AgentRuntime } from "@elizaos/core";
+import type { TrainingServiceWithRuntime } from "../api/training-service-like";
+import type { ElizaConfig } from "../config/config";
+
+type DatasetRecord = {
+  id: string;
+  createdAt: string;
+  limit?: number;
+  minLlmCallsPerTrajectory?: number;
+};
+
+type TrainingJobRecord = {
+  id: string;
+  datasetId: string;
+  status: "queued" | "running" | "completed" | "failed" | "cancelled";
+  createdAt: string;
+};
+
+type TrainingModelRecord = {
+  id: string;
+  createdAt: string;
+};
+
+export class FallbackTrainingService implements TrainingServiceWithRuntime {
+  private readonly listeners = new Set<(event: unknown) => void>();
+  private readonly datasets: DatasetRecord[] = [];
+  private readonly jobs: TrainingJobRecord[] = [];
+  private readonly models: TrainingModelRecord[] = [];
+
+  constructor(
+    private readonly options: {
+      getRuntime: () => AgentRuntime | null;
+      getConfig: () => ElizaConfig;
+      setConfig: (nextConfig: ElizaConfig) => void;
+    },
+  ) {}
+
+  async initialize(): Promise<void> {
+    // No-op fallback implementation.
+  }
+
+  subscribe(listener: (event: unknown) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private emit(event: unknown): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+        // Listener failures must not break service operations.
+      }
+    }
+  }
+
+  getStatus(): {
+    runningJobs: number;
+    datasetCount: number;
+    modelCount: number;
+  } {
+    return {
+      runningJobs: this.jobs.filter((job) => job.status === "running").length,
+      datasetCount: this.datasets.length,
+      modelCount: this.models.length,
+    };
+  }
+
+  async listTrajectories(options: {
+    limit?: number;
+    offset?: number;
+  }): Promise<{
+    available: boolean;
+    reason: string;
+    trajectories: unknown[];
+    total: number;
+    limit: number;
+    offset: number;
+  }> {
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    if (!this.options.getRuntime()) {
+      return {
+        available: false,
+        reason: "runtime_not_started",
+        trajectories: [],
+        total: 0,
+        limit,
+        offset,
+      };
+    }
+    return {
+      available: false,
+      reason: "trajectory_store_unavailable",
+      trajectories: [],
+      total: 0,
+      limit,
+      offset,
+    };
+  }
+
+  async getTrajectoryById(_trajectoryId: string): Promise<null> {
+    return null;
+  }
+
+  listDatasets(): DatasetRecord[] {
+    return [...this.datasets];
+  }
+
+  async buildDataset(options: {
+    limit?: number;
+    minLlmCallsPerTrajectory?: number;
+  }): Promise<DatasetRecord> {
+    const dataset: DatasetRecord = {
+      id: `dataset-${crypto.randomUUID()}`,
+      createdAt: new Date().toISOString(),
+      limit: options.limit,
+      minLlmCallsPerTrajectory: options.minLlmCallsPerTrajectory,
+    };
+    this.datasets.unshift(dataset);
+    this.emit({ kind: "dataset_built", dataset });
+    return dataset;
+  }
+
+  listJobs(): TrainingJobRecord[] {
+    return [...this.jobs];
+  }
+
+  async startTrainingJob(options: {
+    datasetId?: string;
+  }): Promise<TrainingJobRecord> {
+    if (!options.datasetId) {
+      throw new Error("datasetId is required");
+    }
+    if (!this.datasets.some((dataset) => dataset.id === options.datasetId)) {
+      throw new Error("Dataset not found");
+    }
+
+    const job: TrainingJobRecord = {
+      id: `job-${crypto.randomUUID()}`,
+      datasetId: options.datasetId,
+      status: "queued",
+      createdAt: new Date().toISOString(),
+    };
+    this.jobs.unshift(job);
+    this.emit({ kind: "job_started", job });
+    return job;
+  }
+
+  getJob(jobId: string): TrainingJobRecord | null {
+    return this.jobs.find((job) => job.id === jobId) ?? null;
+  }
+
+  async cancelJob(jobId: string): Promise<TrainingJobRecord> {
+    const job = this.getJob(jobId);
+    if (!job) throw new Error("Training job not found");
+    job.status = "cancelled";
+    this.emit({ kind: "job_cancelled", job });
+    return job;
+  }
+
+  listModels(): TrainingModelRecord[] {
+    return [...this.models];
+  }
+
+  async importModelToOllama(
+    modelId: string,
+    _body: {
+      modelName?: string;
+      baseModel?: string;
+      ollamaUrl?: string;
+    },
+  ): Promise<TrainingModelRecord> {
+    const model = this.models.find((entry) => entry.id === modelId);
+    if (!model) throw new Error("Model not found");
+    return model;
+  }
+
+  async activateModel(
+    modelId: string,
+    _providerModel?: string,
+  ): Promise<{ ok: boolean; activeModelId: string }> {
+    const model = this.models.find((entry) => entry.id === modelId);
+    if (!model) throw new Error("Model not found");
+    return { ok: true, activeModelId: model.id };
+  }
+
+  async benchmarkModel(
+    modelId: string,
+  ): Promise<{ ok: boolean; modelId: string }> {
+    const model = this.models.find((entry) => entry.id === modelId);
+    if (!model) throw new Error("Model not found");
+    return { ok: true, modelId: model.id };
+  }
+}

package/src/services/mcp-marketplace.ts

@@ -0,0 +1,327 @@
+/**
+ * MCP Marketplace Service
+ *
+ * Fetches MCP servers from the official registry and manages local config.
+ */
+
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability";
+
+const MCP_REGISTRY_BASE_URL = "https://registry.modelcontextprotocol.io";
+
+export interface McpRegistryServer {
+  name: string;
+  title?: string;
+  description: string;
+  version: string;
+  websiteUrl?: string;
+  repository?: {
+    url?: string;
+    source?: string;
+  };
+  remotes?: Array<{
+    type: "streamable-http" | "sse" | "http";
+    url: string;
+    headers?: Array<{
+      name: string;
+      description?: string;
+      isRequired?: boolean;
+      isSecret?: boolean;
+    }>;
+  }>;
+  packages?: Array<{
+    registryType: "npm" | "oci";
+    identifier: string;
+    version?: string;
+    transport?: {
+      type: "stdio";
+    };
+    environmentVariables?: Array<{
+      name: string;
+      description?: string;
+      isSecret?: boolean;
+      isRequired?: boolean;
+      default?: string;
+    }>;
+    runtimeHint?: string;
+    packageArguments?: Array<{
+      name: string;
+      description?: string;
+      default?: string;
+      isRequired?: boolean;
+    }>;
+  }>;
+  icons?: Array<{
+    src: string;
+    mimeType?: string;
+    sizes?: string[];
+  }>;
+}
+
+export interface McpMarketplaceSearchItem {
+  id: string;
+  name: string;
+  title: string;
+  description: string;
+  version: string;
+  connectionType: "remote" | "stdio";
+  connectionUrl?: string;
+  npmPackage?: string;
+  dockerImage?: string;
+  repositoryUrl?: string;
+  websiteUrl?: string;
+  iconUrl?: string;
+  publishedAt?: string;
+  isLatest: boolean;
+}
+
+export interface McpServerConfig {
+  type: "stdio" | "http" | "streamable-http" | "sse";
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  headers?: Record<string, string>;
+  cwd?: string;
+  timeoutInMillis?: number;
+}
+
+export interface McpConfiguredServers {
+  servers: Record<string, McpServerConfig>;
+}
+
+export async function searchMcpMarketplace(
+  query?: string,
+  limit = 30,
+): Promise<{ results: McpMarketplaceSearchItem[] }> {
+  const url = `${MCP_REGISTRY_BASE_URL}/v0/servers`;
+  const searchSpan = createIntegrationTelemetrySpan({
+    boundary: "mcp",
+    operation: "search_registry_servers",
+  });
+
+  let resp: Response;
+  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: {
+    servers: Array<{
+      server: McpRegistryServer;
+      _meta?: {
+        "io.modelcontextprotocol.registry/official"?: {
+          isLatest?: boolean;
+          publishedAt?: string;
+        };
+      };
+    }>;
+    metadata?: { nextCursor?: string; count?: number };
+  };
+  try {
+    data = (await resp.json()) as {
+      servers: Array<{
+        server: McpRegistryServer;
+        _meta?: {
+          "io.modelcontextprotocol.registry/official"?: {
+            isLatest?: boolean;
+            publishedAt?: string;
+          };
+        };
+      }>;
+      metadata?: { nextCursor?: string; count?: number };
+    };
+  } catch (err) {
+    searchSpan.failure({ error: err, statusCode: resp.status });
+    throw err;
+  }
+
+  const results: McpMarketplaceSearchItem[] = [];
+  const seenNames = new Set<string>();
+
+  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" | "stdio" = "remote";
+    let connectionUrl: string | undefined;
+    let npmPackage: string | undefined;
+    let dockerImage: string | undefined;
+
+    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: string,
+): Promise<McpRegistryServer | null> {
+  const url = `${MCP_REGISTRY_BASE_URL}/v0/servers/${encodeURIComponent(name)}`;
+  const detailsSpan = createIntegrationTelemetrySpan({
+    boundary: "mcp",
+    operation: "get_registry_server_details",
+  });
+  let resp: Response;
+  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: { server: McpRegistryServer };
+  try {
+    data = (await resp.json()) as { server: McpRegistryServer };
+  } catch (err) {
+    detailsSpan.failure({ error: err, statusCode: resp.status });
+    throw err;
+  }
+  detailsSpan.success({ statusCode: resp.status });
+  return data.server;
+}
+
+export function generateMcpConfigFromRegistry(
+  server: McpMarketplaceSearchItem,
+): McpServerConfig | null {
+  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: McpRegistryServer,
+  envValues?: Record<string, string>,
+  headerValues?: Record<string, string>,
+): McpServerConfig | null {
+  if (server.remotes && server.remotes.length > 0) {
+    const remote = server.remotes[0];
+    const config: McpServerConfig = {
+      type: (remote.type as McpServerConfig["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: McpServerConfig = {
+        type: "stdio",
+        command: "npx",
+        args,
+      };
+      if (envValues && Object.keys(envValues).length > 0) {
+        config.env = { ...envValues };
+      }
+      return config;
+    }
+
+    if (pkg.registryType === "oci") {
+      const config: McpServerConfig = {
+        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/src/services/plugin-manager-types.ts

@@ -0,0 +1,185 @@
+export interface RegistryVersionSupport {
+  v0: boolean;
+  v1: boolean;
+  v2: boolean;
+}
+
+export interface RegistryPluginNpmInfo {
+  package: string;
+  v0Version?: string | null;
+  v1Version?: string | null;
+  v2Version?: string | null;
+}
+
+export interface RegistryPluginViewerInfo {
+  url: string;
+  embedParams?: Record<string, string>;
+  postMessageAuth?: boolean;
+  sandbox?: string;
+}
+
+export interface AppUiExtensionConfig {
+  detailPanelId: string;
+}
+
+export interface RegistryPluginAppMeta {
+  displayName?: string;
+  category?: string;
+  launchType?: string;
+  launchUrl?: string | null;
+  icon?: string | null;
+  capabilities?: string[];
+  uiExtension?: AppUiExtensionConfig;
+  viewer?: RegistryPluginViewerInfo;
+}
+
+export interface RegistryPluginInfo {
+  name: string;
+  gitRepo: string;
+  gitUrl: string;
+  displayName?: string;
+  description: string;
+  homepage?: string | null;
+  topics: string[];
+  stars: number;
+  language: string;
+  launchType?: string;
+  launchUrl?: string | null;
+  viewer?: RegistryPluginViewerInfo;
+  uiExtension?: AppUiExtensionConfig;
+  kind?: string;
+  appMeta?: RegistryPluginAppMeta;
+  npm: RegistryPluginNpmInfo;
+  supports: RegistryVersionSupport;
+  // App-specific metadata
+  category?: string;
+  capabilities?: string[];
+  icon?: string | null;
+}
+
+export interface RegistrySearchResult {
+  name: string;
+  description: string;
+  score: number;
+  tags: string[];
+  version: string | null;
+  latestVersion?: string | null;
+  npmPackage: string;
+  repository: string;
+  stars: number;
+  supports: RegistryVersionSupport;
+}
+
+export interface InstalledPluginInfo {
+  name: string;
+  version?: string;
+  installedAt?: string;
+}
+
+export interface InstallProgressLike {
+  phase: string;
+  message: string;
+  pluginName?: string;
+}
+
+export interface PluginInstallResult {
+  success: boolean;
+  pluginName: string;
+  version: string;
+  installPath: string;
+  requiresRestart: boolean;
+  error?: string;
+}
+
+export interface PluginUninstallResult {
+  success: boolean;
+  pluginName: string;
+  requiresRestart: boolean;
+  error?: string;
+}
+
+export interface EjectResult {
+  success: boolean;
+  pluginName: string;
+  ejectedPath: string;
+  requiresRestart: boolean;
+  error?: string;
+}
+
+export interface SyncResult {
+  success: boolean;
+  pluginName: string;
+  ejectedPath: string;
+  requiresRestart: boolean;
+  error?: string;
+}
+
+export interface ReinjectResult {
+  success: boolean;
+  pluginName: string;
+  removedPath: string;
+  requiresRestart: boolean;
+  error?: string;
+}
+
+export interface PluginManagerLike {
+  refreshRegistry(): Promise<Map<string, RegistryPluginInfo>>;
+  listInstalledPlugins(): Promise<InstalledPluginInfo[]>;
+  getRegistryPlugin(name: string): Promise<RegistryPluginInfo | null>;
+  searchRegistry(
+    query: string,
+    limit?: number,
+  ): Promise<RegistrySearchResult[]>;
+  installPlugin(
+    pluginName: string,
+    onProgress?: (progress: InstallProgressLike) => void,
+  ): Promise<PluginInstallResult>;
+  uninstallPlugin(pluginName: string): Promise<PluginUninstallResult>;
+  listEjectedPlugins(): Promise<InstalledPluginInfo[]>;
+  ejectPlugin(pluginName: string): Promise<EjectResult>;
+  syncPlugin(pluginName: string): Promise<SyncResult>;
+  reinjectPlugin(pluginName: string): Promise<ReinjectResult>;
+}
+
+export interface CoreStatusLike {
+  ejected: boolean;
+  ejectedPath: string;
+  monorepoPath: string;
+  corePackagePath: string;
+  coreDistPath: string;
+  version: string;
+  npmVersion: string;
+  commitHash: string | null;
+  localChanges: boolean;
+  upstream: unknown;
+}
+
+export interface CoreManagerLike {
+  getCoreStatus(): Promise<CoreStatusLike>;
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function isPluginManagerLike(
+  candidate: unknown,
+): candidate is PluginManagerLike {
+  if (!isObjectRecord(candidate)) return false;
+
+  return (
+    typeof candidate.refreshRegistry === "function" &&
+    typeof candidate.listInstalledPlugins === "function" &&
+    typeof candidate.getRegistryPlugin === "function" &&
+    typeof candidate.searchRegistry === "function" &&
+    typeof candidate.installPlugin === "function" &&
+    typeof candidate.uninstallPlugin === "function"
+  );
+}
+
+export function isCoreManagerLike(
+  candidate: unknown,
+): candidate is CoreManagerLike {
+  if (!isObjectRecord(candidate)) return false;
+  return typeof candidate.getCoreStatus === "function";
+}