@steel-dev/atlas 0.1.0

package/dist/orchestrate.js

@@ -0,0 +1,277 @@
+import { generateObject, generateText } from "ai";
+import { z } from "zod";
+import { minViableSubtaskUSD, resolvePricing } from "./budget.js";
+import { deriveChildCtx } from "./context.js";
+import { errorMessage } from "./errors.js";
+import { MODEL_CALL_MAX_RETRIES } from "./model.js";
+import { runSpine } from "./spine.js";
+import { withTraceFrame } from "./trace.js";
+export const ATLAS_KEY = "atlas";
+const DEFAULT_ATLAS_DESCRIPTION = "Atlas's own deep-research spine: plans, searches, fetches, and synthesizes a grounded, citation-backed report. Strong on academic, finance, and multi-source synthesis. Default for any sub-task without a more specialized fit.";
+const DECOMPOSE_SYSTEM = "You are a research orchestrator. Decompose the question into independent sub-tasks, each routed to the best-fit researcher from the roster. " +
+    "Cut along independent seams so the sub-reports compose without cross-referencing each other's internals. " +
+    "For a simple question, return a SINGLE sub-task — never split more than the question needs. " +
+    "Each subtask.researcher MUST be one of the roster keys. Structured output only.";
+const SYNTH_SYSTEM = "You synthesize ONE cited research report from several independent sub-reports. " +
+    "Merge overlapping findings, surface and resolve contradictions, and write an integrated answer to the question — not a list of the sub-reports. " +
+    "Preserve every concrete specific (figures, names, dates). Cite sources inline as [N] using ONLY the numbers in the provided source roster; never invent a number and never write your own Sources list — one is appended for you. Open with a brief bottom-line answer.";
+const decomposeSchema = z.object({
+    strategy: z.string(),
+    subtasks: z
+        .array(z.object({
+        query: z.string(),
+        researcher: z.string(),
+        rationale: z.string().optional(),
+    }))
+        .min(1)
+        .max(8),
+});
+const DECOMPOSE_FRACTION = 0.05;
+const DECOMPOSE_MIN_USD = 0.02;
+const SYNTH_MERGE_FRACTION = 0.3;
+const SYNTH_MERGE_MIN_USD = 0.05;
+const MAX_SUBTASKS = 8;
+export async function runOrchestrated(rctx, researchers) {
+    const meter = rctx.meter;
+    const researchModelId = rctx.config.models.research.modelId ?? "";
+    const minViable = minViableSubtaskUSD("broad", rctx.config.envelope.maxReportTokens, resolvePricing(researchModelId, rctx.pricing).pricing);
+    const synthGrant = meter.grant({
+        fraction: SYNTH_MERGE_FRACTION,
+        minUSD: SYNTH_MERGE_MIN_USD,
+    }) ?? meter;
+    const releaseSynth = () => {
+        if (synthGrant !== meter)
+            synthGrant.release();
+    };
+    const roster = [ATLAS_KEY, ...Object.keys(researchers)]
+        .map((key) => `- ${key}: ${key === ATLAS_KEY ? DEFAULT_ATLAS_DESCRIPTION : researchers[key].description}`)
+        .join("\n");
+    const acquisitionBefore = meter.remainingUSD();
+    const maxSubtasks = minViable > 0
+        ? Math.max(1, Math.min(MAX_SUBTASKS, Math.floor((acquisitionBefore * 0.95) / minViable)))
+        : MAX_SUBTASKS;
+    let strategy = "";
+    let subtasks = [{ query: rctx.question, researcher: ATLAS_KEY }];
+    const decomposeGrant = meter.grant({ fraction: DECOMPOSE_FRACTION, minUSD: DECOMPOSE_MIN_USD }) ??
+        meter;
+    try {
+        const decomposed = await withTraceFrame(rctx.recorder, { site: "decompose" }, () => generateObject({
+            model: rctx.bindModel("lead", decomposeGrant),
+            system: DECOMPOSE_SYSTEM,
+            prompt: `Question:\n${rctx.question}\n\nResearcher roster:\n${roster}\n\n` +
+                `Return the decomposition: a one-line strategy and at most ${maxSubtasks} sub-task(s) — fewer when the question is simple.`,
+            schema: decomposeSchema,
+            maxOutputTokens: 1200,
+            maxRetries: MODEL_CALL_MAX_RETRIES,
+            abortSignal: rctx.signal,
+        }));
+        strategy = decomposed.object.strategy;
+        subtasks = decomposed.object.subtasks.slice(0, maxSubtasks).map((st) => ({
+            query: st.query,
+            researcher: st.researcher === ATLAS_KEY || researchers[st.researcher]
+                ? st.researcher
+                : ATLAS_KEY,
+        }));
+    }
+    catch (err) {
+        if (rctx.signal?.aborted)
+            throw err;
+    }
+    finally {
+        if (decomposeGrant !== meter)
+            decomposeGrant.release();
+    }
+    if (strategy.trim())
+        rctx.emit({ type: "plan.updated", rationale: strategy });
+    const acquisition = meter.remainingUSD();
+    const perTask = subtasks.length > 0 ? acquisition / subtasks.length : acquisition;
+    const dispatched = await Promise.all(subtasks.map(async (subtask) => {
+        const grant = meter.grant({ maxUSD: perTask }) ?? meter;
+        try {
+            if (subtask.researcher === ATLAS_KEY) {
+                const child = deriveChildCtx(rctx, subtask.query);
+                const out = await withTraceFrame(rctx.recorder, { site: `researcher:${ATLAS_KEY}` }, () => runSpine(child, { meter: grant }));
+                const sources = child.sources.fetchedSources.map((s) => {
+                    const doc = s.sourceId
+                        ? child.sources.byId.get(s.sourceId)
+                        : undefined;
+                    return {
+                        url: s.url,
+                        title: s.title,
+                        via: doc?.metadata.method ?? "unknown",
+                        chars: doc?.storedChars ?? 0,
+                    };
+                });
+                return { subtask, report: out.report, sources, ok: true, spine: out };
+            }
+            const researcher = researchers[subtask.researcher];
+            const ctx = {
+                budget: { maxUSD: grant.remainingUSD() },
+                log: () => { },
+                ...(rctx.signal ? { signal: rctx.signal } : {}),
+            };
+            const report = await researcher.research(subtask.query, ctx);
+            grant.charge(report.cost ?? 0);
+            return {
+                subtask,
+                report: report.report,
+                sources: report.sources.map((s) => ({
+                    url: s.url,
+                    title: s.title ?? s.url,
+                    via: subtask.researcher,
+                })),
+                ok: true,
+            };
+        }
+        catch (err) {
+            if (rctx.signal?.aborted)
+                throw err;
+            return {
+                subtask,
+                report: "",
+                sources: [],
+                ok: false,
+                error: errorMessage(err),
+            };
+        }
+        finally {
+            if (grant !== meter)
+                grant.release();
+        }
+    }));
+    const ok = dispatched.filter((d) => d.ok && d.report.trim());
+    const failed = dispatched.filter((d) => !d.ok || !d.report.trim());
+    const warnings = failed.map((d) => `Researcher "${d.subtask.researcher}" returned no report for "${d.subtask.query}"` +
+        (d.error ? `: ${d.error}` : "."));
+    if (ok.length === 0) {
+        releaseSynth();
+        return {
+            report: "No researcher returned a usable report for this question.",
+            note: strategy,
+            citations: [],
+            unboundCitations: [],
+            sources: [],
+            warnings,
+        };
+    }
+    // A single complete child report can pass through without a merge pass.
+    const soleAtlas = ok.length === 1 ? ok[0].spine : undefined;
+    if (soleAtlas) {
+        releaseSynth();
+        return {
+            report: soleAtlas.report,
+            note: soleAtlas.note,
+            citations: soleAtlas.citations,
+            unboundCitations: soleAtlas.unboundCitations,
+            sources: ok[0].sources,
+            warnings,
+        };
+    }
+    const sources = dedupeSources(ok);
+    let merged;
+    if (ok.length === 1) {
+        merged = ok[0].report;
+    }
+    else {
+        const rosterList = sources
+            .map((s, i) => `[${i + 1}] ${s.title} — ${s.url}`)
+            .join("\n");
+        const blocks = ok
+            .map((d, i) => `## Sub-report ${i + 1} — via "${d.subtask.researcher}"\n` +
+            `Query: ${d.subtask.query}\n\n${stripSourcesSection(d.report)}`)
+            .join("\n\n---\n\n");
+        let text = "";
+        try {
+            const synth = await withTraceFrame(rctx.recorder, { site: "synthesize" }, () => generateText({
+                model: rctx.bindModel("write", synthGrant),
+                system: SYNTH_SYSTEM,
+                prompt: `Question:\n${rctx.question}\n\n` +
+                    `Source roster (cite inline as [N], using only these numbers):\n${rosterList || "(none)"}\n\n` +
+                    `Sub-reports to merge:\n${blocks}\n\n` +
+                    "Write the integrated final report.",
+                maxOutputTokens: rctx.config.envelope.maxReportTokens,
+                maxRetries: MODEL_CALL_MAX_RETRIES,
+                abortSignal: rctx.signal,
+            }));
+            text = synth.text;
+        }
+        catch (err) {
+            if (rctx.signal?.aborted)
+                throw err;
+        }
+        merged = text.trim() || ok.map((d) => d.report).join("\n\n---\n\n");
+    }
+    releaseSynth();
+    const bound = bindRosterCitations(stripSourcesSection(merged), sources);
+    return {
+        report: bound.report,
+        note: strategy,
+        citations: bound.citations,
+        unboundCitations: bound.unboundCitations,
+        sources,
+        warnings,
+    };
+}
+function dedupeSources(ok) {
+    const seen = new Set();
+    const out = [];
+    for (const d of ok) {
+        for (const s of d.sources) {
+            if (s.url && !seen.has(s.url)) {
+                seen.add(s.url);
+                out.push(s);
+            }
+        }
+    }
+    return out;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Remove local source lists before renumbering against the merged source roster.
+function stripSourcesSection(text) {
+    return text
+        .replace(/\n#{1,6}\s*(?:sources|references)\b[\s\S]*$/i, "")
+        .trimEnd();
+}
+// Bind the merged report to a compact, report-wide source list.
+function bindRosterCitations(text, roster) {
+    let bound = text;
+    roster.forEach((source, i) => {
+        const marker = i + 1;
+        bound = bound.replace(new RegExp(`\\[([^\\]]+)\\]\\(${escapeRegExp(source.url)}\\)`, "g"), `$1 [${marker}]`);
+    });
+    const order = [];
+    const display = new Map();
+    const unbound = new Set();
+    let renumbered = bound.replace(/\[(\d+)\](?!\()/g, (_match, digits) => {
+        const n = Number(digits);
+        if (n < 1 || n > roster.length) {
+            unbound.add(`source_${n}`);
+            return "";
+        }
+        if (!display.has(n)) {
+            order.push(n);
+            display.set(n, order.length);
+        }
+        return `[${display.get(n)}]`;
+    });
+    renumbered = renumbered
+        .replace(/ {2,}/g, " ")
+        .replace(/ +([.,;:)])/g, "$1")
+        .trim();
+    const citations = order.map((rosterN, idx) => ({
+        sourceId: `source_${rosterN}`,
+        marker: idx + 1,
+    }));
+    const references = order
+        .map((rosterN, idx) => {
+        const source = roster[rosterN - 1];
+        return `${idx + 1}. [${source.title}](${source.url})`;
+    })
+        .join("\n");
+    const report = references
+        ? `${renumbered}\n\n## Sources\n\n${references}`
+        : renumbered;
+    return { report, citations, unboundCitations: [...unbound] };
+}

package/dist/pdf-extract.d.ts

@@ -0,0 +1,5 @@
+interface PdfTextExtraction {
+    text: string;
+}
+export declare function extractPdfText(data: Uint8Array): Promise<PdfTextExtraction>;
+export {};

package/dist/pdf-extract.js

@@ -0,0 +1,20 @@
+import { PDFParse } from "pdf-parse";
+const PAGE_MARKER = /--\s*\d+\s+of\s+\d+\s*--/g;
+const NO_TEXT_LAYER = "[This PDF has no extractable text layer — it is likely a scanned or image-only document, so its text could not be read. Do not treat this as 'the fact is not in the document'; try an alternate source, an HTML version, or a different URL for the same content.]";
+export async function extractPdfText(data) {
+    const parser = new PDFParse({ data });
+    try {
+        const result = await parser.getText();
+        const text = result.text;
+        const pages = (text.match(PAGE_MARKER) ?? []).length;
+        const body = text.replace(PAGE_MARKER, " ");
+        const alnum = (body.match(/[\p{L}\p{N}]/gu) ?? []).length;
+        if (pages >= 2 && alnum < Math.max(200, pages * 20)) {
+            return { text: NO_TEXT_LAYER };
+        }
+        return { text };
+    }
+    finally {
+        await parser.destroy();
+    }
+}

package/dist/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare function isoDate(epochMs: number): string;
+export declare function todayLine(todayISO: string): string;

package/dist/prompts.js

@@ -0,0 +1,6 @@
+export function isoDate(epochMs) {
+    return new Date(epochMs).toISOString().slice(0, 10);
+}
+export function todayLine(todayISO) {
+    return `Today's date is ${todayISO}. Interpret "current", "recent", and "latest" relative to this date, not your training data; for any time-bound question, seek the most recent figures available.`;
+}

package/dist/providers/domain/arxiv.d.ts

@@ -0,0 +1,6 @@
+import { type SearchProvider } from "../search.js";
+export interface ArxivOptions {
+    defaultLimit?: number;
+    sort?: "relevance" | "lastUpdated" | "submitted";
+}
+export declare function arxiv(opts?: ArxivOptions): SearchProvider;

package/dist/providers/domain/arxiv.js

@@ -0,0 +1,83 @@
+import * as cheerio from "cheerio";
+import { errorMessage } from "../../errors.js";
+import { safeDomain, } from "../search.js";
+import { buildContent, clampLimit, collapse, fetchText } from "./shared.js";
+const ENDPOINT = "https://export.arxiv.org/api/query";
+const SORT = {
+    relevance: "relevance",
+    lastUpdated: "lastUpdatedDate",
+    submitted: "submittedDate",
+};
+export function arxiv(opts = {}) {
+    const defaultLimit = clampLimit(opts.defaultLimit ?? 5);
+    const sortBy = SORT[opts.sort ?? "relevance"] ?? "relevance";
+    return {
+        id: "arxiv",
+        async search({ query, maxResults, signal }) {
+            const q = query.trim();
+            if (!q)
+                return [];
+            const params = new URLSearchParams({
+                search_query: `all:${q}`,
+                start: "0",
+                max_results: String(clampLimit(maxResults ?? defaultLimit)),
+                sortBy,
+                sortOrder: "descending",
+            });
+            let xml;
+            try {
+                xml = await fetchText(`${ENDPOINT}?${params.toString()}`, signal, "application/atom+xml");
+            }
+            catch (err) {
+                throw new Error(`arxiv: request failed: ${errorMessage(err)}`);
+            }
+            return toResults(xml);
+        },
+    };
+}
+function toResults(xml) {
+    const $ = cheerio.load(xml, { xml: true });
+    const out = [];
+    $("entry").each((_, el) => {
+        const entry = $(el);
+        const title = collapse(entry.children("title").first().text());
+        const url = entry
+            .children("id")
+            .first()
+            .text()
+            .trim()
+            .replace(/^http:\/\//, "https://");
+        if (!title || !url)
+            return;
+        const abstract = collapse(entry.children("summary").first().text());
+        const authors = entry
+            .find("author > name")
+            .map((_, n) => collapse($(n).text()))
+            .get()
+            .filter(Boolean);
+        const published = entry
+            .children("published")
+            .first()
+            .text()
+            .trim()
+            .slice(0, 10);
+        const meta = published ? [`Published: ${published}`] : [];
+        out.push({
+            position: out.length + 1,
+            title,
+            url,
+            snippet: abstract,
+            domain: safeDomain(url),
+            meta: {
+                openUrls: pdfUrls(url),
+                fallbackText: buildContent({ title, authors, meta, abstract }),
+            },
+        });
+    });
+    return out;
+}
+function pdfUrls(absUrl) {
+    return absUrl.includes("/abs/")
+        ? [absUrl.replace("/abs/", "/pdf/"), absUrl]
+        : [absUrl];
+}

package/dist/providers/domain/clinicaltrials.d.ts

@@ -0,0 +1,6 @@
+import { type ResearchTool } from "../../custom-tools.js";
+export interface ClinicalTrialsOptions {
+    defaultLimit?: number;
+    status?: string[];
+}
+export declare function clinicaltrials(opts?: ClinicalTrialsOptions): ResearchTool;

package/dist/providers/domain/clinicaltrials.js

@@ -0,0 +1,104 @@
+import { jsonSchema } from "ai";
+import { researchTool, } from "../../custom-tools.js";
+import { errorMessage } from "../../errors.js";
+import { buildContent, clampLimit, collapse, fetchJson, manifest, } from "./shared.js";
+const ENDPOINT = "https://clinicaltrials.gov/api/v2/studies";
+export function clinicaltrials(opts = {}) {
+    const defaultLimit = clampLimit(opts.defaultLimit ?? 5);
+    const status = (opts.status ?? [])
+        .map((s) => s.trim().toUpperCase())
+        .filter(Boolean);
+    return researchTool({
+        description: "Search ClinicalTrials.gov, the registry of clinical studies conducted around the world. Returns trial summaries (status, conditions, interventions, sponsor) as cited sources — including ongoing and unpublished trials not yet in the literature.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query (condition, intervention, sponsor, or free text)",
+                },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        }),
+        async execute(input, ctx) {
+            const query = String(input.query ?? "").trim();
+            if (!query)
+                return "clinicaltrials: empty query";
+            const params = new URLSearchParams({
+                "query.term": query,
+                pageSize: String(defaultLimit),
+                format: "json",
+            });
+            if (status.length)
+                params.set("filter.overallStatus", status.join(","));
+            let data;
+            try {
+                data = await fetchJson(`${ENDPOINT}?${params.toString()}`, ctx.signal);
+            }
+            catch (err) {
+                return `clinicaltrials: request failed: ${errorMessage(err)}`;
+            }
+            return manifest("clinicaltrials", query, ingest(data, ctx));
+        },
+    });
+}
+function ingest(data, ctx) {
+    const studies = data && typeof data === "object"
+        ? data.studies
+        : undefined;
+    if (!Array.isArray(studies))
+        return [];
+    const titles = [];
+    for (const study of studies) {
+        const p = (study ?? {})
+            .protocolSection ?? {};
+        const idm = p.identificationModule ?? {};
+        const nctId = collapse(String(idm.nctId ?? ""));
+        const title = collapse(String(idm.briefTitle ?? idm.officialTitle ?? ""));
+        if (!nctId || !title)
+            continue;
+        const overallStatus = collapse(String(p.statusModule?.overallStatus ?? "")).replace(/_/g, " ");
+        const sponsor = collapse(String(p.sponsorCollaboratorsModule?.leadSponsor?.name ?? ""));
+        const conditions = list(p.conditionsModule?.conditions);
+        const interventions = Array.isArray(p.armsInterventionsModule?.interventions)
+            ? p.armsInterventionsModule.interventions
+                .map((i) => collapse(String(i?.name ?? "")))
+                .filter(Boolean)
+                .slice(0, 8)
+            : [];
+        const studyType = collapse(String(p.designModule?.studyType ?? ""));
+        const phases = list(p.designModule?.phases).map((x) => x.replace(/_/g, " "));
+        const enrollment = p.designModule?.enrollmentInfo?.count;
+        const abstract = collapse(String(p.descriptionModule?.briefSummary ?? ""));
+        const typeLine = [studyType, phases.join("/")].filter(Boolean).join(" · ");
+        const meta = [];
+        if (overallStatus)
+            meta.push(`Status: ${overallStatus}`);
+        if (typeLine)
+            meta.push(typeLine);
+        if (conditions.length)
+            meta.push(`Conditions: ${conditions.join(", ")}`);
+        if (interventions.length)
+            meta.push(`Interventions: ${interventions.join(", ")}`);
+        if (sponsor)
+            meta.push(`Sponsor: ${sponsor}`);
+        if (typeof enrollment === "number")
+            meta.push(`Enrollment: ${enrollment}`);
+        ctx.addSource({
+            url: `https://clinicaltrials.gov/study/${nctId}`,
+            title,
+            content: buildContent({ title, meta, abstract }),
+        });
+        titles.push(title);
+    }
+    return titles;
+}
+function list(value) {
+    return Array.isArray(value)
+        ? value
+            .map((v) => collapse(String(v)))
+            .filter(Boolean)
+            .slice(0, 8)
+        : [];
+}

