nexus-agentd 0.3.0 → 0.4.0

package/dist/artifact-store.js

@@ -35,6 +35,7 @@ export class ArtifactStore {
     pending = new Map();
     inFlight = new Map();
     pendingDeletes = new Set();
+    pendingManifests = new Set();
     queuedBytes = 0;
     totalBytes = 0;
     activeDrain;
@@ -261,11 +262,49 @@ export class ArtifactStore {
             this.entries.set(entryKey(runId, normalized.id), entry);
             byId.set(normalized.id, next);
         }
-        const views = Array.from(byId.values()).slice(0, this.maxArtifactsPerRun);
+        this.trimRunEntries(runId);
+        const views = this.viewsForRun(runId);
         this.emit(runId, views);
         this.scheduleDrain();
         return structuredClone(views);
     }
+    /**
+     * Caps how many artifacts a single run retains. `recordArtifacts` is
+     * incremental, so a protocol stream that reports a fresh id per event
+     * (screenshots, timestamped logs) would otherwise grow `entries` without
+     * bound and make every emit clone the whole run.
+     */
+    trimRunEntries(runId) {
+        const entries = Array.from(this.entries.values())
+            .filter((entry) => entry.runId === runId)
+            .sort((left, right) => left.view.createdAt - right.view.createdAt);
+        let excess = entries.length - this.maxArtifactsPerRun;
+        if (excess <= 0)
+            return;
+        for (const entry of entries) {
+            if (excess <= 0)
+                break;
+            // An in-flight payload cannot be unlinked while it is being
+            // written; it is the newest entry in practice, so a later call
+            // trims it instead.
+            if (this.inFlight.has(entryKey(runId, entry.id)))
+                continue;
+            this.dropEntry(entry);
+            excess -= 1;
+        }
+    }
+    dropEntry(entry) {
+        this.entries.delete(entryKey(entry.runId, entry.id));
+        this.removePending(entry.runId, entry.id);
+        this.totalBytes -= entry.bytes || 0;
+        if (entry.filePath) {
+            const filePath = entry.filePath;
+            void this.safeUnlink(filePath).catch(() => undefined);
+        }
+        // The manifest still lists the dropped entry; rewrite it on the next
+        // drain so a restart cannot resurrect an artifact with no payload.
+        this.pendingManifests.add(entry.runId);
+    }
     /** Merge display metadata from a RunStore update without dropping storage state. */
     mergeViews(runId, views, notify = true) {
         this.assertInitialized();
@@ -356,14 +395,45 @@ export class ArtifactStore {
                 this.queuedBytes -= item.bytes.length;
             this.pending.delete(runId);
         }
+        this.pendingManifests.delete(runId);
         this.pendingDeletes.add(runId);
         this.scheduleDrain();
     }
