tnega 0.1.0 → 0.3.0

package/dist/types/packages/agent/src/llm-service.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "../../core/src/index.js";
+import type { LLMAdapter } from './types.js';
+export interface LlmRouteCapacity {
+    provider: string;
+    model: string;
+    contextWindow?: number;
+}
+export declare class LlmService {
+    private _adapters;
+    private _current;
+    private _defaultName;
+    register(name: string, adapter: LLMAdapter): () => void;
+    setCurrent(name: string): LLMAdapter;
+    current(): LLMAdapter | undefined;
+    list(): readonly {
+        name: string;
+        adapter: LLMAdapter;
+    }[];
+    /**
+     * Report provider/model/contextWindow for the current route. The adapter
+     * may be registered with an optional capacity provider by callers that own
+     * the model catalog (for example the CLI runtime).
+     */
+    routeCapacity(): LlmRouteCapacity | undefined;
+    private _capacityFor;
+    /** Install a catalog-backed contextWindow resolver (optional). */
+    setCapacityResolver(resolver: (model: string | undefined) => number | undefined): void;
+}
+export declare const llmService: {
+    name: string;
+    apply: (ctx: Context) => () => void;
+};

package/dist/types/packages/agent/src/prompt.d.ts

@@ -0,0 +1,55 @@
+import type { Context } from "../../core/src/index.js";
+export interface PromptSection {
+    name: string;
+    order?: number;
+    content: string;
+}
+export interface SystemPromptAssemblyOptions {
+    scope?: unknown;
+    [key: string]: unknown;
+}
+export interface PromptAssembly {
+    sections: readonly PromptSection[];
+    text: string;
+    context?: SystemPromptAssemblyOptions;
+    variables?: Record<string, string>;
+    tools?: readonly {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+    }[];
+}
+export type ToolSchemaSnapshot = {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+};
+export type ToolSchemaProvider = (context: SystemPromptAssemblyOptions) => readonly ToolSchemaSnapshot[] | Promise<readonly ToolSchemaSnapshot[]>;
+export type PromptVariableProvider = (context: SystemPromptAssemblyOptions) => string | undefined | Promise<string | undefined>;
+export interface PromptContextProvider {
+    name: string;
+    order?: number;
+    content: PromptVariableProvider;
+}
+export declare class SystemPromptService {
+    private _sections;
+    private _toolProviders;
+    private _variables;
+    private _contexts;
+    private _ctx;
+    constructor(ctx?: Context);
+    registerSection(section: PromptSection): () => void;
+    sections(): readonly PromptSection[];
+    registerTools(provider: ToolSchemaProvider): () => void;
+    toolSchemas(options?: SystemPromptAssemblyOptions): Promise<ToolSchemaSnapshot[]>;
+    registerVariable(name: string, provider: PromptVariableProvider): () => void;
+    registerContext(context: PromptContextProvider): () => void;
+    assemble(options?: SystemPromptAssemblyOptions, ctx?: Context): Promise<PromptAssembly>;
+    private _resolveVariables;
+    private _resolveContexts;
+    private _emitChange;
+}
+export declare const systemPrompt: {
+    name: string;
+    apply: (ctx: Context) => () => void;
+};

package/dist/types/packages/agent/src/service.d.ts

