tnega 0.1.0 → 0.3.0

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

@@ -0,0 +1,176 @@
+import type { Plugin } from "../../core/src/index.js";
+import type { CandidatePreset, CompareResult, EvalRun, EvalRunOptions, RunBudget, Task, VerdictStatus } from "../../eval/src/index.js";
+export interface CandidateMutation {
+    type: string;
+    description: string;
+    patch?: Record<string, unknown>;
+    config?: Record<string, unknown>;
+}
+export interface Candidate {
+    name: string;
+    version?: string;
+    config?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+    plugin: Plugin;
+    mutation?: CandidateMutation;
+    rationale?: string;
+}
+export type CandidateSnapshot = Omit<Candidate, 'plugin'>;
+export interface FailureMode {
+    taskId: string;
+    strategy: string;
+    status: VerdictStatus;
+    score: number;
+    reason?: string;
+}
+export interface StrategySummary {
+    total: number;
+    passed: number;
+    failed: number;
+    errors: number;
+}
+export interface Diagnosis {
+    score: number;
+    total: number;
+    passed: number;
+    failed: number;
+    errors: number;
+    aborted: boolean;
+    abortedReason?: string;
+    failureModes: FailureMode[];
+    failingTasks: string[];
+    strategySummary: Record<string, StrategySummary>;
+}
+export interface ProposalContext {
+    baseline?: EvalRun;
+    diagnosis: Diagnosis;
+    iteration: number;
+    history: readonly ExperimentNode[];
+    rules: readonly ProposeRule[];
+}
+export type ProposeRuleResult = Candidate | readonly Candidate[] | null | undefined;
+export interface ProposeRule {
+    id: string;
+    description?: string;
+    apply(context: ProposalContext): ProposeRuleResult | Promise<ProposeRuleResult>;
+}
+export type ExperimentStatus = 'pending' | 'accepted' | 'rejected' | 'aborted' | 'error';
+export interface GateCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+export interface SelectionDecision {
+    status: ExperimentStatus;
+    reason: string;
+    checks: GateCheck[];
+    approved?: boolean;
+    requiresApproval?: boolean;
+    delta?: number;
+    regressions?: string[];
+    improvements?: string[];
+    abortedReason?: string;
+}
+export interface ApprovalRequest {
+    nodeId: string;
+    candidate: CandidateSnapshot;
+    run: EvalRun;
+    baseline?: EvalRun;
+}
+export interface SelectionPolicy {
+    minScore?: number;
+    requiredStrategies?: string[];
+    safetyStrategies?: string[];
+    safetyTasks?: string[];
+    maxDegradation?: number;
+    maxRegressions?: number;
+    maxRegressionRatio?: number;
+    minDelta?: number;
+    minPairs?: number;
+    requireImprovement?: boolean;
+    requiresApproval?: boolean;
+    significance?: (compare: CompareResult, policy: SelectionPolicy) => boolean | Promise<boolean>;
+}
+export interface ExperimentNode {
+    id: string;
+    parentId?: string;
+    candidate: CandidateSnapshot;
+    run: EvalRun;
+    status: ExperimentStatus;
+    createdAt: number;
+    decision?: SelectionDecision;
+}
+export interface ExperimentLogData {
+    version: 1;
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    baselineId?: string;
+    nodes: Record<string, ExperimentNode>;
+}
+export interface ExperimentReplay {
+    node: ExperimentNode;
+    diagnosis: Diagnosis;
+    history: string[];
+    baseline?: ExperimentNode;
+}
+export type EvolveStepResult = {
+    kind: 'established';
+    node: ExperimentNode;
+} | {
+    kind: 'accepted';
+    node: ExperimentNode;
+} | {
+    kind: 'rejected';
+    node: ExperimentNode;
+} | {
+    kind: 'aborted';
+    node: ExperimentNode;
+} | {
+    kind: 'approval-pending';
+    node: ExperimentNode;
+} | {
+    kind: 'no-candidate';
+    reason: string;
+};
+export interface EvolveStepOptions {
+    candidate?: Candidate;
+    establishBaseline?: boolean;
+    iteration?: number;
+    run?: Partial<EvalRunOptions>;
+}
+export interface EvolveOptions {
+    maxIterations?: number;
+    maxRuns?: number;
+    candidate?: Candidate;
+    run?: Partial<EvalRunOptions>;
+}
+export interface EvolvePluginConfig {
+    outputDir?: string;
+    logFile?: string;
+    policy?: SelectionPolicy;
+    rules?: ProposeRule[];
+    tasks?: readonly Task[];
+    strategyNames?: string[];
+    budget?: RunBudget;
+    cache?: boolean;
+}
+export interface EvolveRunEvent {
+    nodeId: string;
+    runId: string;
+    candidate: CandidateSnapshot;
+}
+export interface EvolveApprovalEvent {
+    node: ExperimentNode;
+    request: ApprovalRequest;
+}
+export interface EvolveDecisionEvent {
+    node: ExperimentNode;
+    decision: SelectionDecision;
+}
+export interface EvolveProposeEvent {
+    iteration: number;
+    baselineRunId?: string;
+    candidates: CandidateSnapshot[];
+}
+export type { CandidatePreset };

