@axiom-lattice/gateway 2.1.111 → 2.1.113

package/src/export_registrations/eval.registration.ts

@@ -0,0 +1,334 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { EvalStore } from '@axiom-lattice/protocols';
+
+function getStore(): EvalStore {
+  return getStoreLattice('default', 'eval').store as unknown as EvalStore;
+}
+
+export const evalRegistration: ExportableEntityDefinition = {
+  entityType: 'eval',
+  label: 'Eval(评估)',
+  category: 'core',
+  dependsOn: [],
+  cascadeParents: [],
+  referenceFields: { suiteId: 'eval_suite', projectId: 'eval_project', runId: 'eval_run', caseId: 'eval_case' },
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const projects = await store.getProjectsByTenant(tenantId);
+    const entities: ExportableEntity[] = [];
+
+    for (const project of projects) {
+      entities.push({
+        _exportId: '',
+        data: {
+          _subType: 'eval_project',
+          id: project.id,
+          name: project.name,
+          description: project.description,
+          version: project.version,
+          judgeModelConfig: project.judgeModelConfig,
+          targetServerConfig: project.targetServerConfig,
+          concurrency: project.concurrency,
+          reportConfig: project.reportConfig,
+        },
+      });
+
+      const suites = await store.getSuitesByProject(tenantId, project.id);
+      for (const suite of suites) {
+        entities.push({
+          _exportId: '',
+          data: {
+            _subType: 'eval_suite',
+            id: suite.id,
+            projectId: suite.projectId,
+            name: suite.name,
+          },
+        });
+
+        const cases = await store.getCasesBySuite(tenantId, suite.id);
+        for (const c of cases) {
+          entities.push({
+            _exportId: '',
+            data: {
+              _subType: 'eval_case',
+              id: c.id,
+              suiteId: c.suiteId,
+              inputMessage: c.inputMessage,
+              inputFiles: c.inputFiles,
+              steps: c.steps,
+              outputType: c.outputType,
+              contentAssertion: c.contentAssertion,
+              rubrics: c.rubrics,
+            },
+          });
+        }
+      }
+
+      const runs = await store.getRunsByTenant(tenantId, { projectId: project.id });
+      for (const run of runs) {
+        entities.push({
+          _exportId: '',
+          data: {
+            _subType: 'eval_run',
+            id: run.id,
+            projectId: run.projectId,
+            status: run.status,
+            concurrency: run.concurrency,
+            totalCases: run.totalCases,
+            passedCases: run.passedCases,
+            failedCases: run.failedCases,
+            avgScore: run.avgScore,
+            error: run.error,
+          },
+        });
+
+        const results = await store.getResultsByRun(tenantId, run.id);
+        for (const result of results) {
+          entities.push({
+            _exportId: '',
+            data: {
+              _subType: 'eval_run_result',
+              id: result.id,
+              runId: result.runId,
+              suiteName: result.suiteName,
+              caseId: result.caseId,
+              pass: result.pass,
+              score: result.score,
+              summary: result.summary,
+              dimensionResults: result.dimensionResults,
+              durationMs: result.durationMs,
+              messages: result.messages,
+              logs: result.logs,
+              error: result.error,
+            },
+          });
+        }
+      }
+    }
+
+    return entities;
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+
+    const existingProjects = await store.getProjectsByTenant(tenantId);
+    const existingProjectIds = new Set(existingProjects.map((p) => p.id));
+    const existingProjectNames = new Set(existingProjects.map((p) => p.name));
+
+    const existingSuites: Map<string, Set<string>> = new Map();
+    const existingSuiteIds = new Set<string>();
+    const existingCaseIds = new Set<string>();
+    const existingRunIds = new Set<string>();
+    const existingResultIds = new Set<string>();
+
+    for (const project of existingProjects) {
+      const suites = await store.getSuitesByProject(tenantId, project.id);
+      existingSuites.set(project.id, new Set(suites.map((s) => `${s.projectId}:${s.name}`)));
+      for (const s of suites) {
+        existingSuiteIds.add(s.id);
+        try {
+          const cases = await store.getCasesBySuite(tenantId, s.id);
+          for (const c of cases) existingCaseIds.add(c.id);
+        } catch { /* suite may not exist */ }
+      }
+    }
+
+    for (const project of existingProjects) {
+      const runs = await store.getRunsByTenant(tenantId, { projectId: project.id });
+      for (const run of runs) {
+        existingRunIds.add(run.id);
+        try {
+          const results = await store.getResultsByRun(tenantId, run.id);
+          for (const r of results) existingResultIds.add(r.id);
+        } catch { /* run may not exist */ }
+      }
+    }
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const subType = d._subType as string;
+      const id = d.id as string;
+
+      switch (subType) {
+        case 'eval_project': {
+          const name = d.name as string;
+          if (existingProjectIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_project',
+              conflictType: 'id_exists',
+              existingId: id,
+              existingName: name,
+            });
+          } else if (name && existingProjectNames.has(name)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_project',
+              conflictType: 'unique_constraint',
+              existingName: name,
+              field: 'name',
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: 'eval_project', name });
+          }
+          break;
+        }
+        case 'eval_suite': {
+          const projectId = d.projectId as string;
+          const name = d.name as string;
+          const suiteKey = `${projectId}:${name}`;
+          const projectSuites = existingSuites.get(projectId);
+          if (existingSuiteIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_suite',
+              conflictType: 'id_exists',
+              existingId: id,
+              existingName: name,
+            });
+          } else if (projectSuites?.has(suiteKey)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_suite',
+              conflictType: 'unique_constraint',
+              existingName: name,
+              field: 'projectId+name',
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: 'eval_suite', name });
+          }
+          break;
+        }
+        case 'eval_case': {
+          if (existingCaseIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_case',
+              conflictType: 'id_exists',
+              existingId: id,
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: 'eval_case', name: id });
+          }
+          break;
+        }
+        case 'eval_run': {
+          if (existingRunIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_run',
+              conflictType: 'id_exists',
+              existingId: id,
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: 'eval_run', name: id });
+          }
+          break;
+        }
+        case 'eval_run_result': {
+          if (existingResultIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: 'eval_run_result',
+              conflictType: 'id_exists',
+              existingId: id,
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: 'eval_run_result', name: id });
+          }
+          break;
+        }
+      }
+    }
+
+    return { conflicts, insertions, errors: [] };
+  },
+
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === 'skip') return {};
+    const store = getStore();
+    const d = entity.data as Record<string, unknown>;
+    const subType = d._subType as string;
+    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : d.id as string;
+
+    switch (subType) {
+      case 'eval_project': {
+        if (resolution.action === 'overwrite') {
+          try { await store.deleteProject(tenantId, id); } catch { /* may not exist */ }
+        }
+        await store.createProject(tenantId, id, {
+          name: d.name as string,
+          description: d.description as string | undefined,
+          version: d.version as string | undefined,
+          judgeModelConfig: d.judgeModelConfig as Record<string, unknown>,
+          targetServerConfig: d.targetServerConfig as Record<string, unknown>,
+          concurrency: d.concurrency as number | undefined,
+          reportConfig: d.reportConfig as Record<string, unknown> | undefined,
+        });
+        break;
+      }
+      case 'eval_suite': {
+        if (resolution.action === 'overwrite') {
+          try { await store.deleteSuite(tenantId, id); } catch { /* may not exist */ }
+        }
+        await store.createSuite(tenantId, d.projectId as string, id, {
+          name: d.name as string,
+        });
+        break;
+      }
+      case 'eval_case': {
+        if (resolution.action === 'overwrite') {
+          try { await store.deleteCase(tenantId, id); } catch { /* may not exist */ }
+        }
+        await store.createCase(tenantId, d.suiteId as string, id, {
+          inputMessage: d.inputMessage as string,
+          inputFiles: d.inputFiles as Record<string, string> | undefined,
+          steps: d.steps as Array<{ agent_id: string; override_message?: string }>,
+          outputType: d.outputType as 'file_content' | 'message_content',
+          contentAssertion: d.contentAssertion as string,
+          rubrics: d.rubrics as Array<{ name: string; weight: number; description: string }> | undefined,
+        });
+        break;
+      }
+      case 'eval_run': {
+        if (resolution.action === 'overwrite') {
+          try { await store.deleteRun(tenantId, id); } catch { /* may not exist */ }
+        }
+        await store.createRun(tenantId, d.projectId as string, id, {
+          totalCases: d.totalCases as number,
+          concurrency: d.concurrency as number,
+        });
+        break;
+      }
+      case 'eval_run_result': {
+        if (resolution.action === 'overwrite') {
+          try { await store.deleteRunResult(tenantId, entity.data.id as string); } catch { /* may not exist */ }
+        }
+        await store.createRunResult(tenantId, d.runId as string, id, {
+          suiteName: d.suiteName as string,
+          caseId: d.caseId as string | undefined,
+          pass: d.pass as boolean,
+          score: d.score as number,
+          summary: d.summary as string | undefined,
+          dimensionResults: d.dimensionResults as Array<{ name: string; score: number; reason: string }> | undefined,
+          durationMs: d.durationMs as number | undefined,
+          messages: d.messages as Array<{ role: string; content: string; id?: string }> | undefined,
+          logs: d.logs as Array<{ timestamp: string; level: string; message: string; data?: unknown }> | undefined,
+          error: d.error as string | undefined,
+        });
+        break;
+      }
+    }
+
+    return { newId: id };
+  },
+};

