@axiom-lattice/gateway 2.1.111 → 2.1.113

package/src/export_registrations/agent.registration.ts

@@ -0,0 +1,80 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { AssistantStore } from '@axiom-lattice/protocols';
+
+function getStore(): AssistantStore {
+  return getStoreLattice('default', 'assistant').store as unknown as AssistantStore;
+}
+
+export const agentRegistration: ExportableEntityDefinition = {
+  entityType: 'agent',
+  label: 'Agent(智能体)',
+  category: 'core',
+  dependsOn: ['skill'],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const agents = await store.getAllAssistants(tenantId);
+    return agents.map((a) => ({
+      _exportId: '',
+      data: {
+        id: a.id,
+        name: a.name,
+        description: a.description,
+        graphDefinition: a.graphDefinition,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.getAllAssistants(tenantId);
+    const existingIds = new Set(existing.map((a) => a.id));
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const id = entity.data.id as string;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'agent',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (entity.data.name as string) || id,
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'agent',
+          name: (entity.data.name as string) || id,
+        });
+      }
+    }
+
+    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.deleteAssistant(tenantId, id); } catch { /* may not exist */ }
+    }
+
+    await store.createAssistant(tenantId, id, {
+      name: data.name as string,
+      description: (data.description as string) || '',
+      graphDefinition: data.graphDefinition as Record<string, unknown>,
+    });
+
+    return { newId: id };
+  },
+};

package/src/export_registrations/binding.registration.ts

@@ -0,0 +1,106 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { BindingRegistry } from '@axiom-lattice/protocols';
+
+function getStore(): BindingRegistry {
+  return getStoreLattice('default', 'channelBinding').store as unknown as BindingRegistry;
+}
+
+export const bindingRegistration: ExportableEntityDefinition = {
+  entityType: 'binding',
+  label: 'Binding(渠道绑定)',
+  category: 'core',
+  dependsOn: ['agent', 'channel_installation'],
+  cascadeParents: [],
+  referenceFields: { agentId: 'agent', channelInstallationId: 'channel_installation' },
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const bindings = await store.list({ tenantId, limit: 10000, offset: 0 });
+    return bindings.map((b) => ({
+      _exportId: '',
+      data: {
+        channel: b.channel,
+        channelInstallationId: b.channelInstallationId,
+        senderId: b.senderId,
+        agentId: b.agentId,
+        threadId: b.threadId,
+        workspaceId: b.workspaceId,
+        projectId: b.projectId,
+        threadMode: b.threadMode,
+        senderDisplayName: b.senderDisplayName,
+        senderMetadata: b.senderMetadata,
+        enabled: b.enabled,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.list({ tenantId, limit: 10000, offset: 0 });
+
+    const existingKeys = new Set(
+      existing.map((b) => `${b.channel}:${b.channelInstallationId}:${b.senderId}`),
+    );
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const key = `${d.channel}:${d.channelInstallationId}:${d.senderId}`;
+      if (existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'binding',
+          conflictType: 'unique_constraint',
+          existingName: `${d.channel}:${d.senderId}`,
+          field: 'channel+channelInstallationId+senderId',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'binding',
+          name: `${d.channel}:${d.senderId}`,
+        });
+      }
+    }
+
+    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>;
+
+    if (resolution.action === 'overwrite') {
+      const existing = await store.list({ tenantId, limit: 10000, offset: 0 });
+      const match = existing.find(
+        (b) => b.channel === d.channel && b.channelInstallationId === d.channelInstallationId && b.senderId === d.senderId,
+      );
+      if (match) {
+        await store.delete(match.id);
+      }
+    }
+
+    await store.create({
+      channel: d.channel as string,
+      channelInstallationId: d.channelInstallationId as string,
+      tenantId,
+      senderId: d.senderId as string,
+      agentId: d.agentId as string,
+      threadMode: (d.threadMode as 'fixed' | 'per_conversation') || 'fixed',
+      senderDisplayName: d.senderDisplayName as string | undefined,
+      senderMetadata: d.senderMetadata as Record<string, unknown> | undefined,
+      workspaceId: d.workspaceId as string | undefined,
+      projectId: d.projectId as string | undefined,
+    });
+
+    return { newId: undefined };
+  },
+};

