@exellix/graph-engine 6.0.0

package/dist/src/integrations/ActivityTrackerIntegration.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Integration helper for @athenices/ai-activities-tracking
+ *
+ * This module provides a bridge between exellix-graphs events and ActivityTracker.
+ * It listens to graph and node execution events and forwards them to ActivityTracker.
+ *
+ * Usage:
+ * ```typescript
+ * import { ActivityTracker } from '@athenices/ai-activities-tracking';
+ * import { createActivityTrackerIntegration } from '@exellix/graph-engine/integrations';
+ *
+ * const tracker = new ActivityTracker({ // config });
+ * await tracker.init();
+ *
+ * const integration = createActivityTrackerIntegration(tracker);
+ *
+ * // Use integration.eventEmitter with createExellixGraphRuntime (5.x canonical API).
+ * const runtime = createExellixGraphRuntime({
+ *   // ... graphLoader, tasksClient, engineFactory, ...
+ *   eventEmitter: integration.eventEmitter,
+ * });
+ * ```
+ */
+import { EventEmitter } from '../runtime/events.js';
+/**
+ * ActivityTracker interface (type-only to avoid requiring the package at build time)
+ */
+export interface ActivityTrackerLike {
+    logGraphStart(metadata: {
+        jobId: string;
+        taskId?: string;
+        graphId: string;
+        agentId?: string;
+        startTime: number;
+        graphDefinition?: any;
+        input?: any;
+    }): Promise<{
+        activityId?: string;
+    }>;
+    logGraphComplete(metadata: {
+        jobId: string;
+        taskId?: string;
+        graphId: string;
+        endTime: number;
+        status: 'completed';
+        output?: any;
+        nodesExecuted?: number;
+        finalMemory?: any;
+    }): Promise<void>;
+    logGraphFail(error: any, metadata: {
+        jobId: string;
+        taskId?: string;
+        graphId: string;
+        endTime: number;
+        finalMemory?: any;
+    }): Promise<void>;
+    logNodeStart(metadata: {
+        jobId: string;
+        taskId?: string;
+        graphId: string;
+        nodeId: string;
+        startTime: number;
+        skillKey?: string;
+        nodeDefinition?: any;
+        input?: any;
+    }): Promise<{
+        activityId?: string;
+    }>;
+    logNodeComplete(activityId: string, metadata: {
+        endTime: number;
+        status: 'completed';
+        output?: any;
+        memoryAfter?: any;
+    }): Promise<void>;
+    logNodeFail(activityId: string, error: any, metadata: {
+        endTime: number;
+        memoryAfter?: any;
+    }): Promise<void>;
+}
+/**
+ * Creates an event emitter that forwards events to ActivityTracker
+ */
+export declare function createActivityTrackerIntegration(tracker: ActivityTrackerLike): {
+    eventEmitter: EventEmitter;
+    nodeActivityIds: Map<string, string>;
+};

package/dist/src/integrations/ActivityTrackerIntegration.js