package/dist/types/packages/llm/src/anthropic-messages.d.ts

@@ -0,0 +1,4 @@
+import type { LLMAdapter } from "../../agent/src/index.js";
+import type { LlmConfig } from './types.js';
+export type AnthropicMessagesConfig = LlmConfig;
+export declare function anthropicMessagesAdapter(config?: AnthropicMessagesConfig): LLMAdapter;

package/dist/types/packages/llm/src/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class OpenAICompatibleError extends Error {
+    readonly status: number;
+    readonly detail?: string | undefined;
+    name: string;
+    constructor(status: number, message: string, detail?: string | undefined);
+}

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

@@ -0,0 +1,7 @@
+export { anthropicMessagesAdapter, type AnthropicMessagesConfig, } from './anthropic-messages.js';
+export { OpenAICompatibleError } from './errors.js';
+export { DEFAULT_DEEPSEEK_MODEL, DEFAULT_MODEL, MODEL_CATALOG, lookupModel, type LlmProtocol, type ModelDefinition, type ModelPricing, type ModelPricingMeta, } from './models.js';
+export { openaiCompatAdapter, listModels } from './openai.js';
+export { createLlmAdapter } from './provider.js';
+export { DEFAULT_LLM_MAX_RETRIES, DEFAULT_LLM_RETRY_DELAY_MS, DEFAULT_LLM_TIMEOUT_MS, DEFAULT_OPENCODE_GO_BASE_URL, assertOk, combineSignal, errorMessage, isAbortLike, isExternalAbort, isRetryableStatus, normalizeBaseUrl, parseArguments, parseJson, sleep, stringifyArguments, } from './shared.js';
+export type { LlmConfig, OpenAICompatibleConfig } from './types.js';

package/dist/types/packages/llm/src/models.d.ts

@@ -0,0 +1,29 @@
+export type LlmProtocol = 'openai' | 'anthropic';
+export interface ModelPricing {
+    /** USD per 1M input tokens */
+    input: number;
+    /** USD per 1M output tokens */
+    output: number;
+    /** USD per 1M cached input tokens, when the provider publishes a rate */
+    cachedRead?: number;
+}
+export interface ModelPricingMeta {
+    /** USD per 1M tokens for peak / off-peak tiers */
+    rates: ModelPricing | {
+        offPeak: ModelPricing;
+        peak: ModelPricing;
+    };
+    /** USD usage allowance included in the OpenCode Go subscription */
+    monthlyUsage: number;
+}
+export interface ModelDefinition {
+    id: string;
+    provider: 'opencode-go';
+    protocol: LlmProtocol;
+    contextWindow: number;
+    pricing: ModelPricingMeta;
+}
+export declare const DEFAULT_MODEL = "deepseek-v4-flash";
+export declare const DEFAULT_DEEPSEEK_MODEL = "deepseek-v4-flash";
+export declare const MODEL_CATALOG: readonly ModelDefinition[];
+export declare function lookupModel(id: string | undefined): ModelDefinition | undefined;

package/dist/types/packages/llm/src/openai.d.ts

@@ -0,0 +1,4 @@
+import type { LLMAdapter } from "../../agent/src/index.js";
+import type { OpenAICompatibleConfig } from './types.js';
+export declare function openaiCompatAdapter(config?: OpenAICompatibleConfig): LLMAdapter;
+export declare function listModels(config?: OpenAICompatibleConfig): Promise<string[]>;

package/dist/types/packages/llm/src/provider.d.ts

@@ -0,0 +1,3 @@
+import { openaiCompatAdapter } from './openai.js';
+import type { LlmConfig } from './types.js';
+export declare function createLlmAdapter(config: LlmConfig): ReturnType<typeof openaiCompatAdapter>;

package/dist/types/packages/llm/src/shared.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+export declare const DEFAULT_LLM_TIMEOUT_MS = 120000;
+export declare const DEFAULT_LLM_MAX_RETRIES = 2;
+export declare const DEFAULT_LLM_RETRY_DELAY_MS = 500;
+export declare function combineSignal(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal;
+export declare function isRetryableStatus(status: number): boolean;
+export declare function isExternalAbort(error: unknown, signal: AbortSignal | undefined): boolean;
+export declare function isAbortLike(error: unknown): boolean;
+export declare function errorMessage(error: unknown): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function normalizeBaseUrl(baseUrl: string | undefined): string;
+export declare function stringifyArguments(value: unknown): string;
+export declare function parseArguments(raw: string): unknown;
+export declare function assertOk(response: Response, redact?: string): Promise<void>;
+export declare function parseJson(response: Response): Promise<unknown>;

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

@@ -0,0 +1,13 @@
+export interface LlmConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    /** Force the wire protocol instead of inferring it from the model catalog. */
+    protocol?: 'anthropic' | 'openai';
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+}
+export type OpenAICompatibleConfig = LlmConfig;