nemo-fabric-adapters-pi 0.4.0-beta.2 → 0.4.0

package/README.md

@@ -22,16 +22,24 @@ The adapter supports:
 - Explicit local `.ts` or `.js` extension files contained by the NeMo Fabric
   workspace
 - Slash commands registered by those explicit extensions
+- NeMo Relay 0.9 telemetry through a runtime-owned gateway and an explicitly
+  configured Relay Pi extension
+- Live model-turn ATOF records for successful Relay redirects through the
+  default embedded NeMo Fabric collector. Startup `model_redirect` marks remain
+  in the configured Relay ATOF artifacts and are not included in per-invocation
+  `invoke_stream()` records
 - Ordered plain-text invocations with a `{ "response": "..." }` terminal
-  output
+  output, Relay runtime details, and collected ATOF artifacts
 
 Ambient Pi settings, context files, packages, extensions, skills, prompts,
 themes, model files, credentials, and session files are disabled. Explicitly
-configured extensions are trusted code.
+configured extensions are trusted code. The adapter raises the compaction
+reserve toward the selected model's maximum output while retaining at least
+half of the context window for input.
 
 ## Install the Adapter
 
-Pi 0.84.x requires Node.js 22.19.0 or newer.
+Pi 0.86.x requires Node.js 22.19.0 or newer.
 
 ### Install for Consumers
 
@@ -40,7 +48,7 @@ then install the compatible Pi SDK harness version selected by that project:
 
 ```bash
 npm install nemo-fabric-adapters-pi
-npm install @earendil-works/pi-ai@^0.84.2 @earendil-works/pi-coding-agent@^0.84.2
+npm install @earendil-works/pi-ai@^0.86.0 @earendil-works/pi-coding-agent@^0.86.0
 ```
 
 The adapter declares the Pi packages as optional peers. Installing the adapter
@@ -65,6 +73,27 @@ just build-typescript
 The full build installs its own dependencies, so you do not need to run
 `just install-typescript-pi` first.
 