@@ -0,0 +1,68 @@
+import type { Context } from "../../core/src/index.js";
+import { type SessionLog } from "../../session/src/index.js";
+import type { AgentContextBudget, AgentHooks, AgentInput, AgentRunOptions, AgentRunResult, AgentStreamEvent, LLMAdapter } from './types.js';
+export declare class AgentError extends Error {
+    name: string;
+}
+export declare class AgentInbox {
+    private _queue;
+    private _steerQueue;
+    private _injected;
+    get size(): number;
+    get steerSize(): number;
+    push(input: AgentInput): AgentInput;
+    followup(input: AgentInput): AgentInput;
+    steer(input: AgentInput): AgentInput;
+    send(input: AgentInput, options?: {
+        mode?: 'followup' | 'steer';
+        wake?: boolean;
+    }): AgentInput;
+    claim(): AgentInput | undefined;
+    peek(): AgentInput | undefined;
+    inject(key: string, value: unknown): void;
+    injected(): ReadonlyMap<string, unknown>;
+}
+export interface AgentConfig {
+    llm?: LLMAdapter;
+    /** Bind the loop to a specific session instead of the ctx-provided singleton. */
+    session?: SessionLog;
+    /** Fail fast when the actual request would not be reconstructable from the log. */
+    assertReplayable?: boolean;
+    maxTurns?: number;
+    maxSteps?: number;
+    inbox?: AgentInbox;
+    hooks?: AgentHooks;
+    contextBudget?: AgentContextBudget;
+}
+export declare class AgentService {
+    private ctx;
+    private config;
+    readonly inbox: AgentInbox;
+    private _seriesStarted;
+    private _persistedRequest;
+    constructor(ctx: Context, config?: AgentConfig);
+    /** Call when a request begins an explicit new model-message series. */
+    startSeries(): void;
+    /** Clear any pending series marker after a completed run. */
+    endSeriesBoundary(): void;
+    /** True when this service instance has already persisted a model-visible step. */
+    get hasPersistedRequest(): boolean;
+    run(input?: AgentInput, options?: AgentRunOptions): Promise<AgentRunResult>;
+    runStream(input?: AgentInput, options?: AgentRunOptions): AsyncGenerator<AgentStreamEvent, AgentRunResult, void>;
+    private _stream;
+    private _enforceContextBudget;
+    private _persistStepInput;
+    private _assertReplayable;
+    private _initialMessages;
+    private _extendMessages;
+    private _session;
+    private _tools;
+    private _resolveAvailableTools;
+    private _llm;
+}
+export declare const agent: {
+    name: string;
+    inject: string[];
+    apply: (ctx: Context, config?: AgentConfig) => () => void;
+};
+export declare const name = "index.js";

package/dist/types/packages/agent/src/types.d.ts