package/src/export_registrations/index.ts

@@ -0,0 +1,31 @@
+import { ExportableEntityRegistry } from '@axiom-lattice/core';
+import { skillRegistration } from './skill.registration';
+import { agentRegistration } from './agent.registration';
+import { bindingRegistration } from './binding.registration';
+import { databaseConfigRegistration } from './database-config.registration';
+import { metricsConfigRegistration } from './metrics-config.registration';
+import { mcpConfigRegistration } from './mcp-config.registration';
+import { connectionRegistration } from './connection.registration';
+import { collectionRegistration } from './collection.registration';
+import { channelInstallationRegistration } from './channel-installation.registration';
+import { menuRegistration } from './menu.registration';
+import { taskRegistration } from './task.registration';
+import { a2aApiKeyRegistration } from './a2a-api-key.registration';
+import { evalRegistration } from './eval.registration';
+
+export function registerAllBuiltinEntities(): void {
+  const registry = ExportableEntityRegistry.getInstance();
+  registry.register(skillRegistration);
+  registry.register(agentRegistration);
+  registry.register(bindingRegistration);
+  registry.register(databaseConfigRegistration);
+  registry.register(metricsConfigRegistration);
+  registry.register(mcpConfigRegistration);
+  registry.register(connectionRegistration);
+  registry.register(collectionRegistration);
+  registry.register(channelInstallationRegistration);
+  registry.register(menuRegistration);
+  registry.register(taskRegistration);
+  registry.register(a2aApiKeyRegistration);
+  registry.register(evalRegistration);
+}