+### Install NeMo Relay
+
+Relay-enabled Pi runs require `nemo-relay>=0.9.0,<0.10.0` on `PATH`. Install it
+separately from the npm adapter:
+
+```bash
+pip install "nemo-relay-cli-bin>=0.9.0,<0.10.0"
+```
+
+To select a specific Relay executable instead of relying on `PATH`, set
+`FABRIC_NEMO_RELAY_COMMAND` to its absolute path:
+
+```bash
+FABRIC_NEMO_RELAY_COMMAND="/absolute/path/to/nemo-relay" uv run python your_app.py
+```
+
+The adapter does not bundle the Relay Pi extension. Obtain the
+[`crates/cli/assets/pi-extension`](https://github.com/NVIDIA/NeMo-Relay/tree/0.9.0/crates/cli/assets/pi-extension)
+directory from the Relay 0.9 release and configure its path as described in the
+next section.
+
 ## Configure the Adapter
 
 The npm package includes its adapter descriptor as `pi.fabric-adapter.json`.
@@ -85,6 +114,95 @@ harness = HarnessConfig(adapter_id="nvidia.fabric.pi")
 For a source build, set `discovery.local_paths` to
 `adapters/typescript/pi/pi.fabric-adapter.json` instead.
 
+## Configure NeMo Relay
+
+Enable Relay with the standard NeMo Fabric configuration and provide the Relay
+Pi extension as an adapter setting:
+
+```python
+config.runtime.artifacts = "./artifacts/pi"
+config.enable_relay(output_dir="./artifacts/relay")
+config.harness.settings["relay_extension_path"] = (
+    "/path/to/NeMo-Relay/crates/cli/assets/pi-extension"
+)
+```
+
+Relay requires `runtime.artifacts` so NeMo Fabric can create the runtime-owned
+configuration passed to the adapter. The extension path can be absolute or
+relative to `environment.workspace`. It can identify a JavaScript or TypeScript
+file or a Pi extension package directory. Unlike user-configured Pi extensions,
+the Relay extension does not need to remain inside `environment.workspace` when
+an absolute path is used.
+
+When the runtime starts, the adapter validates the Relay 0.9 CLI, writes an
+explicit `plugins.toml`, starts a loopback gateway, and loads the extension into
+the isolated Pi session. The result includes `relay_runtime` and
+`relay_artifacts` in `output`. The gateway can produce ATOF, ATIF,
+OpenTelemetry, and OpenInference output from the Relay observability
+configuration.
+
+The adapter supports one Relay-enabled Pi runtime per adapter process because
+the Relay 0.9 extension receives its gateway and upstream configuration through
+process environment variables. NeMo Fabric starts each runtime in a separate
+adapter process, so concurrent NeMo Fabric runtimes remain isolated. Direct
+embedders must likewise place concurrent Relay-enabled Pi runtimes in separate
+processes.
+
+Local ATIF trajectories are finalized only after the Pi session closes and are
+therefore not included in `relay_artifacts`. The adapter does not wait for local
+ATIF during invocation; it collects per-invocation artifacts such as ATOF and
+returns the result. After runtime shutdown, retrieve the finalized file directly
+from the ATIF output directory. For the configuration above and the default
+filename template, it is written to
+`./artifacts/relay/<runtime_id>/trajectory-<session_id>.atif.json`. Invocation
+results do not prevent subsequent turns.
+
+Session, turn, and tool telemetry does not depend on model redirection. Model
+telemetry is available only when Relay supports the selected model API and the
+gateway upstream matches the model endpoint. Relay records a skipped redirect
+as a `model_redirect` mark with the reason in configured ATOF artifacts. Pi
+emits its startup redirect marks before NeMo Fabric registers an invocation, so
+they are not included in the per-invocation records from `invoke_stream()`.
+
+Install the matching collector for the embedded streaming path:
+
+```bash
+pip install "nemo-fabric[streaming]"
+```
+
+Start the runtime with streaming enabled to consume live model-turn ATOF
+records for successful Relay redirects in one Pi invocation:
+
+```python
+from nemo_fabric import Fabric
+
+async with await Fabric().start_runtime(config, streaming=True) as runtime:
+    stream = runtime.invoke_stream(input="Review the latest patch")
+    async for record in stream:
+        print(record)
+    result = await stream.result()
+```
+
+The terminal `RunResult` remains separate from the ATOF records. Fully consume
+each stream, or call `await stream.aclose()` if iteration stops early, before
+starting another invocation; the same runtime can then alternate
+`invoke_stream()` and `invoke()` calls. The embedded collector serializes both
+methods behind one Pi invocation lease. Streaming capture begins at the first
+Pi `turn_start` and closes at `agent_settled`. If Relay output is interrupted or
+late, the collector waits for a bounded interval, then admits the next native
+invocation and uses Pi's cumulative turn count to discard ambiguous delayed
+records until a higher `turn_start` arrives. This can thin the ATOF stream but
+does not block later invocations. Increase `completion_wait_timeout` from its
+one-second default when Relay delivery can take longer. Use the default embedded
+collector for Pi streaming. The Pi extension does not attach NeMo Fabric
+request IDs, so
+`start_runtime(..., streaming=True, launch_collector=False)` cannot correlate
+its records through an externally managed collector.
+
+This Relay-backed path runs the adapter's ordinary `invoke` operation. It is
+independent of native OpenAI streaming, so the adapter descriptor's
+`capabilities.streaming` value remains `false`.
+
 ## Custom Tool Modules
 
 The adapter accepts custom tools with `kind: "module"`. The `ref` is a
@@ -125,7 +243,23 @@ TypeScript packages, inspect the plan from the repository root:
 
 Refer to the
 [code-review example](../../../examples/code_review_agent/README.md) for the
-live NVIDIA-backed run command. Relay and MCP are not currently supported.
+live NVIDIA-backed run command. For a Relay-enabled Pi run, pass the extension
+path explicitly:
+
+```bash
+.venv/bin/python -m examples.code_review_agent \
+  --variant pi \
+  --relay \
+  --stream \
+  --pi-relay-extension-path /path/to/NeMo-Relay/crates/cli/assets/pi-extension \
+  --input "Review calculator.py"
+```
+
+The command collects per-invocation model-turn ATOF records for successful Relay
+redirects, then prints one JSON document containing `atof_records` and the
+separate terminal `result`. Redirect-decision marks remain in configured Relay
+ATOF artifacts; Pi's startup marks are not included in `atof_records`. MCP is
+not currently supported.
 
 ## Dependency Rationale
 
@@ -135,7 +269,7 @@ process; maintaining a second JSON-RPC translation was rejected for the bundled
 adapter. `@earendil-works/pi-ai` supplies Pi's model catalog and credential
 store, which the coding-agent SDK expects. Both packages are optional peer
 dependencies so deployments control the compatible harness version. Exact
-0.84.2 development dependencies keep repository builds and tests reproducible.
+0.86.0 development dependencies keep repository builds and tests reproducible.
 
 `jiti` loads explicitly configured, trusted JavaScript and TypeScript tool
 modules. Native Node.js loading cannot execute TypeScript modules, while a

package/dist/pi-sdk.d.ts

@@ -1,8 +1,17 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { AgentToolDefinition } from "nemo-fabric-adapter-contract";
 import { type AdapterStartInput } from "nemo-fabric-adapters-common";
+import { type PiRelayControllerFactory } from "./relay.js";
 import type { PiSessionFactory, PiSessionHandle } from "./runtime.js";
+export declare function withCustomBaseUrl<T extends {
+    api: string;
+    baseUrl: string;
+    compat?: object;
+}>(catalogModel: T, baseUrl: string | null | undefined, overrideBaseUrl?: boolean): T;
+export declare function modelAwareCompactionReserveTokens(configuredReserveTokens: number, maxOutputTokens: number, contextWindow: number): number;
 export declare function resolveCustomTools(workspace: string, definitions: Record<string, AgentToolDefinition>): Promise<ToolDefinition[]>;
 export declare class PiSdkSessionFactory implements PiSessionFactory {
+    private readonly relayFactory;
+    constructor(relayFactory?: PiRelayControllerFactory);
     create(input: AdapterStartInput): Promise<PiSessionHandle>;
 }

package/dist/pi-sdk.js

@@ -7,9 +7,32 @@ import { realpath, stat } from "node:fs/promises";
 import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createJiti } from "jiti/static";
 import { LifecycleError } from "nemo-fabric-adapters-common";