@@ -0,0 +1,215 @@
+import type { CancelCause, ContextUsage, ModelMessage } from "../../session/src/index.js";
+import type { ToolDefinition, ToolResult } from "../../tools/src/index.js";
+export type AgentCancelCause = CancelCause;
+export type AgentFinishReason = 'stop' | 'tool_calls' | 'length' | 'max_turns' | 'max_steps' | 'error' | 'cancelled';
+export interface LLMToolCall {
+    id: string;
+    name: string;
+    arguments: unknown;
+}
+export interface LLMCompletion {
+    content?: string;
+    toolCalls?: LLMToolCall[];
+    finishReason: AgentFinishReason;
+}
+export interface CompleteOptions {
+    maxSteps?: number;
+    signal?: AbortSignal;
+    provider?: string;
+    model?: string;
+    temperature?: number;
+}
+export interface LLMMessageStartEvent {
+    type: 'message_start';
+    id: string;
+    model?: string;
+}
+export interface LLMMessageDeltaEvent {
+    type: 'message_delta';
+    id: string;
+    delta: string;
+}
+export interface LLMToolCallStartEvent {
+    type: 'toolcall_start';
+    id: string;
+    index: number;
+    name: string;
+}
+export interface LLMToolCallEndEvent {
+    type: 'toolcall_end';
+    id: string;
+    index: number;
+    name: string;
+    arguments: unknown;
+}
+export interface LLMMessageStopEvent {
+    type: 'message_stop';
+    id: string;
+    finishReason: AgentFinishReason;
+}
+export type LLMStreamEvent = LLMMessageStartEvent | LLMMessageDeltaEvent | LLMToolCallStartEvent | LLMToolCallEndEvent | LLMMessageStopEvent;
+export interface LLMStreamRequestEvent {
+    index: number;
+    messages: ModelMessage[];
+    tools: readonly ToolDefinition[];
+    options: CompleteOptions;
+}
+export interface LLMAdapter {
+    complete(messages: readonly ModelMessage[], tools: readonly ToolDefinition[], options: CompleteOptions): Promise<LLMCompletion>;
+    stream?(messages: readonly ModelMessage[], tools: readonly ToolDefinition[], options: CompleteOptions): AsyncIterable<LLMStreamEvent>;
+}
+export interface AgentInput {
+    text?: string;
+    messages?: ModelMessage[];
+    context?: unknown;
+}
+export interface AgentStep {
+    index: number;
+    input: readonly ModelMessage[];
+    completion: LLMCompletion;
+    toolResults: readonly ToolResult[];
+}
+export interface AgentRunResult {
+    input: AgentInput;
+    output: string;
+    finishReason: AgentFinishReason;
+    /** Durable turn number this run executed, when a turn was opened. */
+    turn?: number;
+    steps: readonly AgentStep[];
+    messages: readonly ModelMessage[];
+}
+export interface AgentRunOptions {
+    maxTurns?: number;
+    maxSteps?: number;
+    signal?: AbortSignal;
+    contextBudget?: AgentContextBudget;
+}
+export interface AgentContextBudget {
+    limit?: number;
+    compactRatio?: number;
+    keepTokens?: number;
+    summarize?: AgentContextSummarizer;
+}
+export type AgentContextSummarizer = (messages: readonly ModelMessage[], usage: ContextUsage) => readonly ModelMessage[] | Promise<readonly ModelMessage[]>;
+export interface AgentContextCompactEvent {
+    type: 'agent/context-compact';
+    messagesBefore: number;
+    tokensBefore: number;
+    limit: number;
+    keepTokens: number;
+    messagesAfter: number;
+}
+export interface AgentHooks {
+    beforeRun?: (input: AgentInput, options: AgentRunOptions) => void | Promise<void>;
+    afterRun?: (result: AgentRunResult, options: AgentRunOptions) => void | Promise<void>;
+}
+export interface AgentStartEvent {
+    input: AgentInput;
+    options: AgentRunOptions;
+    injected: ReadonlyMap<string, unknown>;
+}
+export interface AgentTurnStartEvent {
+    input: AgentInput;
+    messages: readonly ModelMessage[];
+    injected: ReadonlyMap<string, unknown>;
+}
+export interface AgentStepEvent {
+    index: number;
+    turn?: number;
+    step?: number;
+    input: readonly ModelMessage[];
+}
+export interface AgentPreStepEvent {
+    index: number;
+    /** Durable turn that will own the proposed step. */
+    turn?: number;
+    /** Durable step proposed by the loop. */
+    step?: number;
+    /** Cancellation signal for the current turn. */
+    signal?: AbortSignal;
+    messages: ModelMessage[];
+    /** Begin a distinct model-message series before this step's admitted messages. */
+    startsRequestSeries?: boolean;
+}
+export interface AgentRequestEvent {
+    index: number;
+    /** Read-only snapshot of the model-visible messages for this request. */
+    readonly messages: readonly ModelMessage[];
+    tools: readonly ToolDefinition[];
+    options: CompleteOptions;
+}
+export interface AgentRequestErrorEvent {
+    index: number;
+    turn: number;
+    step: number;
+    messages: readonly ModelMessage[];
+    tools: readonly ToolDefinition[];
+    options: CompleteOptions;
+    attempt: number;
+    error: unknown;
+    /** Normalized durable failure fact surfaced to recovery listeners. */
+    failure: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    provider?: string;
+    model?: string;
+    signal?: AbortSignal;
+    retryPolicy?: {
+        maxRetries: number;
+        retryDelayMs: number;
+    };
+}
+export type AgentRequestRetryDecision = {
+    kind: 'retry';
+    delayMs?: number;
+} | undefined;
+export interface AgentTurnStoppingEvent {
+    index: number;
+    turn?: number;
+    steps: readonly AgentStep[];
+    finishReason: AgentFinishReason;
+}
+export interface AgentToolCallEvent {
+    index: number;
+    turn?: number;
+    step?: number;
+    call: LLMToolCall;
+}
+export interface AgentToolResultEvent {
+    index: number;
+    turn?: number;
+    step?: number;
+    call: LLMToolCall;
+    result: ToolResult;
+}
+export interface AgentTurnEndEvent {
+    input: AgentInput;
+    steps: readonly AgentStep[];
+    messages: readonly ModelMessage[];
+    output: string;
+    finishReason: AgentFinishReason;
+}
+export type AgentEndEvent = AgentTurnEndEvent;
+export interface AgentToolStartEvent {
+    type: 'tool/start';
+    index: number;
+    turn?: number;
+    step?: number;
+    call: LLMToolCall;
+}
+export interface AgentToolEndEvent {
+    type: 'tool/end';
+    index: number;
+    turn?: number;
+    step?: number;
+    call: LLMToolCall;
+    result: ToolResult;
+}
+export interface AgentRunEndEvent {
+    type: 'run/end';
+    run: AgentRunResult;
+}
+export type AgentStreamEvent = LLMStreamEvent | AgentToolStartEvent | AgentToolEndEvent | AgentRunEndEvent;
+export type AgentLoop = (input?: AgentInput, options?: AgentRunOptions) => Promise<AgentRunResult>;

