n8n/dist/modules/instance-ai/tracing/instance-ai-tracing.service.d.ts

n8n Workflow Automation Tool

import type { Logger } from '@n8n/backend-common';
import type { User } from '@n8n/db';
import { type InstanceAiTraceContext, type ManagedBackgroundTask, type ModelConfig, type RunStateRegistry, type ServiceProxyConfig } from '@n8n/instance-ai';
import type { AiService } from '../../../services/ai.service';
import type { InProcessEventBus } from '../event-bus/in-process-event-bus';
import { type InstanceAiRunTraceMetadataOptions } from '../run-trace-metadata';
import type { DbSnapshotStorage } from '../storage/db-snapshot-storage';
export interface MessageTraceFinalization {
    status: 'completed' | 'cancelled' | 'error' | 'suspended';
    outputText?: string;
    reason?: string;
    modelId?: ModelConfig;
    outputs?: Record<string, unknown>;
    metadata?: Record<string, unknown>;
    error?: string;
}
export type OrchestratorResumeReason = 'approval' | 'background_task_completed' | 'workflow_verification' | 'workflow_setup' | 'planned_checkpoint' | 'replan' | 'synthesize';
export type InstanceAiTracingEventBus = Pick<InProcessEventBus, 'getEventsForRun'>;
export type InstanceAiTracingRunState = Pick<RunStateRegistry<User>, 'attachTracing'>;
export type InstanceAiTracingSnapshotStorage = Pick<DbSnapshotStorage, 'findLangsmithAnchor'>;
export type InstanceAiTracingAiService = Pick<AiService, 'isProxyEnabled' | 'getClient'>;
export type InstanceAiTracingServiceOptions = {
    logger: Logger;
    eventBus: InstanceAiTracingEventBus;
    runState: InstanceAiTracingRunState;
    dbSnapshotStorage: InstanceAiTracingSnapshotStorage;
    aiService: InstanceAiTracingAiService;
};
export declare class InstanceAiTracingService {
    private readonly traceContextsByRunId;
    private readonly traceReplay;
    private readonly logger;
    private readonly eventBus;
    private readonly runState;
    private readonly dbSnapshotStorage;
    private readonly aiService;
    constructor(options: InstanceAiTracingServiceOptions);
    storeTraceContext(runId: string, threadId: string, tracing: InstanceAiTraceContext, messageGroupId?: string): void;
    getTraceContext(runId: string): InstanceAiTraceContext | undefined;
    getMessageGroupId(runId: string): string | undefined;
    getTrackedThreadIds(): string[];
    clear(): void;
    getTraceContextForContinuation(threadId: string, messageGroupId?: string): InstanceAiTraceContext | undefined;
    createOrchestratorResumeTraceContext(options: {
        baseTracing?: InstanceAiTraceContext;
        threadId: string;
        messageId: string;
        messageGroupId?: string;
        runId: string;
        userId: string;
        modelId?: ModelConfig;
        input: Record<string, unknown>;
        proxyConfig?: ServiceProxyConfig;
        resumeReason: OrchestratorResumeReason;
        metadata?: Record<string, unknown>;
    }): Promise<InstanceAiTraceContext | undefined>;
    configureTraceReplayMode(tracing: InstanceAiTraceContext): Promise<void>;
    finalizeMessageTraceRoot(runId: string, tracing: InstanceAiTraceContext, options: MessageTraceFinalization): Promise<void>;
    maybeFinalizeRunTraceRoot(runId: string, options: MessageTraceFinalization): Promise<void>;
    buildMessageTraceMetadata(threadId: string, runId: string, options: InstanceAiRunTraceMetadataOptions): Record<string, unknown>;
    finalizeRemainingMessageTraceRoots(threadId: string, options: MessageTraceFinalization): Promise<void>;
    deleteTraceContextsForThread(threadId: string): void;
    private deleteTraceContextsForSlug;
    clearTraceContextsForTest(): void;
    finalizeDetachedTraceRun(taskId: string, traceContext: InstanceAiTraceContext | undefined, options: {
        status: 'completed' | 'failed' | 'cancelled';
        outputs?: Record<string, unknown>;
        error?: string;
        metadata?: Record<string, unknown>;
    }): Promise<void>;
    finalizeRunTracing(runId: string, tracing: InstanceAiTraceContext | undefined, options: MessageTraceFinalization): Promise<void>;
    finalizeBackgroundTaskTracing(task: ManagedBackgroundTask, status: 'completed' | 'failed' | 'cancelled'): Promise<void>;
    submitLangsmithFeedback(user: User, threadId: string, responseId: string, payload: {
        rating: 'up' | 'down';
        comment?: string;
    }): Promise<void>;
    loadTraceEvents(slug: string, events: unknown[]): void;
    getTraceEvents(slug: string): unknown[];
    activateTraceSlug(slug: string): void;
    clearTraceEvents(slug: string): void;
}