@citeark/agent 0.3.20

package/src/provider/relay.mjs

@@ -0,0 +1,263 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import http from "node:http";
+import { Readable } from "node:stream";
+
+import { CiteArkError } from "../util.mjs";
+import { executeObservedExternalRequest } from "../observability/event-contract.mjs";
+import { rewriteGeminiToolText } from "../../docker/claude-code/codex-pro-relay.mjs";
+
+const MAX_REQUEST_BYTES = 32 * 1024 * 1024;
+const PROTOCOL_PATHS = Object.freeze({
+  "anthropic-messages": new Set([
+    "/v1/messages",
+    "/v1/messages/count_tokens",
+  ]),
+  "openai-responses": new Set([
+    "/v1/responses",
+    "/v1/responses/compact",
+    "/v1/models",
+  ]),
+  "openai-chat-completions": new Set([
+    "/v1/chat/completions",
+    "/v1/models",
+  ]),
+});
+
+export function previewProviderSession(runtimeAgent) {
+  return {
+    mode: "host-credential-relay",
+    apiProtocol: runtimeAgent.api.protocol,
+    credentialSource: runtimeAgent.api.credentialSource,
+    credentialInjectedIntoSandbox: false,
+    containerBaseUrl: "http://host.docker.internal:<relay-port>",
+    containerCredential: "<ephemeral-relay-token>",
+    close: async () => {},
+  };
+}
+
+export async function startProviderSession(runtimeAgent, {
+  observe,
+  correlation = {},
+} = {}) {
+  const { api } = runtimeAgent;
+  if (!api.apiKey) throw new CiteArkError("缺少本次运行的 API Key");
+  if (!PROTOCOL_PATHS[api.protocol]) {
+    throw new CiteArkError(`不支持的模型 API 协议：${api.protocol}`);
+  }
+
+  const relayToken = randomBytes(32).toString("base64url");
+  const activeControllers = new Set();
+  const server = http.createServer((request, response) => {
+    relayRequest({
+      request,
+      response,
+      relayToken,
+      api,
+      reasoningMode: runtimeAgent.reasoningMode,
+      activeControllers,
+      observe,
+      correlation: {
+        ...correlation,
+        protocol: api.protocol,
+        model: runtimeAgent.model,
+      },
+    }).catch(
+      (error) => {
+        if (!response.headersSent) response.writeHead(502);
+        response.end("provider relay error");
+        process.stderr.write(
+          `CiteArk Provider Relay：${error instanceof Error ? error.message : String(error)}\n`,
+        );
+      },
+    );
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "0.0.0.0", resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    await closeServer(server);
+    throw new CiteArkError("无法取得 Provider 密钥隔离代理的监听端口");
+  }
+
+  return {
+    mode: "host-credential-relay",
+    apiProtocol: api.protocol,
+    credentialSource: api.credentialSource,
+    credentialInjectedIntoSandbox: false,
+    containerBaseUrl: `http://host.docker.internal:${address.port}`,
+    containerCredential: relayToken,
+    close: async () => await closeServer(server, activeControllers),
+  };
+}
+
+async function relayRequest({
+  request,
+  response,
+  relayToken,
+  api,
+  reasoningMode,
+  activeControllers,
+  observe,
+  correlation,
+}) {
+  const requestUrl = new URL(request.url ?? "/", "http://citeark-relay.local");
+  const allowedPaths = PROTOCOL_PATHS[api.protocol];
+  const allowedMethod =
+    request.method === "POST" ||
+    (request.method === "GET" && requestUrl.pathname === "/v1/models");
+  if (!allowedMethod || !allowedPaths.has(requestUrl.pathname)) {
+    response.writeHead(404).end();
+    return;
+  }
+  if (!authorized(request, relayToken)) {
+    response.writeHead(401).end();
+    return;
+  }
+
+  let body = request.method === "POST" ? await readRequestBody(request) : undefined;
+  if (
+    new Set(["openai-responses", "openai-chat-completions"]).has(api.protocol) &&
+    new Set(["/v1/responses", "/v1/chat/completions"]).has(requestUrl.pathname) &&
+    reasoningMode === "pro"
+  ) {
+    body = injectReasoningMode(body, reasoningMode);
+  }
+  body = rewriteGeminiToolText(body, api.baseUrl, requestUrl.pathname);
+  const headers = copyRequestHeaders(request.headers);
+  headers.delete("authorization");
+  headers.delete("x-api-key");
+  if (api.protocol === "anthropic-messages") {
+    headers.set("x-api-key", api.apiKey);
+  } else {
+    headers.set("authorization", `Bearer ${api.apiKey}`);
+  }
+
+  const controller = new AbortController();
+  activeControllers.add(controller);
+  try {
+    const targetUrl = upstreamUrl(api.baseUrl, requestUrl);
+    const upstream = await executeObservedExternalRequest({
+      request: async () => await fetch(targetUrl, {
+        method: request.method,
+        headers,
+        body,
+        signal: controller.signal,
+      }),
+      observe,
+      component: "provider_relay",
+      service: targetUrl.hostname,
+      operation: requestUrl.pathname,
+      method: request.method,
+      url: targetUrl,
+      correlation,
+    });
+    response.statusCode = upstream.status;
+    upstream.headers.forEach((value, name) => {
+      if (!hopByHopHeader(name)) response.setHeader(name, value);
+    });
+    response.flushHeaders();
+    if (!upstream.body) {
+      response.end();
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const stream = Readable.fromWeb(upstream.body);
+      stream.once("error", reject);
+      response.once("error", reject);
+      response.once("finish", resolve);
+      stream.pipe(response);
+    });
+  } finally {
+    activeControllers.delete(controller);
+  }
+}
+
+export function injectReasoningMode(body, reasoningMode) {
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(body ?? []).toString("utf8"));
+  } catch {
+    throw new CiteArkError("Responses 请求不是有效 JSON");
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new CiteArkError("Responses 请求必须是对象");
+  }
+  const reasoning = payload.reasoning && typeof payload.reasoning === "object" && !Array.isArray(payload.reasoning)
+    ? payload.reasoning
+    : {};
+  return Buffer.from(JSON.stringify({
+    ...payload,
+    reasoning: { ...reasoning, mode: reasoningMode },
+  }));
+}
+
+function upstreamUrl(baseUrl, requestUrl) {
+  const upstream = new URL(baseUrl);
+  const basePath = upstream.pathname.replace(/\/$/, "");
+  const requestPath = requestUrl.pathname;
+  upstream.pathname =
+    basePath.endsWith("/v1") && requestPath.startsWith("/v1/")
+      ? `${basePath}${requestPath.slice("/v1".length)}`
+      : `${basePath}${requestPath}` || "/";
+  upstream.search = requestUrl.search;
+  return upstream;
+}
+
+function authorized(request, relayToken) {
+  const authorization = request.headers.authorization ?? "";
+  const candidate = authorization.startsWith("Bearer ")
+    ? authorization.slice("Bearer ".length)
+    : request.headers["x-api-key"] ?? "";
+  const expectedBuffer = Buffer.from(relayToken);
+  const candidateBuffer = Buffer.from(String(candidate));
+  return (
+    expectedBuffer.length === candidateBuffer.length &&
+    timingSafeEqual(expectedBuffer, candidateBuffer)
+  );
+}
+
+async function readRequestBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > MAX_REQUEST_BYTES) {
+      throw new CiteArkError("Provider 代理请求超过 32 MiB 限制");
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+function copyRequestHeaders(input) {
+  const output = new Headers();
+  for (const [name, value] of Object.entries(input)) {
+    if (value !== undefined && !hopByHopHeader(name)) {
+      output.set(name, Array.isArray(value) ? value.join(", ") : value);
+    }
+  }
+  return output;
+}
+
+function hopByHopHeader(name) {
+  return new Set([
+    "connection",
+    "content-encoding",
+    "content-length",
+    "host",
+    "transfer-encoding",
+  ]).has(name.toLowerCase());
+}
+
+async function closeServer(server, activeControllers = new Set()) {
+  for (const controller of activeControllers) controller.abort();
+  activeControllers.clear();
+  if (!server.listening) return;
+  await new Promise((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+    server.closeAllConnections?.();
+  });
+}

package/src/provider/runtime-auth.mjs

@@ -0,0 +1,40 @@
+import { GcpSecretManagerClient } from "../gcp/secret-manager.mjs";
+
+export function runtimeProviderConfiguration(runtimeAgent = {}) {
+  return {
+    baseUrl: nonEmpty(runtimeAgent.apiBaseUrl) ?? nonEmpty(runtimeAgent.api?.baseUrl),
+    apiKey: nonEmpty(runtimeAgent.apiKey) ?? nonEmpty(runtimeAgent.api?.apiKey),
+    model: nonEmpty(runtimeAgent.model),
+  };
+}
+
+export function isOpenRouterBaseUrl(value) {
+  try {
+    return new URL(value).hostname.toLowerCase() === "openrouter.ai";
+  } catch {
+    return false;
+  }
+}
+
+export function providerEndpoint(baseUrl, resource) {
+  const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(resource.replace(/^\/+/, ""), normalized).toString();
+}
+
+export async function resolveProviderApiKey({
+  runtimeAgent,
+  providerSecret,
+  secretManager,
+}) {
+  if (runtimeAgent?.codexAccountId || runtimeAgent?.billingMode === "subscription") throw new Error("Subscription model calls cannot resolve an API key");
+  const configured = runtimeProviderConfiguration(runtimeAgent);
+  if (configured.apiKey) return configured.apiKey;
+  if (!providerSecret) return null;
+  const client = secretManager ?? new GcpSecretManagerClient();
+  const apiKey = await client.accessVersion(providerSecret);
+  return nonEmpty(apiKey);
+}
+
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/src/public/cap.d.mts

@@ -0,0 +1,90 @@
+export interface CapReference { ref: string; digest: string; recordType?: string; artifactDigest?: string; role?: string }
+export interface CapRecord { id: string; type: string; role: string; [key: string]: any }
+export interface CapDescriptor { id: string; recordType: string; role: string; path: string; digest: string; mediaType: string; schema: string; size: number }
+export interface CapManifest {
+  specVersion: string; mediaType: string; profiles: string[];
+  artifact: { id?: string; createdAt: string; createdBy: CapReference };
+  roots: Array<CapReference & { role: string }>;
+  records: CapDescriptor[];
+  blobs: Array<{id: string; path?: string; digest: string; size: number; mediaType: string; availability: 'embedded' | 'external' | 'withheld'; roles: string[]; rights?: Record<string, unknown>; accessPolicy?: Record<string, unknown>}>;
+  relations: Array<{relationship: string; artifactDigest: string; recordDigest?: string; summary?: string}>;
+}
+export interface CapAttestation { signatureValid: boolean; subjectValid: boolean; publicKeyDigest: string; [key: string]: unknown }
+export interface CapVerification { archive?: {sha256: string; size: number; [key: string]: unknown}; valid: boolean; issues: string[]; warnings: string[]; protocolVersion: string; artifactDigest: string; manifest: CapManifest; attestations: CapAttestation[] }
+export interface CapArtifact extends CapVerification {
+  kind: 'reproduction' | 'research-plan' | 'research-compilation' | 'computational-run' | 'research-graph';
+  /** Domain projections; graphRecords contains the authenticated scientific objects. */
+  records: Record<string, CapRecord[]>; graphRecords: CapRecord[];
+  signerDigest: string; directory: string; attestation: CapAttestation;
+}
+export interface ArkGraphArtifact { artifactDigest: string; manifest: CapManifest; graphRecords: CapRecord[]; attestations?: CapAttestation[] }
+export interface ArkGraphNode { key: string; ref: string; digest: string; recordType: string; role: string; record: CapRecord; artifacts: string[] }
+export interface ArkGraphRelation extends ArkGraphNode {
+  predicate: string; subject: CapReference; object: CapReference;
+  resolution: { subject: string; object: string }; selection?: { subject: boolean; object: boolean };
+}
+export interface ArkGraph { queryVersion: string; artifacts: string[]; nodes: ArkGraphNode[]; relations: ArkGraphRelation[]; truncated?: boolean; attestations: Array<{artifactDigest: string; attestations: CapAttestation[]}> }
+export interface ArkGraphQuery { roots?: CapReference[]; predicates?: string[]; depth?: number; limit?: number; cursor?: string }
+export interface ArkGraphResult extends ArkGraph { scope: {roots: CapReference[]; predicates: string[] | null; depth: number}; missingRoots: CapReference[]; truncated: boolean; nextCursor: string | null; totalSelected: number }
+export interface ArkRoute extends ArkGraphResult {
+  target: CapReference; activities: CapReference[]; groups: { reference: string[]; planned: string[]; actual: string[] };
+  assessments: Array<{reference: CapReference; conclusion: string; scope: any; limitations: string[]; performedBy: CapReference}>;
+  unknowns: Array<{relation: string; reference: CapReference; reason: string}>;
+  independence: {status: string; reason: string};
+}
+export interface ArkRouteSelection { artifactDigests?: string[]; target: CapReference; activities?: CapReference[]; limit?: number; depth?: number }
+export interface ArkRouteComparison {
+  queryVersion: string; inputs: any; shared: string[]; onlyLeft: string[]; onlyRight: string[];
+  changedVersions: Array<{ref: string; digests: string[]}>;
+  coverage: {left: Array<{target: CapReference; status: string; assessments: any[]}>; right: Array<{target: CapReference; status: string; assessments: any[]}>};
+  incomplete: boolean; independence: {status: string; reason: string};
+}
+export function readCapArchive(archivePath: string, directory: string, options?: {trustedKeyDigests?: string[]}): Promise<CapArtifact>;
+export function readCapBlob(artifact: CapArtifact, role: string): Promise<any>;
+export function verifyCapArchive(archivePath: string, options?: {trustedKeyDigests?: string[]}): Promise<CapVerification>;
+export function packCap(options: { directory: string; outputPath: string; reuseExisting?: boolean }): Promise<any>;
+export function createArkGraph(artifacts: ArkGraphArtifact[]): ArkGraph;
+export function queryArkGraph(graph: ArkGraph, query?: ArkGraphQuery): ArkGraphResult;
+export function getArkGraphRecord(graph: ArkGraph, reference: CapReference): (ArkGraphNode & {relations: ArkGraphRelation[]}) | null;
+export function deriveArkRoute(graph: ArkGraph, selection: ArkRouteSelection): ArkRoute | null;
+export function compareArkRoutes(left: ArkRoute, right: ArkRoute, options?: {targets?: CapReference[]}): ArkRouteComparison;
+export function traceArkGraphProvenance(graph: ArkGraph, reference: CapReference, options?: ArkGraphQuery): (ArkGraphResult & {record: ArkGraphNode}) | null;
+export function scientificProjections(records: CapRecord[]): Record<string, CapRecord[]>;
+export const ARKGRAPH_QUERY_VERSION: string;
+export const SUBJECT_TAGS: Set<string>;
+export function executionTimeoutCapMinutes(fidelity: string): number;
+export const CAP_PROFILE: Record<string, string>;
+export const CAP_RECORD_TYPE: Record<string, string>;
+export const CAP_RECORD_ROLE: Record<string, string>;
+export const CAP_PREDICATES: Record<string, [string | null, string | null]>;
+
+export function canonicalJson(value: unknown): string;
+export function canonicalJsonBytes(value: unknown): Uint8Array;
+export function sha256Bytes(value: Uint8Array): string;
+
+export type ResearchReadingCategory = 'question' | 'concept' | 'hypothesis' | 'claim' | 'method' | 'plan' | 'activity' | 'result' | 'argument' | 'assessment' | 'resource' | 'agent';
+export const RESEARCH_READING_TYPES: Readonly<Record<ResearchReadingCategory, string>>;
+export function readingCategory(node: ArkGraphNode): ResearchReadingCategory;
+export interface ArkGraphPresentationNode {
+  key: string; local: string; ref: string; digest: string; recordType: string; role: string;
+  category: ResearchReadingCategory; subtype: string; label: string; brief: string;
+  sourcePage?: number; image?: string; imageCaption?: string;
+  source: string; sourceLocators: any[]; measurements: any[]; conditions: any;
+  limitations: string[]; prospective: boolean; basis: string | null; raw: CapRecord;
+}
+export interface ArkGraphPresentationExperiment {
+  id: string; experimentId?: string; procedure: CapReference; index: number;
+  source: string; target: string; question: string; title: string; summary: string; criterion: string; limitations: string[];
+  contextNodeIds: string[]; targetKeys: string[]; inputKeys: string[]; stepKeys: string[];
+  requiredProcedureKeys: string[]; unresolvedInputs: CapReference[];
+}
+export interface ArkGraphPresentation {
+  schemaVersion: 'arkgraph-presentation/1'; digest: string; paperTitle: string; titleZh: string;
+  sourceDocument?: string; question: string; provenance: string; nodes: ArkGraphPresentationNode[];
+  edges: Array<{id: string; ref: string; digest: string; from: string; to: string; predicate: string; basis: string; raw: CapRecord; available: boolean; source: string; qualification: string}>;
+  experiments: ArkGraphPresentationExperiment[];
+  presentation: {spine: string[]; primary: string[]; groups: Array<{parent:string;label:string;members:string[]}>; contextGroups: Array<{parent:string;children:string[]}>; shortLabels: Record<string,string>};
+  classification: {assignments: Record<string,{category:ResearchReadingCategory;subtype:string;reason:string;contextualRoles:string[]}>};
+  completeness: {nodes:number;relations:number;unavailableRelations:number};
+}
+export function buildArkGraphPresentation(graph: ArkGraph, options?: {artifactDigest?:string}): ArkGraphPresentation;

package/src/public/cap.mjs

@@ -0,0 +1,12 @@
+export { readCapArchive, readCapBlob } from '../cap/v2/read.mjs';
+export { verifyCapArchive, packCap } from '../cap/v2/archive.mjs';
+export { CAP_PROFILE, CAP_RECORD_TYPE } from '../cap/v2/core.mjs';
+export { SUBJECT_TAGS } from '../contracts/subject-tags.mjs';
+export { executionTimeoutCapMinutes } from '../contracts/execution-timeouts.mjs';
+
+export { CAP_RECORD_ROLE, CAP_PREDICATES, scientificProjections } from '../graph/model.mjs';
+export { ARKGRAPH_QUERY_VERSION, createArkGraph, queryArkGraph, getArkGraphRecord, deriveArkRoute, compareArkRoutes, traceArkGraphProvenance } from '../graph/query.mjs';
+
+export { canonicalJson, canonicalJsonBytes, sha256Bytes } from '../cap/v2/canonical-json.mjs';
+
+export { buildArkGraphPresentation, readingCategory, RESEARCH_READING_TYPES } from '../graph/presentation.mjs';

package/src/public/contracts.d.mts

@@ -0,0 +1,2 @@
+export function executionTimeoutCapMinutes(fidelity: string): number;
+export const SUBJECT_TAGS: ReadonlySet<string>;

package/src/public/host.mjs

@@ -0,0 +1,171 @@
+// Supported library operations for an external research hosting service.
+export { AUTODL_TOOL_DEFINITIONS } from '../autodl/tools.mjs';
+export { AutoDlApiError } from '../autodl/client.mjs';
+export { AutoDlGcsStageTransfer } from '../compute/autodl-pro-staging.mjs';
+export { AutoDlProClient } from '../autodl/client.mjs';
+export { AutoDlProLeasePool } from '../compute/autodl-pro-job.mjs';
+export { AutoDlSshClient } from '../autodl/ssh.mjs';
+export { CAP_ARCHIVE_MEDIA_TYPE } from '../cap/v2/core.mjs';
+export { CAP_MANIFEST } from '../cap/v2/core.mjs';
+export { CAP_PROFILE } from '../cap/v2/core.mjs';
+export { CAP_RECORD_TYPE, CAP_RECORD_ROLE } from '../cap/v2/core.mjs';
+export { CiteArkError } from '../util.mjs';
+export { EXECUTION_TIMEOUT_CAPS_MINUTES } from '../contracts/execution-timeouts.mjs';
+export { GcpBatchClient } from '../gcp/batch-client.mjs';
+export { GcsStagingClient } from '../gcp/storage.mjs';
+export { discoverGcpResources, discoveredGcpPrice, gcpDiscoverySummary, GCP_DISCOVERY_READ_PERMISSIONS } from '../gcp/resource-discovery.mjs';
+export { OBSERVABILITY_SCHEMA_VERSION } from '../observability/event-contract.mjs';
+export { RECONSTRUCTION_REPOSITORY } from '../repository-origin.mjs';
+export { RecoveryStateError } from '../pipeline/recovery-error.mjs';
+export { SourceDiscoveryError } from '../research/source-discovery.mjs';
+export { accountSession } from '../compute/codex-account-session.mjs';
+export { acquireAutoDlProLease } from '../compute/autodl-pro-job.mjs';
+export { agentInvocationPromptArgument } from '../runtime/index.mjs';
+export * as archive_module from '../cap/v2/archive.mjs';
+export { assembleReassessmentCap } from '../cap/v2/reassessment-artifact.mjs';
+export { assembleResearchCompilationCap } from '../cap/v2/compilation-artifact.mjs';
+export { assembleResearchPlanCap } from '../cap/v2/research-artifact.mjs';
+export { assertCommunityCap } from '../deployment/community-policy.mjs';
+export { assertRemoteUploads } from '../compute/autodl-pro-remote.mjs';
+export { assetTransportCompatibilityIssues } from '../assets/source-grounding.mjs';
+export { autoDlExternalObjectTransferTimeoutMs } from '../compute/autodl-pro-remote.mjs';
+export { autoDlHourlyCny } from '../compute/autodl-pro-job.mjs';
+export { autoDlInstanceCandidates } from '../compute/autodl-pro-job.mjs';
+export { autoDlInstanceRequest } from '../compute/autodl-pro-job.mjs';
+export { autoDlStageDownloadChunkBytes } from '../compute/autodl-pro-remote.mjs';
+export { autoDlStageDownloadTimeoutSeconds } from '../compute/autodl-pro-remote.mjs';
+export { automaticAdmissionByExperiment } from '../research/automatic-admission.mjs';
+export { automaticExperimentAdmission } from '../research/automatic-admission.mjs';
+export { blockingCompilerReconstructionIssues } from '../research/structure.mjs';
+export { buildAgentInvocation } from '../runtime/index.mjs';
+export { buildAssessmentEvidenceContext } from '../verification/evidence-context.mjs';
+export { buildCodexInvocation } from '../runtime/codex.mjs';
+export { buildGcpBatchJob } from '../compute/gcp-batch-job.mjs';
+export { campaignExecutionTargets } from '../compute/campaign.mjs';
+export { campaignTargetDirectory } from '../contracts/campaign-contract.mjs';
+export { campaignWorkEstimate } from '../compute/campaign.mjs';
+export { canReuseAutoDlProLease } from '../compute/autodl-pro-job.mjs';
+export { canonicalJson } from '../cap/v2/canonical-json.mjs';
+export { canonicalJsonBytes } from '../cap/v2/canonical-json.mjs';
+export { capPublicKeyDigestFromPrivateKeyFile } from '../cap/v2/attestation.mjs';
+export { captureProcess } from '../process.mjs';
+export * as catalog_module from '../compute/catalog.mjs';
+export { checkOpenRouterReadiness } from '../provider/openrouter-readiness.mjs';
+export { commandMatchesFragment } from '../verification/integrity.mjs';
+export { compilerExecutionProfile } from '../compute/compiler-profile.mjs';
+export { compilerReconstructionRetryIssues } from '../research/structure.mjs';
+export { continuationRepairTargets } from '../research/continuation-selection.mjs';
+export { copyPaper } from '../job.mjs';
+export { createAssetPreparationComputeDecision } from '../assets/compute.mjs';
+export { createAssetPreparationPlan } from '../assets/plan.mjs';
+export { createAutoDlStageArchive } from '../compute/autodl-pro-remote.mjs';
+export { createAutoDlToolExecutor } from '../autodl/tools.mjs';
+export { createBudgetedProviderFetch } from '../../docker/claude-code/codex-pro-relay.mjs';
+export { createCampaignContract } from '../contracts/campaign-contract.mjs';
+export { createExecutionContract } from '../contracts/execution-contract.mjs';
+export { createOpenRouterScientificAssessor } from '../verification/ai-assessor.mjs';
+export { createStageCheckpoint } from '../pipeline/stage-checkpoint.mjs';
+export { discoverRepository } from '../research/source-discovery.mjs';
+export { downloadVerifiedAutoDlStage } from '../compute/autodl-pro-remote.mjs';
+export { emitStructuredObservation } from '../observability/event-contract.mjs';
+export { evaluateClaim } from '../verification/claim-evaluator.mjs';
+export { executeAutoDlRemoteAttempt } from '../compute/autodl-pro-remote.mjs';
+export { executeAutoDlRemoteAttemptWithLeaseRetry } from '../compute/autodl-pro-executor.mjs';
+export { executeFullPipeline } from '../pipeline/orchestrator.mjs';
+export { executeScheduledCompilation } from '../compute/compiler-router.mjs';
+export { executeScheduledReproduction } from '../compute/executor-router.mjs';
+export { executionWorkloadIssues } from '../contracts/execution-workload.mjs';
+export * as execution_contract_module from '../contracts/execution-contract.mjs';
+export * as execution_timeouts_module from '../contracts/execution-timeouts.mjs';
+export { externalRequestObservation } from '../observability/event-contract.mjs';
+export * as handoff_module from '../deployment/handoff.mjs';
+export { initialResearchPlan } from '../reproduction/plan.mjs';
+export { initializeResearchPlan } from '../reproduction/plan.mjs';
+export { isRetryableAutoDlRemoteInfrastructureError } from '../compute/autodl-pro-executor.mjs';
+export { listComputeExecutors } from '../compute/executor-router.mjs';
+export { loadComputeCatalog } from '../compute/catalog.mjs';
+export { loadComputePolicy } from '../compute/catalog.mjs';
+export { loadExecutionContract } from '../contracts/execution-contract.mjs';
+export { loadVerificationPolicy } from '../contracts/execution-contract.mjs';
+export * as local_contract_module from '../deployment/local-contract.mjs';
+export * as local_module from '../deployment/local.mjs';
+export { measurementHardwareIssues } from '../compute/measurement-hardware.mjs';
+export { metricAvailability } from '../records/views.mjs';
+export { normalizeExperimentImportance } from '../research/experiment-importance.mjs';
+export { normalizeResearchStructure } from '../research/structure.mjs';
+export { normalizeTask } from '../protocol.mjs';
+export { packCap } from '../cap/v2/archive.mjs';
+export { parseAutoDlRegionImagePairs } from '../compute/autodl-pro-job.mjs';
+export { parseAutoDlSshConnection } from '../autodl/ssh.mjs';
+export { pathExists } from '../util.mjs';
+export { prepareInventoryForExecution } from '../research/inventory-handoff.mjs';
+export { prepareRepository } from '../job.mjs';
+export { primaryMetric } from '../records/views.mjs';
+export { priorCompletedContinuationTargets } from '../research/continuation-selection.mjs';
+export { projectSharedExecutionClaim } from '../pipeline/shared-execution.mjs';
+export { publicAgentRuntime } from '../runtime/config.mjs';
+export { publicContractPolicyIssues } from '../contracts/public-contract.mjs';
+export { quoteBudgetedModelRequest } from '../../docker/claude-code/codex-pro-relay.mjs';
+export { readJson } from '../util.mjs';
+export { readTargetFailureDiagnosis } from '../diagnosis/target-failure.mjs';
+export * as recipe_module from '../deployment/recipe.mjs';
+export { recoverInvalidExecutionResult } from '../reproduction/lifecycle.mjs';
+export * as recovery_error_module from '../pipeline/recovery-error.mjs';
+export { redactString } from '../cap/redaction.mjs';
+export { relocateStageValue } from '../pipeline/stage-checkpoint.mjs';
+export { remoteProviderSession } from '../compute/gcp-batch-job.mjs';
+export { replayRunToCap } from '../pipeline/replay.mjs';
+export { reproductionCampaign } from '../compute/campaign.mjs';
+export { researchPublicContract } from '../contracts/public-contract.mjs';
+export { resolveAgentRuntime } from '../runtime/config.mjs';
+export { resolveAutoDlProConfig } from '../compute/autodl-pro-job.mjs';
+export { resolveAutoDlProviderEnvironment } from '../compute/autodl-pro-job.mjs';
+export { resolveComputeRequirement } from '../compute/requirements.mjs';
+export { resolveGcpBatchConfig } from '../compute/gcp-batch-job.mjs';
+export { resolveReproductionTargets } from '../pipeline/targets.mjs';
+export { resolveResearchPlan } from '../reproduction/plan.mjs';
+export { restoreAutoDlExternalObjects } from '../compute/autodl-pro-remote.mjs';
+export { restoreRemoteRecovery } from '../compute/coordinator-recovery.mjs';
+export { restoreRunRecovery } from '../compute/coordinator-recovery.mjs';
+export { runProcess } from '../process.mjs';
+export { safeRelativePath } from '../util.mjs';
+export { sanitizeObservation } from '../observability/event-contract.mjs';
+export { saveRemoteRecovery } from '../compute/coordinator-recovery.mjs';
+export { saveRunRecovery } from '../compute/coordinator-recovery.mjs';
+export { scheduleCompute } from '../compute/scheduler.mjs';
+export { selectAssetPreparationProfile } from '../assets/compute.mjs';
+export { selectContinuationTargets } from '../research/continuation-selection.mjs';
+export { sha256Bytes } from '../cap/v2/canonical-json.mjs';
+export { sha256File } from '../util.mjs';
+export { sha256Value } from '../util.mjs';
+export { sharedWorkloads } from '../compute/shared-workloads.mjs';
+export { shellEnvironmentFile } from '../compute/autodl-pro-job.mjs';
+export * as structure_module from '../research/structure.mjs';
+export { summarizeResearchCoverage } from '../pipeline/targets.mjs';
+export * as supplement_module from '../deployment/supplement.mjs';
+export { targetMeasurementIds } from '../pipeline/targets.mjs';
+export { transferAutoDlStageArchive } from '../compute/autodl-pro-remote.mjs';
+export { uploadVerifiedFiles } from '../compute/autodl-pro-remote.mjs';
+export { usesWorkspaceSummary } from '../reproduction/workspace-mode.mjs';
+export * as util_module from '../util.mjs';
+export { validateExecutionResult } from '../protocol.mjs';
+export { validateResultFile } from '../protocol.mjs';
+export { verifyCapArchive } from '../cap/v2/archive.mjs';
+export { verifyCapDirectory } from '../cap/v2/verify.mjs';
+export { writeJson } from '../util.mjs';
+export { ReproductionAdmissionProbeError, assessAutomaticReproductionAdmission, assertNoTransientAdmissionFailures, assetInventoryPreparationHints, assetInventoryCompatibilityIssues } from "../assets/reproduction-admission.mjs";
+export { probePublicAssetUrl } from "../assets/public-asset-probe.mjs";
+export { needsCompilerRepairGeneration } from '../research/compiler-repair.mjs';
+export { validateCodexLogin } from '../compute/codex-account-session.mjs';
+export { readDeploymentArchive } from '../deployment/local.mjs';
+
+export { createScientificAssessor } from '../verification/ai-assessor.mjs';
+export { createModelClient } from '../provider/model-client.mjs';
+export { modelRoute } from '../provider/model-route.mjs';
+export { openCodexAccount } from '../provider/codex-account.mjs';
+export { checkModelReadiness } from '../provider/openrouter-readiness.mjs';
+
+export { preparePaperMarkdown, PAPER_MARKDOWN_CONFIG } from "../research/paper-markdown.mjs";
+export { MINERU_RUNTIME_DIRECTORY } from "../research/mineru-local.mjs";
+export { GoogleAccessTokenProvider } from "../gcp/auth.mjs";
+export { executeObservedExternalRequest } from "../observability/event-contract.mjs";

package/src/public/operations.d.mts

@@ -0,0 +1,11 @@
+export function createFailureDiagnosticArchive(options: {
+  root: string;
+  destination: string;
+  jobId: string;
+  stage: string;
+  attemptCount: number;
+  error: Error;
+}): Promise<{ path: string; digest: string; byteSize: number; mediaType: string }>;
+export function verifyCapArchive(path: string, options?: Record<string, unknown>): Promise<any>;
+export function readDeploymentArchive(path: string, directory: string): Promise<{ handoff: any; artifactDigest: string }>;
+export function validateCodexLogin(text: string): unknown;

package/src/public/presentation.d.mts

@@ -0,0 +1,4 @@
+export function renderResearchVisualization(manifest: unknown): Promise<string>;
+export const visualizationPresentationVersion: string;
+export function renderInteractiveLearning(html: string): string;
+export const interactiveLearningRuntimeVersion: string;

package/src/records/views.mjs

@@ -0,0 +1,26 @@
+export function metricMeasurements(metrics) {
+  return Array.isArray(metrics?.measurements) ? metrics.measurements : [];
+}
+
+export function primaryMetric(metrics) {
+  return metricMeasurements(metrics)[0]?.primary ?? null;
+}
+
+export function metricAvailability(metrics) {
+  const measurements = metricMeasurements(metrics);
+  const unavailable = measurements.find((measurement) => measurement?.availability?.status === "unavailable");
+  return unavailable?.availability ?? measurements[0]?.availability ?? null;
+}
+
+export function metricObservations(metrics) {
+  return metricMeasurements(metrics).flatMap((measurement) =>
+    (measurement?.observations ?? []).map((observation) => ({
+      ...observation,
+      ...(measurement?.measurementId ? { measurementId: measurement.measurementId } : {}),
+    })),
+  );
+}
+
+export function primaryComparison(assessment) {
+  return assessment?.measurementAssessments?.[0]?.comparison ?? null;
+}