@steel-dev/atlas 0.1.0

package/dist/state.d.ts

@@ -0,0 +1,90 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { ConcurrencyGate } from "./async.js";
+import type { BudgetGrant, BudgetMeter, PricingTable } from "./budget.js";
+import type { Ledger } from "./checklist.js";
+import type { ResolvedRunConfig } from "./config.js";
+import type { ResolvedCustomTool } from "./custom-tools.js";
+import type { ResearchEvent } from "./events.js";
+import type { ModelRole, ResolvedModel, RunUsage } from "./model.js";
+import type { FetchProvider } from "./providers/fetch.js";
+import type { MergedSearchResult, ResolvedSearch } from "./providers/search.js";
+import type { JournalWriter, ReplayCache } from "./providers/store.js";
+import type { SafeDispatcher } from "./safe-dispatcher.js";
+import type { FetchedSource, SourceDocument } from "./sources.js";
+import type { TraceRecorder } from "./trace.js";
+import type { Trail } from "./trail.js";
+export interface SearchCacheEntry {
+    merged: MergedSearchResult[];
+    warnings: string[];
+}
+export interface OaCandidate {
+    openUrls: string[];
+    title?: string;
+    fallbackText?: string;
+}
+export interface SurfacedCandidate {
+    url: string;
+    title: string;
+    snippet: string;
+}
+export interface SourceStore {
+    fetchedSources: FetchedSource[];
+    byUrl: Map<string, SourceDocument>;
+    byId: Map<string, SourceDocument>;
+    reservedUrls: Set<string>;
+    reservedSlots: number;
+    nextSourceNumber: number;
+    inFlight: Map<string, Promise<SourceDocument | null>>;
+    searchCache: Map<string, Promise<SearchCacheEntry>>;
+}
+export declare function createSourceStore(): SourceStore;
+export interface RunCounters {
+    searches: number;
+    searchCacheHits: number;
+    modelCacheHits: number;
+    modelGatePeakWidth: number;
+    sourcesFetched: number;
+    sourcesFailed: number;
+}
+export declare function createRunCounters(): RunCounters;
+export interface RunCtx {
+    runId: string;
+    question: string;
+    todayISO: string;
+    config: ResolvedRunConfig;
+    meter: BudgetMeter;
+    usage: RunUsage;
+    pricing: PricingTable;
+    ledger: Ledger | null;
+    trail: Trail;
+    notes: string[];
+    readCounts: Map<string, number>;
+    sources: SourceStore;
+    search: ResolvedSearch;
+    searchBySource: Map<string, ResolvedSearch>;
+    oaCandidates: Map<string, OaCandidate>;
+    surfacedCandidates: Map<string, SurfacedCandidate>;
+    fetchChain: FetchProvider[];
+    safeDispatcher: SafeDispatcher;
+    customTools: ReadonlyMap<string, ResolvedCustomTool>;
+    runCodeEnabled: boolean;
+    emit(event: ResearchEvent): void;
+    journal?: JournalWriter | undefined;
+    replay?: ReplayCache | undefined;
+    recorder?: TraceRecorder | undefined;
+    signal?: AbortSignal | undefined;
+    stopSignal?: AbortSignal | undefined;
+    deadlineAt?: number | undefined;
+    now(): number;
+    modelGate: ConcurrencyGate;
+    ioGate: ConcurrencyGate;
+    seenDomains: Set<string>;
+    counters: RunCounters;
+    agentSequence: {
+        next: number;
+    };
+    bindModel(role: ModelRole, grant: BudgetGrant): LanguageModelV3;
+    rawModel(role: ModelRole): ResolvedModel;
+    stopReason(): string | null;
+}
+export declare function budgetStatusLine(rctx: RunCtx): string;

package/dist/state.js

@@ -0,0 +1,27 @@
+export function createSourceStore() {
+    return {
+        fetchedSources: [],
+        byUrl: new Map(),
+        byId: new Map(),
+        reservedUrls: new Set(),
+        reservedSlots: 0,
+        nextSourceNumber: 1,
+        inFlight: new Map(),
+        searchCache: new Map(),
+    };
+}
+export function createRunCounters() {
+    return {
+        searches: 0,
+        searchCacheHits: 0,
+        modelCacheHits: 0,
+        modelGatePeakWidth: 0,
+        sourcesFetched: 0,
+        sourcesFailed: 0,
+    };
+}
+export function budgetStatusLine(rctx) {
+    const spent = rctx.meter.totalSpentUSD();
+    const total = rctx.meter.totalUSD;
+    return `budget: ≈$${Math.max(0, total - spent).toFixed(2)} of $${total.toFixed(2)} remaining`;
+}

package/dist/structured.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import { type FlexibleSchema } from "ai";
+import type { ResearchResult } from "./run.js";
+export interface StructuredResult<T> extends ResearchResult {
+    object: T;
+}
+export declare function extractStructured<T>(model: LanguageModelV3, question: string, report: string, schema: FlexibleSchema<T>, signal?: AbortSignal): Promise<T>;

package/dist/structured.js

@@ -0,0 +1,18 @@
+import { generateObject } from "ai";
+import { MODEL_CALL_MAX_RETRIES } from "./model.js";
+const EXTRACT_SYSTEM = "You convert a finished research report into a structured object that conforms to the given schema. " +
+    "Use ONLY facts asserted in the report; never invent or infer a value the report does not support. " +
+    "When the report leaves a field undetermined, use the schema's allowance — null, empty, or omission — rather than guessing.";
+export async function extractStructured(model, question, report, schema, signal) {
+    const { object } = await generateObject({
+        model,
+        schema,
+        system: EXTRACT_SYSTEM,
+        prompt: `Question:\n${question}\n\n` +
+            `Research report:\n${report}\n\n` +
+            "Return the object the schema defines, grounded only in the report above.",
+        maxRetries: MODEL_CALL_MAX_RETRIES,
+        ...(signal ? { abortSignal: signal } : {}),
+    });
+    return object;
+}

package/dist/tools.d.ts

@@ -0,0 +1,33 @@
+import { type ToolSet } from "ai";
+import type { BudgetGrant } from "./budget.js";
+import type { AgentRole } from "./events.js";
+import type { SourceDocument } from "./sources.js";
+import { type RunCtx } from "./state.js";
+export declare const BUILTIN_TOOL_NAMES: readonly ["search", "fetch", "read_source", "search_sources", "run_code", "note"];
+export declare const LEDGER_TOOL_NAMES: readonly ["close_slot", "add_slot", "retarget_slot"];
+export type ToolName = (typeof BUILTIN_TOOL_NAMES)[number] | (typeof LEDGER_TOOL_NAMES)[number];
+export interface AgentCtx {
+    agentId: string;
+    role: AgentRole;
+    grant: BudgetGrant;
+    depth: number;
+}
+export declare function authorityMultiplier(url: string): number;
+export declare function renderUnfetchedCandidates(rctx: RunCtx, max: number): string;
+export declare function execSearchTool(rctx: RunCtx, queries: string[], limit: number, source?: string): Promise<string>;
+type SingleFetchOutcome = {
+    ok: true;
+    card: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function fetchOneUrl(rctx: RunCtx, actx: AgentCtx, requestedUrl: string, previewChars: number, goal: string): Promise<SingleFetchOutcome>;
+export declare function addCustomToolSource(rctx: RunCtx, _actx: AgentCtx, opts: {
+    url: string;
+    title?: string;
+    content: string;
+    toolName: string;
+}): SourceDocument | null;
+export declare function buildAgentTools(rctx: RunCtx, actx: AgentCtx, names: ToolName[]): ToolSet;
+export {};