@steel-dev/atlas 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { exaAgent } from "./providers/exa-agent.js";
+import { basicFetch, exaContents, steel as steelFetch } from "./providers/fetch.js";
+import { parallelAgent } from "./providers/parallel-agent.js";
+import { perplexityAgent } from "./providers/perplexity-agent.js";
+import { brave as braveSearch, exa as exaSearch, nativeModelSearch, tavily as tavilySearch } from "./providers/search.js";
+export { Atlas } from "./atlas.js";
+export type { ModelPricing, PricingTable } from "./budget.js";
+export { DEFAULT_PRICING } from "./budget.js";
+export type { AtlasConfig, Budget, ConcurrencyConfig, Effort, ResearchOptions, SourceFilter, TraceMode, } from "./config.js";
+export type { ResearchTool, ToolContext } from "./custom-tools.js";
+export { researchTool } from "./custom-tools.js";
+export type { Citation, ResearchEvent, ResearchEventMap, ResearchEventType, RunStats, StopReason, } from "./events.js";
+export { EVENT_SCHEMA_VERSION } from "./events.js";
+export type { ModelRole } from "./model.js";
+export type { Researcher, ResearcherContext, ResearchReport, } from "./researcher.js";
+export { researcher } from "./researcher.js";
+export type { ResearchResult, ResearchRun, ResumeOptions, RunStatus, SourceRecord, } from "./run.js";
+export type { SafetyPolicy } from "./safety.js";
+export type { StructuredResult } from "./structured.js";
+export type { CriticalSpan, DigestAgent, DigestAnomaly, DigestPhase, RunDigest, RunTrace, Span, SpanKind, SpanStatus, TraceStep, } from "./trace.js";
+export { TRACE_SCHEMA_VERSION } from "./trace.js";
+export declare const exa: {
+    search: typeof exaSearch;
+    contents: typeof exaContents;
+    agent: typeof exaAgent;
+};
+export declare const brave: {
+    search: typeof braveSearch;
+};
+export declare const tavily: {
+    search: typeof tavilySearch;
+};
+export declare const native: {
+    search: typeof nativeModelSearch;
+};
+export declare const steel: {
+    fetch: typeof steelFetch;
+};
+export declare const basic: {
+    fetch: typeof basicFetch;
+};
+export declare const perplexity: {
+    agent: typeof perplexityAgent;
+};
+export declare const parallel: {
+    agent: typeof parallelAgent;
+};
+export type { AtlasErrorCode } from "./errors.js";
+export { AtlasError } from "./errors.js";
+export type { ArxivOptions, ClinicalTrialsOptions, EdgarOptions, OpenAlexOptions, PubmedOptions, SemanticScholarOptions, WikipediaOptions, } from "./providers/domain/index.js";
+export { arxiv, clinicaltrials, edgar, openalex, pubmed, semanticScholar, wikipedia, } from "./providers/domain/index.js";
+export type { ExaAgentOptions } from "./providers/exa-agent.js";
+export type { FetchAttempt, FetchedPage, FetchProvider, FetchRequest, SteelOptions, } from "./providers/fetch.js";
+export type { ParallelAgentOptions } from "./providers/parallel-agent.js";
+export type { PerplexityAgentOptions } from "./providers/perplexity-agent.js";
+export type { BraveOptions, ExaOptions, NativeModelSearchOptions, SearchProvider, SearchQuery, SearchResult, TavilyOptions, } from "./providers/search.js";
+export type { JournalEntry, RunStore, RunSummary } from "./providers/store.js";
+export { fileStore, loadTrace, memoryStore } from "./providers/store.js";
+export type { SourceDiscoveredLink, SourceExtractionAttempt, SourceExtractionMetadata, } from "./sources.js";

package/dist/index.js

@@ -0,0 +1,26 @@
+import { exaAgent } from "./providers/exa-agent.js";
+import { basicFetch, exaContents, steel as steelFetch, } from "./providers/fetch.js";
+import { parallelAgent } from "./providers/parallel-agent.js";
+import { perplexityAgent } from "./providers/perplexity-agent.js";
+import { brave as braveSearch, exa as exaSearch, nativeModelSearch, tavily as tavilySearch, } from "./providers/search.js";
+export { Atlas } from "./atlas.js";
+export { DEFAULT_PRICING } from "./budget.js";
+export { researchTool } from "./custom-tools.js";
+export { EVENT_SCHEMA_VERSION } from "./events.js";
+export { researcher } from "./researcher.js";
+export { TRACE_SCHEMA_VERSION } from "./trace.js";
+export const exa = {
+    search: exaSearch,
+    contents: exaContents,
+    agent: exaAgent,
+};
+export const brave = { search: braveSearch };
+export const tavily = { search: tavilySearch };
+export const native = { search: nativeModelSearch };
+export const steel = { fetch: steelFetch };
+export const basic = { fetch: basicFetch };
+export const perplexity = { agent: perplexityAgent };
+export const parallel = { agent: parallelAgent };
+export { AtlasError } from "./errors.js";
+export { arxiv, clinicaltrials, edgar, openalex, pubmed, semanticScholar, wikipedia, } from "./providers/domain/index.js";
+export { fileStore, loadTrace, memoryStore } from "./providers/store.js";

