@steel-dev/atlas 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USAGE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+![Atlas — Research Agent for the Open Web](https://raw.githubusercontent.com/steel-dev/atlas/main/cover.png)
+
+# Atlas
+
+**Research Agent for the Open Web**
+
+```ts
+import { Atlas } from "@steel-dev/atlas";
+import { anthropic } from "@ai-sdk/anthropic";
+
+const atlas = new Atlas({ model: anthropic("claude-fable-5") });
+const { report } = await atlas.research(
+  "What's changing in browser automation for AI agents?",
+);
+```
+
+## Install
+
+```bash
+npm install @steel-dev/atlas ai @ai-sdk/anthropic
+# or @ai-sdk/openai / @ai-sdk/google
+```
+
+**Search:** `tavily.search()` / `exa.search()` / `brave.search()` (auto from env keys), or `native.search({ model })` to use the model provider's own web search.
+
+**Fetch:** `basic.fetch()` by default; `steel.fetch()` for JS-rendered pages when `STEEL_API_KEY` is set.
+
+```ts
+import { Atlas, exa, steel, basic } from "@steel-dev/atlas";
+
+const atlas = new Atlas({
+  model,
+  search: exa.search(),
+  fetch: [basic.fetch(), steel.fetch({ proxy: true })],
+});
+```
+
+## Orchestrate researchers
+
+Register other research agents — including Atlas itself — as a fleet. Atlas decomposes the question, routes each sub-task to the best-fit researcher (`query → report`), runs them in isolation, then synthesizes one report. With no `researchers` set it stays a single spine run.
+
+```ts
+import { Atlas, exa, perplexity, parallel } from "@steel-dev/atlas";
+
+const atlas = new Atlas({
+  model,
+  researchers: {
+    exa: exa.agent(), // Exa deep-research (via exa-js)
+    perplexity: perplexity.agent(), // Perplexity Sonar
+    parallel: parallel.agent(), // parallel.ai task API
+  },
+});
+
+await atlas.research("Compare X across academic and shopping angles");
+```
+
+Any `query → report` worker plugs in via `researcher({ description, research })` — `description` drives routing. `atlas.asResearcher(description)` exposes an Atlas instance as a worker, so fan-out can recurse. A worker returns `{ report, sources }` and may add `cost` (USD).
+
+## Extend it
+
+Plug in domain sources with `researchTool`: anything via `ctx.addSource` flows through the same source store:
+
+```ts
+import { Atlas, researchTool } from "@steel-dev/atlas";
+
+const atlas = new Atlas({
+  model,
+  tools: {
+    pubmed_search: researchTool({
+      description: "Search PubMed.",
+      inputSchema: z.object({ query: z.string() }),
+      execute: async ({ query }, ctx) => {
+        const studies = await pubmed.search(query, { signal: ctx.signal });
+        for (const s of studies)
+          ctx.addSource({ url: s.url, title: s.title, content: s.abstract });
+        return studies.map((s) => `- ${s.title}`).join("\n");
+      },
+    }),
+  },
+});
+```
+
+`ctx` (`ToolContext`) provides `addSource({ url, title?, content })`, `fetchText(url)` (a guarded fetch returning extracted text or `null`), `log(message)`, and `signal`.
+
+**Models per role:** the top-level `model` is the lead; override the stage models with `models.research` and `models.write`. Each defaults to the lead model when unset.
+
+**Z.ai / GLM:** use Z.ai through its OpenAI-compatible endpoint:
+
+```ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { Atlas, tavily } from "@steel-dev/atlas";
+
+const zai = createOpenAI({
+  apiKey: process.env.ZAI_API_KEY!,
+  baseURL: "https://api.z.ai/api/paas/v4",
+});
+
+const atlas = new Atlas({
+  model: zai.chat("glm-5.2"),
+  search: tavily.search(),
+});
+```
+
+The examples also accept `--provider zai` with `ZAI_API_KEY` / `ATLAS_ZAI_API_KEY`. Configure `tavily.search()`, `exa.search()`, or `brave.search()` for search; Atlas does not map Z.ai's web-search API to an AI SDK native search tool.
+
+**Concurrency:** `concurrency: { models: 4, io: 10 }` or `ATLAS_MODEL_CONCURRENCY` / `ATLAS_IO_CONCURRENCY`.
+
+## Stream it
+
+```ts
+const run = atlas.start(question, { effort: "balanced" });
+
+let preview = "";
+for await (const e of run.events()) {
+  if (e.type === "report.reset") preview = "";
+  if (e.type === "report.delta") preview += e.text;
+  if (e.type === "source.fetched") console.error(e.url);
+}
+
+const result = await run.result();
+```
+
+`report.delta` carries the working draft as it is written and revised; `report.reset` precedes each rewrite, so clear your preview buffer on it. `report.completed` (and `result.report`) is canonical after citation binding. `run.finish()` synthesizes from whatever's gathered so far; `run.abort()` discards it. Late subscribers get full event history.
+
+## Resume & providers
+
+Journaled runs replay completed model/search/fetch calls without new provider charges after a crash or deploy:
+
+```ts
+import { Atlas, fileStore } from "@steel-dev/atlas";
+
+const store = fileStore("./runs");
+const atlas = new Atlas({ model, store });
+atlas.start(question, { runId: "run_42" });
+// …restart…
+await new Atlas({ model, store }).resume("run_42");
+```
+
+Replay issues no new provider calls, but it re-charges the run's original budget and token caps as it restores progress — so a resumed run continues within the headroom left when it stopped, and `resume()` keeps those original caps (it doesn't take a higher budget). `result.stats.costUSD` reports only the new spend, excluding replayed calls.
+
+## Results
+
+```ts
+result.report; // cited markdown
+result.note; // short note on how the research was approached
+result.citations; // { sourceId, marker } per cited source — marker is its [N] in the report (same contract on single-spine and orchestrated runs)
+result.unboundCitations; // source ids cited in the draft that didn't resolve to a fetched source
+result.warnings; // non-fatal issues (e.g. a researcher that returned nothing)
+result.sources; // sources backing the report (via = fetch method, or the researcher that returned it on a fleet run)
+result.stats; // cost, tokens, duration, …
+result.trace; // timing/cost trace + bottleneck digest when trace !== "off"
+```
+
+## Structured output
+
+Pass a `schema` to get a typed object extracted from the finished report, returned alongside the full result. It runs as a final pass over the report, so it works on any path — single spine run, orchestrated fleet, or an outsourced researcher — and its cost is charged to the same budget and counted in `result.stats.costUSD`.
+
+```ts
+import { z } from "zod";
+
+const r = await atlas.research("Acme's latest annual revenue and CEO?", {
+  schema: z.object({ revenue: z.string(), ceo: z.string() }),
+});
+
+r.object; // typed: { revenue: string; ceo: string }
+r.report; // the cited report it was extracted from
+```
+
+## Budget
+
+One meter for everything. Pick an effort, or override any cap with `budget`.
+
+| effort     | ~budget | sources | tokens |
+| ---------- | ------- | ------- | ------ |
+| `fast`     | $0.50   | 15      | 200K   |
+| `balanced` | $2.50   | 40      | 1M     |
+| `deep`     | $10     | 100     | 4M     |
+| `max`      | $40     | 250     | 16M    |
+
+```ts
+await atlas.research(question, {
+  effort: "deep",
+  budget: { maxUSD: 5, maxTokens: 50_000_000 },
+});
+```
+
+`maxUSD` is a **best-effort target, not a hard ceiling.** The meter checks between agent turns, so a run stops _starting_ work once spent, but in-flight calls (up to `concurrency.models`) can overshoot. Pricing comes from a built-in table that can lag provider changes — pass `pricing` to correct a rate when the cap must be accurate.
+
+The real backstops are **price-independent** — each defaults to the effort row above and is enforced regardless of prices:
+
+- `budget.maxTokens` — input + output tokens run-wide (cache reads excluded). Checked between turns like `maxUSD`, but never drifts with prices.
+- `budget.maxSources`, `budget.maxDurationMs` — fetched-source and wall-clock caps.
+
+`result.stats` reports `budgetExhausted` and `tokensExhausted` so you can see which limit bound the run. Leave headroom on `maxUSD`, or set a provider-side spend limit, when the cap is truly hard.
+
+`result.stats.stopReason` folds those into one value — `"completed"`, `"finished"` (`run.finish()`), or a binding cap (`"budget"`, `"tokens"`, `"timeout"`). When several apply, the most proximate wins.
+
+## Safety
+
+Untrusted web content is quarantined (data, not instructions). Fetches pass SSRF guards hop-by-hop; `run_code` runs in a memory-capped V8 isolate with no network, filesystem, or host access. Direct fetch honors robots.txt.
+
+The isolate needs the optional `isolated-vm` dependency; without it, `run_code` is dropped from the toolset and the run proceeds without it — Atlas never falls back to an unsandboxed evaluator.
+
+The SSRF guard validates DNS at check time but can't pin the connection, so an attacker controlling DNS can defeat it via rebinding. Treat it as defense-in-depth — for hostile targets, run behind network-level egress controls that block private ranges.
+
+## Dev
+
+```bash
+git clone https://github.com/steel-dev/atlas.git && cd atlas
+npm install && npm run dev -- "your question"
+```
+
+- `examples/cli.ts`: terminal runs
+- `examples/serve.ts`: SSE web app
+- `evals/`: BrowseComp + DRACO (`npm run eval:browsecomp`, `npm run eval:draco`)
+
+## License
+
+MIT