+import { PiRelayFactory, } from "./relay.js";
+export function withCustomBaseUrl(catalogModel, baseUrl, overrideBaseUrl = true) {
+    if (!baseUrl) {
+        return catalogModel;
+    }
+    const model = overrideBaseUrl ? { ...catalogModel, baseUrl } : catalogModel;
+    if (catalogModel.api !== "openai-completions") {
+        return model;
+    }
+    return {
+        ...model,
+        // Generic OpenAI-compatible proxies may reject provider-specific
+        // reasoning_content fields when Pi replays an assistant tool call.
+        compat: { ...catalogModel.compat, requiresThinkingAsText: true },
+    };
+}
+export function modelAwareCompactionReserveTokens(configuredReserveTokens, maxOutputTokens, contextWindow) {
+    const reserveTokens = Math.max(configuredReserveTokens, maxOutputTokens);
+    if (contextWindow <= 0) {
+        return reserveTokens;
+    }
+    return Math.min(reserveTokens, Math.floor(contextWindow / 2));
+}
 const PI_BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
 const TOOL_MODULE_EXTENSIONS = new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
-const PI_HARNESS_INSTALL_COMMAND = "npm install @earendil-works/pi-ai@^0.84.2 @earendil-works/pi-coding-agent@^0.84.2";
+const PI_HARNESS_INSTALL_COMMAND = "npm install @earendil-works/pi-ai@^0.86.0 @earendil-works/pi-coding-agent@^0.86.0";
 function isMissingModuleError(error) {
     return (typeof error === "object" &&
         error !== null &&
@@ -163,11 +186,6 @@ export async function resolveCustomTools(workspace, definitions) {
     }
     return tools;
 }
-function extensionToolNames(resourceLoader) {
-    return resourceLoader
-        .getExtensions()
-        .extensions.flatMap((extension) => Array.from(extension.tools.keys()));
-}
 function rejectToolCollisions(customTools, configuredExtensionTools) {
     const customNames = new Set(customTools.map((tool) => tool.name));
     const seenExtensionNames = new Set();
@@ -180,6 +198,19 @@ function rejectToolCollisions(customTools, configuredExtensionTools) {
         seenExtensionNames.add(name);
     }
 }
+function relayExtensionLoadErrors(errors, extensions, relay, workspace) {
+    if (relay === undefined) {
+        return [];
+    }
+    const loaded = extensions.some((extension) => [extension.path, extension.resolvedPath].some((path) => path !== undefined && resolve(workspace, path) === relay.extensionPath));
+    if (loaded) {
+        return [];
+    }
+    return errors.filter((error) => {
+        const path = resolve(workspace, error.path);
+        return path === relay.extensionPath || containedBy(relay.extensionPath, path);
+    });
+}
 async function resolveExtensionPaths(workspace, configured) {
     const resolved = [];
     for (const entry of configured) {
@@ -259,17 +290,33 @@ function unsupportedSessionAction(name) {
     throw new LifecycleError("pi_unsupported_session_operation", `Pi session operation ${name} is not supported`);
 }
 class PiSdkSessionHandle {
+    relay;
     session;
     state;
+    unsubscribeTurnCounter;
     stopped = false;
-    constructor(session, state) {
+    cumulativeTurnCount = 0;
+    constructor(session, state, relay) {
         this.session = session;
         this.state = state;
+        this.relay = relay;
+        this.unsubscribeTurnCounter = this.session.subscribe((event) => {
+            if (event.type === "turn_start") {
+                this.cumulativeTurnCount += 1;
+            }
+        });
+    }
+    get turnCount() {
+        return this.cumulativeTurnCount;
     }
     async prompt(text) {
         let accepted = false;
+        let turnStarted = false;
         let finalAssistant;
         const unsubscribe = this.session.subscribe((event) => {
+            if (event.type === "turn_start") {
+                turnStarted = true;
+            }
             if (event.type === "message_end" && event.message.role === "assistant") {
                 finalAssistant = event.message;
             }
@@ -288,6 +335,8 @@ class PiSdkSessionHandle {
         }
         return {
             accepted,
+            turnStarted,
+            turnCount: this.cumulativeTurnCount,
             text: finalAssistant === undefined ? undefined : promptText(finalAssistant),
             stopReason: finalAssistant?.stopReason,
             errorMessage: finalAssistant?.errorMessage,
@@ -312,6 +361,12 @@ class PiSdkSessionHandle {
         catch (error) {
             failure ??= error;
         }
+        try {
+            this.unsubscribeTurnCounter();
+        }
+        catch (error) {
+            failure ??= error;
+        }
         try {
             this.session.dispose();
         }
@@ -324,6 +379,10 @@ class PiSdkSessionHandle {
     }
 }
 export class PiSdkSessionFactory {
+    relayFactory;
+    constructor(relayFactory = new PiRelayFactory()) {
+        this.relayFactory = relayFactory;
+    }
     async create(input) {
         const systemInstruction = input.config.instructions?.system;
         if (systemInstruction?.mode === "append") {
@@ -359,38 +418,6 @@ export class PiSdkSessionFactory {
         const extensionPaths = await resolveExtensionPaths(workspace, harnessSettings(input.config).extensions);
         const skillPaths = await resolveSkillPaths(input.baseDir, input.config.skills?.paths ?? []);
         const customTools = await resolveCustomTools(workspace, input.config.tools?.definitions ?? {});
-        const agentDir = join(workspace, ".fabric-pi");
-        const resourceLoader = new pi.DefaultResourceLoader({
-            cwd: workspace,
-            agentDir,
-            settingsManager: settings,
-            additionalExtensionPaths: extensionPaths,
-            additionalSkillPaths: skillPaths,
-            noExtensions: true,
-            noSkills: true,
-            noPromptTemplates: true,
-            noThemes: true,
-            noContextFiles: true,
-            systemPrompt: systemInstruction?.content,
-        });
-        await resourceLoader.reload();
-        const extensionErrors = resourceLoader.getExtensions().errors;
-        if (extensionErrors.length > 0) {
-            throw new LifecycleError("pi_extension_load_failed", "One or more configured Pi extensions failed to load", {
-                metadata: { count: extensionErrors.length },
-            });
-        }
-        rejectToolCollisions(customTools, extensionToolNames(resourceLoader));
-        const skillDiagnostics = resourceLoader.getSkills().diagnostics;
-        const blockingSkillDiagnostics = skillDiagnostics.filter((diagnostic) => diagnostic.type === "error" || diagnostic.type === "collision");
-        for (const diagnostic of skillDiagnostics.filter((entry) => entry.type === "warning")) {
-            process.stderr.write(`Pi skill warning: ${diagnostic.message}\n`);
-        }
-        if (blockingSkillDiagnostics.length > 0) {
-            throw new LifecycleError("pi_skill_load_failed", "One or more configured NeMo Fabric skills failed to load", {
-                metadata: { count: blockingSkillDiagnostics.length },
-            });
-        }
         const credentials = new pi.InMemoryCredentialStore();
         const modelRuntime = await pi.ModelRuntime.create({
             credentials,
@@ -399,28 +426,97 @@ export class PiSdkSessionFactory {
             refreshOnCreate: false,
         });
         await modelRuntime.setRuntimeApiKey(selected.provider, apiKey);
+        const relayEnabled = input.runtimeContext.telemetry?.relay_enabled === true;
+        if (relayEnabled && selected.base_url) {
+            // Configure the provider before Relay loads so its provider-wide redirect
+            // sees a consistent catalog instead of one overlaid selected model.
+            modelRuntime.registerProvider(selected.provider, {
+                baseUrl: selected.base_url,
+            });
+        }
         const catalogModel = modelRuntime.getModel(selected.provider, selected.model);
         if (catalogModel === undefined) {
             throw new LifecycleError("pi_model_unknown", "The selected provider and model are not present in Pi's catalog");
         }
-        const model = selected.base_url ? { ...catalogModel, baseUrl: selected.base_url } : catalogModel;
-        const enabled = input.config.tools?.enabled;
-        const blocked = input.config.tools?.blocked ?? [];
-        const state = { shutdownRequested: false };
-        const { session } = await pi.createAgentSession({
-            cwd: workspace,
-            agentDir,
-            model,
-            modelRuntime,
-            resourceLoader,
-            sessionManager: pi.SessionManager.inMemory(workspace),
-            settingsManager: settings,
-            customTools,
-            tools: enabled === null ? undefined : enabled,
-            excludeTools: blocked,
+        const model = withCustomBaseUrl(catalogModel, selected.base_url, !relayEnabled);
+        const compactionReserveTokens = modelAwareCompactionReserveTokens(settings.getCompactionReserveTokens(), model.maxTokens, model.contextWindow);
+        settings.applyOverrides({
+            compaction: {
+                reserveTokens: compactionReserveTokens,
+            },
         });
-        const handle = new PiSdkSessionHandle(session, state);
+        let relay;
+        let handle;
         try {
+            relay = await this.relayFactory.start(input, {
+                api: model.api,
+                baseUrl: model.baseUrl,
+            });
+            if (relay !== undefined && !extensionPaths.includes(relay.extensionPath)) {
+                extensionPaths.push(relay.extensionPath);
+            }
+            const agentDir = join(workspace, ".fabric-pi");
+            const resourceLoader = new pi.DefaultResourceLoader({
+                cwd: workspace,
+                agentDir,
+                settingsManager: settings,
+                additionalExtensionPaths: extensionPaths,
+                additionalSkillPaths: skillPaths,
+                noExtensions: true,
+                noSkills: true,
+                noPromptTemplates: true,
+                noThemes: true,
+                noContextFiles: true,
+                systemPrompt: systemInstruction?.content,
+            });
+            await resourceLoader.reload();
+            const extensionResult = resourceLoader.getExtensions();
+            rejectToolCollisions(customTools, extensionResult.extensions.flatMap((extension) => [...extension.tools.keys()]));
+            const extensionErrors = extensionResult.errors;
+            const relayErrors = relayExtensionLoadErrors(extensionErrors, extensionResult.extensions, relay, workspace);
+            if (relayErrors.length > 0) {
+                throw new LifecycleError("pi_relay_extension_load_failed", "The configured NeMo Relay Pi extension failed to load; use the Pi extension from the NeMo Relay 0.9 release", {
+                    metadata: {
+                        count: relayErrors.length,
+                        relay_error: relayErrors.map((error) => error.error).join("; "),
+                    },
+                });
+            }
+            if (extensionErrors.length > 0) {
+                throw new LifecycleError("pi_extension_load_failed", "One or more configured Pi extensions failed to load or conflict", {
+                    metadata: {
+                        count: extensionErrors.length,
+                        extension_error: extensionErrors.map((error) => error.error).join("; "),
+                        extension_paths: extensionErrors.map((error) => error.path),
+                    },
+                });
+            }
+            const skillDiagnostics = resourceLoader.getSkills().diagnostics;
+            const blockingSkillDiagnostics = skillDiagnostics.filter((diagnostic) => diagnostic.type === "error" || diagnostic.type === "collision");
+            for (const diagnostic of skillDiagnostics.filter((entry) => entry.type === "warning")) {
+                process.stderr.write(`Pi skill warning: ${diagnostic.message}\n`);
+            }
+            if (blockingSkillDiagnostics.length > 0) {
+                throw new LifecycleError("pi_skill_load_failed", "One or more configured NeMo Fabric skills failed to load", {
+                    metadata: { count: blockingSkillDiagnostics.length },
+                });
+            }
+            const enabled = input.config.tools?.enabled;
+            const blocked = input.config.tools?.blocked ?? [];
+            const state = { shutdownRequested: false };
+            const { session } = await pi.createAgentSession({
+                cwd: workspace,
+                agentDir,
+                model,
+                modelRuntime,
+                resourceLoader,
+                sessionManager: pi.SessionManager.inMemory(workspace),
+                settingsManager: settings,
+                customTools,
+                tools: enabled === null ? undefined : enabled,
+                excludeTools: blocked,
+            });
+            handle = new PiSdkSessionHandle(session, state, relay);
             const blockedNames = new Set(blocked);
             const availableNames = new Set(session.getAllTools().map((tool) => tool.name));
             const missing = (enabled ?? []).filter((name) => !blockedNames.has(name) && !availableNames.has(name));
@@ -451,15 +547,17 @@ export class PiSdkSessionFactory {
                     process.stderr.write("Pi extension handler failed\n");
                 },
             });
+            // bindExtensions emits session_start; emitting it here would create a
+            // duplicate Relay session scope.
             return handle;
         }
         catch (error) {
-            try {
-                await handle.stop();
-            }
-            catch {
+            await handle?.stop().catch(() => {
                 process.stderr.write("Pi session cleanup failed after adapter startup error\n");
-            }
+            });
+            await relay?.stop().catch(() => {
+                process.stderr.write("NeMo Relay cleanup failed after Pi adapter startup error\n");
+            });
             throw error;
         }
     }

package/dist/relay-config.d.ts

@@ -0,0 +1,35 @@
+import type { Dirent } from "node:fs";
+import type { AdapterStartInput } from "nemo-fabric-adapters-common";
+export type RelayPluginConfig = Record<string, unknown>;
+export interface RelayConfigPaths {
+    configPath: string;
+    pluginConfigPath: string;
+}
+export interface RelayArtifact {
+    kind: "atof" | "atif";
+    path: string;
+}
+export interface RelayAtifMatcher {
+    directory: string;
+    local: boolean;
+    pattern: RegExp;
+    recursive: boolean;
+    template: string;
+}
+type ReadDirectory = (directory: string, options: {
+    withFileTypes: true;
+}) => Promise<Dirent[]>;
+export declare function validateRelayObservabilityV3(pluginConfig: RelayPluginConfig): void;
+export declare function normalizeRelayOutputDirs(pluginConfig: RelayPluginConfig, input: AdapterStartInput): Promise<void>;
+export declare function loadRelayPluginConfig(input: AdapterStartInput): Promise<RelayPluginConfig>;
+export declare function encodeToml(value: Record<string, unknown>): string;
+export declare function writeRelayConfigs(pluginConfig: RelayPluginConfig): Promise<RelayConfigPaths>;
+export declare function matchesRelayAtifPath(matcher: RelayAtifMatcher, path: string): boolean;
+export declare function prepareRelayAtifMatchers(pluginConfig: RelayPluginConfig): Promise<RelayAtifMatcher[]>;
+export declare function collectAtifArtifacts(matchers: RelayAtifMatcher[], options?: {
+    localOnly?: boolean;
+    readDirectory?: ReadDirectory;
+    strict?: boolean;
+}): Promise<RelayArtifact[]>;
+export declare function collectRelayArtifacts(pluginConfig: RelayPluginConfig, atifMatchers?: RelayAtifMatcher[]): Promise<RelayArtifact[]>;
+export {};