@@ -0,0 +1,134 @@
+/**
+ * Integration helper for @athenices/ai-activities-tracking
+ *
+ * This module provides a bridge between exellix-graphs events and ActivityTracker.
+ * It listens to graph and node execution events and forwards them to ActivityTracker.
+ *
+ * Usage:
+ * ```typescript
+ * import { ActivityTracker } from '@athenices/ai-activities-tracking';
+ * import { createActivityTrackerIntegration } from '@exellix/graph-engine/integrations';
+ *
+ * const tracker = new ActivityTracker({ // config });
+ * await tracker.init();
+ *
+ * const integration = createActivityTrackerIntegration(tracker);
+ *
+ * // Use integration.eventEmitter with createExellixGraphRuntime (5.x canonical API).
+ * const runtime = createExellixGraphRuntime({
+ *   // ... graphLoader, tasksClient, engineFactory, ...
+ *   eventEmitter: integration.eventEmitter,
+ * });
+ * ```
+ */
+/**
+ * Creates an event emitter that forwards events to ActivityTracker
+ */
+export function createActivityTrackerIntegration(tracker) {
+    // Store node activity IDs for updates (node:complete and node:fail update the same record)
+    // Use composite key: "graphId:nodeId" since nodeId might not be unique across graphs
+    const nodeActivityIds = new Map();
+    const eventEmitter = {
+        emit(event) {
+            // Handle events asynchronously to avoid blocking graph execution
+            setImmediate(async () => {
+                try {
+                    if (event.type === 'graph:start') {
+                        const graphEvent = event;
+                        await tracker.logGraphStart({
+                            jobId: graphEvent.jobId,
+                            taskId: graphEvent.taskId,
+                            graphId: graphEvent.graphId,
+                            agentId: graphEvent.data?.agentId,
+                            startTime: graphEvent.timestamp,
+                            graphDefinition: graphEvent.data?.graphDefinition,
+                            input: graphEvent.data?.input,
+                        });
+                    }
+                    else if (event.type === 'graph:complete') {
+                        const graphEvent = event;
+                        await tracker.logGraphComplete({
+                            jobId: graphEvent.jobId,
+                            taskId: graphEvent.taskId,
+                            graphId: graphEvent.graphId,
+                            endTime: graphEvent.timestamp,
+                            status: 'completed',
+                            output: graphEvent.data?.output,
+                            nodesExecuted: graphEvent.data?.nodesExecuted,
+                            finalMemory: graphEvent.data?.finalMemory,
+                        });
+                    }
+                    else if (event.type === 'graph:fail') {
+                        const graphEvent = event;
+                        await tracker.logGraphFail(graphEvent.data?.error, {
+                            jobId: graphEvent.jobId,
+                            taskId: graphEvent.taskId,
+                            graphId: graphEvent.graphId,
+                            endTime: graphEvent.timestamp,
+                            finalMemory: graphEvent.data?.finalMemory,
+                        });
+                    }
+                    else if (event.type === 'node:start') {
+                        const nodeEvent = event;
+                        const nodeActivity = await tracker.logNodeStart({
+                            jobId: nodeEvent.jobId,
+                            taskId: nodeEvent.taskId,
+                            graphId: nodeEvent.graphId,
+                            nodeId: nodeEvent.nodeId,
+                            startTime: nodeEvent.timestamp,
+                            skillKey: nodeEvent.skillKey,
+                            nodeDefinition: nodeEvent.data?.nodeDefinition || nodeEvent.node,
+                            input: nodeEvent.data?.input,
+                        });
+                        // Store activityId for later updates (when tracker returns one)
+                        const nodeKey = `${nodeEvent.graphId}:${nodeEvent.nodeId}:${nodeEvent.taskId}`;
+                        if (nodeActivity.activityId)
+                            nodeActivityIds.set(nodeKey, nodeActivity.activityId);
+                    }
+                    else if (event.type === 'node:complete') {
+                        const nodeEvent = event;
+                        const nodeKey = `${nodeEvent.graphId}:${nodeEvent.nodeId}:${nodeEvent.taskId}`;
+                        const activityId = nodeActivityIds.get(nodeKey);
+                        if (activityId) {
+                            await tracker.logNodeComplete(activityId, {
+                                endTime: nodeEvent.timestamp,
+                                status: 'completed',
+                                output: nodeEvent.data?.output || nodeEvent.result,
+                                memoryAfter: nodeEvent.data?.memoryAfter,
+                            });
+                            // Clean up after successful update
+                            nodeActivityIds.delete(nodeKey);
+                        }
+                        else {
+                            console.warn(`Node activity not found for graphId: ${nodeEvent.graphId}, nodeId: ${nodeEvent.nodeId}`);
+                        }
+                    }
+                    else if (event.type === 'node:fail') {
+                        const nodeEvent = event;
+                        const nodeKey = `${nodeEvent.graphId}:${nodeEvent.nodeId}:${nodeEvent.taskId}`;
+                        const activityId = nodeActivityIds.get(nodeKey);
+                        if (activityId) {
+                            await tracker.logNodeFail(activityId, nodeEvent.error || nodeEvent.data?.error, {
+                                endTime: nodeEvent.timestamp,
+                                memoryAfter: nodeEvent.data?.memoryAfter,
+                            });
+                            // Clean up after successful update
+                            nodeActivityIds.delete(nodeKey);
+                        }
+                        else {
+                            console.warn(`Node activity not found for graphId: ${nodeEvent.graphId}, nodeId: ${nodeEvent.nodeId}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Log error but don't throw - activity tracking failures should not break graph execution
+                    console.error('Activity tracking error (non-fatal):', error);
+                }
+            });
+        },
+    };
+    return {
+        eventEmitter,
+        nodeActivityIds,
+    };
+}

package/dist/src/integrations/ActivixGraphRunIntegration.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bridges exellix-graph graph lifecycle events to @x12i/activix.
+ *
+ * Listens for `graph:start`, `graph:complete`, and `graph:fail`.
+ */
+import type { Activix } from '@x12i/activix';
+import type { EventEmitter } from '../runtime/events.js';
+export interface CreateActivixGraphRunIntegrationOptions {
+    /** Activix collection role (passed as `options.collection` to start/complete/fail). */
+    collection?: string;
+    /**
+     * When true, persist the full graph execution response object under `outer.output.data.response`
+     * (can be very large).
+     *
+     * Default: false (persist `outer.output.response` as finalOutput + keep structured node data under `outer.output.data`).
+     */
+    includeFullResponse?: boolean;
+    /**
+     * When true, persist memory snapshots under outer.memory.start/end (can be large).
+     * Default: false (persist summaries only).
+     */
+    includeMemorySnapshots?: boolean;
+}
+/**
+ * Returns an EventEmitter that persists graph lifecycle rows via Activix.
+ * Correlates start → complete/fail via an in-memory map keyed by `jobId:graphId:taskId`
+ * (host job id + graph id + engine-generated graph-run UUID).
+ *
+ * On `graph:start`, `outer.input` contains only bounded **`inputSummary`** / **`requestSummary`**
+ * (JSON-serializable); raw event input/request objects are not copied to Activix.
+ */
+export declare function createActivixGraphRunIntegration(ax: Activix, options?: CreateActivixGraphRunIntegrationOptions): {
+    eventEmitter: EventEmitter;
+};

package/dist/src/integrations/ActivixGraphRunIntegration.js

@@ -0,0 +1,338 @@
+function summarizeValueForRecord(value) {
+    if (value === null || value === undefined) {
+        return { shape: 'empty' };
+    }
+    if (typeof value === 'string') {
+        return { shape: 'string', length: value.length };
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const keys = Object.keys(value);
+        return { shape: 'object', keyCount: keys.length, keysSample: keys.slice(0, 40) };
+    }
+    if (Array.isArray(value)) {
+        return { shape: 'array', length: value.length };
+    }
+    return { shape: typeof value };
+}
+function getGraphNodeCount(graphDefinition) {
+    if (!graphDefinition)
+        return undefined;
+    if (Array.isArray(graphDefinition.nodes))
+        return graphDefinition.nodes.length;
+    if (graphDefinition.nodes && typeof graphDefinition.nodes === 'object') {
+        return Array.isArray(graphDefinition.nodes) ? graphDefinition.nodes.length : Object.values(graphDefinition.nodes).length;
+    }
+    return undefined;
+}
+function extractErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'object' && error) {
+        if ('message' in error)
+            return String(error.message ?? '');
+        if ('error' in error)
+            return extractErrorMessage(error.error);
+    }
+    return String(error ?? 'unknown error');
+}
+function isPlainObject(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/** Max nesting depth when summarizing arrays / nested structures for Activix. */
+const ACTIVIX_SUMMARY_MAX_DEPTH = 4;
+/** First N array elements get a bounded per-element summary. */
+const ACTIVIX_ARRAY_SAMPLE_LEN = 3;
+/** First N own keys on plain objects get shallow per-key summaries. */
+const ACTIVIX_OBJECT_PREVIEW_KEY_COUNT = 20;
+const ACTIVIX_STRING_PREVIEW_MAX = 64;
+/**
+ * Bounded, JSON-serializable summary for `graph:start` Activix payloads.
+ * Aligns with {@link summarizeValueForRecord} for leaves; adds shallow previews and array samples.
+ * Does not copy functions, class instances, streams, or circular structures as raw values.
+ */
+function summarizeForActivix(value, depth = 0, seen = new WeakSet()) {
+    if (depth > ACTIVIX_SUMMARY_MAX_DEPTH) {
+        return { shape: 'truncated', reason: 'maxDepth' };
+    }
+    if (value === null || value === undefined) {
+        return { shape: 'empty' };
+    }
+    const t = typeof value;
+    if (t === 'bigint') {
+        return { shape: 'bigint', hint: String(value).slice(0, 32) };
+    }
+    if (t === 'symbol') {
+        return { shape: 'symbol' };
+    }
+    if (t === 'function') {
+        const fn = value;
+        return { shape: 'function', name: fn.name || '' };
+    }
+    if (t === 'boolean' || t === 'number') {
+        return { shape: t, value: value };
+    }
+    if (t === 'string') {
+        const s = value;
+        return {
+            shape: 'string',
+            length: s.length,
+            preview: s.length <= ACTIVIX_STRING_PREVIEW_MAX ? s : `${s.slice(0, ACTIVIX_STRING_PREVIEW_MAX)}…`,
+        };
+    }
+    if (t !== 'object') {
+        return { shape: t };
+    }
+    const obj = value;
+    if (seen.has(obj)) {
+        return { shape: 'circular' };
+    }
+    if (value instanceof Date) {
+        return { shape: 'date', iso: value.toISOString() };
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+        return { shape: 'buffer', length: value.length };
+    }
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+        const view = value;
+        return { shape: 'typedArray', ctor: value.constructor?.name ?? 'ArrayBufferView', byteLength: view.byteLength };
+    }
+    if (value instanceof Map) {
+        return { shape: 'map', size: value.size };
+    }
+    if (value instanceof Set) {
+        return { shape: 'set', size: value.size };
+    }
+    if (value instanceof RegExp) {
+        return { shape: 'regexp', source: value.source.slice(0, 80) };
+    }
+    const maybeThen = value.then;
+    if (typeof maybeThen === 'function') {
+        return { shape: 'promise' };
+    }
+    if (typeof value.pipe === 'function') {
+        return { shape: 'streamLike' };
+    }
+    if (Array.isArray(value)) {
+        seen.add(obj);
+        const len = value.length;
+        const sample = value.slice(0, ACTIVIX_ARRAY_SAMPLE_LEN).map((el) => summarizeForActivix(el, depth + 1, seen));
+        seen.delete(obj);
+        return { shape: 'array', length: len, sample };
+    }
+    if (isPlainObject(value)) {
+        seen.add(obj);
+        const keys = Object.keys(value);
+        const out = {
+            shape: 'object',
+            keyCount: keys.length,
+            keysSample: keys.slice(0, 40),
+        };
+        const preview = {};
+        for (let i = 0; i < Math.min(keys.length, ACTIVIX_OBJECT_PREVIEW_KEY_COUNT); i++) {
+            const k = keys[i];
+            const v = value[k];
+            if (v === null || v === undefined) {
+                preview[k] = { shape: 'empty' };
+            }
+            else if (typeof v === 'string') {
+                const str = v;
+                preview[k] = {
+                    shape: 'string',
+                    length: str.length,
+                    preview: str.length <= 32 ? str : `${str.slice(0, 32)}…`,
+                };
+            }
+            else if (typeof v === 'number' || typeof v === 'boolean') {
+                preview[k] = { shape: typeof v, value: v };
+            }
+            else if (typeof v === 'bigint') {
+                preview[k] = { shape: 'bigint', hint: String(v).slice(0, 16) };
+            }
+            else {
+                preview[k] = summarizeForActivix(v, depth + 1, seen);
+            }
+        }
+        if (Object.keys(preview).length > 0) {
+            out.shallowPreview = preview;
+        }
+        seen.delete(obj);
+        return out;
+    }
+    return { shape: 'instance', ctor: value.constructor?.name ?? 'Object' };
+}
+/**
+ * Returns an EventEmitter that persists graph lifecycle rows via Activix.
+ * Correlates start → complete/fail via an in-memory map keyed by `jobId:graphId:taskId`
+ * (host job id + graph id + engine-generated graph-run UUID).
+ *
+ * On `graph:start`, `outer.input` contains only bounded **`inputSummary`** / **`requestSummary`**
+ * (JSON-serializable); raw event input/request objects are not copied to Activix.
+ */
+export function createActivixGraphRunIntegration(ax, options) {
+    const collection = options?.collection;
+    const includeFullResponse = options?.includeFullResponse === true;
+    const includeMemorySnapshots = options?.includeMemorySnapshots === true;
+    const colOpts = collection ? { collection } : undefined;
+    const graphRecordIds = new Map();
+    let initPromise = null;
+    function ensureInit() {
+        if (!initPromise) {
+            initPromise = ax.init().catch((err) => {
+                initPromise = null;
+                throw err;
+            });
+        }
+        return initPromise;
+    }
+    const eventEmitter = {
+        emit(event) {
+            setImmediate(async () => {
+                try {
+                    if (event.type === 'graph:start') {
+                        await ensureInit();
+                        const graphEvent = event;
+                        const data = graphEvent.data;
+                        const key = `${graphEvent.jobId}:${graphEvent.graphId}:${graphEvent.taskId}`;
+                        const inputVariables = data?.input?.variables;
+                        const inputVariableKeys = inputVariables ? Object.keys(inputVariables) : [];
+                        const agentId = data?.agentId;
+                        const jobType = data?.jobType;
+                        const graphNodeCount = getGraphNodeCount(data?.graphDefinition);
+                        // Activix v5+ correlation object is `runContext` and must include `sessionId`.
+                        // This SDK does not have a separate session id today, so we align it to `jobId`.
+                        const runContext = {
+                            sessionId: graphEvent.jobId,
+                            jobId: graphEvent.jobId,
+                            taskId: graphEvent.taskId,
+                            graphId: graphEvent.graphId,
+                            agentId,
+                            ...(jobType != null ? { jobType } : {}),
+                        };
+                        const outerMemoryStart = data?.memoryStart;
+                        const outerMetadata = {
+                            kind: 'exellix-graph-run',
+                            jobId: graphEvent.jobId,
+                            taskId: graphEvent.taskId,
+                            graphId: graphEvent.graphId,
+                            agentId,
+                            ...(jobType != null ? { jobType } : {}),
+                            graphNodeCount,
+                            inputVariableKeys,
+                            eventTimestamp: graphEvent.timestamp,
+                        };
+                        const base = {
+                            kind: 'exellix-graph-run',
+                            jobId: graphEvent.jobId,
+                            taskId: graphEvent.taskId,
+                            graphId: graphEvent.graphId,
+                            agentId,
+                            ...(jobType != null ? { jobType } : {}),
+                            graphNodeCount,
+                            inputVariableKeys,
+                            eventTimestamp: graphEvent.timestamp,
+                            runContext,
+                            outer: {
+                                input: {
+                                    inputSummary: summarizeForActivix(data?.input),
+                                    requestSummary: summarizeForActivix(data?.request),
+                                },
+                                output: undefined,
+                                memory: {
+                                    ...(includeMemorySnapshots ? { start: outerMemoryStart } : {}),
+                                },
+                                metadata: outerMetadata,
+                            },
+                        };
+                        const { recordId } = await ax.startRecord(base, colOpts);
+                        graphRecordIds.set(key, recordId);
+                    }
+                    else if (event.type === 'graph:complete') {
+                        await ensureInit();
+                        const graphEvent = event;
+                        const key = `${graphEvent.jobId}:${graphEvent.graphId}:${graphEvent.taskId}`;
+                        const recordId = graphRecordIds.get(key);
+                        if (!recordId)
+                            return;
+                        const data = graphEvent.data;
+                        const outerResponse = data?.response;
+                        const finalOutput = outerResponse?.finalOutput;
+                        const finalOutputSummary = summarizeValueForRecord(finalOutput);
+                        const responseSummary = summarizeValueForRecord(outerResponse);
+                        const outerMemoryEnd = data?.finalMemory;
+                        await ax.completeRecord(recordId, {
+                            completedAt: graphEvent.timestamp,
+                            nodesExecuted: data?.nodesExecuted,
+                            outputSummary: finalOutputSummary,
+                            outer: {
+                                output: {
+                                    // Canonical business response: finalOutput only.
+                                    response: finalOutput,
+                                    finalOutputSummary,
+                                    // Keep rich execution details under `data` (not the canonical response).
+                                    data: {
+                                        responseSummary,
+                                        nodes: outerResponse?.nodes,
+                                        execution: outerResponse?.execution,
+                                        jobMemory: outerResponse?.jobMemory,
+                                        error: outerResponse?.error,
+                                        ...(includeFullResponse ? { response: outerResponse } : {}),
+                                    },
+                                },
+                                memory: {
+                                    ...(includeMemorySnapshots ? { end: outerMemoryEnd } : {}),
+                                },
+                            },
+                        }, colOpts);
+                        graphRecordIds.delete(key);
+                    }
+                    else if (event.type === 'graph:fail') {
+                        await ensureInit();
+                        const graphEvent = event;
+                        const key = `${graphEvent.jobId}:${graphEvent.graphId}:${graphEvent.taskId}`;
+                        const recordId = graphRecordIds.get(key);
+                        if (!recordId)
+                            return;
+                        const data = graphEvent.data;
+                        const errorMessage = extractErrorMessage(data?.error ?? graphEvent.data?.error);
+                        const outerResponse = data?.response;
+                        const finalOutput = outerResponse?.finalOutput;
+                        const finalOutputSummary = summarizeValueForRecord(finalOutput);
+                        const responseSummary = summarizeValueForRecord(outerResponse);
+                        const outerMemoryEnd = data?.finalMemory;
+                        await ax.failRecord(recordId, errorMessage, {
+                            failedAt: graphEvent.timestamp,
+                            outer: {
+                                output: {
+                                    // Canonical business response (may be undefined on failure).
+                                    response: finalOutput,
+                                    finalOutputSummary,
+                                    data: {
+                                        responseSummary,
+                                        nodes: outerResponse?.nodes,
+                                        execution: outerResponse?.execution,
+                                        jobMemory: outerResponse?.jobMemory,
+                                        error: outerResponse?.error,
+                                        ...(includeFullResponse ? { response: outerResponse } : {}),
+                                    },
+                                },
+                                memory: {
+                                    ...(includeMemorySnapshots ? { end: outerMemoryEnd } : {}),
+                                },
+                            },
+                        }, colOpts);
+                        graphRecordIds.delete(key);
+                    }
+                }
+                catch (error) {
+                    console.error('Activix graph run activity error (non-fatal):', error);
+                }
+            });
+        },
+    };
+    return { eventEmitter };
+}

package/dist/src/integrations/ActivixNodeActivityIntegration.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bridges exellix-graph node execution events to @x12i/activix (start → complete / fail records).
+ *
+ * Listens for `node:start`, `node:complete`, and `node:fail` only. Graph-level events are ignored.
+ */
+import type { Activix } from '@x12i/activix';
+import type { EventEmitter } from '../runtime/events.js';
+export interface CreateActivixNodeActivityIntegrationOptions {
+    /** Activix collection role (passed as `options.collection` to start/complete/fail). */
+    collection?: string;
+    /**
+     * When true, attach lightweight input hints (variable keys, execution keys from jobMemory) on start records.
+     */
+    includeInputSnapshot?: boolean;
+    /**
+     * When true, attempt to extract NARRIX triage outcome fields from `node:complete` output and persist them as `narrixSummary`.
+     *
+     * This is intentionally best-effort and schema-light: it only extracts fields that exist on the node output.
+     */
+    extractNarrixOutcome?: boolean;
+}
+/**
+ * Returns an EventEmitter that persists node lifecycle rows via Activix.
+ * Correlates start → complete/fail using `graphId:nodeId:taskId` (includes engine-generated graph-run `taskId`).
+ */
+export declare function createActivixNodeActivityIntegration(ax: Activix, options?: CreateActivixNodeActivityIntegrationOptions): {
+    eventEmitter: EventEmitter;
+    /**
+     * In-flight record creation promises.
+     * We store promises so `node:complete` can await the `node:start` insert if it races.
+     */
+    nodeRecordIds: Map<string, Promise<string>>;
+};