+    /**
+     * Delete a single artifact: drop its payload file and record entry. The
+     * run record itself stays; its artifacts list shrinks via the views
+     * callback. Refused while the payload write is still in flight.
+     */
+    async removeArtifact(runId, artifactId) {
+        this.assertInitialized();
+        const key = entryKey(runId, artifactId);
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        if (this.inFlight.has(key))
+            return false;
+        const batch = this.pending.get(runId);
+        const queued = batch?.get(artifactId);
+        if (queued) {
+            this.queuedBytes -= queued.bytes.length;
+            batch.delete(artifactId);
+            if (!batch.size)
+                this.pending.delete(runId);
+        }
+        if (entry.filePath) {
+            await this.safeUnlink(entry.filePath);
+            this.totalBytes -= entry.bytes || 0;
+        }
+        this.entries.delete(key);
+        await this.writeManifest(runId);
+        this.emit(runId, this.viewsForRun(runId));
+        return true;
+    }
     async flush() {
         this.assertInitialized();
         if (this.activeDrain)
             await this.activeDrain;
-        if (this.pending.size || this.pendingDeletes.size) {
+        if (this.pending.size || this.pendingDeletes.size || this.pendingManifests.size) {
             // A previous background attempt may have failed. Keep the
             // snapshot dirty and let an explicit flush retry it.
             this.lastError = undefined;
@@ -424,11 +494,28 @@ export class ArtifactStore {
     }
     async drainLoop() {
         this.lastError = undefined;
-        while (this.pending.size || this.pendingDeletes.size) {
+        while (this.pending.size || this.pendingDeletes.size || this.pendingManifests.size) {
             const runId = this.pendingDeletes.values().next().value;
             if (runId) {
                 this.pendingDeletes.delete(runId);
-                await this.deleteRunDirectory(runId);
+                try {
+                    await this.deleteRunDirectory(runId);
+                }
+                catch (error) {
+                    // Keep the delete queued: dropping it would leave the
+                    // directory on disk with no record left to remove it.
+                    this.pendingDeletes.add(runId);
+                    throw error;
+                }
+                continue;
+            }
+            const manifestRunId = this.pendingManifests.values().next().value;
+            if (manifestRunId) {
+                this.pendingManifests.delete(manifestRunId);
+                // removeRun drops the whole directory; rewriting a manifest
+                // afterwards would recreate it.
+                if (this.runIds.has(manifestRunId))
+                    await this.writeManifest(manifestRunId);
                 continue;
             }
             const batchEntry = this.pending.entries().next().value;
@@ -468,8 +555,13 @@ export class ArtifactStore {
         const startedAt = performance.now();
         const key = entryKey(item.runId, item.id);
         let entry = this.entries.get(key);
-        if (!entry)
+        if (!entry) {
+            // The entry was dropped after this batch left `pending`, so
+            // removeRun and dropEntry could no longer see it there. Releasing
+            // the budget here is the only remaining place that can.
+            this.queuedBytes -= item.bytes.length;
             return;
+        }
         const runDir = this.runDirectory(item.runId);
         await this.io.mkdir(runDir, { recursive: true, mode: 0o700 });
         await this.ensureDirectory(runDir, false);

package/dist/process-tree.js

@@ -1,23 +1,45 @@
 import { spawn } from 'node:child_process';
 const DEFAULT_GRACE_MS = 2_000;
 const FORCE_KILL_WAIT_MS = 1_000;
+// Enumerating costs about a second on an idle machine and considerably more
+// when the gateway is busy. The sweep runs on every teardown — including a
+// failed ACP startup, which callers bound at five seconds — so it is capped
+// short: an incomplete sweep beats a teardown that never returns.
+const PROCESS_TABLE_TIMEOUT_MS = 1_200;
+const PROCESS_TABLE_TTL_MS = 1_000;
+// Windows reports a killed process as gone from `tasklist` slightly before the
+// kernel closes the handles it held, so callers that delete the workspace or
+// temp directory right after a teardown can still see EBUSY.
+const PROCESS_EXIT_SETTLE_MS = 150;
+let processTableCache;
 export async function terminateProcessTree(child, options = {}) {
     const pid = child.pid;
     if (!pid)
         return;
     const graceMs = Math.max(0, options.graceMs ?? DEFAULT_GRACE_MS);
     if (process.platform === 'win32') {
-        // Once a Windows process has exited taskkill can no longer address its
-        // descendants by the parent's PID. Callers should tear down before
-        // exit when they need Windows tree semantics.
-        if (hasExited(child))
-            return;
-        await taskkill(pid, false);
-        if (await waitForExit(child, graceMs))
-            return;
-        await taskkill(pid, true);
-        if (await waitForExit(child, FORCE_KILL_WAIT_MS))
+        // `taskkill` without /F only posts WM_CLOSE, which console processes
+        // never handle: the graceful pass always fails and burns the whole
+        // grace period before the forced retry. Force the tree kill directly.
+        if (!hasExited(child)) {
+            await taskkill(pid, true);
+            if (!(await waitForExit(child, Math.max(graceMs, FORCE_KILL_WAIT_MS)))) {
+                // A forced kill can still lose the race on a loaded machine,
+                // where the process takes longer than the wait to disappear.
+                await taskkill(pid, true);
+                await waitForExit(child, FORCE_KILL_WAIT_MS);
+            }
+        }
+        // A forced `taskkill /T` walks the tree as it exists at that instant,
+        // so a child spawned moments before the leader died survives as an
+        // orphan holding ports, file locks and inherited pipes — and a leader
+        // that exited before we got here cannot be addressed by taskkill at
+        // all. Sweep by parent id in both cases.
+        await terminateOrphanedDescendants(pid);
+        if (hasExited(child)) {
+            await delay(PROCESS_EXIT_SETTLE_MS);
             return;
+        }
         throw new Error(`Failed to terminate process ${pid}`);
     }
     if (options.ownsProcessGroup === true) {
@@ -106,6 +128,111 @@ function taskkill(pid, force) {
         killer.once('exit', finish);
     });
 }
+/**
+ * Kills every process that still records `pid` as an ancestor.
+ *
+ * `taskkill /T` walks the live process tree, so it cannot reach children once
+ * their parent has exited. Windows keeps the original parent id on the child
+ * after that, which is enough to find the survivors. Best-effort by design: an
+ * unreadable process table just leaves the sweep incomplete.
+ */
+async function terminateOrphanedDescendants(pid) {
+    const doomed = collectDescendants(await windowsProcessTable(), pid);
+    if (!doomed.length)
+        return;
+    for (const target of doomed)
+        await taskkill(target, true);
+    // Killing a parent can strand its own children, so rescan for what is left.
+    const remaining = collectDescendants(await windowsProcessTable(true), pid);
+    for (const survivor of remaining)
+        await taskkill(survivor, true);
+}
+function collectDescendants(table, root) {
+    if (!table)
+        return [];
+    const found = [];
+    const pending = [...(table.get(root) || [])];
+    while (pending.length) {
+        const next = pending.shift();
+        if (found.includes(next))
+            continue;
+        found.push(next);
+        pending.push(...(table.get(next) || []));
+    }
+    return found;
+}
+/**
+ * Snapshots the Windows process table as parent id -> child ids. Enumerating
+ * costs about a second, and a teardown that arrives alongside others (probing
+ * every driver at startup, shutting a session down) asks the same question, so
+ * concurrent callers share one snapshot. `refresh` bypasses it when the answer
+ * has to describe the state after a kill.
+ */
+function windowsProcessTable(refresh = false) {
+    const now = Date.now();
+    if (!refresh && processTableCache && now - processTableCache.at < PROCESS_TABLE_TTL_MS) {
+        return processTableCache.promise;
+    }
+    const promise = snapshotProcessTable();
+    processTableCache = { at: now, promise };
+    return promise;
+}
+function snapshotProcessTable() {
+    return new Promise((resolve) => {
+        let lister;
+        try {
+            lister = spawn('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId)" }'
+            ], { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        let output = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            try {
+                lister.kill();
+            }
+            catch { }
+            finish(undefined);
+        }, PROCESS_TABLE_TIMEOUT_MS);
+        lister.stdout?.on('data', (chunk) => {
+            output = `${output}${String(chunk)}`.slice(-4_000_000);
+        });
+        lister.once('error', () => finish(undefined));
+        lister.once('exit', (code) => {
+            finish(code === 0 ? parseProcessTable(output) : undefined);
+        });
+    });
+}
+function parseProcessTable(output) {
+    const table = new Map();
+    for (const line of output.split(/\r?\n/)) {
+        const match = /^(\d+)\s+(\d+)$/.exec(line.trim());
+        if (!match)
+            continue;
+        const child = Number(match[1]);
+        const parent = Number(match[2]);
+        const siblings = table.get(parent);
+        if (siblings)
+            siblings.push(child);
+        else
+            table.set(parent, [child]);
+    }
+    return table;
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/run-store.d.ts

@@ -35,6 +35,32 @@ export interface RunListQuery {
     limit?: number;
     offset?: number;
 }
+export interface RunArtifactQuery {
+    agentId?: string;
+    /** 'all' keeps every kind; otherwise one of artifactKind() values. */
+    kind?: string;
+    query?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface RunArtifactRow {
+    id: string;
+    runId: string;
+    agentId: string;
+    agentName: string;
+    runState: AgentdSessionState;
+    runStartedAt: number;
+    name?: string;
+    filename?: string;
+    mediaType?: string;
+    size?: number;
+    kind: string;
+    downloadable: boolean;
+    storageStatus?: string;
+    createdAt?: number;
+}
+/** Coarse bucket used by the console filter and list grouping. */
+export declare function artifactKind(mediaType: string | undefined): "image" | "audio" | "video" | "file";
 export declare class RunStore {
     readonly filePath: string;
     private readonly runs;
@@ -60,6 +86,13 @@ export declare class RunStore {
     recordArtifacts(runId: string, artifacts: AgentdArtifact[]): StoredArtifactView[] | undefined;
     artifactViews(runId: string): StoredArtifactView[] | undefined;
     readArtifact(runId: string, artifactId: string): Promise<ArtifactReadResult | undefined>;
+    /** Flat, newest-first artifact index across all retained runs. */
+    listArtifacts(query?: RunArtifactQuery): {
+        artifacts: RunArtifactRow[];
+        total: number;
+    };
+    /** Delete one artifact's payload and record entry; the run record stays. */
+    removeArtifact(runId: string, artifactId: string): Promise<boolean>;
     getOwnerKeyId(runId: string): string | undefined;
     metrics(): {
         historyBytes: number;
@@ -78,6 +111,11 @@ export declare class RunStore {
         artifactStoreStats: ArtifactStoreMetrics;
     };
     setRetryOfRunId(runId: string, retryOfRunId?: string): AgentdRunDetail | undefined;
+    /**
+     * Remove a terminal run record and its stored artifacts. Active runs are
+     * refused so a live turn cannot lose its progress tracking.
+     */
+    deleteRun(id: string): AgentdRunDetail | undefined;
     get(id: string): AgentdRunDetail | undefined;
     list(query?: RunListQuery): {
         runs: AgentdRunView[];

package/dist/run-store.js

@@ -3,6 +3,17 @@ import { chmod, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promi
 import path from 'node:path';
 import { ArtifactStore, artifactStorePathForRunStore } from './artifact-store.js';
 export { ArtifactStore, artifactStorePathForRunStore } from './artifact-store.js';
+/** Coarse bucket used by the console filter and list grouping. */
+export function artifactKind(mediaType) {
+    const type = String(mediaType || '').toLowerCase();
+    if (type.startsWith('image/'))
+        return 'image';
+    if (type.startsWith('video/'))
+        return 'video';
+    if (type.startsWith('audio/'))
+        return 'audio';
+    return 'file';
+}
 const STATES = new Set([
     'created',
     'running',
@@ -187,6 +198,55 @@ export class RunStore {
             return undefined;
         return this.artifactStore.readArtifact(runId, artifactId);
     }
+    /** Flat, newest-first artifact index across all retained runs. */
+    listArtifacts(query = {}) {
+        this.assertInitialized();
+        const needle = String(query.query || '').trim().toLowerCase();
+        const limit = Math.min(200, Math.max(1, Number(query.limit) || 50));
+        const offset = Math.max(0, Math.floor(Number(query.offset) || 0));
+        const rows = [];
+        for (const run of this.runs.values()) {
+            for (const view of run.artifacts || []) {
+                if (!view.id)
+                    continue;
+                if (query.agentId && run.agentId !== query.agentId)
+                    continue;
+                const kind = artifactKind(view.mediaType);
+                if (query.kind && query.kind !== 'all' && kind !== query.kind)
+                    continue;
+                if (needle) {
+                    const haystack = `${view.name || ''} ${view.filename || ''}`.toLowerCase();
+                    if (!haystack.includes(needle))
+                        continue;
+                }
+                rows.push({
+                    id: view.id,
+                    runId: run.id,
+                    agentId: run.agentId,
+                    agentName: run.agentName,
+                    runState: run.state,
+                    runStartedAt: run.startedAt,
+                    name: view.name,
+                    filename: view.filename,
+                    mediaType: view.mediaType,
+                    size: view.size,
+                    kind,
+                    downloadable: view.downloadable === true,
+                    storageStatus: view.storageStatus,
+                    createdAt: view.createdAt
+                });
+            }
+        }
+        rows.sort((left, right) => (right.createdAt || 0) - (left.createdAt || 0));
+        return { artifacts: rows.slice(offset, offset + limit), total: rows.length };
+    }
+    /** Delete one artifact's payload and record entry; the run record stays. */
+    async removeArtifact(runId, artifactId) {
+        this.assertInitialized();
+        if (!this.runs.has(runId))
+            return false;
+        return this.artifactStore.removeArtifact(runId, artifactId);
+    }
     getOwnerKeyId(runId) {
         this.assertInitialized();
         return this.runs.get(runId)?.ownerKeyId;
@@ -211,6 +271,22 @@ export class RunStore {
     setRetryOfRunId(runId, retryOfRunId) {
         return this.update(runId, { retryOfRunId });
     }
+    /**
+     * Remove a terminal run record and its stored artifacts. Active runs are
+     * refused so a live turn cannot lose its progress tracking.
+     */
+    deleteRun(id) {
+        this.assertInitialized();
+        const run = this.runs.get(id);
+        if (!run)
+            return undefined;
+        if (isActive(run.state))
+            return undefined;
+        this.runs.delete(id);
+        this.artifactStore.removeRun(id);
+        this.changed();
+        return publicDetail(run);
+    }
     get(id) {
         this.assertInitialized();
         const run = this.runs.get(id);
@@ -366,16 +442,31 @@ export class RunStore {
         const run = this.runs.get(runId);
         if (!run)
             return;
-        run.artifacts = structuredClone(views);
-        run.artifactCount = run.artifacts.length;
-        run.updatedAt = this.now();
         if (!this.initialized) {
+            // The artifact store prunes during its own init and emits as it
+            // goes, but at that point it only knows about manifest-backed
+            // entries — the rest of runs.json has not been restored yet.
+            // Replacing wholesale would drop metadata-only artifacts for good,
+            // while skipping the update would lose the storage status the
+            // prune just decided (expired/evicted), which restoreRun then
+            // misreads as metadata_only. Merge both sides instead.
+            run.artifacts = mergeArtifactViews(run.artifacts, views);
+            run.artifactCount = run.artifacts.length;
             this.dirty = true;
             return;
         }
+        run.artifacts = structuredClone(views);
+        run.artifactCount = run.artifacts.length;
+        run.updatedAt = this.now();
         this.changed();
     }
 }
+function mergeArtifactViews(existing, incoming) {
+    const merged = new Map(existing.map((view) => [view.id, view]));
+    for (const view of incoming)
+        merged.set(view.id, view);
+    return Array.from(merged.values());
+}
 export function runStorePathForConfig(configPath) {
     const absolute = path.resolve(configPath);
     const extension = path.extname(absolute);

package/dist/server.js

@@ -505,15 +505,68 @@ async function handleAdminRoute(context, url) {
         await handleAdminRunAction(context, decodeURIComponent(runActionMatch[1]), runActionMatch[2]);
         return;
     }
+    if (url.pathname === '/v1/admin/artifacts' && request.method === 'GET') {
+        writeJson(response, 200, sessions.listArtifacts({
+            agentId: cleanQuery(url.searchParams.get('agentId')),
+            kind: cleanQuery(url.searchParams.get('kind')),
+            query: cleanQuery(url.searchParams.get('q')),
+            offset: boundedOffset(url.searchParams.get('offset')),
+            limit: boundedLimit(url.searchParams.get('limit'))
+        }));
+        return;
+    }
     const adminArtifactMatch = url.pathname.match(/^\/v1\/admin\/runs\/([^/]+)\/artifacts\/([^/]+)$/);
     if (adminArtifactMatch && request.method === 'GET') {
         const run = sessions.getRun(decodeURIComponent(adminArtifactMatch[1]));
         await writeRunArtifact(response, sessions, run, decodeURIComponent(adminArtifactMatch[2]));
         return;
     }
+    if (adminArtifactMatch && request.method === 'DELETE') {
+        await assertEmptyJsonBody(request, config.maxRequestBytes);
+        const runId = decodeURIComponent(adminArtifactMatch[1]);
+        const artifactId = decodeURIComponent(adminArtifactMatch[2]);
+        const run = sessions.getRun(runId);
+        if (!isTerminalState(run.state)) {
+            throw new RequestError(409, 'Artifacts of active runs cannot be deleted; cancel the task first');
+        }
+        const deleted = await sessions.removeRunArtifact(runId, artifactId);
+        if (!deleted)
+            throw new RequestError(404, 'Agent Nexus artifact not found');
+        console.info(JSON.stringify({
+            level: 'info',
+            event: 'admin_artifact_deleted',
+            runId,
+            artifactId,
+            agentId: run.agentId,
+            requestId: String(response.getHeader('X-Request-Id') || '')
+        }));
+        writeJson(response, 200, { deleted: true, runId, artifactId });
+        return;
+    }
     const runMatch = url.pathname.match(/^\/v1\/admin\/runs\/([^/]+)$/);
-    if (runMatch && request.method === 'GET') {
+    if (runMatch && (request.method === 'GET' || request.method === 'DELETE')) {
         const runId = decodeURIComponent(runMatch[1]);
+        if (request.method === 'DELETE') {
+            await assertEmptyJsonBody(request, config.maxRequestBytes);
+            const detail = sessions.getRun(runId);
+            if (!isTerminalState(detail.state)) {
+                throw new RequestError(409, 'Active runs cannot be deleted; cancel the task first');
+            }
+            const deleted = sessions.deleteRun(runId);
+            if (!deleted)
+                throw new RequestError(404, 'Agent Nexus run not found');
+            console.info(JSON.stringify({
+                level: 'info',
+                event: 'admin_run_record_deleted',
+                runId,
+                sessionId: detail.sessionId,
+                agentId: detail.agentId,
+                state: detail.state,
+                requestId: String(response.getHeader('X-Request-Id') || '')
+            }));
+            writeJson(response, 200, { deleted: true, id: runId });
+            return;
+        }
         const detail = sessions.getRun(runId);
         writeJson(response, 200, {
             ...detail,
@@ -778,6 +831,7 @@ function buildRunControls(sessions, detail) {
     return {
         canCancel,
         canRetry,
+        canDelete: !active,
         ...(pendingRequest ? { pendingRequest: structuredClone(pendingRequest) } : {}),
         ...(unavailableReason ? { unavailableReason } : {})
     };

package/dist/session/admin-runs.js

@@ -73,6 +73,7 @@ export class AdminRunManager {
         return {
             canCancel: current && active && Boolean(session?.runtimeAvailable()),
             canRetry,
+            canDelete: isTerminal(run.state),
             ...(pendingRequest ? { pendingRequest } : {}),
             ...(unavailableReason ? { unavailableReason } : {})
         };

package/dist/session.d.ts

@@ -1,6 +1,6 @@
 import type { AgentDriver } from './drivers/index.js';
 import { SessionEventLog } from './events.js';
-import { RunStore, type RunListQuery } from './run-store.js';
+import { RunStore, type RunListQuery, type RunArtifactQuery } from './run-store.js';
 import { type AdminRetryReservationFactory, type AdminRunOperationResult, type AdminRunControls } from './session/admin-runs.js';
 import type { AcpSessionSink, AgentSessionRuntime, AgentSessionSink } from './session-contract.js';
 import type { AgentdAgentView, AgentdArtifact, AgentdConfig, AgentdEvent, AgentdEventType, AgentdInputAttachmentView, AgentdPendingRequest, AgentdPendingResponse, AgentdProtocol, AgentdSessionState, AgentdSessionView, AgentdTurnCompletionProof } from './types.js';
@@ -114,8 +114,14 @@ export declare class SessionManager {
     };
     getRun(id: string): import("./types.js").AgentdRunDetail;
     getRunOwnerKeyId(id: string): string | undefined;
+    deleteRun(id: string): import("./types.js").AgentdRunDetail | undefined;
     ownsRun(id: string, keyId: string): boolean;
     getRunArtifacts(id: string): import("./types.js").AgentdRunArtifactView[];
+    listArtifacts(query?: RunArtifactQuery): {
+        artifacts: import("./run-store.js").RunArtifactRow[];
+        total: number;
+    };
+    removeRunArtifact(runId: string, artifactId: string): Promise<boolean | undefined>;
     getStorageMetrics(): ReturnType<RunStore['metrics']> | undefined;
     readRunArtifact(runId: string, artifactId: string): Promise<import("./artifact-store.js").ArtifactReadResult | undefined>;
     getRunArtifact(runId: string, artifactId: string): Promise<import("./artifact-store.js").ArtifactReadResult | undefined>;