package/dist/types/packages/benchmark/src/bigcodebench.d.ts

@@ -0,0 +1,6 @@
+import type { BenchmarkImportOptions, ImportedBenchmark } from './types.js';
+export declare function isBigCodeBenchEligible(row: {
+    libs?: string;
+    test?: string;
+}): boolean;
+export declare function importBigCodeBench(options: BenchmarkImportOptions): Promise<ImportedBenchmark>;

package/dist/types/packages/benchmark/src/humaneval.d.ts

@@ -0,0 +1,11 @@
+import type { BenchmarkImportOptions, ImportedBenchmark } from './types.js';
+export interface HumanEvalFixture {
+    solution: string;
+    test: string;
+}
+export declare function buildHumanEvalFixture(row: {
+    prompt: string;
+    test: string;
+    entry_point: string;
+}): HumanEvalFixture;
+export declare function importHumanEval(options: BenchmarkImportOptions): Promise<ImportedBenchmark>;

package/dist/types/packages/benchmark/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './bigcodebench.js';
+export * from './humaneval.js';
+export * from './manifest.js';
+export * from './mbpp.js';
+export * from './parquet.js';
+export * from './stdlib.js';
+export * from './swebench.js';
+export * from './types.js';
+export declare const name = "index.js";

package/dist/types/packages/benchmark/src/manifest.d.ts

@@ -0,0 +1,10 @@
+import type { BenchmarkManifest } from './types.js';
+export declare function saveManifest(dir: string, manifest: BenchmarkManifest): Promise<string>;
+export declare function loadManifest(file: string): Promise<BenchmarkManifest>;
+export declare function manifestFile(dir: string): string;
+export declare function tasksFile(dir: string): string;
+export declare function writeTasksFile(dir: string, tasks: Array<{
+    task: import("../../eval/src/index.js").Task;
+    meta: import('./types.js').BenchmarkTaskMeta;
+}>): Promise<string>;
+export declare function ensureDirname(file: string): Promise<string>;

package/dist/types/packages/benchmark/src/mbpp.d.ts

@@ -0,0 +1,10 @@
+import type { BenchmarkImportOptions, ImportedBenchmark } from './types.js';
+export interface MbppFixture {
+    solution: string;
+    test: string;
+}
+export declare function buildMbppFixture(row: {
+    test_list: readonly string[];
+    test_setup_code?: string;
+}): MbppFixture;
+export declare function importMbpp(options: BenchmarkImportOptions): Promise<ImportedBenchmark>;

package/dist/types/packages/benchmark/src/parquet.d.ts

@@ -0,0 +1,2 @@
+export declare function downloadParquet(url: string, file: string, force: boolean): Promise<void>;
+export declare function readParquetRows<T>(file: string): Promise<T[]>;

package/dist/types/packages/benchmark/src/stdlib.d.ts

@@ -0,0 +1,3 @@
+export declare const STDLIB: Set<string>;
+export declare function parseSourceImports(source: string): string[];
+export declare function importsOnlyStdlib(...sourcesAndLocal: Array<readonly string[] | string>): boolean;

package/dist/types/packages/benchmark/src/swebench.d.ts

@@ -0,0 +1,2 @@
+import type { BenchmarkImportOptions, ImportedBenchmark } from './types.js';
+export declare function importSweBench(options: BenchmarkImportOptions): Promise<ImportedBenchmark>;

package/dist/types/packages/benchmark/src/types.d.ts

