@steel-dev/atlas 0.1.0

package/dist/providers/parallel-agent.js

@@ -0,0 +1,100 @@
+import { sleep, withTimeout } from "../async.js";
+import { readEnv } from "../env.js";
+const PARALLEL_PRICE_PER_RUN = {
+    lite: 0.005,
+    base: 0.01,
+    core: 0.025,
+    core2x: 0.05,
+    pro: 0.1,
+    ultra: 0.3,
+    ultra2x: 0.6,
+    ultra4x: 1.2,
+    ultra8x: 2.4,
+};
+const DEFAULT_TIMEOUT_MS = 15 * 60_000;
+const DEFAULT_POLL_INTERVAL_MS = 3_000;
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "failed",
+    "cancelled",
+    "cancelling",
+    "error",
+]);
+const DEFAULT_DESCRIPTION = "Parallel.ai task research: autonomous web research returning a citation-backed result. Strong on enrichment, structured/entity extraction, and broad gathering.";
+export function parallelAgent(opts = {}) {
+    const apiKey = opts.apiKey ?? readEnv("ATLAS_PARALLEL_API_KEY", "PARALLEL_API_KEY");
+    const base = (opts.baseUrl ?? "https://api.parallel.ai").replace(/\/+$/, "");
+    return {
+        description: opts.description ?? DEFAULT_DESCRIPTION,
+        async research(query, ctx) {
+            if (!apiKey) {
+                throw new Error("parallel.agent: no API key (set ATLAS_PARALLEL_API_KEY / PARALLEL_API_KEY or pass { apiKey })");
+            }
+            const headers = {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+            };
+            const processor = opts.processor ?? "core";
+            const data = await withTimeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS, ctx.signal, "parallel.agent", async (signal) => {
+                const created = await fetch(`${base}/v1/tasks/runs`, {
+                    method: "POST",
+                    signal,
+                    headers,
+                    body: JSON.stringify({
+                        input: query,
+                        processor,
+                    }),
+                });
+                if (!created.ok) {
+                    throw new Error(`parallel.agent: create HTTP ${created.status}`);
+                }
+                const run = (await created.json());
+                if (!run.run_id) {
+                    throw new Error("parallel.agent: no run_id in create response");
+                }
+                let status = run.status ?? "queued";
+                while (!TERMINAL_STATUSES.has(status)) {
+                    await sleep(opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS, signal);
+                    const polled = await fetch(`${base}/v1/tasks/runs/${run.run_id}`, {
+                        signal,
+                        headers,
+                    });
+                    if (!polled.ok) {
+                        throw new Error(`parallel.agent: poll HTTP ${polled.status}`);
+                    }
+                    status =
+                        (await polled.json()).status ?? status;
+                }
+                if (status !== "completed") {
+                    throw new Error(`parallel.agent: task run ${status}`);
+                }
+                const resultResp = await fetch(`${base}/v1/tasks/runs/${run.run_id}/result`, { signal, headers });
+                if (!resultResp.ok) {
+                    throw new Error(`parallel.agent: result HTTP ${resultResp.status}`);
+                }
+                return (await resultResp.json());
+            });
+            const content = data.output?.content;
+            const report = (typeof content === "string" ? content : JSON.stringify(content ?? "")).trim();
+            const seen = new Set();
+            const sources = [];
+            for (const field of data.output?.basis ?? []) {
+                for (const citation of field.citations ?? []) {
+                    if (citation.url && !seen.has(citation.url)) {
+                        seen.add(citation.url);
+                        sources.push({
+                            url: citation.url,
+                            ...(citation.title ? { title: citation.title } : {}),
+                        });
+                    }
+                }
+            }
+            const cost = opts.costPerRunUSD ?? PARALLEL_PRICE_PER_RUN[processor];
+            ctx.log(`parallel.agent: ${sources.length} sources` +
+                (cost != null
+                    ? `, $${cost.toFixed(4)}`
+                    : " (cost unknown — set costPerRunUSD)"));
+            return { report, sources, ...(cost != null ? { cost } : {}) };
+        },
+    };
+}

package/dist/providers/perplexity-agent.d.ts

@@ -0,0 +1,17 @@
+import type { Researcher } from "../researcher.js";
+export interface PerplexityPricing {
+    inputPerMTok: number;
+    outputPerMTok: number;
+    citationPerMTok: number;
+    reasoningPerMTok: number;
+    perThousandSearches: number;
+}
+export interface PerplexityAgentOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    description?: string;
+    pricing?: Partial<PerplexityPricing>;
+    timeoutMs?: number;
+}
+export declare function perplexityAgent(opts?: PerplexityAgentOptions): Researcher;

package/dist/providers/perplexity-agent.js