package/dist/memory.d.ts

@@ -0,0 +1,2 @@
+import type { ModelMessage } from "ai";
+export declare function stubToolResultWindow(messages: ModelMessage[], keep: number): ModelMessage[];

package/dist/memory.js

@@ -0,0 +1,38 @@
+const STUB_TOOLS = new Set([
+    "search",
+    "fetch",
+    "read_source",
+    "search_sources",
+    "run_code",
+]);
+function stubPart(part) {
+    const name = String(part.toolName ?? "tool");
+    const stub = `[${name} result paged out — the sources it produced are stored; reopen them with search_sources or read_source]`;
+    return { ...part, output: { type: "text", value: stub } };
+}
+export function stubToolResultWindow(messages, keep) {
+    const positions = [];
+    messages.forEach((m, i) => {
+        if (m.role === "tool" && Array.isArray(m.content)) {
+            m.content.forEach((part, k) => {
+                if (part?.type === "tool-result" &&
+                    STUB_TOOLS.has(String(part.toolName))) {
+                    positions.push(`${i}:${k}`);
+                }
+            });
+        }
+    });
+    if (positions.length <= keep)
+        return messages;
+    const keepSet = new Set(positions.slice(positions.length - keep));
+    return messages.map((m, i) => {
+        if (m.role !== "tool" || !Array.isArray(m.content))
+            return m;
+        const content = m.content.map((part, k) => part?.type === "tool-result" &&
+            STUB_TOOLS.has(String(part.toolName)) &&
+            !keepSet.has(`${i}:${k}`)
+            ? stubPart(part)
+            : part);
+        return { ...m, content };
+    });
+}

package/dist/model.d.ts

@@ -0,0 +1,49 @@
+import type { LanguageModelV3, LanguageModelV3GenerateResult, LanguageModelV3Usage } from "@ai-sdk/provider";
+import { type LanguageModel } from "ai";
+import type { ConcurrencyGate } from "./async.js";
+import { type BudgetGrant, type PricingTable, type TokenUsage } from "./budget.js";
+import type { JournalWriter, ReplayCache } from "./providers/store.js";
+import { type TraceRecorder } from "./trace.js";
+export type ModelRole = "lead" | "research" | "write";
+export type ResolvedModel = Exclude<LanguageModel, string>;
+export interface RunUsage {
+    byRole: Map<string, TokenUsage>;
+    replayedUSD: number;
+}
+export declare function createRunUsage(): RunUsage;
+export declare function totalFreshTokens(usage: RunUsage): number;
+export declare function tokenUsageFromV3(usage: LanguageModelV3Usage): TokenUsage;
+export interface RateLimitNotice {
+    attempt: number;
+    delayMs: number;
+    error: unknown;
+}
+export interface EngineModelHooks {
+    role: ModelRole;
+    grant: BudgetGrant;
+    pricing: PricingTable;
+    gate: ConcurrencyGate;
+    usage: RunUsage;
+    journal?: JournalWriter | undefined;
+    replay?: ReplayCache | undefined;
+    modelCache?: ModelCallCache | undefined;
+    recorder?: TraceRecorder | undefined;
+    onCost?: ((usd: number) => void) | undefined;
+    onUnknownModel?: ((modelId: string) => void) | undefined;
+    onRateLimit?: ((notice: RateLimitNotice) => void) | undefined;
+    onCacheHit?: (() => void) | undefined;
+    budgetExhausted?: (() => boolean) | undefined;
+    callOrdinals?: Map<string, number> | undefined;
+}
+export declare function normalizeForCacheKey(serialized: string): string;
+interface JournaledCall {
+    content: LanguageModelV3GenerateResult["content"];
+    finishReason: LanguageModelV3GenerateResult["finishReason"];
+    usage: LanguageModelV3Usage;
+    providerMetadata?: LanguageModelV3GenerateResult["providerMetadata"];
+}
+export type ModelCallCache = Map<string, JournaledCall>;
+export declare function createModelCallCache(): ModelCallCache;
+export declare function engineModel(model: ResolvedModel, hooks: EngineModelHooks): LanguageModelV3;
+export declare const MODEL_CALL_MAX_RETRIES = 0;
+export {};