@@ -0,0 +1,58 @@
+import type { Task } from "../../eval/src/index.js";
+export type BenchmarkSource = 'bigcodebench' | 'swebench' | 'humaneval' | 'mbpp';
+export interface BenchmarkImportOptions {
+    /** Destination directory for the materialized benchmark. */
+    outDir: string;
+    /** Number of tasks to import, default source-specific. */
+    subset?: number;
+    /** Optional comma-separated repo filter for swebench, e.g. "psf/requests,sympy/sympy". */
+    repo?: string;
+    /** Optional comma-separated instance filter for swebench, e.g. "psf__requests-6028". */
+    ids?: string;
+    /** Dataset version, default latest known. */
+    version?: string;
+    /** HuggingFace mirror base URL, default https://hf-mirror.com. */
+    mirror?: string;
+    /** Force re-download of the raw parquet file. */
+    force?: boolean;
+}
+export interface BenchmarkTaskMeta {
+    dataset: string;
+    instanceId: string;
+    version: string;
+    entryPoint?: string;
+    libs?: string[];
+    repo?: string;
+    baseCommit?: string;
+    failToPass?: string[];
+    passToPass?: string[];
+    testCount?: number;
+}
+export interface BenchmarkTask {
+    task: Task;
+    meta: BenchmarkTaskMeta;
+    /** Directory containing the fixture workspace. */
+    fixtureDir: string;
+}
+export interface BenchmarkManifest {
+    source: BenchmarkSource;
+    version: string;
+    importedAt: number;
+    total: number;
+    tasks: Array<{
+        id: string;
+        fixtureDir: string;
+        taskFile: string;
+        dataset: BenchmarkSource;
+    }>;
+    sources?: Record<string, {
+        version: string;
+        total: number;
+    }>;
+}
+export interface ImportedBenchmark {
+    manifest: BenchmarkManifest;
+    tasksFile: string;
+    manifestFile: string;
+    dir: string;
+}

package/dist/types/packages/cli/src/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/packages/cli/src/commands.d.ts

@@ -0,0 +1,146 @@
+import { Context, type Plugin } from "../../core/src/index.js";
+import type { AgentProfile } from './profile.js';
+import { type AgentContextBudget, type AgentDefinition, type AgentInbox, type AgentRunResult, type LLMAdapter } from "../../agent/src/index.js";
+import { type BuiltinToolsConfig, type ToolPolicy } from "../../tools/src/index.js";
+import { type CompareResult, type EvalRun, type RunBudget, type Task } from "../../eval/src/index.js";
+import { type ImportedBenchmark } from "../../benchmark/src/index.js";
+import { type EvolveStepResult, type SelectionPolicy } from "../../evolve/src/index.js";
+export interface TasksFile {
+    tasks: Task[];
+    candidates?: Record<string, unknown>;
+    defaultCandidate?: string;
+    strategyNames?: string[];
+    outputDir?: string;
+    evolve?: EvolveFileConfig;
+}
+export interface EvolveFileConfig {
+    maxIterations?: number;
+    maxRuns?: number;
+    baseSystem?: string;
+    policy?: SelectionPolicy;
+    budget?: RunBudget;
+}
+export interface RunCommandOptions {
+    tasksFile: string;
+    candidateName?: string;
+    taskFilter?: string;
+    cache?: boolean;
+    budget?: RunBudget;
+    outputFile?: string;
+    cwd?: string;
+    model?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+    temperature?: number;
+    maxTurns?: number;
+    maxSteps?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+}
+export interface CompareCommandOptions {
+    base: string;
+    head: string;
+    outputDir?: string;
+    cwd?: string;
+}
+export interface RunAgentCommandOptions {
+    prompt: string;
+    cwd?: string;
+    sessionFile?: string;
+    configFile?: string;
+    profile?: string;
+    model?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+    temperature?: number;
+    maxTurns?: number;
+    maxSteps?: number;
+    allowNetwork?: boolean;
+    allowShell?: boolean;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+}
+export interface RunAgentCommandResult {
+    run: AgentRunResult;
+    sessionFile: string;
+}
+export interface RunEvolveCommandOptions {
+    tasksFile: string;
+    cwd?: string;
+    outputDir?: string;
+    configFile?: string;
+    maxIterations?: number;
+    maxRuns?: number;
+    baseSystem?: string;
+    model?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+    temperature?: number;
+    maxTurns?: number;
+    maxSteps?: number;
+    budget?: RunBudget;
+    cache?: boolean;
+    policy?: SelectionPolicy;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+}
+export interface RunEvolveCommandResult {
+    prime: EvolveStepResult;
+    result: EvolveStepResult;
+    logFile: string;
+    runDir: string;
+}
+export interface ImportBenchmarkCommandOptions {
+    source: string;
+    outDir?: string;
+    subset?: number;
+    repo?: string;
+    ids?: string;
+    version?: string;
+    mirror?: string;
+    force?: boolean;
+}
+export interface LlmEnvConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
+export { resolveLlmEnv } from './config.js';
+export interface AgentRuntimeOptions {
+    cwd: string;
+    sessionFile: string;
+    profile?: AgentProfile;
+    llm?: LLMAdapter;
+    inbox?: AgentInbox;
+    allowNetwork?: boolean;
+    allowShell?: boolean;
+    maxTurns?: number;
+    maxSteps?: number;
+    contextBudget?: AgentContextBudget;
+    agent?: AgentDefinition;
+    toolPolicy?: ToolPolicy;
+    builtinTools?: false | BuiltinToolsConfig;
+    plugins?: readonly Plugin[];
+}
+export interface AgentRuntime {
+    root: Context;
+    dispose: () => Promise<void>;
+}
+export declare class CliError extends Error {
+    name: string;
+}
+export declare function loadTasksFile(file: string): TasksFile;
+export declare function runCommand(options: RunCommandOptions): Promise<EvalRun>;
+export declare function formatRun(run: EvalRun): string;
+export declare function formatCompare(result: CompareResult): string;
+export declare function compareCommand(options: CompareCommandOptions): Promise<CompareResult>;
+export declare function runAgentCommand(options: RunAgentCommandOptions): Promise<RunAgentCommandResult>;
+export declare function createAgentRuntime(options: AgentRuntimeOptions): Promise<AgentRuntime>;
+export declare function formatAgentRun(result: RunAgentCommandResult): string;
+export declare function runEvolveCommand(options: RunEvolveCommandOptions): Promise<RunEvolveCommandResult>;
+export declare function importBenchmarkCommand(options: ImportBenchmarkCommandOptions): Promise<ImportedBenchmark>;
+export declare function formatBenchmarkImport(result: ImportedBenchmark): string;
+export declare function formatEvolveResult(result: RunEvolveCommandResult): string;