package/dist/agent.d.ts

@@ -0,0 +1,34 @@
+import { type ModelMessage } from "ai";
+import type { BudgetGrant } from "./budget.js";
+import type { AgentRole } from "./events.js";
+import { type ModelRole } from "./model.js";
+import { type RunCtx } from "./state.js";
+import { type ToolName } from "./tools.js";
+export declare const CONTEXT_BUDGET_STOP = "context budget reached";
+export interface AgentSpec {
+    role: AgentRole;
+    modelRole: ModelRole;
+    task: string;
+    system: string;
+    tools: ToolName[];
+    grant: BudgetGrant;
+    depth: number;
+    parentId?: string | undefined;
+    maxTurns?: number | undefined;
+    maxOutputTokensPerStep?: number | undefined;
+    maxContextTokens?: number | undefined;
+    tokenCeiling?: number | undefined;
+    captureMessages?: boolean | undefined;
+    memoryCursor?: number | undefined;
+    forceFirstTool?: ToolName | undefined;
+    stopWhenSatisfied?: (() => boolean) | undefined;
+}
+export interface AgentResult {
+    agentId: string;
+    note: string;
+    spentUSD: number;
+    stopReason: string;
+    messages?: ModelMessage[];
+}
+export declare function runAgent(rctx: RunCtx, spec: AgentSpec): Promise<AgentResult>;
+export declare function describeBudget(rctx: RunCtx): string;