package/src/export_registrations/channel-installation.registration.ts

@@ -0,0 +1,88 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { ChannelInstallationStore } from '@axiom-lattice/protocols';
+
+function getStore(): ChannelInstallationStore {
+  return getStoreLattice('default', 'channelInstallation').store as unknown as ChannelInstallationStore;
+}
+
+export const channelInstallationRegistration: ExportableEntityDefinition = {
+  entityType: 'channel_installation',
+  label: 'Channel Installation(渠道安装)',
+  category: 'core',
+  dependsOn: ['agent'],
+  cascadeParents: [],
+  referenceFields: { fallbackAgentId: 'agent' },
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const installations = await store.getInstallationsByTenant(tenantId);
+    return installations.map((i) => ({
+      _exportId: '',
+      data: {
+        id: i.id,
+        channel: i.channel,
+        name: i.name,
+        config: i.config,
+        enabled: i.enabled,
+        fallbackAgentId: i.fallbackAgentId,
+        rejectWhenNoBinding: i.rejectWhenNoBinding,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.getInstallationsByTenant(tenantId);
+    const existingIds = new Set(existing.map((i) => i.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: 'channel_installation',
+          conflictType: 'id_exists',
+          existingId: id,
+          existingName: (d.name as string) || id,
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'channel_installation',
+          name: (d.name as string) || id,
+        });
+      }
+    }
+
+    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.deleteInstallation(tenantId, id); } catch { /* may not exist */ }
+    }
+
+    await store.createInstallation(tenantId, id, {
+      channel: data.channel as 'lark' | 'email' | 'slack' | 'wechat',
+      name: data.name as string | undefined,
+      config: data.config as any,
+      enabled: data.enabled as boolean | undefined,
+      fallbackAgentId: data.fallbackAgentId as string | undefined,
+      rejectWhenNoBinding: data.rejectWhenNoBinding as boolean | undefined,
+    });
+
+    return { newId: id };
+  },
+};

package/src/export_registrations/collection.registration.ts

@@ -0,0 +1,85 @@
+import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
+import { getStoreLattice } from '@axiom-lattice/core';
+import type { CollectionStore } from '@axiom-lattice/protocols';
+
+function getStore(): CollectionStore {
+  return getStoreLattice('default', 'collection').store as unknown as CollectionStore;
+}
+
+export const collectionRegistration: ExportableEntityDefinition = {
+  entityType: 'collection',
+  label: 'Collection(知识库)',
+  category: 'core',
+  dependsOn: [],
+  cascadeParents: [],
+
+  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
+    const store = getStore();
+    const collections = await store.getAllCollections(tenantId);
+    return collections.map((c) => ({
+      _exportId: '',
+      data: {
+        id: c.id,
+        name: c.name,
+        label: c.label,
+        embeddingKey: c.embeddingKey,
+        schema: c.schema,
+      },
+    }));
+  },
+
+  async previewImport(
+    tenantId: string,
+    entities: ExportableEntity[],
+  ): Promise<ImportPreviewResult> {
+    const store = getStore();
+    const existing = await store.getAllCollections(tenantId);
+    const existingNames = new Set(existing.map((c) => c.name));
+
+    const conflicts: ImportPreviewResult['conflicts'] = [];
+    const insertions: ImportPreviewResult['insertions'] = [];
+
+    for (const entity of entities) {
+      const d = entity.data as Record<string, unknown>;
+      const name = d.name as string;
+      if (existingNames.has(name)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: 'collection',
+          conflictType: 'unique_constraint',
+          existingName: name,
+          field: 'name',
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: 'collection',
+          name: name,
+        });
+      }
+    }
+
+    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 name = d.name as string;
+
+    if (resolution.action === 'overwrite') {
+      try { await store.deleteCollection(tenantId, name); } catch { /* may not exist */ }
+    }
+
+    await store.createCollection(tenantId, {
+      name,
+      label: d.label as string,
+      embeddingKey: d.embeddingKey as string,
+      schema: d.schema as any,
+    });
+
+    return { newId: undefined };
+  },
+};

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