@namzu/sdk 43.0.0 → 44.0.0

package/src/eval/from-run.ts

@@ -1,48 +0,0 @@
-import type { Run } from '../types/run/entity.js'
-import type { EvalRun } from './types.js'
-
-/**
- * Project a finished `Run` into the shape scorers consume.
- *
- * This is the whole bridge between the harness and the runtime, and it is
- * three lines of mapping because `Run.steps` now exists. Before that, a
- * trajectory scorer would have had to correlate raw `RunEvent`s by
- * iteration number and diff cumulative counters — which is why the step
- * record had to land before the harness could.
- */
-export function evalRunFromRun(run: Run, opts: { durationMs?: number } = {}): EvalRun {
-	const steps = run.steps ?? []
-	return {
-		output: run.result ?? null,
-		...(run.structuredOutput !== undefined ? { structuredOutput: run.structuredOutput } : {}),
-		steps,
-		// Flattened in call order across steps — the trajectory.
-		toolCalls: steps.flatMap((s) => s.toolCalls.map((c) => c.function.name)),
-		...(run.stopReason ? { stopReason: run.stopReason } : {}),
-		totalTokens: run.tokenUsage.totalTokens,
-		totalCostUsd: run.costInfo.totalCost,
-		durationMs: opts.durationMs ?? (run.endedAt ?? Date.now()) - run.startedAt,
-		...(run.lastError ? { error: run.lastError } : {}),
-	}
-}
-
-/**
- * Drain a `query()` generator to its returned `Run`, then project it.
- *
- * The common case, so it does not need writing per suite:
- *
- * ```ts
- * runExperiment({
- *   name: 'file-editing',
- *   cases,
- *   scorers: [trajectoryScorer(), completionScorer()],
- *   run: (input) => evalRunFromQuery(query({ provider, tools, messages: input, … })),
- * })
- * ```
- */
-export async function evalRunFromQuery(generator: AsyncGenerator<unknown, Run>): Promise<EvalRun> {
-	const startedAt = Date.now()
-	let next = await generator.next()
-	while (!next.done) next = await generator.next()
-	return evalRunFromRun(next.value, { durationMs: Date.now() - startedAt })
-}

package/src/manager/run/emergency.ts

@@ -1,148 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import {
-	mkdirSync,
-	readFileSync,
-	readdirSync,
-	renameSync,
-	unlinkSync,
-	writeFileSync,
-} from 'node:fs'
-import { join } from 'node:path'
-import {
-	EMERGENCY_DIR_NAME,
-	EMERGENCY_EVENTS,
-	EMERGENCY_SIGNALS,
-} from '../../constants/emergency.js'
-import { NAMZU } from '../../constants/telemetry/index.js'
-import type { EmergencySaveData } from '../../types/run/emergency.js'
-import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
-import type { Logger } from '../../utils/logger.js'
-import type { RunPersistence } from './persistence.js'
-
-export class EmergencySaveManager {
-	private static _instance: EmergencySaveManager | undefined
-	private runRef: WeakRef<RunPersistence> | undefined
-	private outputDir: string | undefined
-	private signalHandlers: Map<string, () => void> = new Map()
-	private log: Logger
-
-	private constructor(log: Logger) {
-		this.log = log
-	}
-
-	static instance(log?: Logger): EmergencySaveManager {
-		if (!EmergencySaveManager._instance) {
-			if (!log) {
-				throw new Error('EmergencySaveManager requires a logger on first initialization')
-			}
-			EmergencySaveManager._instance = new EmergencySaveManager(log)
-		}
-		return EmergencySaveManager._instance
-	}
-
-	attach(runMgr: RunPersistence, outputDir: string, log: Logger): void {
-		this.detach()
-		this.runRef = new WeakRef(runMgr)
-		this.outputDir = outputDir
-		this.log = log.child({ [SCOPE_ATTRIBUTE]: 'manager/run/emergency' })
-
-		// Attaching a listener for SIGINT/SIGTERM/uncaughtException suppresses
-		// Node's default termination behavior. After saving state we MUST
-		// terminate explicitly, otherwise Ctrl+C leaves the process running
-		// and uncaught errors stop propagating as crashes.
-		for (const signal of EMERGENCY_SIGNALS) {
-			const exitCode = signal === 'SIGINT' ? 130 : 143 // 128 + signal number
-			const handler = (): void => {
-				this.emergencySave(signal)
-				process.exit(exitCode)
-			}
-			this.signalHandlers.set(signal, handler)
-			process.on(signal, handler)
-		}
-
-		for (const event of EMERGENCY_EVENTS) {
-			const handler = (): void => {
-				this.emergencySave(event)
-				process.exit(1)
-			}
-			this.signalHandlers.set(event, handler)
-			process.on(event, handler)
-		}
-
-		this.log.info('Emergency save handlers attached', { 'namzu.manager.output_dir': outputDir })
-	}
-
-	detach(): void {
-		for (const [signal, handler] of this.signalHandlers) {
-			process.removeListener(signal, handler)
-		}
-		this.signalHandlers.clear()
-		this.runRef = undefined
-		this.outputDir = undefined
-	}
-
-	emergencySave(signal: string): void {
-		const runMgr = this.runRef?.deref()
-		if (!runMgr || !this.outputDir) {
-			return
-		}
-
-		let tmpPath: string | undefined
-		try {
-			const snapshot = runMgr.toEmergencySnapshot(signal)
-
-			const emergencyDir = join(this.outputDir, '..', EMERGENCY_DIR_NAME)
-			mkdirSync(emergencyDir, { recursive: true })
-
-			tmpPath = join(emergencyDir, `${snapshot.runId}.json.tmp.${randomUUID()}`)
-			const finalPath = join(emergencyDir, `${snapshot.runId}.json`)
-
-			writeFileSync(tmpPath, JSON.stringify(snapshot, null, '\t'), 'utf-8')
-			renameSync(tmpPath, finalPath)
-			tmpPath = undefined
-
-			this.log.warn('Emergency save completed', {
-				[NAMZU.RUN_ID]: snapshot.runId,
-				'namzu.manager.signal': signal,
-				'namzu.manager.path': finalPath,
-			})
-		} catch (err) {
-			if (tmpPath) {
-				try {
-					unlinkSync(tmpPath)
-				} catch {
-					// best-effort cleanup; swallowing here is intentional because we
-					// are already in a crash-handling path and must not throw.
-				}
-			}
-			try {
-				this.log.error('Emergency save failed', {
-					'namzu.manager.signal': signal,
-					'exception.message': err instanceof Error ? err.message : String(err),
-				})
-			} catch {
-				// Logger itself failed — nothing more we can safely do.
-			}
-		}
-	}
-
-	static listSaves(baseDir: string): string[] {
-		const emergencyDir = join(baseDir, EMERGENCY_DIR_NAME)
-		try {
-			return readdirSync(emergencyDir)
-				.filter((f) => f.endsWith('.json'))
-				.map((f) => join(emergencyDir, f))
-		} catch {
-			return []
-		}
-	}
-
-	static loadSave(filePath: string): EmergencySaveData {
-		const raw = readFileSync(filePath, 'utf-8')
-		return JSON.parse(raw) as EmergencySaveData
-	}
-
-	static clearSave(filePath: string): void {
-		unlinkSync(filePath)
-	}
-}