package/dist/agent.js

@@ -0,0 +1,133 @@
+import { generateText, stepCountIs } from "ai";
+import { stubToolResultWindow } from "./memory.js";
+import { MODEL_CALL_MAX_RETRIES, totalFreshTokens, } from "./model.js";
+import { budgetStatusLine } from "./state.js";
+import { buildAgentTools } from "./tools.js";
+import { currentFrame, withTraceFrame } from "./trace.js";
+const TASK_PREVIEW_CHARS = 300;
+export const CONTEXT_BUDGET_STOP = "context budget reached";
+export async function runAgent(rctx, spec) {
+    const agentId = `agent_${rctx.agentSequence.next++}`;
+    const actx = {
+        agentId,
+        role: spec.role,
+        grant: spec.grant,
+        depth: spec.depth,
+    };
+    const toolNames = spec.tools;
+    const tools = buildAgentTools(rctx, actx, toolNames);
+    const model = rctx.bindModel(spec.modelRole, spec.grant);
+    let governorReason = null;
+    let lastText = "";
+    const recorder = rctx.recorder;
+    const parentSpanId = recorder ? currentFrame()?.parentSpanId : undefined;
+    const agentSpanId = recorder?.mintSpanId();
+    const agentStartedAt = recorder ? recorder.now() : 0;
+    const logicalAgentId = agentId;
+    const agentFrame = {
+        agentId,
+        logicalAgentId,
+        role: spec.role,
+        depth: spec.depth,
+        site: spec.role,
+        ...(agentSpanId ? { parentSpanId: agentSpanId } : {}),
+    };
+    const result = await withTraceFrame(recorder, agentFrame, () => generateText({
+        model,
+        system: spec.system,
+        prompt: spec.task,
+        tools,
+        maxRetries: MODEL_CALL_MAX_RETRIES,
+        abortSignal: rctx.signal,
+        ...(spec.maxOutputTokensPerStep
+            ? { maxOutputTokens: spec.maxOutputTokensPerStep }
+            : {}),
+        stopWhen: [
+            stepCountIs(spec.maxTurns ?? rctx.config.envelope.maxTurns),
+            ({ steps }) => {
+                if (spec.grant.floored()) {
+                    governorReason = "budget exhausted";
+                    return true;
+                }
+                if (spec.tokenCeiling !== undefined &&
+                    totalFreshTokens(rctx.usage) >= spec.tokenCeiling) {
+                    governorReason = "token ceiling reached";
+                    return true;
+                }
+                const runReason = rctx.stopReason();
+                if (runReason) {
+                    governorReason = runReason;
+                    return true;
+                }
+                if (spec.stopWhenSatisfied?.()) {
+                    governorReason = "ledger satisfied";
+                    return true;
+                }
+                if (spec.maxContextTokens !== undefined) {
+                    const inputTokens = steps.at(-1)?.usage.inputTokens;
+                    if (typeof inputTokens === "number" &&
+                        inputTokens >= spec.maxContextTokens) {
+                        governorReason = CONTEXT_BUDGET_STOP;
+                        return true;
+                    }
+                }
+                return false;
+            },
+        ],
+        prepareStep: ({ stepNumber, messages }) => {
+            const memory = spec.memoryCursor !== undefined
+                ? {
+                    messages: stubToolResultWindow(messages, spec.memoryCursor),
+                }
+                : {};
+            if (spec.forceFirstTool && stepNumber === 0) {
+                return {
+                    toolChoice: {
+                        type: "tool",
+                        toolName: spec.forceFirstTool,
+                    },
+                    ...memory,
+                };
+            }
+            return memory;
+        },
+        onStepFinish: (step) => {
+            if (step.text?.trim())
+                lastText = step.text.trim();
+        },
+    }));
+    const note = result.text.trim() || lastText;
+    const stopReason = governorReason ??
+        (result.finishReason === "stop" || result.finishReason === "tool-calls"
+            ? "completed"
+            : result.finishReason);
+    if (recorder && agentSpanId) {
+        recorder.recordAgentSpan({
+            id: agentSpanId,
+            ...(parentSpanId ? { parentId: parentSpanId } : {}),
+            site: spec.role,
+            agentId,
+            logicalAgentId,
+            role: spec.role,
+            t0: agentStartedAt,
+            t1: recorder.now(),
+            costUSD: spec.grant.spentUSD(),
+            status: rctx.signal?.aborted ? "aborted" : "ok",
+            attrs: {
+                depth: spec.depth,
+                task: spec.task.slice(0, TASK_PREVIEW_CHARS),
+                stopReason,
+            },
+        });
+    }
+    return {
+        agentId,
+        note,
+        spentUSD: spec.grant.spentUSD(),
+        stopReason,
+        ...(spec.captureMessages ? { messages: result.response.messages } : {}),
+    };
+}
+export function describeBudget(rctx) {
+    return budgetStatusLine(rctx);
+}

