@axiom-lattice/gateway 3.0.2 → 3.0.4

package/src/export_registrations/eval.registration.ts

@@ -1,334 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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 };
-  },
-};