package/dist/providers/domain/edgar.d.ts

@@ -0,0 +1,10 @@
+import { type SearchProvider } from "../search.js";
+export interface EdgarOptions {
+    defaultLimit?: number;
+    forms?: string[];
+    from?: string;
+    to?: string;
+    userAgent?: string;
+    email?: string;
+}
+export declare function edgar(opts?: EdgarOptions): SearchProvider;

package/dist/providers/domain/edgar.js

@@ -0,0 +1,92 @@
+import { readEnv } from "../../env.js";
+import { errorMessage } from "../../errors.js";
+import { safeDomain, } from "../search.js";
+import { clampLimit, collapse } from "./shared.js";
+const ENDPOINT = "https://efts.sec.gov/LATEST/search-index";
+const ARCHIVES = "https://www.sec.gov/Archives/edgar/data";
+export function edgar(opts = {}) {
+    const defaultLimit = clampLimit(opts.defaultLimit ?? 10, 10);
+    const forms = (opts.forms ?? []).map((f) => f.trim()).filter(Boolean);
+    const email = opts.email ?? readEnv("ATLAS_SEC_EMAIL");
+    const userAgent = opts.userAgent ??
+        readEnv("ATLAS_SEC_USER_AGENT") ??
+        (email ? `atlas-research/0.1 (${email})` : undefined);
+    return {
+        id: "edgar",
+        async search({ query, maxResults, signal }) {
+            const q = query.trim();
+            if (!q)
+                return [];
+            if (!userAgent) {
+                throw new Error("edgar: SEC requires a contact email in the User-Agent; set ATLAS_SEC_EMAIL (or pass { email } / { userAgent }).");
+            }
+            const params = new URLSearchParams({ q });
+            if (forms.length)
+                params.set("forms", forms.join(","));
+            if (opts.from)
+                params.set("startdt", opts.from);
+            if (opts.to)
+                params.set("enddt", opts.to);
+            let data;
+            try {
+                data = await fetchEdgar(`${ENDPOINT}?${params.toString()}`, userAgent, signal);
+            }
+            catch (err) {
+                throw new Error(`edgar: request failed: ${errorMessage(err)}`);
+            }
+            return parse(data, clampLimit(maxResults ?? defaultLimit, 10));
+        },
+    };
+}
+async function fetchEdgar(url, userAgent, signal) {
+    const resp = await fetch(url, {
+        signal,
+        headers: { "user-agent": userAgent, accept: "application/json" },
+    });
+    if (!resp.ok)
+        throw new Error(`HTTP ${resp.status} ${resp.statusText}`.trim());
+    return resp.json();
+}
+function parse(data, limit) {
+    const hits = data && typeof data === "object"
+        ? data.hits?.hits
+        : undefined;
+    if (!Array.isArray(hits))
+        return [];
+    const out = [];
+    for (const hit of hits.slice(0, limit)) {
+        const h = (hit ?? {});
+        const src = (h._source ?? {});
+        const id = String(h._id ?? "");
+        const colon = id.indexOf(":");
+        const accession = colon >= 0 ? id.slice(0, colon) : String(src.adsh ?? "");
+        const filename = colon >= 0 ? id.slice(colon + 1) : "";
+        const cik = String(src.ciks?.[0] ?? "").replace(/^0+/, "");
+        if (!cik || !accession || !filename)
+            continue;
+        const url = `${ARCHIVES}/${cik}/${accession.replace(/-/g, "")}/${filename}`;
+        const display = collapse(String(src.display_names?.[0] ?? ""));
+        const company = display.split("(")[0].trim() || display || `CIK ${cik}`;
+        const form = collapse(String(src.form ?? src.file_type ?? ""));
+        const filed = collapse(String(src.file_date ?? ""));
+        const period = collapse(String(src.period_ending ?? ""));
+        const label = [
+            company,
+            form,
+            filed && `filed ${filed}`,
+            period && `period ${period}`,
+        ]
+            .filter(Boolean)
+            .join(" · ");
+        out.push({
+            position: out.length + 1,
+            title: label,
+            url,
+            snippet: [form, filed && `filed ${filed}`, period && `period ${period}`]
+                .filter(Boolean)
+                .join(" · "),
+            domain: safeDomain(url),
+        });
+    }
+    return out;
+}

