@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/export_registrations/a2a-api-key.registration.ts

@@ -1,89 +0,0 @@
-import type { ExportableEntityDefinition, ExportableEntity, ImportPreviewResult } from '@axiom-lattice/core';
-import { getStoreLattice } from '@axiom-lattice/core';
-import type { A2AApiKeyStore } from '@axiom-lattice/protocols';
-
-function getStore(): A2AApiKeyStore {
-  return getStoreLattice('default', 'a2aApiKey').store as unknown as A2AApiKeyStore;
-}
-
-export const a2aApiKeyRegistration: ExportableEntityDefinition = {
-  entityType: 'a2a_api_key',
-  label: 'A2A API Key(API密钥)',
-  category: 'core',
-  dependsOn: [],
-  cascadeParents: [],
-
-  async listForExport(tenantId: string): Promise<ExportableEntity[]> {
-    const store = getStore();
-    const keys = await store.list({ tenantId, limit: 10000, offset: 0 });
-    return keys.map((k) => ({
-      _exportId: '',
-      data: {
-        id: k.id,
-        tenantId: k.tenantId,
-        projectId: k.projectId,
-        workspaceId: k.workspaceId,
-        label: k.label,
-        enabled: k.enabled,
-      },
-    }));
-  },
-
-  async previewImport(
-    tenantId: string,
-    entities: ExportableEntity[],
-  ): Promise<ImportPreviewResult> {
-    const store = getStore();
-    const existing = await store.list({ tenantId, limit: 10000, offset: 0 });
-    const existingIds = new Set(existing.map((k) => k.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: 'a2a_api_key',
-          conflictType: 'id_exists',
-          existingId: id,
-          existingName: (d.label as string) || id,
-        });
-      } else {
-        insertions.push({
-          _exportId: entity._exportId,
-          entityType: 'a2a_api_key',
-          name: (d.label as string) || id,
-        });
-      }
-    }
-
-    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') {
-      try {
-        await store.delete(d.id as string);
-      } catch { /* may not exist */ }
-    }
-
-    // Always generate a new key_value — key_value is globally unique
-    await store.create({
-      tenantId,
-      projectId: d.projectId as string | undefined,
-      workspaceId: d.workspaceId as string | undefined,
-      label: d.label as string | undefined,
-    });
-
-    return { newId: undefined };
-  },
-};

package/src/export_registrations/agent.registration.ts

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

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

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

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

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

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