package/dist/types/packages/cli/src/config.d.ts

@@ -0,0 +1,28 @@
+export interface LlmEnvConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
+export interface SystemConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    protocol?: 'anthropic' | 'openai';
+    temperature?: number;
+    workspaces?: string[];
+}
+export interface EffectiveLlmConfig {
+    apiKeySet: boolean;
+    baseUrl: string;
+    model: string;
+    protocol?: 'anthropic' | 'openai';
+    temperature?: number;
+}
+export declare function systemConfigPath(): string;
+export declare function readSystemConfig(file?: string): Promise<SystemConfig>;
+export declare function writeSystemConfig(config: SystemConfig, file?: string): Promise<void>;
+export declare function updateSystemConfig(patch: SystemConfig, file?: string): Promise<SystemConfig>;
+export declare function effectiveLlmConfig(config: SystemConfig, env?: NodeJS.ProcessEnv): EffectiveLlmConfig;
+export declare function toLlmEnvConfig(config: SystemConfig): LlmEnvConfig;
+export declare function effectiveApiKey(config: SystemConfig, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveLlmEnv(env?: NodeJS.ProcessEnv): LlmEnvConfig;

package/dist/types/packages/cli/src/index.d.ts

@@ -0,0 +1,9 @@
+import type { CompareResult, EvalRun } from "../../eval/src/index.js";
+export * from './profile.js';
+export * from './profile-file.js';
+export type { AgentRuntime, AgentRuntimeOptions, EvolveFileConfig, ImportBenchmarkCommandOptions, LlmEnvConfig, RunAgentCommandOptions, RunAgentCommandResult, RunEvolveCommandOptions, RunEvolveCommandResult, TasksFile, } from './commands.js';
+export { CliError, compareCommand, createAgentRuntime, formatAgentRun, formatBenchmarkImport, formatCompare, formatEvolveResult, formatRun, importBenchmarkCommand, loadTasksFile, resolveLlmEnv, runAgentCommand, runCommand, runEvolveCommand, } from './commands.js';
+export { parseYaml } from './yaml.js';
+export type { CompareResult, EvalRun };
+export declare function main(argv: readonly string[]): Promise<number>;
+export declare const name = "index.js";