@tangle-network/agent-runtime 0.94.11 → 0.94.12

package/dist/primeintellect/index.d.ts

@@ -0,0 +1,214 @@
+import { c as AgentExecutionBackend, A as AgentBackendInput } from '../types-BwoZWq-i.js';
+import { c as createOpenAICompatibleBackend } from '../backends-BO4Jqoe2.js';
+import { RunRecord } from '@tangle-network/agent-eval';
+
+type PrimeIntellectSplit = 'train' | 'eval';
+type PrimeIntellectJson = null | boolean | number | string | PrimeIntellectJson[] | {
+    [key: string]: PrimeIntellectJson;
+};
+type PrimeIntellectContent = string | Array<{
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}>;
+type PrimeIntellectMessage = {
+    role: 'system' | 'user';
+    content: PrimeIntellectContent;
+} | {
+    role: 'assistant';
+    content?: string | null;
+    reasoning_content?: string | null;
+    tool_calls?: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+    provider_state?: Array<Record<string, PrimeIntellectJson>>;
+} | {
+    role: 'tool';
+    tool_call_id: string;
+    content: PrimeIntellectContent;
+    name?: string;
+};
+/** One immutable problem. References stay inside Prime's task process. */
+interface PrimeIntellectTask {
+    id: string;
+    split: PrimeIntellectSplit;
+    prompt: string | PrimeIntellectMessage[];
+    systemPrompt?: string;
+    answer?: string | string[];
+    metadata?: Record<string, PrimeIntellectJson>;
+}
+type PrimeIntellectScoring = {
+    kind: 'exact';
+    normalization?: 'none' | 'trim' | 'trim-casefold';
+} | {
+    kind: 'reference-judge';
+    model: string;
+    prompt?: string;
+    view?: 'last_reply' | 'full_trace';
+} | {
+    kind: 'command';
+    command: readonly [string, ...string[]];
+    files?: Readonly<Record<string, string>>;
+    forwardEnv?: readonly string[];
+    timeoutSeconds?: number;
+};
+type PrimeIntellectSetupCommand = readonly [string, ...string[]];
+/** Files and commands that make the caller's real agent program runnable. */
+interface PrimeIntellectRunner {
+    command: readonly [string, ...string[]];
+    files?: Readonly<Record<string, string>>;
+    setup?: readonly PrimeIntellectSetupCommand[];
+    forwardEnv?: readonly string[];
+    /** Container image used by the generated eval config. */
+    image: string;
+}
+interface PrimeIntellectPackageOptions {
+    name: string;
+    version: string;
+    description?: string;
+    tasks: readonly PrimeIntellectTask[];
+    scoring: PrimeIntellectScoring;
+    runner: PrimeIntellectRunner;
+    /** Prime-enforced model turn cap. Default 16. */
+    maxTurns?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxTotalTokens?: number;
+    rolloutTimeoutSeconds?: number;
+    scoringTimeoutSeconds?: number;
+}
+interface PrimeIntellectPackageManifest {
+    schema: 'tangle.primeintellect.package/v1';
+    name: string;
+    moduleName: string;
+    version: string;
+    verifiers: '>=0.2.0,<0.3.0';
+    taskCount: number;
+    splits: Record<PrimeIntellectSplit, number>;
+    taskIdsSha256: string;
+    filesSha256: Record<string, string>;
+}
+interface PrimeIntellectPackageBundle {
+    manifest: PrimeIntellectPackageManifest;
+    /** Relative package path to UTF-8 contents. */
+    files: Readonly<Record<string, string>>;
+}
+/** The answer-free task exposed to the caller's runtime program. */
+interface PrimeIntellectPublicTask {
+    id: string;
+    split: PrimeIntellectSplit;
+    prompt: string | PrimeIntellectMessage[];
+    systemPrompt?: string;
+    metadata?: Record<string, PrimeIntellectJson>;
+}
+interface PrimeIntellectEpisodeContext {
+    protocol: 'tangle.primeintellect.episode/v1';
+    task: PrimeIntellectPublicTask;
+    model: {
+        name: string;
+        baseUrl: string;
+        apiKey: string;
+    };
+    mcpServers: Readonly<Record<string, string>>;
+}
+
+interface WritePrimeIntellectPackageOptions {
+    /** Replace an existing generated package and restore it if the final swap fails. */
+    replace?: boolean;
+}
+/** Build a complete PrimeIntellect Verifiers v1 package without writing to disk. */
+declare function createPrimeIntellectPackage(options: PrimeIntellectPackageOptions): PrimeIntellectPackageBundle;
+/** Write a bundle through a sibling temporary directory, then rename it into place. */
+declare function writePrimeIntellectPackage(bundle: PrimeIntellectPackageBundle, outputDirectory: string, options?: WritePrimeIntellectPackageOptions): Promise<string>;
+
+interface RunPrimeIntellectProgramOptions {
+    env?: NodeJS.ProcessEnv;
+}
+type PrimeIntellectBackendOptions = Omit<Parameters<typeof createOpenAICompatibleBackend>[0], 'apiKey' | 'baseUrl' | 'model'>;
+/** Read and validate the private process contract installed by the generated Prime harness. */
+declare function readPrimeIntellectEpisodeContext(env?: NodeJS.ProcessEnv): PrimeIntellectEpisodeContext;
+/** Build the existing runtime backend against Prime's intercepted model endpoint. */
+declare function createPrimeIntellectBackend(context: PrimeIntellectEpisodeContext, options?: PrimeIntellectBackendOptions): AgentExecutionBackend<AgentBackendInput>;
+/**
+ * Execute the caller's canonical runtime program inside a Prime rollout.
+ * The callback may call runPersonified, runAgentic, runLoop, or any product wrapper.
+ */
+declare function runPrimeIntellectProgram<Result>(run: (context: PrimeIntellectEpisodeContext) => Promise<Result>, options?: RunPrimeIntellectProgramOptions): Promise<Result>;
+
+interface PrimeUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    cached_input_tokens?: number | null;
+    reasoning_tokens?: number | null;
+    cost?: number | null;
+}
+interface PrimeTraceNode {
+    parent?: number | null;
+    sampled?: boolean;
+    usage?: PrimeUsage | null;
+    message?: unknown;
+}
+interface PrimeTimeSpan {
+    start?: number;
+    end?: number;
+}
+interface PrimeIntellectTrace {
+    id: string;
+    task: {
+        type: string;
+        data: {
+            idx: number;
+            name?: string | null;
+            split?: 'train' | 'eval';
+            prompt?: unknown;
+            system_prompt?: string | null;
+            metadata?: Record<string, unknown>;
+            [key: string]: unknown;
+        };
+    };
+    runtime?: unknown;
+    nodes: PrimeTraceNode[];
+    rewards: Record<string, number>;
+    metrics: Record<string, number>;
+    info?: Record<string, unknown>;
+    extra_usage?: PrimeUsage[];
+    is_completed?: boolean;
+    stop_condition?: string | null;
+    errors?: Array<{
+        type: string;
+        message: string;
+        traceback?: string | null;
+    }>;
+    timing?: {
+        start?: number;
+        setup?: PrimeTimeSpan;
+        generation?: PrimeTimeSpan;
+        finalize?: PrimeTimeSpan;
+        scoring?: PrimeTimeSpan;
+    };
+}
+interface PrimeIntellectTraceImportOptions {
+    experimentId: string;
+    candidateId: string;
+    seed: number;
+    /** Snapshot-pinned model id required by RunRecord validation. */
+    model: string;
+    promptHash: string;
+    configHash: string;
+    commitSha: string;
+}
+type PrimeIntellectImportDefaults = PrimeIntellectTraceImportOptions;
+/** Parse Prime's durable `traces.jsonl` and reject malformed rows with a line number. */
+declare function parsePrimeIntellectTraces(jsonl: string): PrimeIntellectTrace[];
+/** Convert all Prime traces to agent-eval RunRecords while retaining one shared run config. */
+declare function importPrimeIntellectTraces(jsonl: string, defaults: PrimeIntellectImportDefaults): RunRecord[];
+/** Project one complete Prime trace into the common agent-eval analysis row. */
+declare function primeIntellectTraceToRunRecord(trace: PrimeIntellectTrace, options: PrimeIntellectTraceImportOptions): RunRecord;
+
+export { type PrimeIntellectBackendOptions, type PrimeIntellectContent, type PrimeIntellectEpisodeContext, type PrimeIntellectImportDefaults, type PrimeIntellectJson, type PrimeIntellectMessage, type PrimeIntellectPackageBundle, type PrimeIntellectPackageManifest, type PrimeIntellectPackageOptions, type PrimeIntellectPublicTask, type PrimeIntellectRunner, type PrimeIntellectScoring, type PrimeIntellectSetupCommand, type PrimeIntellectSplit, type PrimeIntellectTask, type PrimeIntellectTrace, type PrimeIntellectTraceImportOptions, type RunPrimeIntellectProgramOptions, type WritePrimeIntellectPackageOptions, createPrimeIntellectBackend, createPrimeIntellectPackage, importPrimeIntellectTraces, parsePrimeIntellectTraces, primeIntellectTraceToRunRecord, readPrimeIntellectEpisodeContext, runPrimeIntellectProgram, writePrimeIntellectPackage };