package/src/export_registrations/mcp-config.registration.ts

@@ -0,0 +1,97 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { McpServerConfigStore } from '@axiom-lattice/protocols';
+
+function getStore(): McpServerConfigStore {
+  return getStoreLattice('default', 'mcp').store as unknown as McpServerConfigStore;
+}
+
+export const mcpConfigRegistration: ExportableEntityDefinition = {
+  entityType: 'mcp_config',
+  label: 'MCP Config(MCP配置)',
+  category: 'core',
+  dependsOn: [],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const configs = await store.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: '',
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config,
+        selectedTools: c.selectedTools,
+        status: c.status,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const id = d.id as string;
+      const key = d.key as string;
+
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'mcp_config',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || key,
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'mcp_config',
+          conflictType: 'unique_constraint',
+          existingName: (d.name as string) || key,
+          field: 'key',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'mcp_config',
+          name: (d.name as string) || key,
+        });
+      }
+    }
+
+    return { conflicts, insertions, errors: [] };
+  },
+
+  async applyImport(tenantId, entity, resolution) {
+    const store = getStore();
+    const data = entity.data as Record<string, unknown>;
+    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : data.id as string;
+
+    if (resolution.action === 'overwrite') {
+      try { await store.deleteConfig(tenantId, id); } catch { /* may not exist */ }
+    }
+
+    await store.createConfig(tenantId, id, {
+      key: data.key as string,
+      name: data.name as string | undefined,
+      description: data.description as string | undefined,
+      config: data.config as any,
+      selectedTools: data.selectedTools as string[] | undefined,
+    });
+
+    return { newId: id };
+  },
+};

