@axiom-lattice/gateway 2.1.112 → 2.1.113

package/src/export_registrations/connection.registration.ts

@@ -0,0 +1,97 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { ConnectionEntry, ConnectionStore } from '@axiom-lattice/protocols';
+
+function getStore(): ConnectionStore {
+  return getStoreLattice('default', 'connection').store as unknown as ConnectionStore;
+}
+
+async function listAllConnections(tenantId: string): Promise<ConnectionEntry[]> {
+  const store = getStore();
+  if (typeof store.listByTenant !== 'function') {
+    throw new Error('ConnectionStore.listByTenant is not implemented. SQL bypass removed — upgrade your store adapter.');
+  }
+  return store.listByTenant(tenantId);
+}
+
+export const connectionRegistration: ExportableEntityDefinition = {
+  entityType: 'connection',
+  label: 'Connection(连接)',
+  category: 'core',
+  dependsOn: [],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const connections = await listAllConnections(tenantId);
+    return connections.map((c) => ({
+      _exportId: '',
+      data: {
+        id: c.id,
+        type: c.type,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const existing = await listAllConnections(tenantId);
+    const existingCompositeKeys = new Set(
+      existing.map((c) => `${c.type}:${c.key}`),
+    );
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const compositeKey = `${d.type}:${d.key}`;
+      if (existingCompositeKeys.has(compositeKey)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'connection',
+          conflictType: 'unique_constraint',
+          existingName: `${d.type}:${d.key}`,
+          field: 'type+key',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'connection',
+          name: `${d.type}:${d.key}`,
+        });
+      }
+    }
+
+    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 type = d.type as string;
+    const key = d.key as string;
+
+    if (resolution.action === 'overwrite') {
+      try { await store.delete(tenantId, type, key); } catch { /* may not exist */ }
+    }
+
+    await store.create({
+      tenantId,
+      type,
+      key,
+      name: d.name as string,
+      description: d.description as string | undefined,
+      config: d.config as Record<string, unknown>,
+    });
+
+    return { newId: undefined };
+  },
+};

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

@@ -0,0 +1,94 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { DatabaseConfigStore } from '@axiom-lattice/protocols';
+
+function getStore(): DatabaseConfigStore {
+  return getStoreLattice('default', 'database').store as unknown as DatabaseConfigStore;
+}
+
+export const databaseConfigRegistration: ExportableEntityDefinition = {
+  entityType: 'database_config',
+  label: 'Database 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: 'database_config',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || key,
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'database_config',
+          conflictType: 'unique_constraint',
+          existingName: (d.name as string) || key,
+          field: 'key',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'database_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 };
+  },
+};

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 };
+  },
+};