@@ -0,0 +1,86 @@
+import { withTimeout } from "../async.js";
+import { readEnv } from "../env.js";
+const DEFAULT_TIMEOUT_MS = 10 * 60_000;
+const DEFAULT_DESCRIPTION = "Perplexity Sonar deep-research: fast web-grounded research with inline citations. Strong on current events, quick fact-checks, and broad Q&A.";
+const PERPLEXITY_RATES = {
+    "sonar-deep-research": {
+        inputPerMTok: 2,
+        outputPerMTok: 8,
+        citationPerMTok: 2,
+        reasoningPerMTok: 3,
+        perThousandSearches: 5,
+    },
+    sonar: {
+        inputPerMTok: 1,
+        outputPerMTok: 1,
+        citationPerMTok: 0,
+        reasoningPerMTok: 0,
+        perThousandSearches: 0,
+    },
+    "sonar-pro": {
+        inputPerMTok: 3,
+        outputPerMTok: 15,
+        citationPerMTok: 0,
+        reasoningPerMTok: 0,
+        perThousandSearches: 0,
+    },
+};
+const FALLBACK_RATES = PERPLEXITY_RATES["sonar-deep-research"];
+function perplexityCost(usage, model, override) {
+    if (!usage)
+        return undefined;
+    const r = { ...(PERPLEXITY_RATES[model] ?? FALLBACK_RATES), ...override };
+    return (((usage.prompt_tokens ?? 0) * r.inputPerMTok +
+        (usage.completion_tokens ?? 0) * r.outputPerMTok +
+        (usage.citation_tokens ?? 0) * r.citationPerMTok +
+        (usage.reasoning_tokens ?? 0) * r.reasoningPerMTok) /
+        1_000_000 +
+        ((usage.num_search_queries ?? 0) / 1000) * r.perThousandSearches);
+}
+export function perplexityAgent(opts = {}) {
+    const apiKey = opts.apiKey ?? readEnv("ATLAS_PERPLEXITY_API_KEY", "PERPLEXITY_API_KEY");
+    const endpoint = `${(opts.baseUrl ?? "https://api.perplexity.ai").replace(/\/+$/, "")}/chat/completions`;
+    return {
+        description: opts.description ?? DEFAULT_DESCRIPTION,
+        async research(query, ctx) {
+            if (!apiKey) {
+                throw new Error("perplexity.agent: no API key (set ATLAS_PERPLEXITY_API_KEY / PERPLEXITY_API_KEY or pass { apiKey })");
+            }
+            const model = opts.model ?? "sonar-deep-research";
+            const data = await withTimeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS, ctx.signal, "perplexity.agent", async (signal) => {
+                const resp = await fetch(endpoint, {
+                    method: "POST",
+                    signal,
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model,
+                        messages: [{ role: "user", content: query }],
+                    }),
+                });
+                if (!resp.ok) {
+                    throw new Error(`perplexity.agent: HTTP ${resp.status}`);
+                }
+                return (await resp.json());
+            });
+            if (!data.choices || data.choices.length === 0) {
+                throw new Error("perplexity.agent: response had no choices (HTTP 200 with an error body?)");
+            }
+            const report = (data.choices[0]?.message?.content ?? "").trim();
+            const fromResults = (data.search_results ?? [])
+                .filter((r) => Boolean(r.url))
+                .map((r) => ({ url: r.url, ...(r.title ? { title: r.title } : {}) }));
+            const sources = fromResults.length > 0
+                ? fromResults
+                : (data.citations ?? []).map((url) => ({ url }));
+            const cost = perplexityCost(data.usage, model, opts.pricing);
+            ctx.log(`perplexity.agent: ${sources.length} sources` +
+                (cost != null
+                    ? `, $${cost.toFixed(4)}`
+                    : " (cost unknown — no usage in response)"));
+            return { report, sources, ...(cost != null ? { cost } : {}) };
+        },
+    };
+}

package/dist/providers/search.d.ts

@@ -0,0 +1,65 @@
+import { type LanguageModel } from "ai";
+export interface SearchResult {
+    position: number;
+    title: string;
+    url: string;
+    snippet: string;
+    domain: string;
+    meta?: Record<string, unknown>;
+}
+export interface SearchQuery {
+    query: string;
+    maxResults?: number;
+    signal?: AbortSignal;
+}
+export interface SearchProvider {
+    readonly id: string;
+    search(q: SearchQuery): Promise<SearchResult[]>;
+}
+export declare function safeDomain(url: string): string;
+export interface TavilyOptions {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function tavily(opts?: TavilyOptions): SearchProvider;
+export interface ExaOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    type?: string;
+}
+export declare function exa(opts?: ExaOptions): SearchProvider;
+export interface BraveOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    country?: string;
+    searchLang?: string;
+}
+export declare function brave(opts?: BraveOptions): SearchProvider;
+export interface NativeModelSearchOptions {
+    model: Exclude<LanguageModel, string>;
+}
+export declare function nativeModelSearch(opts: NativeModelSearchOptions): SearchProvider;
+export interface MergedSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    provider: string;
+    providerRank: number;
+    providers: string[];
+    score: number;
+    meta?: Record<string, unknown>;
+}
+export declare function openUrlsOf(meta: Record<string, unknown> | undefined): string[];
+export declare function mergeSearchResults(lists: Array<{
+    provider: string;
+    results: SearchResult[];
+}>, limit: number): MergedSearchResult[];
+export interface ResolvedSearch {
+    providers: SearchProvider[];
+    run(q: SearchQuery): Promise<{
+        merged: MergedSearchResult[];
+        warnings: string[];
+    }>;
+}
+export declare function combineSearchProviders(providers: SearchProvider[]): ResolvedSearch;
+export declare function defaultSearchProviders(model: Exclude<LanguageModel, string>): SearchProvider[];