package/dist/providers/domain/index.d.ts

@@ -0,0 +1,14 @@
+export type { ArxivOptions } from "./arxiv.js";
+export { arxiv } from "./arxiv.js";
+export type { ClinicalTrialsOptions } from "./clinicaltrials.js";
+export { clinicaltrials } from "./clinicaltrials.js";
+export type { EdgarOptions } from "./edgar.js";
+export { edgar } from "./edgar.js";
+export type { OpenAlexOptions } from "./openalex.js";
+export { openalex } from "./openalex.js";
+export type { PubmedOptions } from "./pubmed.js";
+export { pubmed } from "./pubmed.js";
+export type { SemanticScholarOptions } from "./semantic-scholar.js";
+export { semanticScholar } from "./semantic-scholar.js";
+export type { WikipediaOptions } from "./wikipedia.js";
+export { wikipedia } from "./wikipedia.js";

package/dist/providers/domain/index.js

@@ -0,0 +1,7 @@
+export { arxiv } from "./arxiv.js";
+export { clinicaltrials } from "./clinicaltrials.js";
+export { edgar } from "./edgar.js";
+export { openalex } from "./openalex.js";
+export { pubmed } from "./pubmed.js";
+export { semanticScholar } from "./semantic-scholar.js";
+export { wikipedia } from "./wikipedia.js";

package/dist/providers/domain/openalex.d.ts

@@ -0,0 +1,7 @@
+import { type SearchProvider } from "../search.js";
+export interface OpenAlexOptions {
+    defaultLimit?: number;
+    sort?: "relevance" | "date" | "citations";
+    email?: string;
+}
+export declare function openalex(opts?: OpenAlexOptions): SearchProvider;