package/dist/async.d.ts

@@ -0,0 +1,19 @@
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function withTimeout<T>(ms: number, parentSignal: AbortSignal | undefined, label: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export interface ConcurrencyGate {
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    acquire(): Promise<() => void>;
+}
+export declare function createConcurrencyGate(limit: number): ConcurrencyGate;
+export declare function createDynamicConcurrencyGate(limitFn: () => number): ConcurrencyGate;
+export interface AdaptiveLimit {
+    value(): number;
+    onSuccess(): void;
+    onThrottle(): void;
+}
+export declare function createAdaptiveLimit(opts: {
+    start: number;
+    min: number;
+    max: number;
+}): AdaptiveLimit;
+export declare function mapWithConcurrency<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/async.js

@@ -0,0 +1,172 @@
+export async function sleep(ms, signal) {
+    if (ms <= 0) {
+        signal?.throwIfAborted();
+        return;
+    }
+    if (signal?.aborted)
+        throw signal.reason ?? new Error("Aborted");
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason ?? new Error("Aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export async function withTimeout(ms, parentSignal, label, fn) {
+    const timeout = AbortSignal.timeout(ms);
+    const combined = parentSignal
+        ? AbortSignal.any([parentSignal, timeout])
+        : timeout;
+    return await Promise.race([
+        fn(combined),
+        new Promise((_, reject) => {
+            const onAbort = () => reject(timeout.aborted && !parentSignal?.aborted
+                ? new Error(`${label} timed out after ${Math.round(ms / 1000)}s`)
+                : (combined.reason ?? new Error("Aborted")));
+            if (combined.aborted)
+                onAbort();
+            else
+                combined.addEventListener("abort", onAbort, { once: true });
+        }),
+    ]);
+}
+class Semaphore {
+    limit;
+    active = 0;
+    waiting = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async run(fn) {
+        const release = await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    async acquire() {
+        await this.acquireSlot();
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.releaseSlot();
+        };
+    }
+    async acquireSlot() {
+        if (this.active < this.limit) {
+            this.active++;
+            return;
+        }
+        await new Promise((resolve) => this.waiting.push(() => {
+            this.active++;
+            resolve();
+        }));
+    }
+    releaseSlot() {
+        this.active--;
+        this.waiting.shift()?.();
+    }
+}
+export function createConcurrencyGate(limit) {
+    const normalized = Number.isFinite(limit)
+        ? Math.max(1, Math.floor(limit))
+        : 1;
+    return new Semaphore(normalized);
+}
+class DynamicSemaphore {
+    limitFn;
+    active = 0;
+    waiting = [];
+    constructor(limitFn) {
+        this.limitFn = limitFn;
+    }
+    async run(fn) {
+        const release = await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    async acquire() {
+        await this.acquireSlot();
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.releaseSlot();
+        };
+    }
+    limit() {
+        const raw = this.limitFn();
+        return Number.isFinite(raw) ? Math.max(1, Math.floor(raw)) : 1;
+    }
+    async acquireSlot() {
+        if (this.active < this.limit()) {
+            this.active++;
+            return;
+        }
+        await new Promise((resolve) => this.waiting.push(() => {
+            this.active++;
+            resolve();
+        }));
+    }
+    releaseSlot() {
+        this.active--;
+        while (this.active < this.limit() && this.waiting.length > 0) {
+            this.waiting.shift()?.();
+        }
+    }
+}
+export function createDynamicConcurrencyGate(limitFn) {
+    return new DynamicSemaphore(limitFn);
+}
+export function createAdaptiveLimit(opts) {
+    const min = Math.max(1, Math.floor(opts.min));
+    const max = Math.max(min, Math.floor(opts.max));
+    const clamp = (n) => Math.min(max, Math.max(min, n));
+    let width = clamp(Math.floor(opts.start));
+    let cleanRun = 0;
+    return {
+        value: () => width,
+        onSuccess: () => {
+            if (width >= max)
+                return;
+            cleanRun++;
+            if (cleanRun >= width * 2) {
+                width = clamp(width + 1);
+                cleanRun = 0;
+            }
+        },
+        onThrottle: () => {
+            width = clamp(Math.floor(width / 2));
+            cleanRun = 0;
+        },
+    };
+}
+export async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    const normalizedLimit = Number.isFinite(limit)
+        ? Math.max(1, Math.floor(limit))
+        : 1;
+    let next = 0;
+    const workers = Array.from({ length: Math.min(normalizedLimit, items.length) }, async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await fn(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/atlas.d.ts

@@ -0,0 +1,19 @@
+import type { FlexibleSchema } from "ai";
+import type { AtlasConfig, ResearchOptions } from "./config.js";
+import { type ResearchResult, type ResearchRun, type ResumeOptions } from "./run.js";
+export type { AtlasConfig, ResearchOptions } from "./config.js";
+import type { Researcher } from "./researcher.js";
+import type { StructuredResult } from "./structured.js";
+export declare class Atlas {
+    #private;
+    constructor(config: AtlasConfig);
+    research(question: string, options?: ResearchOptions): Promise<ResearchResult>;
+    research<T>(question: string, options: ResearchOptions & {
+        schema: FlexibleSchema<T>;
+    }): Promise<StructuredResult<T>>;
+    start(question: string, options?: ResearchOptions): ResearchRun;
+    asResearcher(description: string): Researcher;
+    resume(runId: string, options?: ResumeOptions): Promise<ResearchRun>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/atlas.js

@@ -0,0 +1,69 @@
+import { resumeRun, startRun, } from "./run.js";
+import { AtlasError } from "./errors.js";
+export class Atlas {
+    #config;
+    #closed = false;
+    #runs = new Set();
+    constructor(config) {
+        this.#config = config;
+    }
+    async research(question, options = {}) {
+        if (this.#closed)
+            throw new AtlasError("Atlas is closed; create a new instance", "config");
+        const { schema, ...rest } = options;
+        const result = await this.#startRun(question, rest, schema).result();
+        return schema ? result : result;
+    }
+    start(question, options = {}) {
+        if (this.#closed)
+            throw new AtlasError("Atlas is closed; create a new instance", "config");
+        return this.#startRun(question, options);
+    }
+    #startRun(question, options, schema) {
+        const run = startRun({
+            config: this.#config,
+            question,
+            options,
+            ...(schema ? { schema } : {}),
+        });
+        this.#track(run);
+        return run;
+    }
+    asResearcher(description) {
+        return {
+            description,
+            research: async (query, ctx) => {
+                const result = await this.#startRun(query, {
+                    budget: { maxUSD: ctx.budget.maxUSD },
+                    ...(ctx.signal ? { signal: ctx.signal } : {}),
+                }).result();
+                return {
+                    report: result.report,
+                    sources: result.sources.map((s) => ({ url: s.url, title: s.title })),
+                    cost: result.stats.costUSD,
+                };
+            },
+        };
+    }
+    async resume(runId, options) {
+        if (this.#closed)
+            throw new AtlasError("Atlas is closed; create a new instance", "config");
+        const run = await resumeRun(runId, this.#config, options);
+        this.#track(run);
+        return run;
+    }
+    async close() {
+        this.#closed = true;
+        await Promise.allSettled([...this.#runs].map((run) => run.abort()));
+    }
+    [Symbol.asyncDispose]() {
+        return this.close();
+    }
+    #track(run) {
+        this.#runs.add(run);
+        void run
+            .result()
+            .then(() => undefined, () => undefined)
+            .finally(() => this.#runs.delete(run));
+    }
+}