package/src/export_registrations/menu.registration.ts

@@ -0,0 +1,91 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { MenuRegistry } from '@axiom-lattice/protocols';
+
+function getStore(): MenuRegistry {
+  return getStoreLattice('default', 'menu').store as unknown as MenuRegistry;
+}
+
+export const menuRegistration: ExportableEntityDefinition = {
+  entityType: 'menu',
+  label: 'Menu(菜单)',
+  category: 'core',
+  dependsOn: ['agent'],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const menus = await store.list({ tenantId });
+    return menus.map((m) => ({
+      _exportId: '',
+      data: {
+        id: m.id,
+        menuTarget: m.menuTarget,
+        group: m.group,
+        name: m.name,
+        icon: m.icon,
+        sortOrder: m.sortOrder,
+        contentType: m.contentType,
+        contentConfig: m.contentConfig,
+        enabled: m.enabled,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.list({ tenantId });
+    const existingIds = new Set(existing.map((m) => m.id));
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const id = d.id as string;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'menu',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || id,
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'menu',
+          name: (d.name as string) || id,
+        });
+      }
+    }
+
+    return { conflicts, insertions, errors: [] };
+  },
+
+  async applyImport(tenantId, entity, resolution) {
+    const store = getStore();
+    const d = entity.data as Record<string, unknown>;
+    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : d.id as string;
+
+    if (resolution.action === 'overwrite') {
+      try { await store.delete(id); } catch { /* may not exist */ }
+    }
+
+    await store.create({
+      tenantId,
+      menuTarget: d.menuTarget as 'sidebar' | 'workspace',
+      group: d.group as string | undefined,
+      name: d.name as string,
+      icon: d.icon as string | undefined,
+      sortOrder: d.sortOrder as number | undefined,
+      contentType: d.contentType as 'agent' | 'html' | 'custom',
+      contentConfig: d.contentConfig as any,
+    });
+
+    return { newId: undefined };
+  },
+};

package/src/export_registrations/metrics-config.registration.ts

@@ -0,0 +1,94 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { MetricsServerConfigStore } from '@axiom-lattice/protocols';
+
+function getStore(): MetricsServerConfigStore {
+  return getStoreLattice('default', 'metrics').store as unknown as MetricsServerConfigStore;
+}
+
+export const metricsConfigRegistration: ExportableEntityDefinition = {
+  entityType: 'metrics_config',
+  label: 'Metrics Config(指标配置)',
+  category: 'core',
+  dependsOn: [],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const configs = await store.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: '',
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const id = d.id as string;
+      const key = d.key as string;
+
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'metrics_config',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || key,
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'metrics_config',
+          conflictType: 'unique_constraint',
+          existingName: (d.name as string) || key,
+          field: 'key',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'metrics_config',
+          name: (d.name as string) || key,
+        });
+      }
+    }
+
+    return { conflicts, insertions, errors: [] };
+  },
+
+  async applyImport(tenantId, entity, resolution) {
+    const store = getStore();
+    const data = entity.data as Record<string, unknown>;
+    const id = resolution.action === 'rename' && resolution.newId ? resolution.newId : data.id as string;
+
+    if (resolution.action === 'overwrite') {
+      try { await store.deleteConfig(tenantId, id); } catch { /* may not exist */ }
+    }
+
+    await store.createConfig(tenantId, id, {
+      key: data.key as string,
+      name: data.name as string | undefined,
+      description: data.description as string | undefined,
+      config: data.config as any,
+    });
+
+    return { newId: id };
+  },
+};